Make Postgres data path configurable for ADS-B history

Allow users to override the pgdata volume mount via PGDATA_PATH env var, enabling external storage (e.g. USB) for ADS-B history. Defaults to ./pgdata for backwards compatibility. Based on PR #88 by JamesIOmete, rebased cleanly onto main. Co-Authored-By: Claude Opus 4.6 <noreply@anthropic.com>
2026-06-13 08:13:32 -07:00 · 2026-02-07 15:34:48 +00:00
225 changed files with 5079 additions and 49338 deletions
@@ -55,12 +55,6 @@ intercept_agent_*.cfg
 /tmp/
 *.tmp
 # Weather satellite runtime data (decoded images, samples, SatDump output)
 data/weather_sat/
 # SDR capture files (large IQ recordings)
 data/subghz/captures/
 # Env files
 .env
 .env.*
@@ -2,56 +2,6 @@
 All notable changes to iNTERCEPT will be documented in this file.
 ## [2.21.0] - 2026-02-20
 ### Added
 - Analytics panels for operational insights and temporal pattern analysis
 ### Changed
 - Global map theme refresh with improved contrast and cross-dashboard consistency
 - Cross-app UX refinements for accessibility, mode consistency, and render performance
 - BT Locate enhancements including improved continuity, smoothing, and confidence reporting
 ### Fixed
 - Weather satellite auto-scheduler and Mercator tracking reliability issues
 - Bluetooth/WiFi runtime health issues affecting scanner continuity
 - ADS-B SSE multi-client fanout stability and remote VDL2 streaming reliability
 ---
 ## [2.15.0] - 2026-02-09
 ### Added
 - **Real-time WebSocket Waterfall** - I/Q capture with server-side FFT
  - Click-to-tune, zoom controls, and auto-scaling quantization
  - Shared waterfall UI across SDR modes with function bar controls
  - WebSocket frame serialization and connection reuse
 - **Cross-Module Frequency Routing** - Tune from Listening Post directly to decoders
 - **Pure Python SSTV Decoder** - Replaces broken slowrx C dependency
  - Real-time decode progress with partial image streaming
  - VIS detector state in signal monitor diagnostics
  - Image gallery with delete and download functionality
 - **Real-time Signal Scope** - Live signal visualization for pager, sensor, and SSTV modes
 - **SSTV Image Gallery** - Delete and download decoded images
 - **USB Device Probe** - Detect broken SDR devices before rtl_fm crashes
 ### Fixed
 - DMR dsd-fme protocol flags, device label, and tuning controls
 - DMR frontend/backend state desync causing 409 on start
 - Digital voice decoder producing no output due to wrong dsd-fme flags
 - SDR device lock-up from unreleased device registry on process crash
 - APRS crash on large station count and station list overflow
 - Settings modal overflowing viewport on smaller screens
 - Waterfall crash on zoom by reusing WebSocket and adding USB release retry
 - PD120 SSTV decode hang and false leader tone detection
 - WebSocket waterfall blocked by login redirect
 - TSCM sweep KeyError on RiskLevel.NEEDS_REVIEW
 ### Removed
 - GSM Spy functionality removed for legal compliance
 ---
 ## [2.14.0] - 2026-02-06
 ### Added
@@ -4,26 +4,11 @@ This file provides guidance to Claude Code (claude.ai/code) when working with co
 ## Project Overview
-INTERCEPT is a web-based Signal Intelligence (SIGINT) platform providing a unified Flask interface for software-defined radio (SDR) tools. It supports pager decoding, 433MHz sensors, ADS-B aircraft tracking, ACARS messaging, WiFi/Bluetooth scanning, satellite tracking, ISS SSTV decoding, AIS vessel tracking, weather satellite imagery (NOAA APT & Meteor LRPT), and Meshtastic mesh networking.
+INTERCEPT is a web-based Signal Intelligence (SIGINT) platform providing a unified Flask interface for software-defined radio (SDR) tools. It supports pager decoding, 433MHz sensors, ADS-B aircraft tracking, ACARS messaging, WiFi/Bluetooth scanning, and satellite tracking.
 ## Common Commands
-### Docker (Primary)
+### Setup and Running
 ```bash
 # Build and run (basic profile)
 docker compose --profile basic up -d
 # Build and run with ADS-B history (Postgres)
 docker compose --profile history up -d
 # Rebuild after code changes
 docker compose --profile basic up -d --build
 # Multi-arch build (amd64 + arm64 for RPi)
 ./build-multiarch.sh
 ```
 ### Local Setup (Alternative)
 ```bash
 # Initial setup (installs dependencies and configures SDR tools)
 ./setup.sh
@@ -81,12 +66,8 @@ Each signal type has its own Flask blueprint:
 - `wifi.py`, `wifi_v2.py` - WiFi scanning (legacy and unified APIs)
 - `bluetooth.py`, `bluetooth_v2.py` - Bluetooth scanning (legacy and unified APIs)
 - `satellite.py` - Pass prediction using TLE data
 - `sstv.py` - ISS SSTV image decoding via slowrx
 - `weather_sat.py` - NOAA APT & Meteor LRPT via SatDump
 - `ais.py` - AIS vessel tracking and VHF DSC distress monitoring
 - `aprs.py` - Amateur packet radio via direwolf
 - `rtlamr.py` - Utility meter reading
 - `meshtastic_routes.py` - Meshtastic LoRa mesh networking
 ### Core Utilities (utils/)
@@ -110,15 +91,6 @@ Each signal type has its own Flask blueprint:
 - Platform-agnostic scanner with parsers for airodump-ng, nmcli, iw, iwlist, airport (macOS)
 - `channel_analyzer.py` - Frequency band analysis
 **Weather Satellite** (`utils/weather_sat.py`):
 - Singleton `WeatherSatDecoder` using SatDump CLI for NOAA APT and Meteor LRPT
 - Subprocess management with stdout parsing, image watcher via rglob
 - Pass prediction using skyfield TLE data
 **SSTV Decoder** (`utils/sstv.py`):
 - ISS SSTV reception via slowrx with Doppler tracking
 - Singleton pattern, image gallery with timestamped filenames
 ### Key Patterns
 **Server-Sent Events (SSE)**: All real-time features stream via SSE endpoints (`/stream_pager`, `/stream_sensor`, etc.). Pattern uses `queue.Queue` with timeout and keepalive messages.
@@ -140,25 +112,9 @@ Each signal type has its own Flask blueprint:
 | acarsdec | ACARS messages | Output parsing |
 | airmon-ng/airodump-ng | WiFi scanning | Monitor mode, CSV parsing |
 | bluetoothctl/hcitool | Bluetooth | Fallback when DBus unavailable |
 | slowrx | SSTV decoding | Subprocess with audio pipe |
 | SatDump | Weather satellites | CLI live mode, NOAA APT + Meteor LRPT |
 | AIS-catcher | AIS vessel tracking | JSON output parsing |
 | direwolf | APRS | TNC modem for packet radio |
 ### Frontend Structure
 - **Templates**: `templates/index.html` (main SPA), `templates/partials/modes/*.html` (sidebar panels), `templates/partials/nav.html` (global nav)
 - **JS Modules**: `static/js/modes/*.js` - IIFE pattern per mode (e.g., `WeatherSat`, `SSTV`, `Meshtastic`)
 - **CSS**: `static/css/modes/*.css` - scoped styles per mode, CSS variables for theming (`--bg-card`, `--accent-cyan`, `--font-mono`)
 - **Mode Integration**: Each mode needs entries in `index.html` at ~12 points: CSS include, welcome card, partial include, visuals container, JS include, `validModes` set, `modeGroups` map, classList toggle, `modeNames`, visuals display toggle, titles, and init call in `switchMode()`
 ### Docker
 - `Dockerfile` - Single-stage build with all SDR tools compiled from source (dump1090, AIS-catcher, slowrx, SatDump, etc.)
 - `docker-compose.yml` - Two profiles: `basic` (standalone) and `history` (with Postgres for ADS-B)
 - `build-multiarch.sh` - Multi-arch build script for amd64 + arm64 (RPi5)
 - Data persisted via `./data:/app/data` volume mount
 ### Configuration
- `config.py` - Environment variable support with `INTERCEPT_` prefix (e.g., `INTERCEPT_PORT`, `INTERCEPT_WEATHER_SAT_GAIN`)
+- `config.py` - Environment variable support with `INTERCEPT_` prefix
 - Database: SQLite in `instance/` directory for settings, baselines, history
 ## Testing Notes
@@ -9,9 +9,6 @@ LABEL description="Signal Intelligence Platform for SDR monitoring"
 # Set working directory
 WORKDIR /app
 # Pre-accept tshark non-root capture prompt for non-interactive install
 RUN echo 'wireshark-common wireshark-common/install-setuid boolean true' | debconf-set-selections
 # Install system dependencies for SDR tools
 RUN apt-get update && apt-get install -y --no-install-recommends \
    # RTL-SDR tools
@@ -24,15 +21,6 @@ RUN apt-get update && apt-get install -y --no-install-recommends \
    multimon-ng \
    # Audio tools for Listening Post
    ffmpeg \
    # SSTV decoder runtime libs
    libsndfile1 \
    # SatDump runtime libs (weather satellite decoding)
    libpng16-16 \
    libtiff6 \
    libjemalloc2 \
    libvolk-bin \
    libnng1 \
    libzstd1 \
    # WiFi tools (aircrack-ng suite)
    aircrack-ng \
    iw \
@@ -41,7 +29,6 @@ RUN apt-get update && apt-get install -y --no-install-recommends \
    bluez \
    bluetooth \
    # GPS support
    gpsd \
    gpsd-clients \
    # Utilities
    # APRS
@@ -54,8 +41,6 @@ RUN apt-get update && apt-get install -y --no-install-recommends \
    soapysdr-module-rtlsdr \
    soapysdr-module-hackrf \
    soapysdr-module-lms7 \
    soapysdr-module-airspy \
    airspy \
    limesuite \
    hackrf \
    # Utilities
@@ -71,22 +56,9 @@ RUN apt-get update && apt-get install -y --no-install-recommends \
    cmake \
    libncurses-dev \
    libsndfile1-dev \
    # GTK is required for slowrx (SSTV decoder GUI dependency).
    # Note: slowrx is kept for backwards compatibility, but the pure Python
    # SSTV decoder in utils/sstv/ is now the primary implementation.
    # GTK can be removed if slowrx is deprecated in future releases.
    libgtk-3-dev \
    libasound2-dev \
    libsoapysdr-dev \
    libhackrf-dev \
    liblimesuite-dev \
    libfftw3-dev \
    libpng-dev \
    libtiff-dev \
    libjemalloc-dev \
    libvolk-dev \
    libnng-dev \
    libzstd-dev \
    libsqlite3-dev \
    libcurl4-openssl-dev \
    zlib1g-dev \
@@ -95,8 +67,6 @@ RUN apt-get update && apt-get install -y --no-install-recommends \
    libfftw3-dev \
    liblapack-dev \
    libcodec2-dev \
    libglib2.0-dev \
    libxml2-dev \
    # Build dump1090
    && cd /tmp \
    && git clone --depth 1 https://github.com/flightaware/dump1090.git \
@@ -139,66 +109,10 @@ RUN apt-get update && apt-get install -y --no-install-recommends \
    && git clone --depth 1 https://github.com/TLeconte/acarsdec.git \
    && cd acarsdec \
    && mkdir build && cd build \
-    && cmake .. -Drtl=ON -DCMAKE_POLICY_VERSION_MINIMUM=3.5 \
+    && cmake .. -Drtl=ON \
    && make \
    && cp acarsdec /usr/bin/acarsdec \
    && rm -rf /tmp/acarsdec \
    # Build libacars (required by dumpvdl2)
    && cd /tmp \
    && git clone --depth 1 https://github.com/szpajder/libacars.git \
    && cd libacars \
    && mkdir build && cd build \
    && cmake .. \
    && make \
    && make install \
    && ldconfig \
    && rm -rf /tmp/libacars \
    # Build dumpvdl2 (VDL2 aircraft datalink decoder)
    && cd /tmp \
    && git clone --depth 1 https://github.com/szpajder/dumpvdl2.git \
    && cd dumpvdl2 \
    && mkdir build && cd build \
    && cmake .. \
    && make \
    && cp src/dumpvdl2 /usr/bin/dumpvdl2 \
    && rm -rf /tmp/dumpvdl2 \
    # Build slowrx (SSTV decoder) — pinned to known-good commit
    && cd /tmp \
    && git clone https://github.com/windytan/slowrx.git \
    && cd slowrx \
    && git checkout ca6d7012 \
    && make \
    && install -m 0755 slowrx /usr/local/bin/slowrx \
    && rm -rf /tmp/slowrx \
    # Build SatDump (weather satellite decoder - NOAA APT & Meteor LRPT) — pinned to v1.2.2
    && cd /tmp \
    && git clone --depth 1 --branch 1.2.2 https://github.com/SatDump/SatDump.git \
    && cd SatDump \
    && mkdir build && cd build \
    && cmake -DCMAKE_BUILD_TYPE=Release -DBUILD_GUI=OFF -DCMAKE_INSTALL_LIBDIR=lib .. \
    && make -j$(nproc) \
    && make install \
    && ldconfig \
    # Ensure SatDump plugins are in the expected path (handles multiarch differences)
    && mkdir -p /usr/local/lib/satdump/plugins \
    && if [ -z "$(ls /usr/local/lib/satdump/plugins/*.so 2>/dev/null)" ]; then \
        for dir in /usr/local/lib/*/satdump/plugins /usr/lib/*/satdump/plugins /usr/lib/satdump/plugins; do \
            if [ -d "$dir" ] && [ -n "$(ls "$dir"/*.so 2>/dev/null)" ]; then \
                ln -sf "$dir"/*.so /usr/local/lib/satdump/plugins/; \
                break; \
            fi; \
        done; \
    fi \
    && cd /tmp \
    && rm -rf /tmp/SatDump \
    # Build rtlamr (utility meter decoder - requires Go)
    && cd /tmp \
    && curl -fsSL "https://go.dev/dl/go1.22.5.linux-$(dpkg --print-architecture).tar.gz" | tar -C /usr/local -xz \
    && export PATH="$PATH:/usr/local/go/bin" \
    && export GOPATH=/tmp/gopath \
    && go install github.com/bemasher/rtlamr@latest \
    && cp /tmp/gopath/bin/rtlamr /usr/bin/rtlamr \
    && rm -rf /usr/local/go /tmp/gopath \
    # Build mbelib (required by DSD)
    && cd /tmp \
    && git clone https://github.com/lwvmobile/mbelib.git \
@@ -221,7 +135,6 @@ RUN apt-get update && apt-get install -y --no-install-recommends \
    && ldconfig \
    && rm -rf /tmp/dsd-fme \
    # Cleanup build tools to reduce image size
    # libgtk-3-dev is explicitly removed; runtime GTK libs remain for slowrx
    && apt-get remove -y \
    build-essential \
    git \
@@ -229,14 +142,6 @@ RUN apt-get update && apt-get install -y --no-install-recommends \
    cmake \
    libncurses-dev \
    libsndfile1-dev \
    libgtk-3-dev \
    libasound2-dev \
    libpng-dev \
    libtiff-dev \
    libjemalloc-dev \
    libvolk-dev \
    libnng-dev \
    libzstd-dev \
    libsoapysdr-dev \
    libhackrf-dev \
    liblimesuite-dev \
@@ -259,7 +164,7 @@ RUN pip install --no-cache-dir -r requirements.txt
 COPY . .
 # Create data directory for persistence
-RUN mkdir -p /app/data /app/data/weather_sat
+RUN mkdir -p /app/data
 # Expose web interface port
 EXPOSE 5050
@@ -1,200 +1,21 @@
 MIT License
-                                 Apache License
+Copyright (c) 2025 smittix
                           Version 2.0, January 2004
                        http://www.apache.org/licenses/
-   TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
+Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal
 in the Software without restriction, including without limitation the rights
 to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
 copies of the Software, and to permit persons to whom the Software is
 furnished to do so, subject to the following conditions:
-   1. Definitions.
+The above copyright notice and this permission notice shall be included in all
 copies or substantial portions of the Software.
-      "License" shall mean the terms and conditions for use, reproduction,
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-      and distribution as defined by Sections 1 through 9 of this document.
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-      "Licensor" shall mean the copyright owner or entity authorized by
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-      the copyright owner that is granting the License.
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
-      "Legal Entity" shall mean the union of the acting entity and all
+SOFTWARE.
      other entities that control, are controlled by, or are under common
      control with that entity. For the purposes of this definition,
      "control" means (i) the power, direct or indirect, to cause the
      direction or management of such entity, whether by contract or
      otherwise, or (ii) ownership of fifty percent (50%) or more of the
      outstanding shares, or (iii) beneficial ownership of such entity.
      "You" (or "Your") shall mean an individual or Legal Entity
      exercising permissions granted by this License.
      "Source" form shall mean the preferred form for making modifications,
      including but not limited to software source code, documentation
      source, and configuration files.
      "Object" form shall mean any form resulting from mechanical
      transformation or translation of a Source form, including but
      not limited to compiled object code, generated documentation,
      and conversions to other media types.
      "Work" shall mean the work of authorship, whether in Source or
      Object form, made available under the License, as indicated by a
      copyright notice that is included in or attached to the work
      (an example is provided in the Appendix below).
      "Derivative Works" shall mean any work, whether in Source or Object
      form, that is based on (or derived from) the Work and for which the
      editorial revisions, annotations, elaborations, or other modifications
      represent, as a whole, an original work of authorship. For the purposes
      of this License, Derivative Works shall not include works that remain
      separable from, or merely link (or bind by name) to the interfaces of,
      the Work and Derivative Works thereof.
      "Contribution" shall mean any work of authorship, including
      the original version of the Work and any modifications or additions
      to that Work or Derivative Works thereof, that is intentionally
      submitted to the Licensor for inclusion in the Work by the copyright owner
      or by an individual or Legal Entity authorized to submit on behalf of
      the copyright owner. For the purposes of this definition, "submitted"
      means any form of electronic, verbal, or written communication sent
      to the Licensor or its representatives, including but not limited to
      communication on electronic mailing lists, source code control systems,
      and issue tracking systems that are managed by, or on behalf of, the
      Licensor for the purpose of discussing and improving the Work, but
      excluding communication that is conspicuously marked or otherwise
      designated in writing by the copyright owner as "Not a Contribution."
      "Contributor" shall mean Licensor and any individual or Legal Entity
      on behalf of whom a Contribution has been received by the Licensor and
      subsequently incorporated within the Work.
   2. Grant of Copyright License. Subject to the terms and conditions of
      this License, each Contributor hereby grants to You a perpetual,
      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
      copyright license to reproduce, prepare Derivative Works of,
      publicly display, publicly perform, sublicense, and distribute the
      Work and such Derivative Works in Source or Object form.
   3. Grant of Patent License. Subject to the terms and conditions of
      this License, each Contributor hereby grants to You a perpetual,
      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
      (except as stated in this section) patent license to make, have made,
      use, offer to sell, sell, import, and otherwise transfer the Work,
      where such license applies only to those patent claims licensable
      by such Contributor that are necessarily infringed by their
      Contribution(s) alone or by combination of their Contribution(s)
      with the Work to which such Contribution(s) was submitted. If You
      institute patent litigation against any entity (including a
      cross-claim or counterclaim in a lawsuit) alleging that the Work
      or a Contribution incorporated within the Work constitutes direct
      or contributory patent infringement, then any patent licenses
      granted to You under this License for that Work shall terminate
      as of the date such litigation is filed.
   4. Redistribution. You may reproduce and distribute copies of the
      Work or Derivative Works thereof in any medium, with or without
      modifications, and in Source or Object form, provided that You
      meet the following conditions:
      (a) You must give any other recipients of the Work or
          Derivative Works a copy of this License; and
      (b) You must cause any modified files to carry prominent notices
          stating that You changed the files; and
      (c) You must retain, in the Source form of any Derivative Works
          that You distribute, all copyright, patent, trademark, and
          attribution notices from the Source form of the Work,
          excluding those notices that do not pertain to any part of
          the Derivative Works; and
      (d) If the Work includes a "NOTICE" text file as part of its
          distribution, then any Derivative Works that You distribute must
          include a readable copy of the attribution notices contained
          within such NOTICE file, excluding any notices that do not
          pertain to any part of the Derivative Works, in at least one
          of the following places: within a NOTICE text file distributed
          as part of the Derivative Works; within the Source form or
          documentation, if provided along with the Derivative Works; or,
          within a display generated by the Derivative Works, if and
          wherever such third-party notices normally appear. The contents
          of the NOTICE file are for informational purposes only and
          do not modify the License. You may add Your own attribution
          notices within Derivative Works that You distribute, alongside
          or as an addendum to the NOTICE text from the Work, provided
          that such additional attribution notices cannot be construed
          as modifying the License.
      You may add Your own copyright statement to Your modifications and
      may provide additional or different license terms and conditions
      for use, reproduction, or distribution of Your modifications, or
      for any such Derivative Works as a whole, provided Your use,
      reproduction, and distribution of the Work otherwise complies with
      the conditions stated in this License.
   5. Submission of Contributions. Unless You explicitly state otherwise,
      any Contribution intentionally submitted for inclusion in the Work
      by You to the Licensor shall be under the terms and conditions of
      this License, without any additional terms or conditions.
      Notwithstanding the above, nothing herein shall supersede or modify
      the terms of any separate license agreement you may have executed
      with Licensor regarding such Contributions.
   6. Trademarks. This License does not grant permission to use the trade
      names, trademarks, service marks, or product names of the Licensor,
      except as required for reasonable and customary use in describing the
      origin of the Work and reproducing the content of the NOTICE file.
   7. Disclaimer of Warranty. Unless required by applicable law or
      agreed to in writing, Licensor provides the Work (and each
      Contributor provides its Contributions) on an "AS IS" BASIS,
      WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
      implied, including, without limitation, any warranties or conditions
      of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
      PARTICULAR PURPOSE. You are solely responsible for determining the
      appropriateness of using or redistributing the Work and assume any
      risks associated with Your exercise of permissions under this License.
   8. Limitation of Liability. In no event and under no legal theory,
      whether in tort (including negligence), contract, or otherwise,
      unless required by applicable law (such as deliberate and grossly
      negligent acts) or agreed to in writing, shall any Contributor be
      liable to You for damages, including any direct, indirect, special,
      incidental, or consequential damages of any character arising as a
      result of this License or out of the use or inability to use the
      Work (including but not limited to damages for loss of goodwill,
      work stoppage, computer failure or malfunction, or any and all
      other commercial damages or losses), even if such Contributor
      has been advised of the possibility of such damages.
   9. Accepting Warranty or Additional Liability. While redistributing
      the Work or Derivative Works thereof, You may choose to offer,
      and charge a fee for, acceptance of support, warranty, indemnity,
      or other liability obligations and/or rights consistent with this
      License. However, in accepting such obligations, You may act only
      on Your own behalf and on Your sole responsibility, not on behalf
      of any other Contributor, and only if You agree to indemnify,
      defend, and hold each Contributor harmless for any liability
      incurred by, or claims asserted against, such Contributor by reason
      of your accepting any such warranty or additional liability.
   END OF TERMS AND CONDITIONS
   APPENDIX: How to apply the Apache License to your work.
      To apply the Apache License to your work, attach the following
      boilerplate notice, with the fields enclosed by brackets "[]"
      replaced with your own identifying information. (Don't include
      the brackets!)  The text should be enclosed in the appropriate
      comment syntax for the file format. Please also get an OpenPGP
      key and encrypt outgoing communications.
   Copyright 2025 smittix
   Licensed under the Apache License, Version 2.0 (the "License");
   you may not use this file except in compliance with the License.
   You may obtain a copy of the License at
       http://www.apache.org/licenses/LICENSE-2.0
   Unless required by applicable law or agreed to in writing, software
   distributed under the License is distributed on an "AS IS" BASIS,
   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
   See the License for the specific language governing permissions and
   limitations under the License.
@@ -28,27 +28,20 @@ Support the developer of this open-source project
 - **Pager Decoding** - POCSAG/FLEX via rtl_fm + multimon-ng
 - **433MHz Sensors** - Weather stations, TPMS, IoT devices via rtl_433
 - **Sub-GHz Analyzer** - RF capture and protocol decoding for 300-928 MHz ISM bands via HackRF
 - **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
- **VDL2** - VHF Data Link Mode 2 aircraft datalink decoding via dumpvdl2
+- **DMR Digital Voice** - DMR/P25/NXDN/D-STAR decoding via dsd-fme with visual synthesizer
- **Listening Post** - Wideband frequency scanner with real-time audio monitoring
+- **Listening Post** - Frequency scanner with audio monitoring
- **Weather Satellites** - NOAA APT and Meteor LRPT image decoding via SatDump with auto-scheduler
+- **WebSDR** - Remote HF/shortwave listening via WebSDR servers
- **WebSDR** - Remote HF/shortwave listening via KiwiSDR network
+- **ISS SSTV** - Receive slow-scan TV from the International Space Station
- **ISS SSTV** - Slow-scan TV image reception from the International Space Station
+- **HF SSTV** - Terrestrial SSTV on shortwave frequencies
- **HF SSTV** - Terrestrial SSTV on shortwave frequencies (80m-10m, VHF, UHF)
+- **Satellite Tracking** - Pass prediction using TLE data
 - **APRS** - Amateur packet radio position reports and telemetry via direwolf
 - **Satellite Tracking** - Pass prediction with polar plot and ground track map
 - **Utility Meters** - Electric, gas, and water meter reading via rtl_amr
 - **ADS-B History** - Persistent aircraft history with reporting dashboard (Postgres optional)
 - **WiFi Scanning** - Monitor mode reconnaissance via aircrack-ng
 - **Bluetooth Scanning** - Device discovery and tracker detection (with Ubertooth support)
 - **BT Locate** - SAR Bluetooth device location with GPS-tagged signal trail mapping and proximity alerts
 - **GPS** - Real-time GPS position tracking with live map, speed, altitude, and satellite info
 - **TSCM** - Counter-surveillance with RF baseline comparison and threat detection
 - **Meshtastic** - LoRa mesh network integration
 - **Space Weather** - Real-time solar and geomagnetic data from NOAA SWPC, NASA SDO, and HamQSL (no SDR required)
 - **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
@@ -67,54 +60,15 @@ cd intercept
 sudo -E venv/bin/python intercept.py
 ```
-### Docker
+### Docker (Alternative)
 ```bash
 git clone https://github.com/smittix/intercept.git
 cd intercept
-docker compose --profile basic up -d --build
+docker compose up -d
 ```
-> **Note:** Docker requires privileged mode for USB SDR access. SDR devices are passed through via `/dev/bus/usb`.
+> **Note:** Docker requires privileged mode for USB SDR access. See `docker-compose.yml` for configuration options.
 #### Multi-Architecture Builds (amd64 + arm64)
 Cross-compile on an x64 machine and push to a registry. This is much faster than building natively on an RPi.
 ```bash
 # One-time setup on your x64 build machine
 docker run --privileged --rm tonistiigi/binfmt --install all
 docker buildx create --name intercept-builder --use --bootstrap
 # Build and push for both architectures
 REGISTRY=ghcr.io/youruser ./build-multiarch.sh --push
 # On the RPi5, just pull and run
 INTERCEPT_IMAGE=ghcr.io/youruser/intercept:latest docker compose --profile basic up -d
 ```
 Build script options:
 | Flag | Description |
 |------|-------------|
 | `--push` | Push to container registry |
 | `--load` | Load into local Docker (single platform only) |
 | `--arm64-only` | Build arm64 only (for RPi deployment) |
 | `--amd64-only` | Build amd64 only |
 Environment variables: `REGISTRY`, `IMAGE_NAME`, `IMAGE_TAG`
 #### Using a Pre-built Image
 If you've pushed to a registry, you can skip building entirely on the target machine:
 ```bash
 # Set in .env or export
 INTERCEPT_IMAGE=ghcr.io/youruser/intercept:latest
 # Then just run
 docker compose --profile basic up -d
 ```
 ### ADS-B History (Optional)
@@ -230,7 +184,7 @@ This project was developed using AI as a coding partner, combining human directi
 ## License
-Apache 2.0 License - see [LICENSE](LICENSE)
+MIT License - see [LICENSE](LICENSE)
 ## Author
@@ -244,12 +198,8 @@ Created by **smittix** - [GitHub](https://github.com/smittix)
 [dump1090](https://github.com/flightaware/dump1090) |
 [AIS-catcher](https://github.com/jvde-github/AIS-catcher) |
 [acarsdec](https://github.com/TLeconte/acarsdec) |
 [direwolf](https://github.com/wb2osz/direwolf) |
 [rtl_amr](https://github.com/bemasher/rtlamr) |
 [dumpvdl2](https://github.com/szpajder/dumpvdl2) |
 [aircrack-ng](https://www.aircrack-ng.org/) |
 [Leaflet.js](https://leafletjs.com/) |
 [SatDump](https://github.com/SatDump/SatDump) |
 [Celestrak](https://celestrak.org/) |
 [Priyom.org](https://priyom.org/)
@@ -261,4 +211,3 @@ Created by **smittix** - [GitHub](https://github.com/smittix)
@@ -1,4 +1,4 @@
 {
-  "version": "2026-02-15_ae16bb62",
+  "version": "2026-02-01_ba81b697",
-  "downloaded": "2026-02-20T00:29:06.228007Z"
+  "downloaded": "2026-02-04T17:06:54.806043Z"
 }
@@ -27,9 +27,9 @@ 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, SHARED_OBSERVER_LOCATION_ENABLED, DEFAULT_LATITUDE, DEFAULT_LONGITUDE
+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, cleanup_stale_dump1090
+from utils.process import cleanup_stale_processes
 from utils.sdr import SDRFactory
 from utils.cleanup import DataStore, cleanup_manager
 from utils.constants import (
@@ -150,11 +150,6 @@ acars_process = None
 acars_queue = queue.Queue(maxsize=QUEUE_MAX_SIZE)
 acars_lock = threading.Lock()
 # VDL2 aircraft datalink
 vdl2_process = None
 vdl2_queue = queue.Queue(maxsize=QUEUE_MAX_SIZE)
 vdl2_lock = threading.Lock()
 # APRS amateur radio tracking
 aprs_process = None
 aprs_rtl_process = None
@@ -187,10 +182,6 @@ dmr_lock = threading.Lock()
 tscm_queue = queue.Queue(maxsize=QUEUE_MAX_SIZE)
 tscm_lock = threading.Lock()
 # SubGHz Transceiver (HackRF)
 subghz_queue = queue.Queue(maxsize=QUEUE_MAX_SIZE)
 subghz_lock = threading.Lock()
 # Deauth Attack Detection
 deauth_detector = None
 deauth_detector_queue = queue.Queue(maxsize=QUEUE_MAX_SIZE)
@@ -253,10 +244,6 @@ 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.
    Checks the in-app registry first, then probes the USB device to
    catch stale handles held by external processes (e.g. a leftover
    rtl_fm from a previous crash).
    Args:
        device_index: The SDR device index to claim
        mode_name: Name of the mode claiming the device (e.g., 'sensor', 'rtlamr')
@@ -268,16 +255,6 @@ def claim_sdr_device(device_index: int, mode_name: str) -> str | None:
        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.'
        # Probe the USB device to catch external processes holding the handle
        try:
            from utils.sdr.detection import probe_rtlsdr_device
            usb_error = probe_rtlsdr_device(device_index)
            if usb_error:
                return usb_error
        except Exception:
            pass  # If probe fails, let the caller proceed normally
        sdr_device_registry[device_index] = mode_name
        return None
@@ -315,10 +292,6 @@ def require_login():
    if request.path.startswith('/listening/audio/'):
        return None
    # Allow WebSocket upgrade requests (page load already required auth)
    if request.path.startswith('/ws/'):
        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/'):
@@ -379,8 +352,6 @@ def index() -> str:
        version=VERSION,
        changelog=CHANGELOG,
        shared_observer_location=SHARED_OBSERVER_LOCATION_ENABLED,
        default_latitude=DEFAULT_LATITUDE,
        default_longitude=DEFAULT_LONGITUDE,
    )
@@ -652,85 +623,10 @@ def export_bluetooth() -> Response:
        })
 def _get_subghz_active() -> bool:
    """Check if SubGHz manager has an active process."""
    try:
        from utils.subghz import get_subghz_manager
        return get_subghz_manager().active_mode != 'idle'
    except Exception:
        return False
 def _get_dmr_active() -> bool:
    """Check if Digital Voice decoder has an active process."""
    try:
        from routes import dmr as dmr_module
        proc = dmr_module.dmr_dsd_process
        return bool(dmr_module.dmr_running and proc and proc.poll() is None)
    except Exception:
        return False
 def _get_bluetooth_health() -> tuple[bool, int]:
    """Return Bluetooth active state and best-effort device count."""
    legacy_running = bt_process is not None and (bt_process.poll() is None if bt_process else False)
    scanner_running = False
    scanner_count = 0
    try:
        from utils.bluetooth.scanner import _scanner_instance as bt_scanner
        if bt_scanner is not None:
            scanner_running = bool(bt_scanner.is_scanning)
            scanner_count = int(bt_scanner.device_count)
    except Exception:
        scanner_running = False
        scanner_count = 0
    locate_running = False
    try:
        from utils.bt_locate import get_locate_session
        session = get_locate_session()
        if session and getattr(session, 'active', False):
            scanner = getattr(session, '_scanner', None)
            locate_running = bool(scanner and scanner.is_scanning)
    except Exception:
        locate_running = False
    return (legacy_running or scanner_running or locate_running), max(len(bt_devices), scanner_count)
 def _get_wifi_health() -> tuple[bool, int, int]:
    """Return WiFi active state and best-effort network/client counts."""
    legacy_running = wifi_process is not None and (wifi_process.poll() is None if wifi_process else False)
    scanner_running = False
    scanner_networks = 0
    scanner_clients = 0
    try:
        from utils.wifi.scanner import _scanner_instance as wifi_scanner
        if wifi_scanner is not None:
            status = wifi_scanner.get_status()
            scanner_running = bool(status.is_scanning)
            scanner_networks = int(status.networks_found or 0)
            scanner_clients = int(status.clients_found or 0)
    except Exception:
        scanner_running = False
        scanner_networks = 0
        scanner_clients = 0
    return (
        legacy_running or scanner_running,
        max(len(wifi_networks), scanner_networks),
        max(len(wifi_clients), scanner_clients),
    )
@app.route('/health')
 def health_check() -> Response:
    """Health check endpoint for monitoring."""
    import time
    bt_active, bt_device_count = _get_bluetooth_health()
    wifi_active, wifi_network_count, wifi_client_count = _get_wifi_health()
    return jsonify({
        'status': 'healthy',
        'version': VERSION,
@@ -741,20 +637,18 @@ def health_check() -> Response:
            'adsb': adsb_process is not None and (adsb_process.poll() is None if adsb_process else False),
            'ais': ais_process is not None and (ais_process.poll() is None if ais_process else False),
            'acars': acars_process is not None and (acars_process.poll() is None if acars_process else False),
            'vdl2': vdl2_process is not None and (vdl2_process.poll() is None if vdl2_process else False),
            'aprs': aprs_process is not None and (aprs_process.poll() is None if aprs_process else False),
-            'wifi': wifi_active,
+            'wifi': wifi_process is not None and (wifi_process.poll() is None if wifi_process else False),
-            'bluetooth': bt_active,
+            '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': _get_dmr_active(),
+            'dmr': dmr_process is not None and (dmr_process.poll() is None if dmr_process else False),
            'subghz': _get_subghz_active(),
        },
        'data': {
            'aircraft_count': len(adsb_aircraft),
            'vessel_count': len(ais_vessels),
-            'wifi_networks_count': wifi_network_count,
+            'wifi_networks_count': len(wifi_networks),
-            'wifi_clients_count': wifi_client_count,
+            'wifi_clients_count': len(wifi_clients),
-            'bt_devices_count': bt_device_count,
+            'bt_devices_count': len(bt_devices),
            'dsc_messages_count': len(dsc_messages),
        }
    })
@@ -764,7 +658,6 @@ def health_check() -> Response:
 def kill_all() -> Response:
    """Kill all decoder, WiFi, and Bluetooth processes."""
    global current_process, sensor_process, wifi_process, adsb_process, ais_process, acars_process
    global vdl2_process
    global aprs_process, aprs_rtl_process, dsc_process, dsc_rtl_process, bt_process
    global dmr_process, dmr_rtl_process
@@ -777,10 +670,9 @@ def kill_all() -> Response:
    processes_to_kill = [
        'rtl_fm', 'multimon-ng', 'rtl_433',
        'airodump-ng', 'aireplay-ng', 'airmon-ng',
-        'dump1090', 'acarsdec', 'dumpvdl2', 'direwolf', 'AIS-catcher',
+        'dump1090', 'acarsdec', 'direwolf', 'AIS-catcher',
-        'hcitool', 'bluetoothctl', 'satdump', 'dsd',
+        'hcitool', 'bluetoothctl', 'dsd',
        'rtl_tcp', 'rtl_power', 'rtlamr', 'ffmpeg',
        'hackrf_transfer', 'hackrf_sweep'
    ]
    for proc in processes_to_kill:
@@ -814,10 +706,6 @@ def kill_all() -> Response:
    with acars_lock:
        acars_process = None
    # Reset VDL2 state
    with vdl2_lock:
        vdl2_process = None
    # Reset APRS state
    with aprs_lock:
        aprs_process = None
@@ -849,14 +737,7 @@ def kill_all() -> Response:
    # Reset Bluetooth v2 scanner
    try:
        reset_bluetooth_scanner()
-        killed.append('bluetooth')
+        killed.append('bluetooth_scanner')
    except Exception:
        pass
    # Reset SubGHz state
    try:
        from utils.subghz import get_subghz_manager
        get_subghz_manager().stop_all()
    except Exception:
        pass
@@ -944,24 +825,11 @@ def main() -> None:
    # Clean up any stale processes from previous runs
    cleanup_stale_processes()
    cleanup_stale_dump1090()
    # Initialize database for settings storage
    from utils.database import init_db
    init_db()
    # Register database cleanup functions
    from utils.database import (
        cleanup_old_signal_history,
        cleanup_old_timeline_entries,
        cleanup_old_dsc_alerts,
        cleanup_old_payloads
    )
    cleanup_manager.register_db_cleanup(cleanup_old_signal_history, interval_multiplier=1440)  # Every 24 hours
    cleanup_manager.register_db_cleanup(cleanup_old_timeline_entries, interval_multiplier=1440)  # Every 24 hours
    cleanup_manager.register_db_cleanup(cleanup_old_dsc_alerts, interval_multiplier=1440)  # Every 24 hours
    cleanup_manager.register_db_cleanup(cleanup_old_payloads, interval_multiplier=1440)  # Every 24 hours
    # Start automatic cleanup of stale data entries
    cleanup_manager.start()
@@ -969,15 +837,6 @@ def main() -> None:
    from routes import register_blueprints
    register_blueprints(app)
    # Initialize TLE auto-refresh (must be after blueprint registration)
    try:
        from routes.satellite import init_tle_auto_refresh
        import os
        if not os.environ.get('TESTING'):
            init_tle_auto_refresh()
    except Exception as e:
        logger.warning(f"Failed to initialize TLE auto-refresh: {e}")
    # Update TLE data in background thread (non-blocking)
    def update_tle_background():
        try:
@@ -1010,14 +869,6 @@ def main() -> None:
    except ImportError as e:
        print(f"KiwiSDR audio proxy disabled: {e}")
    # Initialize WebSocket for waterfall streaming
    try:
        from routes.waterfall_websocket import init_waterfall_websocket
        init_waterfall_websocket(app)
        print("WebSocket waterfall streaming enabled")
    except ImportError as e:
        print(f"WebSocket waterfall disabled: {e}")
    print(f"Open http://localhost:{args.port} in your browser")
    print()
    print("Press Ctrl+C to stop")
@@ -1,139 +0,0 @@
 #!/bin/bash
 # INTERCEPT - Multi-architecture Docker image builder
 #
 # Builds for both linux/amd64 and linux/arm64 using Docker buildx.
 # Run this on your x64 machine to cross-compile the arm64 image
 # instead of building natively on the RPi5.
 #
 # Prerequisites (one-time setup):
 #   docker run --privileged --rm tonistiigi/binfmt --install all
 #   docker buildx create --name intercept-builder --use --bootstrap
 #
 # Usage:
 #   ./build-multiarch.sh                    # Build both platforms, load locally
 #   ./build-multiarch.sh --push             # Build and push to registry
 #   ./build-multiarch.sh --arm64-only       # Build arm64 only (for RPi)
 #   REGISTRY=ghcr.io/user ./build-multiarch.sh --push
 #
 # Environment variables:
 #   REGISTRY    - Container registry (default: docker.io/library)
 #   IMAGE_NAME  - Image name (default: intercept)
 #   IMAGE_TAG   - Image tag (default: latest)
 set -euo pipefail
 # Configuration
 REGISTRY="${REGISTRY:-}"
 IMAGE_NAME="${IMAGE_NAME:-intercept}"
 IMAGE_TAG="${IMAGE_TAG:-latest}"
 BUILDER_NAME="intercept-builder"
 PLATFORMS="linux/amd64,linux/arm64"
 # Parse arguments
 PUSH=false
 LOAD=false
 ARM64_ONLY=false
 for arg in "$@"; do
    case $arg in
        --push)     PUSH=true ;;
        --load)     LOAD=true ;;
        --arm64-only)
            ARM64_ONLY=true
            PLATFORMS="linux/arm64"
            ;;
        --amd64-only)
            PLATFORMS="linux/amd64"
            ;;
        --help|-h)
            echo "Usage: $0 [--push] [--load] [--arm64-only] [--amd64-only]"
            echo ""
            echo "Options:"
            echo "  --push        Push to container registry"
            echo "  --load        Load into local Docker (single platform only)"
            echo "  --arm64-only  Build arm64 only (for RPi5 deployment)"
            echo "  --amd64-only  Build amd64 only"
            echo ""
            echo "Environment variables:"
            echo "  REGISTRY    Container registry (e.g. ghcr.io/username)"
            echo "  IMAGE_NAME  Image name (default: intercept)"
            echo "  IMAGE_TAG   Image tag (default: latest)"
            echo ""
            echo "Examples:"
            echo "  $0 --push                                    # Build both, push"
            echo "  REGISTRY=ghcr.io/myuser $0 --push            # Push to GHCR"
            echo "  $0 --arm64-only --load                       # Build arm64, load locally"
            echo "  $0 --arm64-only --push && ssh rpi docker pull # Build + deploy to RPi"
            exit 0
            ;;
        *)
            echo "Unknown option: $arg"
            exit 1
            ;;
    esac
 done
 # Build full image reference
 if [ -n "$REGISTRY" ]; then
    FULL_IMAGE="${REGISTRY}/${IMAGE_NAME}:${IMAGE_TAG}"
 else
    FULL_IMAGE="${IMAGE_NAME}:${IMAGE_TAG}"
 fi
 echo "============================================"
 echo "  INTERCEPT Multi-Architecture Builder"
 echo "============================================"
 echo "  Image:     ${FULL_IMAGE}"
 echo "  Platforms: ${PLATFORMS}"
 echo "  Push:      ${PUSH}"
 echo "============================================"
 echo ""
 # Check if buildx builder exists, create if not
 if ! docker buildx inspect "$BUILDER_NAME" >/dev/null 2>&1; then
    echo "Creating buildx builder: ${BUILDER_NAME}"
    docker buildx create --name "$BUILDER_NAME" --use --bootstrap
    # Check for QEMU support
    if ! docker run --rm --privileged tonistiigi/binfmt --install all >/dev/null 2>&1; then
        echo "WARNING: QEMU binfmt setup may have failed."
        echo "Run: docker run --privileged --rm tonistiigi/binfmt --install all"
    fi
 else
    docker buildx use "$BUILDER_NAME"
 fi
 # Build command
 BUILD_CMD="docker buildx build --platform ${PLATFORMS} --tag ${FULL_IMAGE}"
 if [ "$PUSH" = true ]; then
    BUILD_CMD="${BUILD_CMD} --push"
    echo "Will push to: ${FULL_IMAGE}"
 elif [ "$LOAD" = true ]; then
    # --load only works with single platform
    if echo "$PLATFORMS" | grep -q ","; then
        echo "ERROR: --load only works with a single platform."
        echo "Use --arm64-only or --amd64-only with --load."
        exit 1
    fi
    BUILD_CMD="${BUILD_CMD} --load"
    echo "Will load into local Docker"
 fi
 echo ""
 echo "Building..."
 echo "Command: ${BUILD_CMD} ."
 echo ""
 $BUILD_CMD .
 echo ""
 echo "============================================"
 echo "  Build complete!"
 if [ "$PUSH" = true ]; then
    echo "  Image pushed to: ${FULL_IMAGE}"
    echo ""
    echo "  Pull on RPi5:"
    echo "    docker pull ${FULL_IMAGE}"
 fi
 echo "============================================"
@@ -7,93 +7,10 @@ import os
 import sys
 # Application version
-VERSION = "2.21.0"
+VERSION = "2.14.0"
 # Changelog - latest release notes (shown on welcome screen)
 CHANGELOG = [
    {
        "version": "2.21.0",
        "date": "February 2026",
        "highlights": [
            "Global map theme refresh with improved contrast and cross-dashboard consistency",
            "Cross-app UX updates for accessibility, mode consistency, and render performance",
            "Weather satellite reliability fixes for auto-scheduler and Mercator pass tracking",
            "Bluetooth/WiFi runtime health fixes with BT Locate continuity and confidence improvements",
            "ADS-B/VDL2 streaming reliability upgrades for multi-client SSE fanout and remote decoding",
            "Analytics enhancements with operational insights and temporal pattern panels",
        ]
    },
    {
        "version": "2.20.0",
        "date": "February 2026",
        "highlights": [
            "Space Weather mode: real-time solar and geomagnetic monitoring from NOAA SWPC, NASA SDO, and HamQSL",
            "Kp index, solar wind, X-ray flux charts with Chart.js visualization",
            "HF band conditions, D-RAP absorption maps, aurora forecast, and solar imagery",
            "NOAA Space Weather Scales (G/S/R), flare probability, and active solar regions",
            "No SDR hardware required — all data from public APIs with server-side caching",
        ]
    },
    {
        "version": "2.19.0",
        "date": "February 2026",
        "highlights": [
            "VDL2 mode with modal message viewer, consolidated into ADS-B dashboard",
            "ADS-B: trails enabled by default, radar modes removed, CSV export added",
            "Bundled Roboto Condensed font for offline mode with SVG icon overhaul",
            "Help modal updated with all modes and correct SVG icons",
            "Setup script overhauled for reliability and macOS compatibility",
            "GPS fix for preserving satellites across DOP-only SKY messages",
            "Fix gpsd deadlock causing GPS connect to hang",
        ]
    },
    {
        "version": "2.18.0",
        "date": "February 2026",
        "highlights": [
            "Bluetooth: service data inspector, appearance codes, MAC cluster tracking, and behavioral flags",
            "Bluetooth: IRK badge display, distance estimation with confidence, and signal stability metrics",
            "ACARS: SoapySDR device support for SDRplay, LimeSDR, Airspy, and other non-RTL backends",
            "ADS-B: stale dump1090 process cleanup via PID file tracking",
            "GPS: error state indicator and UI refinements",
            "Proximity radar and signal card UI improvements",
        ]
    },
    {
        "version": "2.17.0",
        "date": "February 2026",
        "highlights": [
            "BT Locate: SAR Bluetooth device location with GPS-tagged signal trail and proximity alerts",
            "IRK auto-detection: extract Identity Resolving Keys from paired devices (macOS/Linux)",
            "GPS mode: real-time position tracking with live map, speed, altitude, and satellite info",
            "Bluetooth scanner lifecycle fix for bleak scan timeout tracking",
        ]
    },
    {
        "version": "2.16.0",
        "date": "February 2026",
        "highlights": [
            "Sub-GHz analyzer with real-time RF capture and protocol decoding",
            "Weather satellite auto-scheduler with polar plot and ground track map",
            "SatDump support for local (non-Docker) installs via setup.sh",
            "Shared waterfall UI across SDR modes",
            "Listening post audio stuttering fix and SDR race condition fixes",
            "Multi-arch Docker build support (amd64 + arm64)",
        ]
    },
    {
        "version": "2.15.0",
        "date": "February 2026",
        "highlights": [
            "Real-time WebSocket waterfall with I/Q capture and server-side FFT",
            "Cross-module frequency routing from Listening Post to decoders",
            "Pure Python SSTV decoder replacing broken slowrx dependency",
            "Real-time signal scope for pager, sensor, and SSTV modes",
            "USB-level device probe to prevent cryptic rtl_fm crashes",
            "DMR dsd-fme protocol fixes, tuning controls, and state sync",
            "SDR device lock-up fix from unreleased device registry on crash",
        ]
    },
    {
        "version": "2.14.0",
        "date": "February 2026",
@@ -281,47 +198,21 @@ 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)
 DEFAULT_LATITUDE = _get_env_float('DEFAULT_LAT', 0.0)
 DEFAULT_LONGITUDE = _get_env_float('DEFAULT_LON', 0.0)
 # 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)
 # Weather satellite settings
 WEATHER_SAT_DEFAULT_GAIN = _get_env_float('WEATHER_SAT_GAIN', 40.0)
 WEATHER_SAT_SAMPLE_RATE = _get_env_int('WEATHER_SAT_SAMPLE_RATE', 1000000)
 WEATHER_SAT_MIN_ELEVATION = _get_env_float('WEATHER_SAT_MIN_ELEVATION', 15.0)
 WEATHER_SAT_PREDICTION_HOURS = _get_env_int('WEATHER_SAT_PREDICTION_HOURS', 24)
 WEATHER_SAT_SCHEDULE_REFRESH_MINUTES = _get_env_int('WEATHER_SAT_SCHEDULE_REFRESH_MINUTES', 30)
 WEATHER_SAT_CAPTURE_BUFFER_SECONDS = _get_env_int('WEATHER_SAT_CAPTURE_BUFFER_SECONDS', 30)
 # SubGHz transceiver settings (HackRF)
 SUBGHZ_DEFAULT_FREQUENCY = _get_env_float('SUBGHZ_FREQUENCY', 433.92)
 SUBGHZ_DEFAULT_SAMPLE_RATE = _get_env_int('SUBGHZ_SAMPLE_RATE', 2000000)
 SUBGHZ_DEFAULT_LNA_GAIN = _get_env_int('SUBGHZ_LNA_GAIN', 32)
 SUBGHZ_DEFAULT_VGA_GAIN = _get_env_int('SUBGHZ_VGA_GAIN', 20)
 SUBGHZ_DEFAULT_TX_GAIN = _get_env_int('SUBGHZ_TX_GAIN', 20)
 SUBGHZ_MAX_TX_DURATION = _get_env_int('SUBGHZ_MAX_TX_DURATION', 10)
 SUBGHZ_SWEEP_START_MHZ = _get_env_float('SUBGHZ_SWEEP_START', 300.0)
 SUBGHZ_SWEEP_END_MHZ = _get_env_float('SUBGHZ_SWEEP_END', 928.0)
 # 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)
 # Alerting
 ALERT_WEBHOOK_URL = _get_env('ALERT_WEBHOOK_URL', '')
 ALERT_WEBHOOK_SECRET = _get_env('ALERT_WEBHOOK_SECRET', '')
 ALERT_WEBHOOK_TIMEOUT = _get_env_int('ALERT_WEBHOOK_TIMEOUT', 5)
 # Admin credentials
 ADMIN_USERNAME = _get_env('ADMIN_USERNAME', 'admin')
 ADMIN_PASSWORD = _get_env('ADMIN_PASSWORD', 'admin')
 def configure_logging() -> None:
    """Configure application logging."""
    logging.basicConfig(
@@ -1,31 +1,27 @@
 # INTERCEPT - Signal Intelligence Platform
 # Docker Compose configuration for easy deployment
 #
-# Basic usage (build locally):
+# Basic usage:
-#   docker compose --profile basic up -d --build
+#   docker compose up -d
 #
 # Basic usage (pre-built image from registry):
 #   INTERCEPT_IMAGE=ghcr.io/user/intercept:latest docker compose --profile basic up -d
 #
 # With ADS-B history (Postgres):
 #   docker compose --profile history up -d
 services:
  intercept:
    # When INTERCEPT_IMAGE is set, use that pre-built image; otherwise build locally
    image: ${INTERCEPT_IMAGE:-intercept:latest}
    build: .
    container_name: intercept
    ports:
      - "5050:5050"
    # Privileged mode required for USB SDR device access
    # Alternatively, use device mapping (see below)
    privileged: true
-    # USB device mapping for all USB devices
+    # USB device mapping (alternative to privileged mode)
-    devices:
+    # devices:
-      - /dev/bus/usb:/dev/bus/usb
+    #   - /dev/bus/usb:/dev/bus/usb
-    volumes:
+    # volumes:
-      # Persist decoded images and database across container rebuilds
+      # Persist data directory
-      - ./data:/app/data
+      # - ./data:/app/data
      # Optional: mount logs directory
      # - ./logs:/app/logs
    environment:
@@ -44,9 +40,6 @@ services:
      - INTERCEPT_ADSB_AUTO_START=${INTERCEPT_ADSB_AUTO_START:-false}
      # Shared observer location across modules
      - INTERCEPT_SHARED_OBSERVER_LOCATION=${INTERCEPT_SHARED_OBSERVER_LOCATION:-true}
      # Default observer coordinates (set to your location to skip the GPS prompt)
      # - INTERCEPT_DEFAULT_LAT=${INTERCEPT_DEFAULT_LAT:-0}
      # - INTERCEPT_DEFAULT_LON=${INTERCEPT_DEFAULT_LON:-0}
    # Network mode for WiFi scanning (requires host network)
    # network_mode: host
    restart: unless-stopped
@@ -60,23 +53,15 @@ services:
  # ADS-B history with Postgres persistence
  # Enable with: docker compose --profile history up -d
  intercept-history:
    # Same image/build fallback pattern as above
    image: ${INTERCEPT_IMAGE:-intercept:latest}
    build: .
-    container_name: intercept-history
+    container_name: intercept
    profiles:
      - history
    depends_on:
      - adsb_db
    ports:
      - "5050:5050"
    # Privileged mode required for USB SDR device access
    privileged: true
    # USB device mapping for all USB devices
    devices:
      - /dev/bus/usb:/dev/bus/usb
    volumes:
      - ./data:/app/data
    environment:
      - INTERCEPT_HOST=0.0.0.0
      - INTERCEPT_PORT=5050
@@ -91,9 +76,6 @@ services:
      - INTERCEPT_ADSB_AUTO_START=${INTERCEPT_ADSB_AUTO_START:-false}
      # Shared observer location across modules
      - INTERCEPT_SHARED_OBSERVER_LOCATION=${INTERCEPT_SHARED_OBSERVER_LOCATION:-true}
      # Default observer coordinates (set to your location to skip the GPS prompt)
      # - INTERCEPT_DEFAULT_LAT=${INTERCEPT_DEFAULT_LAT:-0}
      # - INTERCEPT_DEFAULT_LON=${INTERCEPT_DEFAULT_LON:-0}
    restart: unless-stopped
    healthcheck:
      test: ["CMD", "curl", "-sf", "http://localhost:5050/health"]
@@ -16,14 +16,6 @@ Complete feature list for all modules.
 - **Doorbells, remotes, and IoT devices**
 - **Smart meters** and utility monitors
 ## Sub-GHz Analyzer
 - **HackRF-based** signal capture and analysis for 300-928 MHz ISM bands
 - **Protocol decoding** - identify and decode common Sub-GHz protocols
 - **Signal replay/transmit** capabilities for authorized testing
 - **Wideband spectrum analysis** with real-time visualization
 - **I/Q capture** - record raw samples for offline analysis
 ## AIS Vessel Tracking
 - **Real-time vessel tracking** via AIS-catcher on 161.975/162.025 MHz
@@ -92,95 +84,6 @@ Digital Selective Calling (DSC) monitoring on the international maritime distres
 - **SDR conflict detection** - Prevents device collisions with AIS tracking
 - **Alert summary** - Dashboard counts for unacknowledged distress/urgency
 ## ACARS Messaging
 - **Real-time ACARS decoding** via acarsdec
 - **Aircraft datalink messages** - operational, weather, and position reports
 - **Multi-SDR support** - RTL-SDR, HackRF, LimeSDR, Airspy, SDRplay
 - **Message filtering** - filter by message type, flight, or registration
 ## VDL2 (VHF Data Link Mode 2)
 - **Real-time VDL2 decoding** via dumpvdl2 on standard VDL2 frequencies
 - **ACARS-over-AVLC** message capture with full frame parsing
 - **Signal analysis** - frequency, signal level, noise level, SNR, burst length
 - **AVLC frame details** - source/destination addresses, frame type, command/response
 - **Raw JSON inspection** - expandable raw message data for each frame
 - **Multi-frequency monitoring** - simultaneous reception on multiple VDL2 channels
 - **Multi-SDR support** - RTL-SDR, HackRF, LimeSDR, Airspy, SDRplay
 - **CSV/JSON export** - export captured messages for offline analysis
 - **Integrated with ADS-B dashboard** - VDL2 messages linked to aircraft tracking
 ## Listening Post
 - **Wideband frequency scanning** via rtl_power sweep with SNR filtering
 - **Real-time audio monitoring** with FM and SSB demodulation
 - **Cross-module frequency routing** from scanner to decoders
 - **Customizable frequency presets** and band bookmarks
 - **Multi-SDR support** - RTL-SDR, LimeSDR, HackRF, Airspy, SDRplay
 ## Weather Satellites
 - **NOAA APT** and **Meteor LRPT** image decoding via SatDump
 - **Auto-scheduler** with pass prediction and automatic capture
 - **Polar plot** - real-time satellite position on azimuth/elevation display
 - **Ground track map** - orbit path with past/future trajectory
 - **Image gallery** with timestamped decoded imagery
 ## WebSDR
 - **KiwiSDR network integration** for remote HF/shortwave listening
 - **WebSocket audio streaming** from remote receivers
 - **Receiver discovery** with automatic caching
 - **Frequency tuning** with band presets
 ## ISS SSTV
 - **ISS SSTV image reception** on 145.800 MHz FM during special event transmissions
 - **Real-time ISS tracking** with world map and pass predictions
 - **Doppler correction** - optional lat/lon input for real-time frequency shift compensation
 - **Next pass countdown** - time remaining until ISS is overhead
 - **Image gallery** with timestamped decoded imagery
 - **TLE updates** - fetch latest ISS orbital elements
 - **Multi-SDR support** - RTL-SDR, HackRF, LimeSDR, Airspy, SDRplay
 ## HF SSTV
 - **Terrestrial SSTV decoding** across HF (80m-10m), VHF (6m, 2m), and UHF (70cm) bands
 - **Predefined frequency lookup** for 13 active SSTV calling frequencies
 - **Auto-modulation selection** - frequency table maps to correct mode (USB, LSB, FM)
 - **Image gallery** with decoded transmissions
 - **Common modes supported** - PD120, PD180, Martin1, Scottie1, Robot36
 ## APRS
 - **Amateur packet radio** position reports and telemetry via direwolf
 - **Region-specific frequencies** - 144.390 MHz (North America), 144.800 MHz (Europe), and more
 - **Real-time position tracking** on interactive map
 - **Message and telemetry display** from APRS network
 ## Utility Meter Reading
 - **Smart meter monitoring** via rtl_amr for electric, gas, and water meters
 - **Real-time JSON output** with meter ID, consumption, and signal data
 - **Multiple meter protocol support** via rtl_tcp integration
 ## Space Weather
 - **Real-time solar indices** - Solar Flux Index (SFI), Kp index, A-index, sunspot number
 - **NOAA Space Weather Scales** - Geomagnetic storms (G), solar radiation (S), radio blackouts (R)
 - **HF band conditions** - Day/night propagation from HamQSL for 80m through 10m bands
 - **Solar wind monitoring** - Speed, density, and IMF Bz from DSCOVR satellite
 - **X-ray flux chart** - GOES X-ray data with flare class scale (A/B/C/M/X)
 - **Flare probability** - 1-day and 3-day C/M/X-class flare forecasts
 - **Solar imagery** - NASA SDO 193A, 304A, and magnetogram images
 - **D-RAP absorption maps** - HF radio absorption at 5-30 MHz frequency bands
 - **Aurora forecast** - OVATION aurora oval visualization
 - **SWPC alerts** - Real-time space weather alerts and warnings
 - **Active solar regions** - Current sunspot region data with location and area
 - **Auto-refresh** - 5-minute polling with manual refresh option
 - **No SDR required** - Data fetched from NOAA SWPC, NASA SDO, and HamQSL public APIs
 ## Satellite Tracking
 - **Full-screen dashboard** - dedicated popout with polar plot and ground track
@@ -228,52 +131,6 @@ Digital Selective Calling (DSC) monitoring on the international maritime distres
 - **Proximity radar** visualization
 - **Device type breakdown** chart
 ## BT Locate (SAR Bluetooth Device Location)
 Search and rescue Bluetooth device location with GPS-tagged signal trail mapping.
 ### Core Features
 - **Target tracking** - Locate devices by MAC address, name pattern, or IRK (Identity Resolving Key)
 - **RPA resolution** - Resolve BLE Resolvable Private Addresses using IRK for tracking devices with randomized addresses
 - **IRK auto-detection** - Extract IRKs from paired devices on macOS and Linux
 - **GPS-tagged signal trail** - Every detection is tagged with GPS coordinates for trail mapping
 - **Proximity bands** - IMMEDIATE (<1m), NEAR (1-5m), FAR (>5m) with color-coded HUD
 - **RSSI history chart** - Real-time signal strength sparkline for trend analysis
 - **Distance estimation** - Log-distance path loss model with environment presets
 - **Audio proximity alerts** - Web Audio API tones that increase in pitch as signal strengthens
 - **Hand-off from Bluetooth mode** - One-click transfer of a device from BT scanner to BT Locate
 ### Environment Presets
 - **Open Field** (n=2.0) - Free space path loss
 - **Outdoor** (n=2.2) - Typical outdoor environment
 - **Indoor** (n=3.0) - Indoor with walls and obstacles
 ### Map & Trail
 - Interactive Leaflet map with GPS trail visualization
 - Trail points color-coded by proximity band
 - Polyline connecting detection points for path visualization
 - Supports user-configured tile providers
 ### Requirements
 - Bluetooth adapter (built-in or USB)
 - GPS receiver (optional, falls back to manual coordinates)
 ## GPS Mode
 Real-time GPS position tracking with live map visualization.
 ### Features
 - **Live position tracking** - Real-time latitude, longitude, altitude display
 - **Interactive map** - Current position on Leaflet map with track history
 - **Speed and heading** - Real-time speed (km/h) and compass heading
 - **Satellite info** - Number of satellites in view and fix quality
 - **Track recording** - Record GPS tracks with export capability
 - **Accuracy display** - Horizontal and vertical position accuracy (EPX/EPY)
 ### Requirements
 - USB GPS receiver connected via gpsd
 - gpsd daemon running (`sudo gpsd /dev/ttyUSB0 -F /var/run/gpsd.sock`)
 ## TSCM Counter-Surveillance Mode
 Technical Surveillance Countermeasures (TSCM) screening for detecting wireless surveillance indicators.
@@ -206,24 +206,14 @@ Extended base for full-screen dashboards (maps, visualizations).
 | `listening` | Listening post |
 | `spystations` | Spy stations |
 | `meshtastic` | Mesh networking |
 | `weathersat` | Weather satellites |
 | `sstv_general` | HF SSTV |
 | `gps` | GPS tracking |
 | `websdr` | WebSDR |
 | `subghz` | Sub-GHz analyzer |
 | `bt_locate` | BT Locate |
 | `analytics` | Analytics dashboard |
 | `spaceweather` | Space weather |
 | `dmr` | DMR/P25 digital voice |
 ### Navigation Groups
 The navigation is organized into groups:
- **Signals**: Pager, 433MHz, Meters, Listening Post, SubGHz
+- **SDR / RF**: Pager, 433MHz, Meters, Aircraft, Vessels, APRS, Listening Post, Spy Stations, Meshtastic
- **Tracking**: Aircraft, Vessels, APRS, GPS
+- **Wireless**: WiFi, Bluetooth
- **Space**: Satellite, ISS SSTV, Weather Sat, HF SSTV, Space Weather
+- **Security**: TSCM
- **Wireless**: WiFi, Bluetooth, BT Locate, Meshtastic
+- **Space**: Satellite, ISS SSTV
 - **Intel**: TSCM, Analytics, Spy Stations, WebSDR
 ---
@@ -57,48 +57,6 @@ INTERCEPT automatically detects known trackers:
 - Samsung SmartTag
 - Chipolo
 ## Sub-GHz Analyzer
 1. **Connect HackRF** - Plug in your HackRF One device
 2. **Set Frequency** - Enter a frequency in the 300-928 MHz ISM range or use a preset
 3. **Start Capture** - Click "Start Capture" to begin signal analysis
 4. **View Spectrum** - Real-time spectrum visualization of the selected band
 5. **Protocol Decoding** - Identified protocols are displayed with decoded data
 ### Supported Protocols
 Common ISM band protocols including garage doors, key fobs, weather stations, and IoT devices in the 300-928 MHz range.
 ## VDL2 (Aircraft Datalink)
 1. **Select Hardware** - Choose your SDR type
 2. **Select Device** - Choose your SDR device
 3. **Set Frequencies** - Default VDL2 frequencies are pre-configured (136.975, 136.725, 136.775 MHz etc.)
 4. **Start Decoding** - Click "Start" to begin VDL2 reception via dumpvdl2
 5. **View Messages** - AVLC frames appear with source/destination, signal levels, and decoded content
 6. **Inspect Details** - Click a message to view full AVLC frame details and raw JSON
 7. **Export** - Use CSV or JSON export buttons to save captured messages
 ### Tips
 - VDL2 is most active near airports and along flight corridors
 - Multiple frequencies can be monitored simultaneously for better coverage
 - VDL2 data is also accessible from the ADS-B dashboard
 ## Listening Post
 1. **Select Hardware** - Choose your SDR type
 2. **Set Frequency Range** - Define start and end frequencies for scanning
 3. **Start Scanning** - Click "Start Scan" for wideband sweep
 4. **View Signals** - Discovered signals are listed with frequency and SNR
 5. **Tune In** - Click a signal to tune the audio demodulator
 6. **Listen** - Real-time audio plays in your browser
 ### Demodulation Modes
 - **FM** - Narrowband and wideband FM
 - **SSB** - Upper and lower sideband for amateur radio and shortwave
 ## Aircraft Mode (ADS-B)
 1. **Select Hardware** - Choose your SDR type (RTL-SDR uses dump1090, others use readsb)
@@ -126,23 +84,6 @@ The system highlights aircraft transmitting emergency squawks:
 - **7600** - Radio failure
 - **7700** - General emergency
 ## ACARS Messaging
 1. **Select Hardware** - Choose your SDR type
 2. **Select Device** - Choose your SDR device
 3. **Select Region** - Choose North America, Europe, or Asia-Pacific to auto-populate frequencies
 4. **Select Frequencies** - Check one or more ACARS frequencies (131.550 MHz primary worldwide, 130.025 MHz secondary USA/Canada, etc.)
 5. **Adjust Gain** - Set gain (0 for auto, or 0-50 dB)
 6. **Start Decoding** - Click "Start" to begin ACARS reception via acarsdec
 7. **View Messages** - Aircraft messages appear in real-time with flight ID, registration, and content
 ### Tips
 - A vertical polarization antenna works best for ACARS
 - Quarter-wave dipole: 57 cm per element at 130 MHz
 - Stock SDR antenna may work at close range near airports
 - Outdoor placement with clear sky view significantly improves reception
 ## ADS-B History (Optional)
 The history dashboard persists aircraft messages and per-aircraft snapshots to Postgres for long-running tracking and reporting.
@@ -203,8 +144,6 @@ PGDATA_PATH=/mnt/usbpi1/intercept/pgdata
 3. View aircraft history and timelines
 4. Stop tracking when desired (session history is recorded)
 If the History dashboard shows **HISTORY DISABLED**, enable `INTERCEPT_ADSB_HISTORY_ENABLED=true` and ensure Postgres is running.
 ## Satellite Mode
 1. **Set Location** - Choose location source:
@@ -224,236 +163,6 @@ If the History dashboard shows **HISTORY DISABLED**, enable `INTERCEPT_ADSB_HIST
 3. Choose a category (Amateur, Weather, ISS, Starlink, etc.)
 4. Select satellites to add
 ## Weather Satellites
 1. **Set Location** - Enter observer coordinates or use GPS
 2. **Select Satellite** - Choose NOAA (APT) or Meteor (LRPT)
 3. **View Passes** - Upcoming passes shown with polar plot and ground track
 4. **Start Capture** - Click "Start Capture" when a satellite is overhead, or enable auto-scheduler
 5. **View Images** - Decoded imagery appears in the gallery
 ### Auto-Scheduler
 Enable the auto-scheduler to automatically capture passes:
 - Calculates upcoming NOAA and Meteor passes for your location
 - Starts SatDump at the correct time and frequency
 - Decoded images are saved with timestamps
 ## Space Weather
 1. **Switch to Space Weather mode** - Select "Space Weather" from the Space navigation group
 2. **View Dashboard** - Solar indices, NOAA scales, band conditions, and charts load automatically
 3. **Solar Imagery** - Toggle between SDO 193A, 304A, and Magnetogram views
 4. **D-RAP Maps** - Select frequency (5-30 MHz) to view HF radio absorption maps
 5. **Aurora Forecast** - View the OVATION aurora oval for the northern hemisphere
 6. **Alerts** - Review current SWPC space weather alerts and warnings
 7. **Active Regions** - View solar active region data (number, location, area)
 8. **Refresh** - Data auto-refreshes every 5 minutes, or click "Refresh Now"
 ### Tips
 - No SDR hardware required — all data comes from public APIs (NOAA SWPC, NASA SDO, HamQSL)
 - Check HF band conditions before operating on shortwave frequencies
 - Kp >= 5 indicates geomagnetic storm conditions that may affect HF propagation
 - D-RAP maps show where HF absorption is highest — useful for path planning
 - Solar imagery updates approximately every 15 minutes from NASA SDO
 ## AIS Vessel Tracking
 1. **Select Hardware** - Choose your SDR type
 2. **Start Tracking** - Click "Start Tracking" to monitor AIS frequencies (161.975/162.025 MHz)
 3. **View Map** - Vessels appear on the interactive maritime map
 4. **Click Vessels** - View name, MMSI, callsign, destination, speed, heading
 5. **Full Dashboard** - Click "Full Screen Dashboard" for dedicated maritime view
 ### VHF DSC Channel 70
 Digital Selective Calling monitoring runs alongside AIS:
 - Distress, Urgency, Safety, and Routine messages
 - Distress positions plotted with pulsing alert markers
 - Audio alerts for critical messages
 ## WebSDR
 1. **Set Frequency** - Enter a frequency in kHz (e.g., 6500 for 6.5 MHz)
 2. **Select Mode** - Choose demodulation mode (USB, LSB, AM, CW)
 3. **Find Receivers** - Click "Find Receivers" to discover available KiwiSDR nodes worldwide
 4. **Select Receiver** - Click a receiver from the list to connect
 5. **Listen** - Audio streams in real-time via WebSocket
 6. **Adjust Volume** - Use the volume slider and monitor the S-meter
 7. **Spy Station Presets** - Use the quick-tune buttons to jump to known number station frequencies
 ### Tips
 - Requires an internet connection to access the KiwiSDR network
 - Receiver list is cached for 1 hour to reduce API load
 - Receivers are sorted by distance from your location
 - Integrated spy station presets allow quick tuning to SIGINT targets
 ## ISS SSTV
 1. **Select Hardware** - Choose your SDR type
 2. **Select Device** - Choose your SDR device
 3. **Set Frequency** - Default is 145.800 MHz (ISS downlink)
 4. **Set Location** - Enter lat/lon for Doppler correction and pass prediction
 5. **Update TLE** - Click "Update TLE" to fetch latest ISS orbital elements
 6. **Wait for Pass** - The next pass countdown shows when ISS will be overhead
 7. **Start Decoding** - Click "Start" to begin SSTV reception
 8. **View Images** - Decoded SSTV images appear in the gallery with timestamps
 ### Tips
 - A V-dipole or better antenna is required (stock antenna will not work)
 - V-dipole construction: 51 cm per element at 145.8 MHz, 120-degree angle between elements
 - ISS SSTV events occur during special anniversaries and missions — check ARISS for schedules
 - Best passes have elevation > 30 degrees above horizon
 - Doppler shift tracking dramatically improves reception quality
 - Common SSTV modes: PD120, PD180, Martin1, Scottie1
 - Outdoor antenna placement with clear sky view is essential
 ## HF SSTV
 1. **Select Hardware** - Choose your SDR type
 2. **Select Device** - Choose your SDR device
 3. **Select Frequency** - Choose from 13 preset frequencies or enter a custom one
 4. **Modulation** - Auto-selected based on frequency (USB for HF, FM for VHF/UHF)
 5. **Start Decoding** - Click "Start" to begin SSTV reception
 6. **View Images** - Decoded amateur radio images appear in the gallery
 ### Tips
 - HF frequencies (3-30 MHz) require an upconverter with RTL-SDR
 - VHF/UHF frequencies (145 MHz, 433 MHz) work directly with RTL-SDR
 - Most popular frequency: 14.230 MHz USB (20m band) with regular activity
 - Weekend activity peaks on most HF bands
 - Amateur license is not required to receive (listen-only)
 ## APRS
 1. **Select Hardware** - Choose your SDR type
 2. **Set Frequency** - Defaults to regional APRS frequency (144.390 MHz NA, 144.800 MHz EU)
 3. **Start Decoding** - Click "Start Decoding" to begin packet radio reception via direwolf
 4. **View Map** - Station positions appear on the interactive map
 5. **View Messages** - Position reports, telemetry, and messages displayed in real time
 ## Utility Meters
 1. **Start Monitoring** - Click "Start" to begin meter broadcast reception via rtl_amr
 2. **View Meters** - Decoded meter data appears with meter ID, type, and consumption
 3. **Filter** - Filter by meter type (electric, gas, water) or meter ID
 ## BT Locate (SAR Device Location)
 1. **Set Target** - Enter one or more target identifiers:
   - **MAC Address** - Exact Bluetooth address (AA:BB:CC:DD:EE:FF)
   - **Name Pattern** - Substring match (e.g., "iPhone", "Galaxy")
   - **IRK** - 32-character hex Identity Resolving Key for RPA resolution
   - **Detect IRKs** - Click "Detect" to auto-extract IRKs from paired devices
 2. **Choose Environment** - Select the RF environment preset:
   - **Open Field** (n=2.0) - Best for open areas with line-of-sight
   - **Outdoor** (n=2.2) - Default, works well in most outdoor settings
   - **Indoor** (n=3.0) - For buildings with walls and obstacles
 3. **Start Locate** - Click "Start Locate" to begin tracking
 4. **Monitor HUD** - The proximity display shows:
   - Proximity band (IMMEDIATE / NEAR / FAR)
   - Estimated distance in meters
   - Raw RSSI and smoothed RSSI average
   - Detection count and GPS-tagged points
 5. **Follow the Signal** - Move towards stronger signal (higher RSSI / closer distance)
 6. **Audio Alerts** - Enable audio for proximity tones that increase in pitch as you get closer
 7. **Review Trail** - Check the map for GPS-tagged detection trail
 ### Hand-off from Bluetooth Mode
 1. Open Bluetooth scanning mode and find the target device
 2. Click the "Locate" button on the device card
 3. BT Locate opens with the device pre-filled
 4. Click "Start Locate" to begin tracking
 ### Tips
 - For devices with address randomization (iPhones, modern Android), use the IRK method
 - Click "Detect" next to the IRK field to auto-extract IRKs from paired devices
 - The RSSI chart shows signal trend over time — use it to determine if you're getting closer
 - Clear the trail when starting a new search area
 ## GPS Mode
 1. **Start GPS** - Click "Start" to connect to gpsd and begin position tracking
 2. **View Map** - Your position appears on the interactive map with a track trail
 3. **Monitor Stats** - Speed, heading, altitude, and satellite count displayed in real-time
 4. **Record Track** - Enable track recording to save your path
 ### Tips
 - Ensure gpsd is running: `sudo gpsd /dev/ttyUSB0 -F /var/run/gpsd.sock`
 - GPS fix may take 30-60 seconds after cold start
 - Accuracy improves with more satellites in view
 ## TSCM (Counter-Surveillance)
 1. **Select Sweep Type** - Choose from Quick Scan (2 min), Standard (5 min), Full Sweep (15 min), or presets for Wireless Cameras, Body-Worn Devices, or GPS Trackers
 2. **Select Scan Sources** - Toggle WiFi, Bluetooth, and/or RF/SDR scanning and select the appropriate interfaces
 3. **Select Baseline** - Optionally choose a previously recorded baseline to compare against
 4. **Start Sweep** - Click "Start Sweep" to begin scanning
 5. **Review Results** - Detected devices are classified and scored by threat level
 6. **Record Baseline** - In a known clean environment, record a baseline for future comparison
 7. **Export Report** - Generate PDF report, JSON annex, or CSV data
 ### Threat Levels
 - **Informational (0-2)** - Known or expected devices
 - **Needs Review (3-5)** - Unusual devices requiring assessment
 - **High Interest (6+)** - Multiple indicators warrant investigation
 ### Tips
 - Record a baseline in a known clean environment before conducting sweeps
 - Use the meeting window feature to flag new RF signatures during sensitive periods
 - Full functionality requires WiFi adapter, Bluetooth adapter, and SDR hardware
 - Threat detection uses a database of 47K+ known tracker fingerprints
 ## Spy Stations
 1. **Browse Database** - View the full list of documented number stations and diplomatic networks
 2. **Filter by Type** - Toggle between Number Stations and Diplomatic Networks
 3. **Filter by Country** - Select specific countries (Russia, Cuba, Israel, Poland, etc.)
 4. **Filter by Mode** - Filter by demodulation mode (USB, AM, CW, OFDM)
 5. **View Details** - Click "Details" on a station card for full information
 6. **Tune In** - Click "Tune In" to route the station frequency to the Listening Post or WebSDR
 ### Tips
 - Data sourced from priyom.org (non-profit monitoring community)
 - Most activity is on HF bands (3-30 MHz) — propagation varies by time of day
 - Notable stations: UVB-76 "The Buzzer" (4625 kHz), E06 English Man, HM01 Cuban Numbers
 - Legal to monitor in most countries (check local regulations)
 - No decryption or content decoding is included — this is a reference database
 ## Meshtastic
 1. **Connect Device** - Plug in a Meshtastic device via USB or connect via TCP
 2. **Start** - Click "Start" to connect to the mesh network
 3. **View Messages** - Real-time message stream from the mesh
 4. **View Nodes** - Connected nodes displayed with signal metrics (RSSI, SNR)
 5. **Send Messages** - Type messages to broadcast on the mesh
 ## Offline Mode
 1. **Open Settings** - Click the gear icon in the navigation bar
 2. **Offline Tab** - Toggle "Offline Mode" to enable local assets
 3. **Configure Sources** - Switch assets and fonts from CDN to local
 4. **Set Tile Provider** - Choose a map tile provider or enter a custom tile server URL
 5. **Check Assets** - Click "Check Assets" to verify all local files are present
 ### Tips
 - Download required assets: Leaflet JS/CSS, Chart.js, Inter and JetBrains Mono fonts
 - Assets are stored in the `static/vendor/` directory
 - For maps, you need a local tile server (e.g., self-hosted OpenStreetMap tiles)
 - Missing assets fail gracefully with console warnings
 - Useful for air-gapped environments, field deployments, or reducing latency
 ## Remote Agents (Distributed SIGINT)
 Deploy lightweight sensor nodes across multiple locations and aggregate data to a central controller.
@@ -11,7 +11,6 @@
    <link href="https://fonts.googleapis.com/css2?family=JetBrains+Mono:wght@400;500;600&family=Inter:wght@400;500;600;700&display=swap" rel="stylesheet">
 </head>
 <body>
    <canvas id="bg-canvas"></canvas>
    <nav class="navbar">
        <div class="nav-container">
            <a href="#" class="nav-logo">iNTERCEPT</a>
@@ -36,7 +35,7 @@
            </div>
            <div class="hero-stats">
                <div class="stat">
-                    <span class="stat-value">25+</span>
+                    <span class="stat-value">15+</span>
                    <span class="stat-label">Modes</span>
                </div>
                <div class="stat">
@@ -59,149 +58,97 @@
            <h2>Capabilities</h2>
            <p class="section-subtitle">Everything you need for signal intelligence in one interface</p>
-            <div class="carousel-filters">
+            <div class="features-grid">
-                <button class="filter-btn active" data-filter="all">All</button>
+                <div class="feature-card">
-                <button class="filter-btn" data-filter="signals">Signals</button>
+                    <div class="feature-icon">📟</div>
                <button class="filter-btn" data-filter="tracking">Tracking</button>
                <button class="filter-btn" data-filter="space">Space</button>
                <button class="filter-btn" data-filter="wireless">Wireless</button>
                <button class="filter-btn" data-filter="intel">Intel</button>
                <button class="filter-btn" data-filter="platform">Platform</button>
            </div>
            <div class="carousel-wrapper">
                <button class="carousel-arrow carousel-arrow-left" aria-label="Scroll left">&#8249;</button>
                <div class="carousel-track">
                    <div class="feature-card" data-category="signals">
                        <div class="feature-icon"><svg viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="1.5" stroke-linecap="round" stroke-linejoin="round"><rect x="2" y="5" width="20" height="14" rx="2"/><line x1="6" y1="9" x2="6" y2="15"/><line x1="10" y1="9" x2="10" y2="15"/><line x1="14" y1="11" x2="18" y2="11"/><line x1="14" y1="13" x2="18" y2="13"/></svg></div>
                    <h3>Pager Decoding</h3>
                    <p>Decode POCSAG and FLEX pager messages using rtl_fm and multimon-ng. Monitor emergency services and legacy paging systems.</p>
                </div>
-                    <div class="feature-card" data-category="signals">
+
-                        <div class="feature-icon"><svg viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="1.5" stroke-linecap="round" stroke-linejoin="round"><path d="M12 2v4"/><path d="M12 18v4"/><circle cx="12" cy="12" r="4"/><path d="M4.93 4.93l2.83 2.83"/><path d="M16.24 16.24l2.83 2.83"/><path d="M2 12h4"/><path d="M18 12h4"/><path d="M4.93 19.07l2.83-2.83"/><path d="M16.24 7.76l2.83-2.83"/></svg></div>
+                <div class="feature-card">
-                        <h3>433MHz Sensors</h3>
+                    <div class="feature-icon">✈️</div>
                        <p>Decode 200+ protocols including weather stations, TPMS, smart home devices, and IoT sensors via rtl_433.</p>
                    </div>
                    <div class="feature-card" data-category="signals">
                        <div class="feature-icon"><svg viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="1.5" stroke-linecap="round" stroke-linejoin="round"><path d="M2 12h4l3-9 6 18 3-9h4"/></svg></div>
                        <h3>Sub-GHz Analyzer</h3>
                        <p>HackRF-based signal capture and protocol decoding for 300-928 MHz ISM bands with spectrum analysis and replay.</p>
                    </div>
                    <div class="feature-card" data-category="signals">
                        <div class="feature-icon"><svg viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="1.5" stroke-linecap="round" stroke-linejoin="round"><path d="M12 18.5a6.5 6.5 0 1 1 0-13"/><path d="M17 12h5"/><path d="M12 7V2"/><circle cx="12" cy="12" r="2"/><path d="M8.5 8.5L5 5"/></svg></div>
                        <h3>Listening Post</h3>
                        <p>Frequency scanner with real-time audio monitoring, fine-tuning controls, and customizable frequency presets.</p>
                    </div>
                    <div class="feature-card" data-category="intel">
                        <div class="feature-icon"><svg viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="1.5" stroke-linecap="round" stroke-linejoin="round"><circle cx="12" cy="12" r="10"/><line x1="2" y1="12" x2="22" y2="12"/><path d="M12 2a15.3 15.3 0 0 1 4 10 15.3 15.3 0 0 1-4 10 15.3 15.3 0 0 1-4-10 15.3 15.3 0 0 1 4-10z"/></svg></div>
                        <h3>WebSDR</h3>
                        <p>Remote HF/shortwave listening via the KiwiSDR network. Access receivers worldwide with real-time audio streaming.</p>
                    </div>
                    <div class="feature-card" data-category="intel">
                        <div class="feature-icon"><svg viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="1.5" stroke-linecap="round" stroke-linejoin="round"><rect x="4" y="4" width="16" height="16" rx="2"/><path d="M8 8h2v2H8z"/><path d="M14 8h2v2h-2z"/><path d="M8 14h2v2H8z"/><path d="M14 14h2v2h-2z"/><path d="M11 8h2v2h-2z"/><path d="M11 11h2v2h-2z"/></svg></div>
                        <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" data-category="tracking">
                        <div class="feature-icon"><svg viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="1.5" stroke-linecap="round" stroke-linejoin="round"><path d="M21 10c0 7-9 13-9 13s-9-6-9-13a9 9 0 0 1 18 0z"/><circle cx="12" cy="10" r="3"/></svg></div>
                        <h3>APRS</h3>
                        <p>Amateur packet radio position reports and telemetry via direwolf. Track amateur radio operators on an interactive map.</p>
                    </div>
                    <div class="feature-card" data-category="signals">
                        <div class="feature-icon"><svg viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="1.5" stroke-linecap="round" stroke-linejoin="round"><path d="M13 2L3 14h9l-1 8 10-12h-9l1-8z"/></svg></div>
                        <h3>Utility Meters</h3>
                        <p>Smart meter monitoring via rtl_amr. Receive electric, gas, and water meter broadcasts in real time.</p>
                    </div>
                    <div class="feature-card" data-category="tracking">
                        <div class="feature-icon"><svg viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="1.5" stroke-linecap="round" stroke-linejoin="round"><path d="M17.8 19.2L16 11l3.5-3.5C21 6 21.5 4 21 3c-1-.5-3 0-4.5 1.5L13 8 4.8 6.2c-.5-.1-.9.1-1.1.5l-.3.5c-.2.5-.1 1 .3 1.3L9 12l-2 3H4l-1 1 3 2 2 3 1-1v-3l3-2 3.5 5.3c.3.4.8.5 1.3.3l.5-.2c.4-.3.6-.7.5-1.2z"/></svg></div>
                    <h3>Aircraft Tracking</h3>
                    <p>Real-time ADS-B tracking with interactive maps, aircraft photos, emergency squawk detection, and range visualization.</p>
                </div>
-                    <div class="feature-card" data-category="tracking">
+
-                        <div class="feature-icon"><svg viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="1.5" stroke-linecap="round" stroke-linejoin="round"><rect x="3" y="4" width="18" height="16" rx="2"/><path d="M7 8h10"/><path d="M7 12h6"/><path d="M7 16h8"/></svg></div>
+                <div class="feature-card">
-                        <h3>ACARS</h3>
+                    <div class="feature-icon">📡</div>
-                        <p>Aircraft datalink messages via acarsdec. Decode operational, weather, and position reports from commercial flights.</p>
+                    <h3>433MHz Sensors</h3>
                    <p>Decode 200+ protocols including weather stations, TPMS, smart home devices, and IoT sensors via rtl_433.</p>
                </div>
-                    <div class="feature-card" data-category="tracking">
+
-                        <div class="feature-icon"><svg viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="1.5" stroke-linecap="round" stroke-linejoin="round"><path d="M12 5v14"/><path d="M5 12h14"/><circle cx="12" cy="12" r="9"/><path d="M3.5 9h17"/><path d="M3.5 15h17"/></svg></div>
+                <div class="feature-card">
-                        <h3>VDL2</h3>
+                    <div class="feature-icon">📻</div>
-                        <p>VHF Data Link Mode 2 aircraft datalink decoding via dumpvdl2. Real-time ACARS-over-AVLC message capture with signal analysis.</p>
+                    <h3>Listening Post</h3>
                    <p>Frequency scanner with real-time audio monitoring, fine-tuning controls, and customizable frequency presets.</p>
                </div>
-                    <div class="feature-card" data-category="tracking">
+
-                        <div class="feature-icon"><svg viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="1.5" stroke-linecap="round" stroke-linejoin="round"><path d="M2 20l4-4h3l4-7 2 4h2l5-9"/><path d="M22 20H2"/><path d="M6 16v4"/></svg></div>
+                <div class="feature-card">
-                        <h3>Vessel Tracking</h3>
+                    <div class="feature-icon">🛰️</div>
                        <p>Real-time AIS ship tracking via AIS-catcher. Monitor maritime traffic with vessel details, course, speed, and destination.</p>
                    </div>
                    <div class="feature-card" data-category="space">
                        <div class="feature-icon"><svg viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="1.5" stroke-linecap="round" stroke-linejoin="round"><circle cx="12" cy="12" r="3"/><path d="M12 1v4"/><path d="M12 19v4"/><path d="M5 5l2 2"/><path d="M17 17l2 2"/><path d="M1 12h4"/><path d="M19 12h4"/><path d="M5 19l2-2"/><path d="M17 7l2-2"/><ellipse cx="12" cy="12" rx="10" ry="4" transform="rotate(45 12 12)"/></svg></div>
                    <h3>Satellite Tracking</h3>
                    <p>Track satellites with TLE data, sky plots, ground track visualization, and pass predictions for your location.</p>
                </div>
-                    <div class="feature-card" data-category="space">
+
-                        <div class="feature-icon"><svg viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="1.5" stroke-linecap="round" stroke-linejoin="round"><path d="M12 2v2"/><path d="M12 20v2"/><path d="m4.93 4.93 1.41 1.41"/><path d="m17.66 17.66 1.41 1.41"/><path d="M2 12h2"/><path d="M20 12h2"/><path d="m6.34 17.66-1.41 1.41"/><path d="m19.07 4.93-1.41 1.41"/><circle cx="12" cy="12" r="4"/><path d="M16 12a4 4 0 0 0-4-4"/></svg></div>
+                <div class="feature-card">
-                        <h3>Weather Satellites</h3>
+                    <div class="feature-icon">📶</div>
                        <p>NOAA APT and Meteor LRPT image decoding via SatDump with auto-scheduler, polar plot, and ground track map.</p>
                    </div>
                    <div class="feature-card" data-category="space">
                        <div class="feature-icon"><svg viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="1.5" stroke-linecap="round" stroke-linejoin="round"><rect x="3" y="3" width="18" height="18" rx="2"/><circle cx="8.5" cy="8.5" r="1.5"/><path d="M21 15l-5-5L5 21"/></svg></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 class="feature-card" data-category="space">
                        <div class="feature-icon"><svg viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="1.5" stroke-linecap="round" stroke-linejoin="round"><rect x="3" y="3" width="18" height="18" rx="2"/><path d="M3 9h18"/><path d="M9 3v18"/></svg></div>
                        <h3>HF SSTV</h3>
                        <p>Terrestrial SSTV on shortwave frequencies. Decode amateur radio image transmissions across HF, VHF, and UHF bands.</p>
                    </div>
                    <div class="feature-card" data-category="tracking">
                        <div class="feature-icon"><svg viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="1.5" stroke-linecap="round" stroke-linejoin="round"><circle cx="12" cy="12" r="10"/><path d="M12 2a14.5 14.5 0 0 0 0 20 14.5 14.5 0 0 0 0-20"/><path d="M2 12h20"/><path d="M12 8l4 4-4 4"/></svg></div>
                        <h3>GPS Tracking</h3>
                        <p>Real-time GPS position tracking with live map, speed, heading, altitude, satellite info, and track recording.</p>
                    </div>
                    <div class="feature-card" data-category="space">
                        <div class="feature-icon"><svg viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="1.5" stroke-linecap="round" stroke-linejoin="round"><circle cx="12" cy="12" r="5"/><line x1="12" y1="1" x2="12" y2="3"/><line x1="12" y1="21" x2="12" y2="23"/><line x1="4.22" y1="4.22" x2="5.64" y2="5.64"/><line x1="18.36" y1="18.36" x2="19.78" y2="19.78"/><line x1="1" y1="12" x2="3" y2="12"/><line x1="21" y1="12" x2="23" y2="12"/><line x1="4.22" y1="19.78" x2="5.64" y2="18.36"/><line x1="18.36" y1="5.64" x2="19.78" y2="4.22"/></svg></div>
                        <h3>Space Weather</h3>
                        <p>Real-time solar and geomagnetic monitoring. Kp index, HF band conditions, solar imagery, D-RAP maps, and aurora forecasts from NOAA SWPC.</p>
                    </div>
                    <div class="feature-card" data-category="wireless">
                        <div class="feature-icon"><svg viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="1.5" stroke-linecap="round" stroke-linejoin="round"><path d="M5 12.55a11 11 0 0 1 14.08 0"/><path d="M1.42 9a16 16 0 0 1 21.16 0"/><path d="M8.53 16.11a6 6 0 0 1 6.95 0"/><circle cx="12" cy="20" r="1"/></svg></div>
                    <h3>WiFi Scanning</h3>
                    <p>Monitor mode reconnaissance via aircrack-ng. Network discovery, client tracking, and handshake capture.</p>
                </div>
-                    <div class="feature-card" data-category="wireless">
+
-                        <div class="feature-icon"><svg viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="1.5" stroke-linecap="round" stroke-linejoin="round"><circle cx="12" cy="10" r="6"/><path d="M12 16v5"/><path d="M8 21h8"/><path d="M9.5 7.5L12 10l2.5-2.5"/></svg></div>
+                <div class="feature-card">
                    <div class="feature-icon">🔵</div>
                    <h3>Bluetooth Scanning</h3>
                    <p>Device discovery with tracker detection for AirTags, Tile, Samsung SmartTag, and other Bluetooth devices.</p>
                </div>
-                    <div class="feature-card" data-category="wireless">
+
-                        <div class="feature-icon"><svg viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="1.5" stroke-linecap="round" stroke-linejoin="round"><circle cx="12" cy="12" r="3"/><circle cx="12" cy="12" r="7" stroke-dasharray="4 2"/><circle cx="12" cy="12" r="11" stroke-dasharray="2 3"/><line x1="12" y1="1" x2="12" y2="3"/></svg></div>
+                <div class="feature-card">
-                        <h3>BT Locate</h3>
+                    <div class="feature-icon">🛡️</div>
                        <p>SAR Bluetooth device location with GPS-tagged signal trail mapping, IRK-based RPA resolution, and proximity audio alerts.</p>
                    </div>
                    <div class="feature-card" data-category="intel">
                        <div class="feature-icon"><svg viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="1.5" stroke-linecap="round" stroke-linejoin="round"><path d="M12 22s-8-4.5-8-11.8A8 8 0 0 1 12 2a8 8 0 0 1 8 8.2c0 7.3-8 11.8-8 11.8z"/><circle cx="12" cy="10" r="3"/><path d="M12 2v3"/><path d="M4.93 4.93l2.12 2.12"/><path d="M20 12h-3"/></svg></div>
                    <h3>TSCM</h3>
                    <p>Counter-surveillance with baseline recording, threat detection, device correlation, and risk scoring.</p>
                </div>
-                    <div class="feature-card" data-category="wireless">
+
-                        <div class="feature-icon"><svg viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="1.5" stroke-linecap="round" stroke-linejoin="round"><path d="M12 2L2 7l10 5 10-5-10-5z"/><path d="M2 17l10 5 10-5"/><path d="M2 12l10 5 10-5"/></svg></div>
+                <div class="feature-card">
-                        <h3>Meshtastic</h3>
+                    <div class="feature-icon">⚡</div>
-                        <p>LoRa mesh network integration. Connect to Meshtastic devices for decentralized, long-range communication monitoring.</p>
+                    <h3>Meter Reading</h3>
                    <p>Intercept smart utility meters via rtl_amr. Monitor electricity, gas, and water meter transmissions.</p>
                </div>
-                    <div class="feature-card" data-category="platform">
+
-                        <div class="feature-icon"><svg viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="1.5" stroke-linecap="round" stroke-linejoin="round"><rect x="2" y="3" width="20" height="14" rx="2"/><line x1="8" y1="21" x2="16" y2="21"/><line x1="12" y1="17" x2="12" y2="21"/><circle cx="9" cy="10" r="1.5"/><circle cx="15" cy="10" r="1.5"/><path d="M5 10h2"/><path d="M17 10h2"/></svg></div>
+                <div class="feature-card">
                    <div class="feature-icon">🚢</div>
                    <h3>Vessel Tracking</h3>
                    <p>Real-time AIS ship tracking via AIS-catcher. Monitor maritime traffic with vessel details, course, speed, and destination.</p>
                </div>
                <div class="feature-card">
                    <div class="feature-icon">🔢</div>
                    <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" data-category="platform">
+
-                        <div class="feature-icon"><svg viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="1.5" stroke-linecap="round" stroke-linejoin="round"><path d="M18.36 6.64A9 9 0 0 1 20.77 15"/><path d="M6.16 6.16a9 9 0 0 0-2.57 8.84"/><path d="M12 2v4"/><path d="M2 12h4"/><line x1="2" y1="2" x2="22" y2="22"/><circle cx="12" cy="12" r="3"/></svg></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>
+
-                <button class="carousel-arrow carousel-arrow-right" aria-label="Scroll right">&#8250;</button>
+                <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="carousel-indicators" id="carousel-indicators"></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>
@@ -247,50 +194,6 @@
                    <img src="images/ais.png" alt="AIS Vessel Tracking">
                    <span class="screenshot-label">AIS Vessel Tracking</span>
                </div>
                <div class="screenshot-item">
                    <img src="images/bt-locate.png" alt="BT Locate SAR Tracker">
                    <span class="screenshot-label">BT Locate — SAR Tracker</span>
                </div>
                <div class="screenshot-item">
                    <img src="images/spy-stations.png" alt="Spy Stations Database">
                    <span class="screenshot-label">Spy Stations</span>
                </div>
                <div class="screenshot-item">
                    <img src="images/gps.png" alt="GPS Receiver">
                    <span class="screenshot-label">GPS Receiver</span>
                </div>
                <div class="screenshot-item">
                    <img src="images/websdr.png" alt="WebSDR Remote Listening">
                    <span class="screenshot-label">WebSDR</span>
                </div>
                <div class="screenshot-item">
                    <img src="images/aprs.png" alt="APRS Tracker">
                    <span class="screenshot-label">APRS Tracker</span>
                </div>
                <div class="screenshot-item">
                    <img src="images/vdl2.png" alt="VDL2 Aircraft Datalink">
                    <span class="screenshot-label">VDL2 Aircraft Datalink</span>
                </div>
                <div class="screenshot-item">
                    <img src="images/weather-satellite.png" alt="Weather Satellite Decoder">
                    <span class="screenshot-label">Weather Satellite</span>
                </div>
                <div class="screenshot-item">
                    <img src="images/space-weather-1.png" alt="Space Weather Dashboard">
                    <span class="screenshot-label">Space Weather</span>
                </div>
                <div class="screenshot-item">
                    <img src="images/space-weather-2.png" alt="Space Weather Solar Imagery">
                    <span class="screenshot-label">Space Weather — Solar &amp; Aurora</span>
                </div>
                <div class="screenshot-item">
                    <img src="images/satellite-tracker.png" alt="Satellite Tracker">
                    <span class="screenshot-label">Satellite Tracker</span>
                </div>
                <div class="screenshot-item">
                    <img src="images/iss-sstv.png" alt="ISS SSTV Decoder">
                    <span class="screenshot-label">ISS SSTV</span>
                </div>
            </div>
        </div>
    </section>
@@ -375,36 +278,6 @@ docker compose up -d</code></pre>
        </div>
    </section>
    <section class="support">
        <div class="container">
            <h2>Support & Contact</h2>
            <p class="section-subtitle">Help keep iNTERCEPT alive or get in touch</p>
            <div class="support-grid">
                <a href="https://www.buymeacoffee.com/smittix" target="_blank" class="support-card support-coffee">
                    <div class="support-icon"><svg viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="1.5" stroke-linecap="round" stroke-linejoin="round"><path d="M17 8h1a4 4 0 0 1 0 8h-1"/><path d="M3 8h14v9a4 4 0 0 1-4 4H7a4 4 0 0 1-4-4V8z"/><line x1="6" y1="2" x2="6" y2="4"/><line x1="10" y1="2" x2="10" y2="4"/><line x1="14" y1="2" x2="14" y2="4"/></svg></div>
                    <h3>Buy Me a Coffee</h3>
                    <p>Support development with a one-time donation</p>
                </a>
                <a href="#" id="email-card" class="support-card" onclick="return false;">
                    <div class="support-icon"><svg viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="1.5" stroke-linecap="round" stroke-linejoin="round"><rect x="2" y="4" width="20" height="16" rx="2"/><path d="M22 4L12 13 2 4"/></svg></div>
                    <h3>Email</h3>
                    <p id="email-text">Click to reveal</p>
                </a>
                <a href="https://discord.gg/EyeksEJmWE" target="_blank" class="support-card">
                    <div class="support-icon"><svg viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="1.5" stroke-linecap="round" stroke-linejoin="round"><path d="M9.09 9a3 3 0 0 1 5.83 1c0 2-3 3-3 3"/><circle cx="12" cy="12" r="10"/><line x1="12" y1="17" x2="12.01" y2="17"/></svg></div>
                    <h3>Discord</h3>
                    <p>Join the community for help and discussion</p>
                </a>
                <a href="https://github.com/smittix/intercept/issues" target="_blank" class="support-card">
                    <div class="support-icon"><svg viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="1.5" stroke-linecap="round" stroke-linejoin="round"><circle cx="12" cy="12" r="10"/><line x1="12" y1="8" x2="12" y2="12"/><line x1="12" y1="16" x2="12.01" y2="16"/></svg></div>
                    <h3>Report an Issue</h3>
                    <p>Bug reports and feature requests on GitHub</p>
                </a>
            </div>
        </div>
    </section>
    <footer class="footer">
        <div class="container">
            <div class="footer-content">
@@ -415,8 +288,6 @@ 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="#" id="footer-email">Email</a>
                    <a href="https://www.buymeacoffee.com/smittix" target="_blank">Donate</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>
@@ -465,334 +336,6 @@ docker compose up -d</code></pre>
        document.addEventListener('keydown', (e) => {
            if (e.key === 'Escape') closeLightbox();
        });
        // Carousel functionality
        (function() {
            const track = document.querySelector('.carousel-track');
            const cards = Array.from(track.querySelectorAll('.feature-card'));
            const leftArrow = document.querySelector('.carousel-arrow-left');
            const rightArrow = document.querySelector('.carousel-arrow-right');
            const filterBtns = document.querySelectorAll('.filter-btn');
            const indicatorContainer = document.getElementById('carousel-indicators');
            const SCROLL_AMOUNT = 300;
            function updateArrows() {
                leftArrow.disabled = track.scrollLeft <= 0;
                rightArrow.disabled = track.scrollLeft + track.clientWidth >= track.scrollWidth - 2;
            }
            function buildIndicators() {
                const visible = cards.filter(c => !c.classList.contains('hidden'));
                const totalWidth = visible.length * 300;
                const pages = Math.max(1, Math.ceil(totalWidth / track.clientWidth));
                indicatorContainer.innerHTML = '';
                for (let i = 0; i < pages; i++) {
                    const dot = document.createElement('button');
                    dot.className = 'carousel-dot' + (i === 0 ? ' active' : '');
                    dot.addEventListener('click', () => {
                        track.scrollTo({ left: (track.scrollWidth / pages) * i, behavior: 'smooth' });
                    });
                    indicatorContainer.appendChild(dot);
                }
            }
            function updateIndicators() {
                const dots = indicatorContainer.querySelectorAll('.carousel-dot');
                if (!dots.length) return;
                const ratio = track.scrollLeft / Math.max(1, track.scrollWidth - track.clientWidth);
                const idx = Math.round(ratio * (dots.length - 1));
                dots.forEach((d, i) => d.classList.toggle('active', i === idx));
            }
            leftArrow.addEventListener('click', () => {
                track.scrollBy({ left: -SCROLL_AMOUNT, behavior: 'smooth' });
            });
            rightArrow.addEventListener('click', () => {
                track.scrollBy({ left: SCROLL_AMOUNT, behavior: 'smooth' });
            });
            track.addEventListener('scroll', () => {
                updateArrows();
                updateIndicators();
            });
            filterBtns.forEach(btn => {
                btn.addEventListener('click', () => {
                    filterBtns.forEach(b => b.classList.remove('active'));
                    btn.classList.add('active');
                    const filter = btn.dataset.filter;
                    cards.forEach(card => {
                        if (filter === 'all' || card.dataset.category === filter) {
                            card.classList.remove('hidden');
                        } else {
                            card.classList.add('hidden');
                        }
                    });
                    track.scrollTo({ left: 0 });
                    buildIndicators();
                    updateArrows();
                });
            });
            buildIndicators();
            updateArrows();
            window.addEventListener('resize', () => { buildIndicators(); updateArrows(); });
        })();
        // Obfuscated email - assembled at runtime to defeat scrapers
        (function() {
            const p = ['smittix', 'outlook', 'com'];
            const addr = p[0] + '@' + p[1] + '.' + p[2];
            const card = document.getElementById('email-card');
            const text = document.getElementById('email-text');
            const footerLink = document.getElementById('footer-email');
            let revealed = false;
            card.addEventListener('click', function(e) {
                e.preventDefault();
                if (!revealed) {
                    text.textContent = addr;
                    revealed = true;
                } else {
                    window.location.href = 'mail' + 'to:' + addr;
                }
            });
            footerLink.addEventListener('click', function(e) {
                e.preventDefault();
                window.location.href = 'mail' + 'to:' + addr;
            });
        })();
    </script>
    <script>
    // Animated satellite & signal background
    (function() {
        const canvas = document.getElementById('bg-canvas');
        const ctx = canvas.getContext('2d');
        let w, h, dpr;
        let orbits = [];
        let pulses = [];
        let particles = [];
        let mouse = { x: -1000, y: -1000 };
        function resize() {
            dpr = Math.min(window.devicePixelRatio || 1, 2);
            w = window.innerWidth;
            h = document.documentElement.scrollHeight;
            canvas.width = w * dpr;
            canvas.height = h * dpr;
            canvas.style.width = w + 'px';
            canvas.style.height = h + 'px';
            ctx.setTransform(dpr, 0, 0, dpr, 0, 0);
        }
        // Orbital paths with satellites
        function createOrbits() {
            orbits = [];
            const count = Math.max(4, Math.floor(w / 300));
            for (let i = 0; i < count; i++) {
                const cx = Math.random() * w;
                const cy = Math.random() * h;
                const rx = 120 + Math.random() * 280;
                const ry = 40 + Math.random() * 100;
                const tilt = (Math.random() - 0.5) * 1.2;
                const speed = (0.0002 + Math.random() * 0.0004) * (Math.random() > 0.5 ? 1 : -1);
                const sats = [];
                const satCount = 1 + Math.floor(Math.random() * 2);
                for (let j = 0; j < satCount; j++) {
                    sats.push({ angle: Math.random() * Math.PI * 2, pulseTimer: 0 });
                }
                orbits.push({ cx, cy, rx, ry, tilt, speed, sats });
            }
        }
        // Floating signal particles (tiny dots drifting upward)
        function createParticles() {
            particles = [];
            const count = Math.max(30, Math.floor((w * h) / 25000));
            for (let i = 0; i < count; i++) {
                particles.push({
                    x: Math.random() * w,
                    y: Math.random() * h,
                    vy: -(0.08 + Math.random() * 0.15),
                    vx: (Math.random() - 0.5) * 0.1,
                    size: 0.5 + Math.random() * 1.2,
                    alpha: 0.1 + Math.random() * 0.25,
                    flicker: Math.random() * Math.PI * 2,
                });
            }
        }
        function spawnPulse(x, y) {
            pulses.push({ x, y, r: 2, maxR: 50 + Math.random() * 40, alpha: 0.35 });
        }
        function drawOrbitPath(orbit) {
            ctx.save();
            ctx.translate(orbit.cx, orbit.cy);
            ctx.rotate(orbit.tilt);
            ctx.beginPath();
            ctx.ellipse(0, 0, orbit.rx, orbit.ry, 0, 0, Math.PI * 2);
            ctx.strokeStyle = 'rgba(0, 212, 170, 0.04)';
            ctx.lineWidth = 1;
            ctx.stroke();
            ctx.restore();
        }
        function drawSatellite(orbit, sat, dt) {
            sat.angle += orbit.speed * dt;
            const cos = Math.cos(orbit.tilt);
            const sin = Math.sin(orbit.tilt);
            const ex = orbit.rx * Math.cos(sat.angle);
            const ey = orbit.ry * Math.sin(sat.angle);
            const sx = orbit.cx + ex * cos - ey * sin;
            const sy = orbit.cy + ex * sin + ey * cos;
            // Satellite dot
            ctx.beginPath();
            ctx.arc(sx, sy, 2, 0, Math.PI * 2);
            ctx.fillStyle = 'rgba(0, 212, 170, 0.7)';
            ctx.fill();
            // Faint glow
            ctx.beginPath();
            ctx.arc(sx, sy, 6, 0, Math.PI * 2);
            const g = ctx.createRadialGradient(sx, sy, 0, sx, sy, 6);
            g.addColorStop(0, 'rgba(0, 212, 170, 0.15)');
            g.addColorStop(1, 'rgba(0, 212, 170, 0)');
            ctx.fillStyle = g;
            ctx.fill();
            // Periodic signal pulse
            sat.pulseTimer += dt;
            if (sat.pulseTimer > 3000 + Math.random() * 500) {
                sat.pulseTimer = 0;
                spawnPulse(sx, sy);
            }
        }
        function drawPulses(dt) {
            for (let i = pulses.length - 1; i >= 0; i--) {
                const p = pulses[i];
                p.r += dt * 0.025;
                p.alpha = 0.35 * (1 - p.r / p.maxR);
                if (p.r >= p.maxR) { pulses.splice(i, 1); continue; }
                ctx.beginPath();
                ctx.arc(p.x, p.y, p.r, 0, Math.PI * 2);
                ctx.strokeStyle = `rgba(0, 212, 170, ${p.alpha})`;
                ctx.lineWidth = 1;
                ctx.stroke();
                // Second ring
                if (p.r > 12) {
                    ctx.beginPath();
                    ctx.arc(p.x, p.y, p.r * 0.6, 0, Math.PI * 2);
                    ctx.strokeStyle = `rgba(0, 136, 255, ${p.alpha * 0.5})`;
                    ctx.stroke();
                }
            }
        }
        function drawParticles(dt, time) {
            for (const p of particles) {
                p.y += p.vy * dt * 0.06;
                p.x += p.vx * dt * 0.06;
                p.flicker += dt * 0.002;
                if (p.y < -10) { p.y = h + 10; p.x = Math.random() * w; }
                if (p.x < -10) p.x = w + 10;
                if (p.x > w + 10) p.x = -10;
                const flick = p.alpha * (0.6 + 0.4 * Math.sin(p.flicker));
                // Mouse interaction - subtle brighten
                const dx = p.x - mouse.x;
                const dy = p.y - mouse.y;
                const dist = Math.sqrt(dx * dx + dy * dy);
                const boost = dist < 150 ? 0.3 * (1 - dist / 150) : 0;
                ctx.beginPath();
                ctx.arc(p.x, p.y, p.size, 0, Math.PI * 2);
                ctx.fillStyle = `rgba(0, 212, 170, ${Math.min(flick + boost, 0.6)})`;
                ctx.fill();
            }
        }
        // Faint grid lines (signal grid)
        function drawGrid(time) {
            ctx.strokeStyle = 'rgba(0, 212, 170, 0.015)';
            ctx.lineWidth = 1;
            const spacing = 120;
            const offset = (time * 0.005) % spacing;
            for (let x = -spacing + offset; x < w + spacing; x += spacing) {
                ctx.beginPath();
                ctx.moveTo(x, 0);
                ctx.lineTo(x, h);
                ctx.stroke();
            }
            for (let y = -spacing + offset * 0.7; y < h + spacing; y += spacing) {
                ctx.beginPath();
                ctx.moveTo(0, y);
                ctx.lineTo(w, y);
                ctx.stroke();
            }
        }
        let last = 0;
        function animate(now) {
            const dt = last ? Math.min(now - last, 50) : 16;
            last = now;
            ctx.clearRect(0, 0, w, h);
            drawGrid(now);
            for (const orbit of orbits) {
                drawOrbitPath(orbit);
                for (const sat of orbit.sats) {
                    drawSatellite(orbit, sat, dt);
                }
            }
            drawPulses(dt);
            drawParticles(dt, now);
            requestAnimationFrame(animate);
        }
        // Track mouse for particle interaction
        document.addEventListener('mousemove', (e) => {
            mouse.x = e.clientX;
            mouse.y = e.clientY + window.scrollY;
        });
        // Resize handling
        let resizeTimer;
        function handleResize() {
            clearTimeout(resizeTimer);
            resizeTimer = setTimeout(() => {
                resize();
                createOrbits();
                createParticles();
            }, 200);
        }
        // Keep canvas height synced with document
        const ro = new ResizeObserver(() => { handleResize(); });
        ro.observe(document.documentElement);
        window.addEventListener('resize', handleResize);
        resize();
        createOrbits();
        createParticles();
        requestAnimationFrame(animate);
    })();
    </script>
 </body>
 </html>
@@ -17,22 +17,6 @@
    --gradient-end: #0088ff;
 }
 /* Animated background canvas */
 #bg-canvas {
    position: fixed;
    top: 0;
    left: 0;
    width: 100%;
    height: 100%;
    z-index: 0;
    pointer-events: none;
 }
 body > *:not(#bg-canvas) {
    position: relative;
    z-index: 1;
 }
 * {
    margin: 0;
    padding: 0;
@@ -261,74 +245,18 @@ section h2 {
    background: var(--bg-secondary);
 }
-/* Category filter tabs */
+.features-grid {
-.carousel-filters {
+    display: grid;
-    display: flex;
+    grid-template-columns: repeat(4, 1fr);
-    justify-content: center;
+    gap: 24px;
    gap: 8px;
    margin-bottom: 40px;
    flex-wrap: wrap;
 }
 .filter-btn {
    font-family: 'JetBrains Mono', monospace;
    font-size: 0.8rem;
    font-weight: 500;
    padding: 8px 20px;
    border-radius: 20px;
    border: 1px solid var(--border);
    background: transparent;
    color: var(--text-secondary);
    cursor: pointer;
    transition: all 0.25s;
    letter-spacing: 0.5px;
 }
 .filter-btn:hover {
    border-color: var(--accent);
    color: var(--text-primary);
 }
 .filter-btn.active {
    background: var(--accent);
    color: var(--bg-primary);
    border-color: var(--accent);
 }
 /* Carousel */
 .carousel-wrapper {
    position: relative;
    padding: 0 56px;
 }
 .carousel-track {
    display: flex;
    gap: 20px;
    overflow-x: auto;
    scroll-behavior: smooth;
    scroll-snap-type: x mandatory;
    -webkit-overflow-scrolling: touch;
    scrollbar-width: none;
    padding: 8px 0 16px;
 }
 .carousel-track::-webkit-scrollbar {
    display: none;
 }
 .feature-card {
    flex: 0 0 280px;
    scroll-snap-align: start;
    background: var(--bg-card);
    border: 1px solid var(--border);
    border-radius: 12px;
    padding: 32px 24px;
    transition: all 0.3s;
    min-height: 200px;
 }
 .feature-card.hidden {
    display: none;
 }
 .feature-card:hover {
@@ -338,15 +266,8 @@ section h2 {
 }
 .feature-icon {
-    width: 36px;
+    font-size: 2rem;
    height: 36px;
    margin-bottom: 16px;
    color: var(--accent);
 }
 .feature-icon svg {
    width: 100%;
    height: 100%;
 }
 .feature-card h3 {
@@ -362,81 +283,6 @@ section h2 {
    line-height: 1.7;
 }
 /* Carousel arrows */
 .carousel-arrow {
    position: absolute;
    top: 50%;
    transform: translateY(-50%);
    width: 44px;
    height: 44px;
    border-radius: 50%;
    border: 1px solid var(--border);
    background: var(--bg-card);
    color: var(--text-primary);
    font-size: 1.5rem;
    cursor: pointer;
    transition: all 0.25s;
    display: flex;
    align-items: center;
    justify-content: center;
    z-index: 10;
    line-height: 1;
 }
 .carousel-arrow:hover {
    background: var(--bg-card-hover);
    border-color: var(--accent);
    color: var(--accent);
 }
 .carousel-arrow:disabled {
    opacity: 0.3;
    cursor: default;
 }
 .carousel-arrow:disabled:hover {
    background: var(--bg-card);
    border-color: var(--border);
    color: var(--text-primary);
 }
 .carousel-arrow-left {
    left: 0;
 }
 .carousel-arrow-right {
    right: 0;
 }
 /* Carousel indicators */
 .carousel-indicators {
    display: flex;
    justify-content: center;
    gap: 8px;
    margin-top: 28px;
 }
 .carousel-dot {
    width: 8px;
    height: 8px;
    border-radius: 50%;
    background: var(--border);
    border: none;
    cursor: pointer;
    transition: all 0.25s;
    padding: 0;
 }
 .carousel-dot.active {
    background: var(--accent);
    width: 24px;
    border-radius: 4px;
 }
 .carousel-dot:hover {
    background: var(--text-muted);
 }
 /* Screenshots */
 .screenshot-gallery {
    display: grid;
@@ -704,72 +550,6 @@ section h2 {
    gap: 16px;
 }
 /* Support & Contact */
 .support {
    background: var(--bg-secondary);
 }
 .support-grid {
    display: grid;
    grid-template-columns: repeat(4, 1fr);
    gap: 24px;
 }
 .support-card {
    background: var(--bg-card);
    border: 1px solid var(--border);
    border-radius: 12px;
    padding: 32px 24px;
    text-align: center;
    text-decoration: none;
    transition: all 0.3s;
    display: block;
 }
 .support-card:hover {
    background: var(--bg-card-hover);
    border-color: var(--accent);
    transform: translateY(-4px);
 }
 .support-card.support-coffee {
    border-color: rgba(255, 193, 59, 0.3);
 }
 .support-card.support-coffee:hover {
    border-color: #ffc13b;
    box-shadow: 0 8px 30px rgba(255, 193, 59, 0.1);
 }
 .support-card.support-coffee .support-icon {
    color: #ffc13b;
 }
 .support-icon {
    width: 36px;
    height: 36px;
    margin: 0 auto 16px;
    color: var(--accent);
 }
 .support-icon svg {
    width: 100%;
    height: 100%;
 }
 .support-card h3 {
    font-size: 1.1rem;
    font-weight: 600;
    margin-bottom: 8px;
    color: var(--text-primary);
 }
 .support-card p {
    font-size: 0.85rem;
    color: var(--text-secondary);
    line-height: 1.6;
 }
 /* Footer */
 .footer {
    background: var(--bg-secondary);
@@ -861,19 +641,11 @@ section h2 {
        margin: 0 auto;
    }
-    .carousel-wrapper {
+    .features-grid {
        padding: 0 48px;
    }
    .feature-card {
        flex: 0 0 260px;
    }
    .screenshot-gallery {
        grid-template-columns: repeat(2, 1fr);
    }
-    .support-grid {
+    .screenshot-gallery {
        grid-template-columns: repeat(2, 1fr);
    }
@@ -897,32 +669,11 @@ section h2 {
        gap: 24px;
    }
-    .carousel-wrapper {
+    .features-grid {
        padding: 0 4px;
    }
    .carousel-arrow {
        display: none;
    }
    .feature-card {
        flex: 0 0 260px;
    }
    .carousel-filters {
        gap: 6px;
    }
    .filter-btn {
        font-size: 0.7rem;
        padding: 6px 14px;
    }
    .screenshot-gallery {
        grid-template-columns: 1fr;
    }
-    .support-grid {
+    .screenshot-gallery {
        grid-template-columns: 1fr;
    }
@@ -1,30 +0,0 @@
 #!/usr/bin/env bash
 # Download sample NOAA APT recordings for testing the weather satellite
 # test-decode feature. These are FM-demodulated audio WAV files.
 #
 # Usage:
 #   ./download-weather-sat-samples.sh
 #   docker exec intercept /app/download-weather-sat-samples.sh
 set -euo pipefail
 SAMPLE_DIR="$(dirname "$0")/data/weather_sat/samples"
 mkdir -p "$SAMPLE_DIR"
 echo "Downloading NOAA APT sample files to $SAMPLE_DIR ..."
 # Full satellite pass recorded over Argentina (NOAA, 11025 Hz mono WAV)
 # Source: https://github.com/martinber/noaa-apt
 if [ ! -f "$SAMPLE_DIR/noaa_apt_argentina.wav" ]; then
    echo "  -> noaa_apt_argentina.wav (18 MB) ..."
    curl -fSL -o "$SAMPLE_DIR/noaa_apt_argentina.wav" \
        "https://noaa-apt.mbernardi.com.ar/examples/argentina.wav"
 else
    echo "  -> noaa_apt_argentina.wav (already exists)"
 fi
 echo ""
 echo "Done. Test decode with:"
 echo "  Satellite:    NOAA-18"
 echo "  File path:    data/weather_sat/samples/noaa_apt_argentina.wav"
 echo "  Sample rate:  11025 Hz"
@@ -1,210 +0,0 @@
 DMSP 5D-3 F16 (USA 172) 
 1 28054U 03048A   26037.66410905  .00000171  00000+0  11311-3 0  9991
 2 28054  99.0018  60.5544 0007736 150.6435 318.8272 14.14449870151032
 METEOSAT-9 (MSG-2)      
 1 28912U 05049B   26037.20698824  .00000122  00000+0  00000+0 0  9990
 2 28912   9.0646  55.4438 0001292 220.3216 340.7358  1.00280364  5681
 DMSP 5D-3 F17 (USA 191) 
 1 29522U 06050A   26037.63495522  .00000221  00000+0  13641-3 0  9997
 2 29522  98.7406  46.8646 0011088  71.3269 288.9107 14.14949568993957
 FENGYUN 3A              
 1 32958U 08026A   26037.29889977  .00000162  00000+0  97205-4 0  9995
 2 32958  98.6761 340.6748 0009336 139.4536 220.7337 14.19536323916838
 GOES 14                 
 1 35491U 09033A   26037.59737599  .00000128  00000+0  00000+0 0  9998
 2 35491   1.3510  84.7861 0001663 279.3774 203.6871  1.00112472  5283
 DMSP 5D-3 F18 (USA 210) 
 1 35951U 09057A   26037.59574243  .00000344  00000+0  20119-3 0  9997
 2 35951  98.8912  18.7405 0010014 262.2671  97.7365 14.14814612841124
 EWS-G2 (GOES 15)        
 1 36411U 10008A   26037.42417604  .00000037  00000+0  00000+0 0  9998
 2 36411   0.9477  85.6904 0004764 200.6178  64.5237  1.00275731 58322
 COMS 1                  
 1 36744U 10032A   26037.66884865 -.00000343  00000+0  00000+0 0  9998
 2 36744   4.4730  77.2684 0001088 239.9858 188.4845  1.00274368 49786
 FENGYUN 3B              
 1 37214U 10059A   26037.62488625  .00000510  00000+0  28715-3 0  9992
 2 37214  98.9821  82.9728 0021838 194.4193 280.6049 14.14810700788968
 SUOMI NPP               
 1 37849U 11061A   26037.58885771  .00000151  00000+0  92735-4 0  9993
 2 37849  98.7835 339.4455 0001677  23.1332 336.9919 14.19534335739918
 METEOSAT-10 (MSG-3)     
 1 38552U 12035B   26037.34062893 -.00000007  00000+0  00000+0 0  9993
 2 38552   4.3618  61.5789 0002324 286.1065 271.3938  1.00272839 49549
 METOP-B                 
 1 38771U 12049A   26037.61376690  .00000161  00000+0  93652-4 0  9994
 2 38771  98.6708  91.6029 0002456  28.4142 331.7169 14.21434029694718
 INSAT-3D                
 1 39216U 13038B   26037.58021591 -.00000338  00000+0  00000+0 0  9998
 2 39216   1.5890  84.3012 0001719 220.0673 170.6954  1.00273812 45771
 FENGYUN 3C              
 1 39260U 13052A   26037.57879946  .00000181  00000+0  11337-3 0  9991
 2 39260  98.4839  17.5531 0015475  42.6626 317.5748 14.15718213640089
 METEOR-M 2              
 1 40069U 14037A   26037.57010537  .00000364  00000+0  18579-3 0  9995
 2 40069  98.4979  18.0359 0006835  60.5067 299.6792 14.21415164600761
 HIMAWARI-8              
 1 40267U 14060A   26037.58238259 -.00000273  00000+0  00000+0 0  9991
 2 40267   0.0457 252.0286 0000958  31.3580 203.5957  1.00278490 41450
 FENGYUN 2G              
 1 40367U 14090A   26037.64556289 -.00000299  00000+0  00000+0 0  9996
 2 40367   5.3089  74.4184 0001565 198.1345 195.9683  1.00263067 40698
 METEOSAT-11 (MSG-4)     
 1 40732U 15034A   26037.62779616  .00000065  00000+0  00000+0 0  9990
 2 40732   2.8728  71.8294 0001180 241.7344  58.8290  1.00268087  5909
 ELEKTRO-L 2             
 1 41105U 15074A   26037.40900929 -.00000118  00000+0  00000+0 0  9998
 2 41105   6.3653  72.1489 0003612 229.0998 328.0297  1.00272232 37198
 INSAT-3DR               
 1 41752U 16054A   26037.65505200 -.00000075  00000+0  00000+0 0  9997
 2 41752   0.0554  93.8053 0013744 184.8269 167.9427  1.00271627 34504
 HIMAWARI-9              
 1 41836U 16064A   26037.58238259 -.00000273  00000+0  00000+0 0  9990
 2 41836   0.0124 137.0088 0001068 210.1850 139.9064  1.00271322 33905
 GOES 16                 
 1 41866U 16071A   26037.60517604 -.00000089  00000+0  00000+0 0  9993
 2 41866   0.1490  94.1417 0002832 199.6896 316.0413  1.00271854 33798
 FENGYUN 4A              
 1 41882U 16077A   26037.65041625 -.00000356  00000+0  00000+0 0  9994
 2 41882   1.9907  81.7886 0006284 132.9819 279.8453  1.00276098 33627
 CYGFM05                 
 1 41884U 16078A   26037.42561482  .00027408  00000+0  46309-3 0  9992
 2 41884  34.9596  42.6579 0007295 332.2973  27.7361 15.50585086508404
 CYGFM04                 
 1 41885U 16078B   26037.34428483  .00032519  00000+0  49575-3 0  9994
 2 41885  34.9348  16.2836 0005718 359.2189   0.8525 15.53424088508589
 CYGFM02                 
 1 41886U 16078C   26037.35007768  .00035591  00000+0  50564-3 0  9998
 2 41886  34.9436  13.7490 0006836   2.8379 357.2383 15.55324468508720
 CYGFM01                 
 1 41887U 16078D   26037.39685921  .00028560  00000+0  47572-3 0  9999
 2 41887  34.9425  44.8029 0007415 323.1915  36.8298 15.50976884508344
 CYGFM08                 
 1 41888U 16078E   26037.34185185  .00031327  00000+0  49606-3 0  9997
 2 41888  34.9457  27.4597 0008083 350.5361   9.5208 15.52364941508578
 CYGFM07                 
 1 41890U 16078G   26037.32199955  .00032204  00000+0  49829-3 0  9990
 2 41890  34.9475  16.2411 0005914   7.0804 353.0002 15.53017084508593
 CYGFM03                 
 1 41891U 16078H   26037.35550653  .00031487  00000+0  48940-3 0  9995
 2 41891  34.9430  17.9804 0005939 349.1458  10.9136 15.52895386508574
 FENGYUN 3D              
 1 43010U 17072A   26037.62659924  .00000092  00000+0  65298-4 0  9990
 2 43010  98.9980   9.7978 0002479  69.6779 290.4663 14.19704535426460
 NOAA 20 (JPSS-1)        
 1 43013U 17073A   26037.60336371  .00000124  00000+0  79520-4 0  9999
 2 43013  98.7658 338.3064 0000377  14.6433 345.4754 14.19527655425942
 GOES 17                 
 1 43226U 18022A   26037.60794939 -.00000180  00000+0  00000+0 0  9993
 2 43226   0.6016  88.1527 0002754 213.0089 324.8756  1.00269924 29115
 FENGYUN 2H              
 1 43491U 18050A   26037.66161282 -.00000125  00000+0  00000+0 0  9992
 2 43491   2.6948  80.6967 0002145 171.8276 201.3055  1.00274855 28134
 METOP-C                 
 1 43689U 18087A   26037.63948662  .00000167  00000+0  96262-4 0  9998
 2 43689  98.6834  99.5280 0001629 143.8933 216.2355 14.21510040376280
 GEO-KOMPSAT-2A          
 1 43823U 18100A   26037.57995591  .00000000  00000+0  00000+0 0  9996
 2 43823   0.0152  95.1913 0001141 313.4173  65.1318  1.00271011 26327
 METEOR-M2 2             
 1 44387U 19038A   26037.58492015  .00000244  00000+0  12531-3 0  9993
 2 44387  98.9044  23.0180 0002141  55.2566 304.8814 14.24320728342700
 ARKTIKA-M 1             
 1 47719U 21016A   26035.90384421 -.00000136  00000+0  00000+0 0  9994
 2 47719  63.1930  76.4940 7230705 269.3476  15.2984  2.00623094 36131
 FENGYUN 3E              
 1 49008U 21062A   26037.62586080  .00000245  00000+0  13631-3 0  9992
 2 49008  98.7499  42.4910 0002627  96.2819 263.8657 14.19890127238058
 GOES 18                 
 1 51850U 22021A   26037.59876267  .00000098  00000+0  00000+0 0  9999
 2 51850   0.0198  91.3546 0000843 290.2366 193.6737  1.00273310  5288
 NOAA 21 (JPSS-2)        
 1 54234U 22150A   26037.56792604  .00000152  00000+0  92800-4 0  9995
 2 54234  98.7521 338.1972 0001388 169.8161 190.3044 14.19543641168012
 METEOSAT-12 (MTG-I1)    
 1 54743U 22170C   26037.62580281 -.00000006  00000+0  00000+0 0  9990
 2 54743   0.7119  25.1556 0002027 273.4388  63.0828  1.00270670 11667
 TIANMU-1 03             
 1 55973U 23039A   26037.63298084  .00025307  00000+0  57478-3 0  9994
 2 55973  97.5143 206.9374 0002852 198.5193 161.5950 15.43014921160671
 TIANMU-1 04             
 1 55974U 23039B   26037.59957323  .00027172  00000+0  60888-3 0  9999
 2 55974  97.5075 206.0729 0003605 196.0743 164.0390 15.43399931160675
 TIANMU-1 05             
 1 55975U 23039C   26037.60840428  .00024975  00000+0  56836-3 0  9995
 2 55975  97.5122 206.5750 0002421 224.3240 135.7814 15.42959696160653
 TIANMU-1 06             
 1 55976U 23039D   26037.60004198  .00024821  00000+0  55598-3 0  9996
 2 55976  97.5133 207.0788 0002810 218.0193 142.0857 15.43432906160673
 FENGYUN 3G              
 1 56232U 23055A   26037.30935013  .00046475  00000+0  74423-3 0  9993
 2 56232  49.9940 300.8928 0009962 237.3703 122.6303 15.52544991159665
 METEOR-M2 3             
 1 57166U 23091A   26037.62090481  .00000022  00000+0  28455-4 0  9999
 2 57166  98.6282  95.1607 0004003 174.5474 185.5750 14.24034408135931
 TIANMU-1 07             
 1 57399U 23101A   26037.63242936  .00011510  00000+0  41012-3 0  9991
 2 57399  97.2786  91.2606 0002747 218.4597 141.6448 15.29074661141694
 TIANMU-1 08             
 1 57400U 23101B   26037.66743594  .00011474  00000+0  41016-3 0  9996
 2 57400  97.2774  91.0783 0004440 227.8102 132.2762 15.28966110141699
 TIANMU-1 09             
 1 57401U 23101C   26037.65072558  .00011360  00000+0  40433-3 0  9997
 2 57401  97.2732  90.5514 0003773 229.5297 130.5615 15.29113177141698
 TIANMU-1 10             
 1 57402U 23101D   26037.61974057  .00011836  00000+0  42113-3 0  9994
 2 57402  97.2810  91.4302 0005461 233.7620 126.3116 15.29106286141685
 FENGYUN 3F              
 1 57490U 23111A   26037.61228373  .00000135  00000+0  84019-4 0  9997
 2 57490  98.6988 109.9815 0001494  99.6638 260.4707 14.19912110130332
 ARKTIKA-M 2             
 1 58584U 23198A   26037.15964049  .00000160  00000+0  00000+0 0  9994
 2 58584  63.2225 168.8508 6872222 267.8808  18.8364  2.00612776 15698
 TIANMU-1 11             
 1 58645U 23205A   26037.58628093  .00009545  00000+0  37951-3 0  9999
 2 58645  97.3574  61.2485 0010997 103.8713 256.3749 15.25445149117601
 TIANMU-1 12             
 1 58646U 23205B   26037.61705312  .00010066  00000+0  40129-3 0  9995
 2 58646  97.3561  61.0663 0009308  89.8253 270.4052 15.25355570117590
 TIANMU-1 13             
 1 58647U 23205C   26037.64894829  .00010029  00000+0  39925-3 0  9992
 2 58647  97.3589  61.3229 0009456  74.8265 285.4018 15.25403883117592
 TIANMU-1 14             
 1 58648U 23205D   26037.63305929  .00009719  00000+0  38718-3 0  9993
 2 58648  97.3523  60.6045 0010314  77.9995 282.2399 15.25381326117592
 TIANMU-1 19             
 1 58660U 23208A   26037.58812600  .00016491  00000+0  58449-3 0  9991
 2 58660  97.4377 153.5627 0006125  66.0574 294.1307 15.29155961117352
 TIANMU-1 20             
 1 58661U 23208B   26037.59661536  .00016638  00000+0  56823-3 0  9990
 2 58661  97.4315 154.0738 0008420  72.4906 287.7255 15.30347593117439
 TIANMU-1 21             
 1 58662U 23208C   26037.56944589  .00017161  00000+0  55253-3 0  9998
 2 58662  97.4367 156.2063 0008160  67.8039 292.4068 15.32247056117540
 TIANMU-1 22             
 1 58663U 23208D   26037.59847459  .00015396  00000+0  55169-3 0  9994
 2 58663  97.4371 153.6033 0005010  87.2275 272.9538 15.28818503117364
 TIANMU-1 15             
 1 58700U 24004A   26037.63062994  .00009739  00000+0  38850-3 0  9991
 2 58700  97.4651 223.9243 0008449  88.7599 271.4607 15.25356935115862
 TIANMU-1 16             
 1 58701U 24004B   26037.61474986  .00010691  00000+0  42590-3 0  9993
 2 58701  97.4590 223.2544 0006831  91.0928 269.1093 15.25387104115863
 TIANMU-1 17             
 1 58702U 24004C   26037.59783649  .00011079  00000+0  44078-3 0  9994
 2 58702  97.4624 223.6760 0006020  92.0871 268.1056 15.25425175115852
 TIANMU-1 18             
 1 58703U 24004D   26037.64767373  .00010786  00000+0  42976-3 0  9996
 2 58703  97.4642 223.9320 0005432  91.0134 269.1726 15.25387870115860
 INSAT-3DS               
 1 58990U 24033A   26037.64159978 -.00000153  00000+0  00000+0 0  9998
 2 58990   0.0277 242.2492 0001855  99.2205 108.3003  1.00271452 45758
 METEOR-M2 4             
 1 59051U 24039A   26037.62796654  .00000070  00000+0  51194-4 0  9991
 2 59051  98.6849 358.6843 0006923 178.9165 181.2029 14.22412185100701
 GOES 19                 
 1 60133U 24119A   26037.61098274 -.00000246  00000+0  00000+0 0  9996
 2 60133   0.0027 288.6290 0001204  74.2636 278.5881  1.00270967  5651
 FENGYUN 3H              
 1 65815U 25219A   26037.60879211  .00000151  00000+0  91464-4 0  9990
 2 65815  98.6649 341.0050 0001596  86.5100 273.6260 14.19924132 18857
@@ -843,7 +843,6 @@ class ModeManager:
                'anomalies': getattr(self, 'tscm_anomalies', []),
                'baseline': getattr(self, 'tscm_baseline', {}),
                'wifi_devices': list(self.wifi_networks.values()),
                'wifi_clients': list(getattr(self, 'tscm_wifi_clients', {}).values()),
                'bt_devices': list(self.bluetooth_devices.values()),
                'rf_signals': getattr(self, 'tscm_rf_signals', []),
            }
@@ -1117,7 +1116,6 @@ class ModeManager:
            self.tscm_anomalies = []
            self.tscm_baseline = {}
            self.tscm_rf_signals = []
            self.tscm_wifi_clients = {}
            # Clear reported threat tracking sets
            if hasattr(self, '_tscm_reported_wifi'):
                self._tscm_reported_wifi.clear()
@@ -1543,7 +1541,6 @@ class ModeManager:
        """Start WiFi scanning using Intercept's UnifiedWiFiScanner."""
        interface = params.get('interface')
        channel = params.get('channel')
        channels = params.get('channels')
        band = params.get('band', 'abg')
        scan_type = params.get('scan_type', 'deep')
@@ -1574,21 +1571,8 @@ class ModeManager:
            else:
                scan_band = 'all'
            channel_list = None
            if channels:
                if isinstance(channels, str):
                    channel_list = [c.strip() for c in channels.split(',') if c.strip()]
                elif isinstance(channels, (list, tuple, set)):
                    channel_list = list(channels)
                else:
                    channel_list = [channels]
                try:
                    channel_list = [int(c) for c in channel_list]
                except (TypeError, ValueError):
                    return {'status': 'error', 'message': 'Invalid channels'}
            # Start deep scan
-            if scanner.start_deep_scan(interface=interface, band=scan_band, channel=channel, channels=channel_list):
+            if scanner.start_deep_scan(interface=interface, band=scan_band, channel=channel):
                # Start thread to sync data to agent's dictionaries
                thread = threading.Thread(
                    target=self._wifi_data_sync,
@@ -1609,7 +1593,7 @@ class ModeManager:
        except ImportError:
            # Fallback to direct airodump-ng
-            return self._start_wifi_fallback(interface, channel, band, channels)
+            return self._start_wifi_fallback(interface, channel, band)
        except Exception as e:
            logger.error(f"WiFi scanner error: {e}")
            return {'status': 'error', 'message': str(e)}
@@ -1646,13 +1630,7 @@ class ModeManager:
        if hasattr(self, '_wifi_scanner_instance') and self._wifi_scanner_instance:
            self._wifi_scanner_instance.stop_deep_scan()
-    def _start_wifi_fallback(
+    def _start_wifi_fallback(self, interface: str | None, channel: int | None, band: str) -> dict:
        self,
        interface: str | None,
        channel: int | None,
        band: str,
        channels: list[int] | str | None = None,
    ) -> dict:
        """Fallback WiFi deep scan using airodump-ng directly."""
        if not interface:
            return {'status': 'error', 'message': 'WiFi interface required'}
@@ -1680,22 +1658,7 @@ class ModeManager:
        cmd = [airodump_path, '-w', csv_path, '--output-format', output_formats, '--band', band]
        if gps_manager.is_running:
            cmd.append('--gpsd')
-        channel_list = None
+        if channel:
        if channels:
            if isinstance(channels, str):
                channel_list = [c.strip() for c in channels.split(',') if c.strip()]
            elif isinstance(channels, (list, tuple, set)):
                channel_list = list(channels)
            else:
                channel_list = [channels]
            try:
                channel_list = [int(c) for c in channel_list]
            except (TypeError, ValueError):
                return {'status': 'error', 'message': 'Invalid channels'}
        if channel_list:
            cmd.extend(['-c', ','.join(str(c) for c in channel_list)])
        elif channel:
            cmd.extend(['-c', str(channel)])
        cmd.append(interface)
@@ -2022,7 +1985,7 @@ class ModeManager:
                    'agent_gps': gps_manager.position
                }
-            scanner.add_device_callback(on_device_updated)
+            scanner.set_on_device_updated(on_device_updated)
            # Start scanning
            if scanner.start_scan(mode=mode_param, duration_s=duration):
@@ -3150,10 +3113,7 @@ class ModeManager:
            self.tscm_anomalies = []
        if not hasattr(self, 'tscm_rf_signals'):
            self.tscm_rf_signals = []
        if not hasattr(self, 'tscm_wifi_clients'):
            self.tscm_wifi_clients = {}
        self.tscm_anomalies.clear()
        self.tscm_wifi_clients.clear()
        # Get params for what to scan
        scan_wifi = params.get('wifi', True)
@@ -3208,7 +3168,7 @@ class ModeManager:
        stop_event = self.stop_events.get(mode)
        # Import existing Intercept TSCM functions
-        from routes.tscm import _scan_wifi_networks, _scan_wifi_clients, _scan_bluetooth_devices, _scan_rf_signals
+        from routes.tscm import _scan_wifi_networks, _scan_bluetooth_devices, _scan_rf_signals
        logger.info("TSCM imports successful")
        sweep_ranges = None
@@ -3243,7 +3203,6 @@ class ModeManager:
        # Track devices seen during this sweep (like local mode's all_wifi/all_bt dicts)
        seen_wifi = {}
        seen_wifi_clients = {}
        seen_bt = {}
        last_rf_scan = 0
@@ -3304,47 +3263,6 @@ class ModeManager:
                                    enriched['recommended_action'] = profile.recommended_action
                                self.wifi_networks[bssid] = enriched
                        # WiFi clients (monitor mode only)
                        try:
                            wifi_clients = _scan_wifi_clients(wifi_interface or '')
                            for client in wifi_clients:
                                mac = (client.get('mac') or '').upper()
                                if not mac or mac in seen_wifi_clients:
                                    continue
                                seen_wifi_clients[mac] = client
                                rssi_val = client.get('rssi_current')
                                if rssi_val is None:
                                    rssi_val = client.get('rssi_median') or client.get('rssi_ema')
                                client_device = {
                                    'mac': mac,
                                    'vendor': client.get('vendor'),
                                    'name': client.get('vendor') or 'WiFi Client',
                                    'rssi': rssi_val,
                                    'associated_bssid': client.get('associated_bssid'),
                                    'probed_ssids': client.get('probed_ssids', []),
                                    'probe_count': client.get('probe_count', len(client.get('probed_ssids', []))),
                                    'is_client': True,
                                }
                                if self._tscm_correlation:
                                    profile = self._tscm_correlation.analyze_wifi_device(client_device)
                                    client_device['classification'] = profile.risk_level.value
                                    client_device['score'] = profile.total_score
                                    client_device['score_modifier'] = profile.score_modifier
                                    client_device['known_device'] = profile.known_device
                                    client_device['known_device_name'] = profile.known_device_name
                                    client_device['indicators'] = [
                                        {'type': i.type.value, 'desc': i.description}
                                        for i in profile.indicators
                                    ]
                                    client_device['recommended_action'] = profile.recommended_action
                                self.tscm_wifi_clients[mac] = client_device
                        except Exception as e:
                            logger.debug(f"WiFi client scan error: {e}")
                    except Exception as e:
                        logger.debug(f"WiFi scan error: {e}")
@@ -1,10 +1,10 @@
 [project]
 name = "intercept"
-version = "2.21.0"
+version = "2.14.0"
 description = "Signal Intelligence Platform - Pager/433MHz/ADS-B/Satellite/WiFi/Bluetooth"
 readme = "README.md"
 requires-python = ">=3.9"
-license = {text = "Apache-2.0"}
+license = {text = "MIT"}
 authors = [
    {name = "Intercept Contributors"}
 ]
@@ -14,7 +14,7 @@ classifiers = [
    "Environment :: Web Environment",
    "Framework :: Flask",
    "Intended Audience :: Developers",
-    "License :: OSI Approved :: Apache Software License",
+    "License :: OSI Approved :: MIT License",
    "Operating System :: POSIX :: Linux",
    "Operating System :: MacOS",
    "Programming Language :: Python :: 3",
@@ -32,9 +32,6 @@ scapy>=2.4.5
 # QR code generation for Meshtastic channels (optional)
 qrcode[pil]>=7.4
 # BLE RPA resolution for BT Locate (optional - for SAR device tracking)
 cryptography>=41.0.0
 # Development dependencies (install with: pip install -r requirements-dev.txt)
 # pytest>=7.0.0
 # pytest-cov>=4.0.0
@@ -13,7 +13,6 @@ def register_blueprints(app):
    from .ais import ais_bp
    from .dsc import dsc_bp
    from .acars import acars_bp
    from .vdl2 import vdl2_bp
    from .aprs import aprs_bp
    from .satellite import satellite_bp
    from .gps import gps_bp
@@ -27,16 +26,9 @@ def register_blueprints(app):
    from .offline import offline_bp
    from .updater import updater_bp
    from .sstv import sstv_bp
    from .weather_sat import weather_sat_bp
    from .sstv_general import sstv_general_bp
    from .dmr import dmr_bp
    from .websdr import websdr_bp
    from .alerts import alerts_bp
    from .recordings import recordings_bp
    from .subghz import subghz_bp
    from .bt_locate import bt_locate_bp
    from .analytics import analytics_bp
    from .space_weather import space_weather_bp
    app.register_blueprint(pager_bp)
    app.register_blueprint(sensor_bp)
@@ -49,7 +41,6 @@ def register_blueprints(app):
    app.register_blueprint(ais_bp)
    app.register_blueprint(dsc_bp)  # VHF DSC maritime distress
    app.register_blueprint(acars_bp)
    app.register_blueprint(vdl2_bp)
    app.register_blueprint(aprs_bp)
    app.register_blueprint(satellite_bp)
    app.register_blueprint(gps_bp)
@@ -63,16 +54,9 @@ def register_blueprints(app):
    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(weather_sat_bp)  # NOAA/Meteor weather satellite decoder
    app.register_blueprint(sstv_general_bp)  # General terrestrial SSTV
    app.register_blueprint(dmr_bp)  # DMR / P25 / Digital Voice
    app.register_blueprint(websdr_bp)  # HF/Shortwave WebSDR
    app.register_blueprint(alerts_bp)  # Cross-mode alerts
    app.register_blueprint(recordings_bp)  # Session recordings
    app.register_blueprint(subghz_bp)  # SubGHz transceiver (HackRF)
    app.register_blueprint(bt_locate_bp)  # BT Locate SAR device tracking
    app.register_blueprint(analytics_bp)  # Cross-mode analytics dashboard
    app.register_blueprint(space_weather_bp)  # Space weather monitoring
    # Initialize TSCM state with queue and lock from app
    import app as app_module
@@ -20,9 +20,7 @@ from flask import Blueprint, jsonify, request, Response
 import app as app_module
 from utils.logging import sensor_logger as logger
 from utils.validation import validate_device_index, validate_gain, validate_ppm
-from utils.sdr import SDRFactory, SDRType
+from utils.sse import format_sse
 from utils.sse import sse_stream_fanout
 from utils.event_pipeline import process_event
 from utils.constants import (
    PROCESS_TERMINATE_TIMEOUT,
    SSE_KEEPALIVE_INTERVAL,
@@ -35,8 +33,11 @@ acars_bp = Blueprint('acars', __name__, url_prefix='/acars')
 # Default VHF ACARS frequencies (MHz) - common worldwide
 DEFAULT_ACARS_FREQUENCIES = [
-    '131.725',  # North America
+    '131.550',  # Primary worldwide
-    '131.825',  # North America
+    '130.025',  # Secondary USA/Canada
    '129.125',  # USA
    '131.525',  # Europe
    '131.725',  # Europe secondary
 ]
 # Message counter for statistics
@@ -126,13 +127,6 @@ def stream_acars_output(process: subprocess.Popen, is_text_mode: bool = False) -
                app_module.acars_queue.put(data)
                # Feed flight correlator
                try:
                    from utils.flight_correlator import get_flight_correlator
                    get_flight_correlator().add_acars_message(data)
                except Exception:
                    pass
                # Log if enabled
                if app_module.logging_enabled:
                    try:
@@ -255,22 +249,12 @@ def start_acars() -> Response:
    acars_message_count = 0
    acars_last_message_time = None
    # Resolve SDR type for device selection
    sdr_type_str = data.get('sdr_type', 'rtlsdr')
    try:
        sdr_type = SDRType(sdr_type_str)
    except ValueError:
        sdr_type = SDRType.RTL_SDR
    is_soapy = sdr_type not in (SDRType.RTL_SDR,)
    # Build acarsdec command
    # 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> ...
-    # SoapySDR devices: TLeconte uses -d <device_string>, f00b4r0 uses --soapysdr <device_string>
+    # Note: gain/ppm must come BEFORE -r
    # Note: gain/ppm must come BEFORE -r/-d
    json_flag = get_acarsdec_json_flag(acarsdec_path)
    cmd = [acarsdec_path]
    if json_flag == '--output':
@@ -281,33 +265,21 @@ def start_acars() -> Response:
    else:
        cmd.extend(['-o', '4'])  # JSON output (TLeconte v3.x)
-    # Add gain if not auto (must be before -r/-d)
+    # Add gain if not auto (must be before -r)
    if gain and str(gain) != '0':
        cmd.extend(['-g', str(gain)])
-    # Add PPM correction if specified (must be before -r/-d)
+    # Add PPM correction if specified (must be before -r)
    if ppm and str(ppm) != '0':
        cmd.extend(['-p', str(ppm)])
    # Add device and frequencies
-    if is_soapy:
+    # f00b4r0 uses --rtlsdr <device>, TLeconte uses -r <device>
        # SoapySDR device (SDRplay, LimeSDR, Airspy, etc.)
        sdr_device = SDRFactory.create_default_device(sdr_type, index=device_int)
        # Build SoapySDR driver string (e.g., "driver=sdrplay,serial=...")
        builder = SDRFactory.get_builder(sdr_type)
        device_str = builder._build_device_string(sdr_device)
    if json_flag == '--output':
            cmd.extend(['-m', '256'])
            cmd.extend(['--soapysdr', device_str])
        else:
            cmd.extend(['-d', device_str])
    elif json_flag == '--output':
        # f00b4r0 fork RTL-SDR: --rtlsdr <device>
        # Use 3.2 MS/s sample rate for wider bandwidth (handles NA frequency span)
        cmd.extend(['-m', '256'])
        cmd.extend(['--rtlsdr', str(device)])
    else:
        # TLeconte fork RTL-SDR: -r <device>
        cmd.extend(['-r', str(device)])
    cmd.extend(frequencies)
@@ -414,19 +386,21 @@ def stop_acars() -> Response:
@acars_bp.route('/stream')
 def stream_acars() -> Response:
    """SSE stream for ACARS messages."""
-    def _on_msg(msg: dict[str, Any]) -> None:
+    def generate() -> Generator[str, None, None]:
-        process_event('acars', msg, msg.get('type'))
+        last_keepalive = time.time()
-    response = Response(
+        while True:
-        sse_stream_fanout(
+            try:
-            source_queue=app_module.acars_queue,
+                msg = app_module.acars_queue.get(timeout=SSE_QUEUE_TIMEOUT)
-            channel_key='acars',
+                last_keepalive = time.time()
-            timeout=SSE_QUEUE_TIMEOUT,
+                yield format_sse(msg)
-            keepalive_interval=SSE_KEEPALIVE_INTERVAL,
+            except queue.Empty:
-            on_message=_on_msg,
+                now = time.time()
-        ),
+                if now - last_keepalive >= SSE_KEEPALIVE_INTERVAL:
-        mimetype='text/event-stream',
+                    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
@@ -438,7 +412,7 @@ def get_frequencies() -> Response:
    return jsonify({
        'default': DEFAULT_ACARS_FREQUENCIES,
        'regions': {
-            'north_america': ['131.725', '131.825'],
+            'north_america': ['129.125', '130.025', '130.450', '131.550'],
            'europe': ['131.525', '131.725', '131.550'],
            'asia_pacific': ['131.550', '131.450'],
        }
@@ -38,13 +38,11 @@ from config import (
    SHARED_OBSERVER_LOCATION_ENABLED,
 )
 from utils.logging import adsb_logger as logger
 from utils.process import write_dump1090_pid, clear_dump1090_pid, cleanup_stale_dump1090
 from utils.validation import (
    validate_device_index, validate_gain,
    validate_rtl_tcp_host, validate_rtl_tcp_port
 )
 from utils.sse import format_sse
 from utils.event_pipeline import process_event
 from utils.sdr import SDRFactory, SDRType
 from utils.constants import (
    ADSB_SBS_PORT,
@@ -77,11 +75,6 @@ _sbs_error_logged = False  # Suppress repeated connection error logs
 # Track ICAOs already looked up in aircraft database (avoid repeated lookups)
 _looked_up_icaos: set[str] = set()
 # Per-client SSE queues for ADS-B stream fanout.
 _adsb_stream_subscribers: set[queue.Queue] = set()
 _adsb_stream_subscribers_lock = threading.Lock()
 _ADSB_STREAM_CLIENT_QUEUE_SIZE = 500
 # Load aircraft database at module init
 aircraft_db.load_database()
@@ -208,31 +201,6 @@ def _parse_int_param(value: str | None, default: int, min_value: int | None = No
    return parsed
 def _broadcast_adsb_update(payload: dict[str, Any]) -> None:
    """Fan out a payload to all active ADS-B SSE subscribers."""
    with _adsb_stream_subscribers_lock:
        subscribers = tuple(_adsb_stream_subscribers)
    for subscriber in subscribers:
        try:
            subscriber.put_nowait(payload)
        except queue.Full:
            # Drop oldest queued event for that client and try once more.
            try:
                subscriber.get_nowait()
                subscriber.put_nowait(payload)
            except (queue.Empty, queue.Full):
                # Client queue remains saturated; skip this payload.
                continue
 def _adsb_stream_queue_depth() -> int:
    """Best-effort aggregate queue depth across connected ADS-B SSE clients."""
    with _adsb_stream_subscribers_lock:
        subscribers = tuple(_adsb_stream_subscribers)
    return sum(subscriber.qsize() for subscriber in subscribers)
 def _get_active_session() -> dict[str, Any] | None:
    if not ADSB_HISTORY_ENABLED or not PSYCOPG2_AVAILABLE:
        return None
@@ -469,12 +437,6 @@ def parse_sbs_stream(service_addr):
                            if parts[16]:
                                try:
                                    aircraft['vertical_rate'] = int(float(parts[16]))
                                    if abs(aircraft['vertical_rate']) > 4000:
                                        process_event('adsb', {
                                            'type': 'vertical_rate_anomaly', 'icao': icao,
                                            'callsign': aircraft.get('callsign', ''),
                                            'vertical_rate': aircraft['vertical_rate'],
                                        }, 'vertical_rate_anomaly')
                                except (ValueError, TypeError):
                                    pass
@@ -492,14 +454,6 @@ def parse_sbs_stream(service_addr):
                        elif msg_type == '6' and len(parts) > 17:
                            if parts[17]:
                                aircraft['squawk'] = parts[17]
                                sq = parts[17].strip()
                                _EMERGENCY_SQUAWKS = {'7700': 'General Emergency', '7600': 'Comms Failure', '7500': 'Hijack'}
                                if sq in _EMERGENCY_SQUAWKS:
                                    process_event('adsb', {
                                        'type': 'squawk_emergency', 'icao': icao,
                                        'callsign': aircraft.get('callsign', ''),
                                        'squawk': sq, 'meaning': _EMERGENCY_SQUAWKS[sq],
                                    }, 'squawk_emergency')
                        app_module.adsb_aircraft.set(icao, aircraft)
                        pending_updates.add(icao)
@@ -511,7 +465,7 @@ def parse_sbs_stream(service_addr):
                            for update_icao in pending_updates:
                                if update_icao in app_module.adsb_aircraft:
                                    snapshot = app_module.adsb_aircraft[update_icao]
-                                    _broadcast_adsb_update({
+                                    app_module.adsb_queue.put({
                                        'type': 'aircraft',
                                        **snapshot
                                    })
@@ -532,19 +486,6 @@ def parse_sbs_stream(service_addr):
                                        'source_host': service_addr,
                                        'snapshot': snapshot,
                                    })
                                    # Geofence check
                                    _gf_lat = snapshot.get('lat')
                                    _gf_lon = snapshot.get('lon')
                                    if _gf_lat is not None and _gf_lon is not None:
                                        try:
                                            from utils.geofence import get_geofence_manager
                                            for _gf_evt in get_geofence_manager().check_position(
                                                update_icao, 'aircraft', _gf_lat, _gf_lon,
                                                {'callsign': snapshot.get('callsign'), 'altitude': snapshot.get('altitude')}
                                            ):
                                                process_event('adsb', _gf_evt, 'geofence')
                                        except Exception:
                                            pass
                            pending_updates.clear()
                            last_update = now
@@ -610,7 +551,7 @@ def adsb_status():
        'last_message_time': adsb_last_message_time,
        'aircraft_count': len(app_module.adsb_aircraft),
        'aircraft': dict(app_module.adsb_aircraft),  # Full aircraft data
-        'queue_size': _adsb_stream_queue_depth(),
+        'queue_size': app_module.adsb_queue.qsize(),
        'dump1090_path': find_dump1090(),
        'dump1090_running': dump1090_running,
        'port_30003_open': check_dump1090_service() is not None
@@ -691,9 +632,6 @@ def start_adsb():
            'session': session
        })
    # Kill any stale app-spawned dump1090 from a previous run before checking the port
    cleanup_stale_dump1090()
    # Check if dump1090 is already running externally (e.g., user started it manually)
    existing_service = check_dump1090_service()
    if existing_service:
@@ -746,7 +684,6 @@ def start_adsb():
            except (ProcessLookupError, OSError):
                pass
        app_module.adsb_process = None
        clear_dump1090_pid()
        logger.info("Killed stale ADS-B process")
    # Check if device is available before starting local dump1090
@@ -783,7 +720,6 @@ def start_adsb():
            stderr=subprocess.PIPE,
            start_new_session=True  # Create new process group for clean shutdown
        )
        write_dump1090_pid(app_module.adsb_process.pid)
        time.sleep(DUMP1090_START_WAIT)
@@ -882,7 +818,6 @@ def stop_adsb():
                except (ProcessLookupError, OSError):
                    pass
            app_module.adsb_process = None
            clear_dump1090_pid()
            logger.info("ADS-B process stopped")
        # Release device from registry
@@ -901,39 +836,19 @@ def stop_adsb():
@adsb_bp.route('/stream')
 def stream_adsb():
    """SSE stream for ADS-B aircraft."""
    client_queue: queue.Queue = queue.Queue(maxsize=_ADSB_STREAM_CLIENT_QUEUE_SIZE)
    with _adsb_stream_subscribers_lock:
        _adsb_stream_subscribers.add(client_queue)
    # Prime new clients with current known aircraft so they don't wait for the
    # next positional update before rendering.
    for snapshot in list(app_module.adsb_aircraft.values()):
        try:
            client_queue.put_nowait({'type': 'aircraft', **snapshot})
        except queue.Full:
            break
    def generate():
        last_keepalive = time.time()
        try:
        while True:
            try:
-                    msg = client_queue.get(timeout=SSE_QUEUE_TIMEOUT)
+                msg = app_module.adsb_queue.get(timeout=SSE_QUEUE_TIMEOUT)
                last_keepalive = time.time()
                    try:
                        process_event('adsb', msg, msg.get('type'))
                    except Exception:
                        pass
                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
        finally:
            with _adsb_stream_subscribers_lock:
                _adsb_stream_subscribers.discard(client_queue)
    response = Response(generate(), mimetype='text/event-stream')
    response.headers['Cache-Control'] = 'no-cache'
@@ -1176,17 +1091,3 @@ def aircraft_photo(registration: str):
    except Exception as e:
        logger.debug(f"Error fetching aircraft photo: {e}")
        return jsonify({'success': False, 'error': str(e)}), 500
@adsb_bp.route('/aircraft/<icao>/messages')
 def get_aircraft_messages(icao: str):
    """Get correlated ACARS/VDL2 messages for an aircraft."""
    if not icao or not all(c in '0123456789ABCDEFabcdef' for c in icao):
        return jsonify({'status': 'error', 'message': 'Invalid ICAO'}), 400
    aircraft = app_module.adsb_aircraft.get(icao.upper())
    callsign = aircraft.get('callsign') if aircraft else None
    from utils.flight_correlator import get_flight_correlator
    messages = get_flight_correlator().get_messages_for_aircraft(icao=icao.upper(), callsign=callsign)
    return jsonify({'status': 'success', 'icao': icao.upper(), **messages})
@@ -18,8 +18,7 @@ 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 sse_stream_fanout
+from utils.sse import format_sse
 from utils.event_pipeline import process_event
 from utils.sdr import SDRFactory, SDRType
 from utils.constants import (
    AIS_TCP_PORT,
@@ -124,27 +123,13 @@ def parse_ais_stream(port: int):
                    if now - last_update >= AIS_UPDATE_INTERVAL:
                        for mmsi in pending_updates:
                            if mmsi in app_module.ais_vessels:
                                _vessel_snap = app_module.ais_vessels[mmsi]
                                try:
                                    app_module.ais_queue.put_nowait({
                                        'type': 'vessel',
-                                        **_vessel_snap
+                                        **app_module.ais_vessels[mmsi]
                                    })
                                except queue.Full:
                                    pass
                                # Geofence check
                                _v_lat = _vessel_snap.get('lat')
                                _v_lon = _vessel_snap.get('lon')
                                if _v_lat and _v_lon:
                                    try:
                                        from utils.geofence import get_geofence_manager
                                        for _gf_evt in get_geofence_manager().check_position(
                                            mmsi, 'vessel', _v_lat, _v_lon,
                                            {'name': _vessel_snap.get('name'), 'ship_type': _vessel_snap.get('ship_type_text')}
                                        ):
                                            process_event('ais', _gf_evt, 'geofence')
                                    except Exception:
                                        pass
                        pending_updates.clear()
                        last_update = now
@@ -296,16 +281,6 @@ def process_ais_message(msg: dict) -> dict | None:
    # Timestamp
    vessel['last_seen'] = time.time()
    # Check for DSC DISTRESS matching this MMSI
    try:
        for _dsc_key, _dsc_msg in app_module.dsc_messages.items():
            if (str(_dsc_msg.get('source_mmsi', '')) == mmsi
                    and _dsc_msg.get('category', '').upper() == 'DISTRESS'):
                vessel['dsc_distress'] = True
                break
    except Exception:
        pass
    return vessel
@@ -502,41 +477,26 @@ def stop_ais():
@ais_bp.route('/stream')
 def stream_ais():
    """SSE stream for AIS vessels."""
-    def _on_msg(msg: dict[str, Any]) -> None:
+    def generate() -> Generator[str, None, None]:
-        process_event('ais', msg, msg.get('type'))
+        last_keepalive = time.time()
-    response = Response(
+        while True:
-        sse_stream_fanout(
+            try:
-            source_queue=app_module.ais_queue,
+                msg = app_module.ais_queue.get(timeout=SSE_QUEUE_TIMEOUT)
-            channel_key='ais',
+                last_keepalive = time.time()
-            timeout=SSE_QUEUE_TIMEOUT,
+                yield format_sse(msg)
-            keepalive_interval=SSE_KEEPALIVE_INTERVAL,
+            except queue.Empty:
-            on_message=_on_msg,
+                now = time.time()
-        ),
+                if now - last_keepalive >= SSE_KEEPALIVE_INTERVAL:
-        mimetype='text/event-stream',
+                    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
@ais_bp.route('/vessel/<mmsi>/dsc')
 def get_vessel_dsc(mmsi: str):
    """Get DSC messages associated with a vessel MMSI."""
    if not mmsi or not mmsi.isdigit():
        return jsonify({'status': 'error', 'message': 'Invalid MMSI'}), 400
    matches = []
    try:
        for key, msg in app_module.dsc_messages.items():
            if str(msg.get('source_mmsi', '')) == mmsi:
                matches.append(dict(msg))
    except Exception:
        pass
    return jsonify({'status': 'success', 'mmsi': mmsi, 'dsc_messages': matches})
@ais_bp.route('/dashboard')
 def ais_dashboard():
    """Popout AIS dashboard."""
@@ -1,76 +0,0 @@
 """Alerting API endpoints."""
 from __future__ import annotations
 import queue
 import time
 from typing import Generator
 from flask import Blueprint, Response, jsonify, request
 from utils.alerts import get_alert_manager
 from utils.sse import format_sse
 alerts_bp = Blueprint('alerts', __name__, url_prefix='/alerts')
@alerts_bp.route('/rules', methods=['GET'])
 def list_rules():
    manager = get_alert_manager()
    include_disabled = request.args.get('all') in ('1', 'true', 'yes')
    return jsonify({'status': 'success', 'rules': manager.list_rules(include_disabled=include_disabled)})
@alerts_bp.route('/rules', methods=['POST'])
 def create_rule():
    data = request.get_json() or {}
    if not isinstance(data.get('match', {}), dict):
        return jsonify({'status': 'error', 'message': 'match must be a JSON object'}), 400
    manager = get_alert_manager()
    rule_id = manager.add_rule(data)
    return jsonify({'status': 'success', 'rule_id': rule_id})
@alerts_bp.route('/rules/<int:rule_id>', methods=['PUT', 'PATCH'])
 def update_rule(rule_id: int):
    data = request.get_json() or {}
    manager = get_alert_manager()
    ok = manager.update_rule(rule_id, data)
    if not ok:
        return jsonify({'status': 'error', 'message': 'Rule not found or no changes'}), 404
    return jsonify({'status': 'success'})
@alerts_bp.route('/rules/<int:rule_id>', methods=['DELETE'])
 def delete_rule(rule_id: int):
    manager = get_alert_manager()
    ok = manager.delete_rule(rule_id)
    if not ok:
        return jsonify({'status': 'error', 'message': 'Rule not found'}), 404
    return jsonify({'status': 'success'})
@alerts_bp.route('/events', methods=['GET'])
 def list_events():
    manager = get_alert_manager()
    limit = request.args.get('limit', default=100, type=int)
    mode = request.args.get('mode')
    severity = request.args.get('severity')
    events = manager.list_events(limit=limit, mode=mode, severity=severity)
    return jsonify({'status': 'success', 'events': events})
@alerts_bp.route('/stream', methods=['GET'])
 def stream_alerts() -> Response:
    manager = get_alert_manager()
    def generate() -> Generator[str, None, None]:
        for event in manager.stream_events(timeout=1.0):
            yield format_sse(event)
    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
@@ -1,528 +0,0 @@
 """Analytics dashboard: cross-mode summary, activity sparklines, export, geofence CRUD."""
 from __future__ import annotations
 import csv
 import io
 import json
 from datetime import datetime, timezone
 from typing import Any
 from flask import Blueprint, Response, jsonify, request
 import app as app_module
 from utils.analytics import (
    get_activity_tracker,
    get_cross_mode_summary,
    get_emergency_squawks,
    get_mode_health,
 )
 from utils.alerts import get_alert_manager
 from utils.flight_correlator import get_flight_correlator
 from utils.geofence import get_geofence_manager
 from utils.temporal_patterns import get_pattern_detector
 analytics_bp = Blueprint('analytics', __name__, url_prefix='/analytics')
 # Map mode names to DataStore attribute(s)
 MODE_STORES: dict[str, list[str]] = {
    'adsb': ['adsb_aircraft'],
    'ais': ['ais_vessels'],
    'wifi': ['wifi_networks', 'wifi_clients'],
    'bluetooth': ['bt_devices'],
    'dsc': ['dsc_messages'],
 }
@analytics_bp.route('/summary')
 def analytics_summary():
    """Return cross-mode counts, health, and emergency squawks."""
    return jsonify({
        'status': 'success',
        'counts': get_cross_mode_summary(),
        'health': get_mode_health(),
        'squawks': get_emergency_squawks(),
        'flight_messages': {
            'acars': get_flight_correlator().acars_count,
            'vdl2': get_flight_correlator().vdl2_count,
        },
    })
@analytics_bp.route('/activity')
 def analytics_activity():
    """Return sparkline arrays for each mode."""
    tracker = get_activity_tracker()
    return jsonify({
        'status': 'success',
        'sparklines': tracker.get_all_sparklines(),
    })
@analytics_bp.route('/squawks')
 def analytics_squawks():
    """Return current emergency squawk codes from ADS-B."""
    return jsonify({
        'status': 'success',
        'squawks': get_emergency_squawks(),
    })
@analytics_bp.route('/patterns')
 def analytics_patterns():
    """Return detected temporal patterns."""
    return jsonify({
        'status': 'success',
        'patterns': get_pattern_detector().get_all_patterns(),
    })
@analytics_bp.route('/target')
 def analytics_target():
    """Search entities across multiple modes for a target-centric view."""
    query = (request.args.get('q') or '').strip()
    requested_limit = request.args.get('limit', default=120, type=int) or 120
    limit = max(1, min(500, requested_limit))
    if not query:
        return jsonify({
            'status': 'success',
            'query': '',
            'results': [],
            'mode_counts': {},
        })
    needle = query.lower()
    results: list[dict[str, Any]] = []
    mode_counts: dict[str, int] = {}
    def push(mode: str, entity_id: str, title: str, subtitle: str, last_seen: str | None = None) -> None:
        if len(results) >= limit:
            return
        results.append({
            'mode': mode,
            'id': entity_id,
            'title': title,
            'subtitle': subtitle,
            'last_seen': last_seen,
        })
        mode_counts[mode] = mode_counts.get(mode, 0) + 1
    # ADS-B
    for icao, aircraft in app_module.adsb_aircraft.items():
        if not isinstance(aircraft, dict):
            continue
        fields = [
            icao,
            aircraft.get('icao'),
            aircraft.get('hex'),
            aircraft.get('callsign'),
            aircraft.get('registration'),
            aircraft.get('flight'),
        ]
        if not _matches_query(needle, fields):
            continue
        title = str(aircraft.get('callsign') or icao or 'Aircraft').strip()
        subtitle = f"ICAO {aircraft.get('icao') or icao} | Alt {aircraft.get('altitude', '--')} | Speed {aircraft.get('speed', '--')}"
        push('adsb', str(icao), title, subtitle, aircraft.get('lastSeen') or aircraft.get('last_seen'))
        if len(results) >= limit:
            break
    # AIS
    if len(results) < limit:
        for mmsi, vessel in app_module.ais_vessels.items():
            if not isinstance(vessel, dict):
                continue
            fields = [
                mmsi,
                vessel.get('mmsi'),
                vessel.get('name'),
                vessel.get('shipname'),
                vessel.get('callsign'),
                vessel.get('imo'),
            ]
            if not _matches_query(needle, fields):
                continue
            vessel_name = vessel.get('name') or vessel.get('shipname') or mmsi or 'Vessel'
            subtitle = f"MMSI {vessel.get('mmsi') or mmsi} | Type {vessel.get('ship_type') or vessel.get('type') or '--'}"
            push('ais', str(mmsi), str(vessel_name), subtitle, vessel.get('lastSeen') or vessel.get('last_seen'))
            if len(results) >= limit:
                break
    # WiFi networks and clients
    if len(results) < limit:
        for bssid, net in app_module.wifi_networks.items():
            if not isinstance(net, dict):
                continue
            fields = [bssid, net.get('bssid'), net.get('ssid'), net.get('vendor')]
            if not _matches_query(needle, fields):
                continue
            title = str(net.get('ssid') or net.get('bssid') or bssid or 'WiFi Network')
            subtitle = f"BSSID {net.get('bssid') or bssid} | CH {net.get('channel', '--')} | RSSI {net.get('signal', '--')}"
            push('wifi', str(bssid), title, subtitle, net.get('lastSeen') or net.get('last_seen'))
            if len(results) >= limit:
                break
    if len(results) < limit:
        for client_mac, client in app_module.wifi_clients.items():
            if not isinstance(client, dict):
                continue
            fields = [client_mac, client.get('mac'), client.get('bssid'), client.get('ssid'), client.get('vendor')]
            if not _matches_query(needle, fields):
                continue
            title = str(client.get('mac') or client_mac or 'WiFi Client')
            subtitle = f"BSSID {client.get('bssid') or '--'} | Probe {client.get('ssid') or '--'}"
            push('wifi', str(client_mac), title, subtitle, client.get('lastSeen') or client.get('last_seen'))
            if len(results) >= limit:
                break
    # Bluetooth
    if len(results) < limit:
        for address, dev in app_module.bt_devices.items():
            if not isinstance(dev, dict):
                continue
            fields = [
                address,
                dev.get('address'),
                dev.get('mac'),
                dev.get('name'),
                dev.get('manufacturer'),
                dev.get('vendor'),
            ]
            if not _matches_query(needle, fields):
                continue
            title = str(dev.get('name') or dev.get('address') or address or 'Bluetooth Device')
            subtitle = f"MAC {dev.get('address') or address} | RSSI {dev.get('rssi', '--')} | Vendor {dev.get('manufacturer') or dev.get('vendor') or '--'}"
            push('bluetooth', str(address), title, subtitle, dev.get('lastSeen') or dev.get('last_seen'))
            if len(results) >= limit:
                break
    # DSC recent messages
    if len(results) < limit:
        for msg_id, msg in app_module.dsc_messages.items():
            if not isinstance(msg, dict):
                continue
            fields = [
                msg_id,
                msg.get('mmsi'),
                msg.get('from_mmsi'),
                msg.get('to_mmsi'),
                msg.get('from_callsign'),
                msg.get('to_callsign'),
                msg.get('category'),
            ]
            if not _matches_query(needle, fields):
                continue
            title = str(msg.get('from_mmsi') or msg.get('mmsi') or msg_id or 'DSC Message')
            subtitle = f"To {msg.get('to_mmsi') or '--'} | Cat {msg.get('category') or '--'} | Freq {msg.get('frequency') or '--'}"
            push('dsc', str(msg_id), title, subtitle, msg.get('timestamp') or msg.get('lastSeen') or msg.get('last_seen'))
            if len(results) >= limit:
                break
    return jsonify({
        'status': 'success',
        'query': query,
        'results': results,
        'mode_counts': mode_counts,
    })
@analytics_bp.route('/insights')
 def analytics_insights():
    """Return actionable insight cards and top changes."""
    counts = get_cross_mode_summary()
    tracker = get_activity_tracker()
    sparklines = tracker.get_all_sparklines()
    squawks = get_emergency_squawks()
    patterns = get_pattern_detector().get_all_patterns()
    alerts = get_alert_manager().list_events(limit=120)
    top_changes = _compute_mode_changes(sparklines)
    busiest_mode, busiest_count = _get_busiest_mode(counts)
    critical_1h = _count_recent_alerts(alerts, severities={'critical', 'high'}, max_age_seconds=3600)
    recurring_emitters = sum(1 for p in patterns if float(p.get('confidence') or 0.0) >= 0.7)
    cards = []
    if top_changes:
        lead = top_changes[0]
        direction = 'up' if lead['delta'] >= 0 else 'down'
        cards.append({
            'id': 'fastest_change',
            'title': 'Fastest Change',
            'value': f"{lead['mode_label']} ({lead['signed_delta']})",
            'label': 'last window vs prior',
            'severity': 'high' if lead['delta'] > 0 else 'low',
            'detail': f"Traffic is trending {direction} in {lead['mode_label']}.",
        })
    else:
        cards.append({
            'id': 'fastest_change',
            'title': 'Fastest Change',
            'value': 'Insufficient data',
            'label': 'wait for activity history',
            'severity': 'low',
            'detail': 'Sparklines need more samples to score momentum.',
        })
    cards.append({
        'id': 'busiest_mode',
        'title': 'Busiest Mode',
        'value': f"{busiest_mode} ({busiest_count})",
        'label': 'current observed entities',
        'severity': 'medium' if busiest_count > 0 else 'low',
        'detail': 'Highest live entity count across monitoring modes.',
    })
    cards.append({
        'id': 'critical_alerts',
        'title': 'Critical Alerts (1h)',
        'value': str(critical_1h),
        'label': 'critical/high severities',
        'severity': 'critical' if critical_1h > 0 else 'low',
        'detail': 'Prioritize triage if this count is non-zero.',
    })
    cards.append({
        'id': 'emergency_squawks',
        'title': 'Emergency Squawks',
        'value': str(len(squawks)),
        'label': 'active ADS-B emergency codes',
        'severity': 'critical' if squawks else 'low',
        'detail': 'Immediate aviation anomalies currently visible.',
    })
    cards.append({
        'id': 'recurring_emitters',
        'title': 'Recurring Emitters',
        'value': str(recurring_emitters),
        'label': 'pattern confidence >= 0.70',
        'severity': 'medium' if recurring_emitters > 0 else 'low',
        'detail': 'Potentially stationary or periodic emitters detected.',
    })
    return jsonify({
        'status': 'success',
        'generated_at': datetime.now(timezone.utc).isoformat(),
        'cards': cards,
        'top_changes': top_changes[:5],
    })
 def _compute_mode_changes(sparklines: dict[str, list[int]]) -> list[dict]:
    mode_labels = {
        'adsb': 'ADS-B',
        'ais': 'AIS',
        'wifi': 'WiFi',
        'bluetooth': 'Bluetooth',
        'dsc': 'DSC',
        'acars': 'ACARS',
        'vdl2': 'VDL2',
        'aprs': 'APRS',
        'meshtastic': 'Meshtastic',
    }
    rows = []
    for mode, samples in (sparklines or {}).items():
        if not isinstance(samples, list) or len(samples) < 4:
            continue
        window = max(2, min(12, len(samples) // 2))
        recent = samples[-window:]
        previous = samples[-(window * 2):-window]
        if not previous:
            continue
        recent_avg = sum(recent) / len(recent)
        prev_avg = sum(previous) / len(previous)
        delta = round(recent_avg - prev_avg, 1)
        rows.append({
            'mode': mode,
            'mode_label': mode_labels.get(mode, mode.upper()),
            'delta': delta,
            'signed_delta': ('+' if delta >= 0 else '') + str(delta),
            'recent_avg': round(recent_avg, 1),
            'previous_avg': round(prev_avg, 1),
            'direction': 'up' if delta > 0 else ('down' if delta < 0 else 'flat'),
        })
    rows.sort(key=lambda r: abs(r['delta']), reverse=True)
    return rows
 def _matches_query(needle: str, values: list[Any]) -> bool:
    for value in values:
        if value is None:
            continue
        if needle in str(value).lower():
            return True
    return False
 def _count_recent_alerts(alerts: list[dict], severities: set[str], max_age_seconds: int) -> int:
    now = datetime.now(timezone.utc)
    count = 0
    for event in alerts:
        sev = str(event.get('severity') or '').lower()
        if sev not in severities:
            continue
        created_raw = event.get('created_at')
        if not created_raw:
            continue
        try:
            created = datetime.fromisoformat(str(created_raw).replace('Z', '+00:00'))
        except ValueError:
            continue
        if created.tzinfo is None:
            created = created.replace(tzinfo=timezone.utc)
        age = (now - created).total_seconds()
        if 0 <= age <= max_age_seconds:
            count += 1
    return count
 def _get_busiest_mode(counts: dict[str, int]) -> tuple[str, int]:
    mode_labels = {
        'adsb': 'ADS-B',
        'ais': 'AIS',
        'wifi': 'WiFi',
        'bluetooth': 'Bluetooth',
        'dsc': 'DSC',
        'acars': 'ACARS',
        'vdl2': 'VDL2',
        'aprs': 'APRS',
        'meshtastic': 'Meshtastic',
    }
    filtered = {k: int(v or 0) for k, v in (counts or {}).items() if k in mode_labels}
    if not filtered:
        return ('None', 0)
    mode = max(filtered, key=filtered.get)
    return (mode_labels.get(mode, mode.upper()), filtered[mode])
@analytics_bp.route('/export/<mode>')
 def analytics_export(mode: str):
    """Export current DataStore contents as JSON or CSV."""
    fmt = request.args.get('format', 'json').lower()
    if mode == 'sensor':
        # Sensor doesn't use DataStore; return recent queue-based data
        return jsonify({'status': 'success', 'data': [], 'message': 'Sensor data is stream-only'})
    store_names = MODE_STORES.get(mode)
    if not store_names:
        return jsonify({'status': 'error', 'message': f'Unknown mode: {mode}'}), 400
    all_items: list[dict] = []
    # Try v2 scanners first for wifi/bluetooth
    if mode == 'wifi':
        try:
            from utils.wifi.scanner import _scanner_instance as wifi_scanner
            if wifi_scanner is not None:
                for ap in wifi_scanner.access_points:
                    all_items.append(ap.to_dict())
                for client in wifi_scanner.clients:
                    item = client.to_dict()
                    item['_store'] = 'wifi_clients'
                    all_items.append(item)
        except Exception:
            pass
    elif mode == 'bluetooth':
        try:
            from utils.bluetooth.scanner import _scanner_instance as bt_scanner
            if bt_scanner is not None:
                for dev in bt_scanner.get_devices():
                    all_items.append(dev.to_dict())
        except Exception:
            pass
    # Fall back to legacy DataStores if v2 scanners yielded nothing
    if not all_items:
        for store_name in store_names:
            store = getattr(app_module, store_name, None)
            if store is None:
                continue
            for key, value in store.items():
                item = dict(value) if isinstance(value, dict) else {'id': key, 'value': value}
                item.setdefault('_store', store_name)
                all_items.append(item)
    if fmt == 'csv':
        if not all_items:
            output = ''
        else:
            # Collect all keys across items
            fieldnames: list[str] = []
            seen: set[str] = set()
            for item in all_items:
                for k in item:
                    if k not in seen:
                        fieldnames.append(k)
                        seen.add(k)
            buf = io.StringIO()
            writer = csv.DictWriter(buf, fieldnames=fieldnames, extrasaction='ignore')
            writer.writeheader()
            for item in all_items:
                # Serialize non-scalar values
                row = {}
                for k in fieldnames:
                    v = item.get(k)
                    if isinstance(v, (dict, list)):
                        row[k] = json.dumps(v)
                    else:
                        row[k] = v
                writer.writerow(row)
            output = buf.getvalue()
        response = Response(output, mimetype='text/csv')
        response.headers['Content-Disposition'] = f'attachment; filename={mode}_export.csv'
        return response
    # Default: JSON
    return jsonify({'status': 'success', 'mode': mode, 'count': len(all_items), 'data': all_items})
 # =========================================================================
 # Geofence CRUD
 # =========================================================================
@analytics_bp.route('/geofences')
 def list_geofences():
    return jsonify({
        'status': 'success',
        'zones': get_geofence_manager().list_zones(),
    })
@analytics_bp.route('/geofences', methods=['POST'])
 def create_geofence():
    data = request.get_json() or {}
    name = data.get('name')
    lat = data.get('lat')
    lon = data.get('lon')
    radius_m = data.get('radius_m')
    if not all([name, lat is not None, lon is not None, radius_m is not None]):
        return jsonify({'status': 'error', 'message': 'name, lat, lon, radius_m are required'}), 400
    try:
        lat = float(lat)
        lon = float(lon)
        radius_m = float(radius_m)
    except (TypeError, ValueError):
        return jsonify({'status': 'error', 'message': 'lat, lon, radius_m must be numbers'}), 400
    if not (-90 <= lat <= 90) or not (-180 <= lon <= 180):
        return jsonify({'status': 'error', 'message': 'Invalid coordinates'}), 400
    if radius_m <= 0:
        return jsonify({'status': 'error', 'message': 'radius_m must be positive'}), 400
    alert_on = data.get('alert_on', 'enter_exit')
    zone_id = get_geofence_manager().add_zone(name, lat, lon, radius_m, alert_on)
    return jsonify({'status': 'success', 'zone_id': zone_id})
@analytics_bp.route('/geofences/<int:zone_id>', methods=['DELETE'])
 def delete_geofence(zone_id: int):
    ok = get_geofence_manager().delete_zone(zone_id)
    if not ok:
        return jsonify({'status': 'error', 'message': 'Zone not found'}), 404
    return jsonify({'status': 'success'})
@@ -21,9 +21,7 @@ from flask import Blueprint, jsonify, request, Response
 import app as app_module
 from utils.logging import sensor_logger as logger
 from utils.validation import validate_device_index, validate_gain, validate_ppm
-from utils.sse import sse_stream_fanout
+from utils.sse import format_sse
 from utils.event_pipeline import process_event
 from utils.sdr import SDRFactory, SDRType
 from utils.constants import (
    PROCESS_TERMINATE_TIMEOUT,
    SSE_KEEPALIVE_INTERVAL,
@@ -47,8 +45,6 @@ APRS_FREQUENCIES = {
    'brazil': '145.570',
    'japan': '144.640',
    'china': '144.640',
    'iss': '145.825',
    'sonate2': '145.825',
 }
 # Statistics
@@ -56,7 +52,6 @@ aprs_packet_count = 0
 aprs_station_count = 0
 aprs_last_packet_time = None
 aprs_stations = {}  # callsign -> station data
 APRS_MAX_STATIONS = 500  # Limit tracked stations to prevent memory growth
 # Meter rate limiting
 _last_meter_time = 0.0
@@ -80,11 +75,6 @@ def find_rtl_fm() -> Optional[str]:
    return shutil.which('rtl_fm')
 def find_rx_fm() -> Optional[str]:
    """Find SoapySDR rx_fm binary."""
    return shutil.which('rx_fm')
 def find_rtl_power() -> Optional[str]:
    """Find rtl_power binary for spectrum scanning."""
    return shutil.which('rtl_power')
@@ -1380,26 +1370,6 @@ def stream_aprs_output(rtl_process: subprocess.Popen, decoder_process: subproces
                        'last_seen': packet.get('timestamp'),
                        'packet_type': packet.get('packet_type'),
                    }
                    # Geofence check
                    _aprs_lat = packet.get('lat')
                    _aprs_lon = packet.get('lon')
                    if _aprs_lat and _aprs_lon:
                        try:
                            from utils.geofence import get_geofence_manager
                            for _gf_evt in get_geofence_manager().check_position(
                                callsign, 'aprs_station', _aprs_lat, _aprs_lon,
                                {'callsign': callsign}
                            ):
                                process_event('aprs', _gf_evt, 'geofence')
                        except Exception:
                            pass
                    # Evict oldest stations when limit is exceeded
                    if len(aprs_stations) > APRS_MAX_STATIONS:
                        oldest = min(
                            aprs_stations,
                            key=lambda k: aprs_stations[k].get('last_seen', ''),
                        )
                        del aprs_stations[oldest]
                app_module.aprs_queue.put(packet)
@@ -1438,17 +1408,14 @@ def stream_aprs_output(rtl_process: subprocess.Popen, decoder_process: subproces
 def check_aprs_tools() -> Response:
    """Check for APRS decoding tools."""
    has_rtl_fm = find_rtl_fm() is not None
    has_rx_fm = find_rx_fm() is not None
    has_direwolf = find_direwolf() is not None
    has_multimon = find_multimon_ng() is not None
    has_fm_demod = has_rtl_fm or has_rx_fm
    return jsonify({
        'rtl_fm': has_rtl_fm,
        'rx_fm': has_rx_fm,
        'direwolf': has_direwolf,
        'multimon_ng': has_multimon,
-        'ready': has_fm_demod and (has_direwolf or has_multimon),
+        'ready': has_rtl_fm and (has_direwolf or has_multimon),
        'decoder': 'direwolf' if has_direwolf else ('multimon-ng' if has_multimon else None)
    })
@@ -1491,6 +1458,14 @@ def start_aprs() -> Response:
                'message': 'APRS decoder already running'
            }), 409
    # Check for required tools
    rtl_fm_path = find_rtl_fm()
    if not rtl_fm_path:
        return jsonify({
            'status': 'error',
            'message': 'rtl_fm not found. Install with: sudo apt install rtl-sdr'
        }), 400
    # Check for decoder (prefer direwolf, fallback to multimon-ng)
    direwolf_path = find_direwolf()
    multimon_path = find_multimon_ng()
@@ -1511,25 +1486,6 @@ def start_aprs() -> Response:
    except ValueError as e:
        return jsonify({'status': 'error', 'message': str(e)}), 400
    sdr_type_str = str(data.get('sdr_type', 'rtlsdr')).lower()
    try:
        sdr_type = SDRType(sdr_type_str)
    except ValueError:
        sdr_type = SDRType.RTL_SDR
    if sdr_type == SDRType.RTL_SDR:
        if find_rtl_fm() is None:
            return jsonify({
                'status': 'error',
                'message': 'rtl_fm not found. Install with: sudo apt install rtl-sdr'
            }), 400
    else:
        if find_rx_fm() is None:
            return jsonify({
                'status': 'error',
                'message': f'rx_fm not found. Install SoapySDR tools for {sdr_type.value}.'
            }), 400
    # Reserve SDR device to prevent conflicts with other modes
    error = app_module.claim_sdr_device(device, 'aprs')
    if error:
@@ -1560,29 +1516,28 @@ def start_aprs() -> Response:
    aprs_last_packet_time = None
    aprs_stations = {}
-    # Build FM demod command for APRS (AFSK1200 @ 22050 Hz) via SDR abstraction.
+    # Build rtl_fm command for APRS (narrowband FM at 22050 Hz for AFSK1200)
-    try:
+    freq_hz = f"{float(frequency)}M"
-        sdr_device = SDRFactory.create_default_device(sdr_type, index=device)
+    rtl_cmd = [
-        builder = SDRFactory.get_builder(sdr_type)
+        rtl_fm_path,
-        rtl_cmd = builder.build_fm_demod_command(
+        '-f', freq_hz,
-            device=sdr_device,
+        '-M', 'nfm',             # Narrowband FM for APRS
-            frequency_mhz=float(frequency),
+        '-s', '22050',           # Sample rate matching direwolf -r 22050
-            sample_rate=22050,
+        '-E', 'dc',              # Enable DC blocking filter for cleaner audio
-            gain=float(gain) if gain and str(gain) != '0' else None,
+        '-A', 'fast',            # Fast AGC for packet bursts
-            ppm=int(ppm) if ppm and str(ppm) != '0' else None,
+        '-d', str(device),
-            modulation='nfm' if sdr_type == SDRType.RTL_SDR else 'fm',
+    ]
            squelch=None,
            bias_t=bool(data.get('bias_t', False)),
        )
-        if sdr_type == SDRType.RTL_SDR and rtl_cmd and rtl_cmd[-1] == '-':
+    # Gain: 0 means auto, otherwise set specific gain
-            # APRS benefits from DC blocking + fast AGC on rtl_fm.
+    if gain and str(gain) != '0':
-            rtl_cmd = rtl_cmd[:-1] + ['-E', 'dc', '-A', 'fast', '-']
+        rtl_cmd.extend(['-g', str(gain)])
-    except Exception as e:
+
-        if aprs_active_device is not None:
+    # PPM frequency correction
-            app_module.release_sdr_device(aprs_active_device)
+    if ppm and str(ppm) != '0':
-            aprs_active_device = None
+        rtl_cmd.extend(['-p', str(ppm)])
-        return jsonify({'status': 'error', 'message': f'Failed to build SDR command: {e}'}), 500
+
    # Output raw audio to stdout
    rtl_cmd.append('-')
    # Build decoder command
    if direwolf_path:
@@ -1710,7 +1665,6 @@ def start_aprs() -> Response:
            'frequency': frequency,
            'region': region,
            'device': device,
            'sdr_type': sdr_type.value,
            'decoder': decoder_name
        })
@@ -1766,19 +1720,21 @@ def stop_aprs() -> Response:
@aprs_bp.route('/stream')
 def stream_aprs() -> Response:
    """SSE stream for APRS packets."""
-    def _on_msg(msg: dict[str, Any]) -> None:
+    def generate() -> Generator[str, None, None]:
-        process_event('aprs', msg, msg.get('type'))
+        last_keepalive = time.time()
-    response = Response(
+        while True:
-        sse_stream_fanout(
+            try:
-            source_queue=app_module.aprs_queue,
+                msg = app_module.aprs_queue.get(timeout=SSE_QUEUE_TIMEOUT)
-            channel_key='aprs',
+                last_keepalive = time.time()
-            timeout=SSE_QUEUE_TIMEOUT,
+                yield format_sse(msg)
-            keepalive_interval=SSE_KEEPALIVE_INTERVAL,
+            except queue.Empty:
-            on_message=_on_msg,
+                now = time.time()
-        ),
+                if now - last_keepalive >= SSE_KEEPALIVE_INTERVAL:
-        mimetype='text/event-stream',
+                    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
@@ -1,11 +1,10 @@
 """WebSocket-based audio streaming for SDR."""
 import json
 import shutil
 import socket
 import subprocess
 import threading
 import time
 import shutil
 import json
 from flask import Flask
 # Try to import flask-sock
@@ -41,12 +40,6 @@ def find_ffmpeg():
    return shutil.which('ffmpeg')
 def _rtl_fm_demod_mode(modulation):
    """Map UI modulation names to rtl_fm demod tokens."""
    mod = str(modulation or '').lower().strip()
    return 'wbfm' if mod == 'wfm' else mod
 def kill_audio_processes():
    """Kill any running audio processes."""
    global audio_process, rtl_process
@@ -112,7 +105,7 @@ def start_audio_stream(config):
    rtl_cmd = [
        rtl_fm,
-        '-M', _rtl_fm_demod_mode(mod),
+        '-M', mod,
        '-f', str(freq_hz),
        '-s', str(sample_rate),
        '-r', str(resample_rate),
@@ -258,19 +251,4 @@ def init_audio_websocket(app: Flask):
        finally:
            with process_lock:
                kill_audio_processes()
            # Complete WebSocket close handshake, then shut down the
            # raw socket so Werkzeug cannot write its HTTP 200 response
            # on top of the WebSocket stream.
            try:
                ws.close()
            except Exception:
                pass
            try:
                ws.sock.shutdown(socket.SHUT_RDWR)
            except Exception:
                pass
            try:
                ws.sock.close()
            except Exception:
                pass
            logger.info("WebSocket audio client disconnected")
@@ -20,8 +20,7 @@ from flask import Blueprint, jsonify, request, Response
 import app as app_module
 from utils.dependencies import check_tool
 from utils.logging import bluetooth_logger as logger
-from utils.sse import sse_stream_fanout
+from utils.sse import format_sse
 from utils.event_pipeline import process_event
 from utils.validation import validate_bluetooth_interface
 from data.oui import OUI_DATABASE, load_oui_database, get_manufacturer
 from data.patterns import AIRTAG_PREFIXES, TILE_PREFIXES, SAMSUNG_TRACKER
@@ -556,19 +555,22 @@ def get_bt_devices():
@bluetooth_bp.route('/stream')
 def stream_bt():
    """SSE stream for Bluetooth events."""
-    def _on_msg(msg: dict[str, Any]) -> None:
+    def generate():
-        process_event('bluetooth', msg, msg.get('type'))
+        last_keepalive = time.time()
        keepalive_interval = 30.0
-    response = Response(
+        while True:
-        sse_stream_fanout(
+            try:
-            source_queue=app_module.bt_queue,
+                msg = app_module.bt_queue.get(timeout=1)
-            channel_key='bluetooth',
+                last_keepalive = time.time()
-            timeout=1.0,
+                yield format_sse(msg)
-            keepalive_interval=30.0,
+            except queue.Empty:
-            on_message=_on_msg,
+                now = time.time()
-        ),
+                if now - last_keepalive >= keepalive_interval:
-        mimetype='text/event-stream',
+                    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'
@@ -11,8 +11,6 @@ import csv
 import io
 import json
 import logging
 import threading
 import time
 from datetime import datetime
 from typing import Generator
@@ -30,18 +28,12 @@ from utils.bluetooth import (
 )
 from utils.database import get_db
 from utils.sse import format_sse
 from utils.event_pipeline import process_event
 logger = logging.getLogger('intercept.bluetooth_v2')
 # Blueprint
 bluetooth_v2_bp = Blueprint('bluetooth_v2', __name__, url_prefix='/api/bluetooth')
 # Seen-before tracking
 _bt_seen_cache: set[str] = set()
 _bt_session_seen: set[str] = set()
 _bt_seen_lock = threading.Lock()
 # =============================================================================
 # DATABASE FUNCTIONS
 # =============================================================================
@@ -181,13 +173,6 @@ def save_observation_history(device: BTDeviceAggregate) -> None:
        ''', (device.device_id, device.rssi_current, device.seen_count))
 def load_seen_device_ids() -> set[str]:
    """Load distinct device IDs from history for seen-before tracking."""
    with get_db() as conn:
        cursor = conn.execute('SELECT DISTINCT device_id FROM bt_observation_history')
        return {row['device_id'] for row in cursor}
 # =============================================================================
 # API ENDPOINTS
 # =============================================================================
@@ -229,35 +214,13 @@ def start_scan():
    rssi_threshold = data.get('rssi_threshold', -100)
    # Validate mode
-    valid_modes = ('auto', 'dbus', 'bleak', 'hcitool', 'bluetoothctl', 'ubertooth')
+    valid_modes = ('auto', 'dbus', 'bleak', 'hcitool', 'bluetoothctl')
    if mode not in valid_modes:
        return jsonify({'error': f'Invalid mode. Must be one of: {valid_modes}'}), 400
    # Get scanner instance
    scanner = get_bluetooth_scanner(adapter_id)
    # Initialize database tables if needed
    init_bt_tables()
    def _handle_seen_before(device: BTDeviceAggregate) -> None:
        try:
            with _bt_seen_lock:
                device.seen_before = device.device_id in _bt_seen_cache
                if device.device_id not in _bt_session_seen:
                    save_observation_history(device)
                    _bt_session_seen.add(device.device_id)
        except Exception as e:
            logger.debug(f"BT seen-before update failed: {e}")
    # Setup seen-before callback
    if _handle_seen_before not in scanner._on_device_updated_callbacks:
        scanner.add_device_callback(_handle_seen_before)
    # Ensure cache is initialized
    with _bt_seen_lock:
        if not _bt_seen_cache:
            _bt_seen_cache.update(load_seen_device_ids())
    # Check if already scanning
    if scanner.is_scanning:
        return jsonify({
@@ -265,11 +228,8 @@ def start_scan():
            'scan_status': scanner.get_status().to_dict()
        })
-    # Refresh seen-before cache and reset session set for a new scan
+    # Initialize database tables if needed
-    with _bt_seen_lock:
+    init_bt_tables()
        _bt_seen_cache.clear()
        _bt_seen_cache.update(load_seen_device_ids())
        _bt_session_seen.clear()
    # Load active baseline if exists
    baseline_id = get_active_baseline_id()
@@ -900,10 +860,6 @@ def stream_events():
        """Generate SSE events from scanner."""
        for event in scanner.stream_events(timeout=1.0):
            event_name, event_data = map_event_type(event)
            try:
                process_event('bluetooth', event_data, event_name)
            except Exception:
                pass
            yield format_sse(event_data, event=event_name)
    return Response(
@@ -991,17 +947,6 @@ def get_tscm_bluetooth_snapshot(duration: int = 8) -> list[dict]:
    # Convert to TSCM format with tracker detection data
    tscm_devices = []
    for device in devices:
        manufacturer_name = device.manufacturer_name
        if (not manufacturer_name) or str(manufacturer_name).lower().startswith('unknown'):
            if device.address and not device.is_randomized_mac:
                try:
                    from data.oui import get_manufacturer
                    oui_vendor = get_manufacturer(device.address)
                    if oui_vendor and oui_vendor != 'Unknown':
                        manufacturer_name = oui_vendor
                except Exception:
                    pass
        device_data = {
            'mac': device.address,
            'address_type': device.address_type,
@@ -1011,7 +956,7 @@ def get_tscm_bluetooth_snapshot(duration: int = 8) -> list[dict]:
            'rssi_median': device.rssi_median,
            'rssi_ema': round(device.rssi_ema, 1) if device.rssi_ema else None,
            'type': _classify_device_type(device),
-            'manufacturer': manufacturer_name,
+            'manufacturer': device.manufacturer_name,
            'manufacturer_id': device.manufacturer_id,
            'manufacturer_data': device.manufacturer_bytes.hex() if device.manufacturer_bytes else None,
            'protocol': device.protocol,
@@ -1233,30 +1178,6 @@ def _classify_device_type(device: BTDeviceAggregate) -> str:
    """Classify device type from available data."""
    name_lower = (device.name or '').lower()
    manufacturer_lower = (device.manufacturer_name or '').lower()
    service_uuids = device.service_uuids or []
    if (not manufacturer_lower) or manufacturer_lower.startswith('unknown'):
        if device.address and not device.is_randomized_mac:
            try:
                from data.oui import get_manufacturer
                oui_vendor = get_manufacturer(device.address)
                if oui_vendor and oui_vendor != 'Unknown':
                    manufacturer_lower = oui_vendor.lower()
            except Exception:
                pass
    def normalize_uuid(uuid: str) -> str:
        if not uuid:
            return ''
        value = str(uuid).lower().strip()
        if value.startswith('0x'):
            value = value[2:]
        # Bluetooth Base UUID normalization (16-bit UUIDs)
        if value.endswith('-0000-1000-8000-00805f9b34fb') and len(value) >= 8:
            return value[4:8]
        if len(value) == 4:
            return value
        return value
    # Check by name patterns
    if any(x in name_lower for x in ['airpods', 'headphone', 'earbuds', 'buds', 'beats']):
@@ -1276,29 +1197,6 @@ def _classify_device_type(device: BTDeviceAggregate) -> str:
    if any(x in name_lower for x in ['tv', 'chromecast', 'roku', 'firestick']):
        return 'media'
    # Tracker signals (metadata or Find My service)
    if getattr(device, 'is_tracker', False) or getattr(device, 'tracker_type', None):
        return 'tracker'
    normalized_uuids = {normalize_uuid(u) for u in service_uuids if u}
    if 'fd6f' in normalized_uuids:
        return 'tracker'
    # Service UUIDs (GATT / classic)
    audio_uuids = {'110b', '110a', '111e', '111f', '1108', '1203'}
    wearable_uuids = {'180d', '1814', '1816'}
    hid_uuids = {'1812'}
    beacon_uuids = {'feaa', 'feab', 'feb1', 'febe'}
    if normalized_uuids & audio_uuids:
        return 'audio'
    if normalized_uuids & hid_uuids:
        return 'peripheral'
    if normalized_uuids & wearable_uuids:
        return 'wearable'
    if normalized_uuids & beacon_uuids:
        return 'beacon'
    # Check by manufacturer
    if 'apple' in manufacturer_lower:
        return 'apple_device'
@@ -1,300 +0,0 @@
 """
 BT Locate — Bluetooth SAR Device Location Flask Blueprint.
 Provides endpoints for managing locate sessions, streaming detection events,
 and retrieving GPS-tagged signal trails.
 """
 from __future__ import annotations
 import logging
 from collections.abc import Generator
 from flask import Blueprint, Response, jsonify, request
 from utils.bluetooth.irk_extractor import get_paired_irks
 from utils.bt_locate import (
    Environment,
    LocateTarget,
    get_locate_session,
    resolve_rpa,
    start_locate_session,
    stop_locate_session,
 )
 from utils.sse import format_sse
 logger = logging.getLogger('intercept.bt_locate')
 bt_locate_bp = Blueprint('bt_locate', __name__, url_prefix='/bt_locate')
@bt_locate_bp.route('/start', methods=['POST'])
 def start_session():
    """
    Start a locate session.
    Request JSON:
        - mac_address: Target MAC address (optional)
        - name_pattern: Target name substring (optional)
        - irk_hex: Identity Resolving Key hex string (optional)
        - device_id: Device ID from Bluetooth scanner (optional)
        - device_key: Stable device key from Bluetooth scanner (optional)
        - fingerprint_id: Payload fingerprint ID from Bluetooth scanner (optional)
        - known_name: Hand-off device name (optional)
        - known_manufacturer: Hand-off manufacturer (optional)
        - last_known_rssi: Hand-off last RSSI (optional)
        - environment: 'FREE_SPACE', 'OUTDOOR', 'INDOOR', 'CUSTOM' (default: OUTDOOR)
        - custom_exponent: Path loss exponent for CUSTOM environment (optional)
    Returns:
        JSON with session status.
    """
    data = request.get_json() or {}
    # Build target
    target = LocateTarget(
        mac_address=data.get('mac_address'),
        name_pattern=data.get('name_pattern'),
        irk_hex=data.get('irk_hex'),
        device_id=data.get('device_id'),
        device_key=data.get('device_key'),
        fingerprint_id=data.get('fingerprint_id'),
        known_name=data.get('known_name'),
        known_manufacturer=data.get('known_manufacturer'),
        last_known_rssi=data.get('last_known_rssi'),
    )
    # At least one identifier required
    if not any([
        target.mac_address,
        target.name_pattern,
        target.irk_hex,
        target.device_id,
        target.device_key,
        target.fingerprint_id,
    ]):
        return jsonify({
            'error': (
                'At least one target identifier required '
                '(mac_address, name_pattern, irk_hex, device_id, device_key, or fingerprint_id)'
            )
        }), 400
    # Parse environment
    env_str = data.get('environment', 'OUTDOOR').upper()
    try:
        environment = Environment[env_str]
    except KeyError:
        return jsonify({'error': f'Invalid environment: {env_str}'}), 400
    custom_exponent = data.get('custom_exponent')
    if custom_exponent is not None:
        try:
            custom_exponent = float(custom_exponent)
        except (ValueError, TypeError):
            return jsonify({'error': 'custom_exponent must be a number'}), 400
    # Fallback coordinates when GPS is unavailable (from user settings)
    fallback_lat = None
    fallback_lon = None
    if data.get('fallback_lat') is not None and data.get('fallback_lon') is not None:
        try:
            fallback_lat = float(data['fallback_lat'])
            fallback_lon = float(data['fallback_lon'])
        except (ValueError, TypeError):
            pass
    logger.info(
        f"Starting locate session: target={target.to_dict()}, "
        f"env={environment.name}, fallback=({fallback_lat}, {fallback_lon})"
    )
    session = start_locate_session(
        target, environment, custom_exponent, fallback_lat, fallback_lon
    )
    return jsonify({
        'status': 'started',
        'session': session.get_status(),
    })
@bt_locate_bp.route('/stop', methods=['POST'])
 def stop_session():
    """Stop the active locate session."""
    session = get_locate_session()
    if not session:
        return jsonify({'status': 'no_session'})
    stop_locate_session()
    return jsonify({'status': 'stopped'})
@bt_locate_bp.route('/status', methods=['GET'])
 def get_status():
    """Get locate session status."""
    session = get_locate_session()
    if not session:
        return jsonify({
            'active': False,
            'target': None,
        })
    return jsonify(session.get_status())
@bt_locate_bp.route('/trail', methods=['GET'])
 def get_trail():
    """Get detection trail data."""
    session = get_locate_session()
    if not session:
        return jsonify({'trail': [], 'gps_trail': []})
    return jsonify({
        'trail': session.get_trail(),
        'gps_trail': session.get_gps_trail(),
    })
@bt_locate_bp.route('/stream', methods=['GET'])
 def stream_detections():
    """SSE stream of detection events."""
    def event_generator() -> Generator[str, None, None]:
        while True:
            # Re-fetch session each iteration in case it changes
            s = get_locate_session()
            if not s:
                yield format_sse({'type': 'session_ended'}, event='session_ended')
                return
            try:
                event = s.event_queue.get(timeout=2.0)
                yield format_sse(event, event='detection')
            except Exception:
                yield format_sse({}, event='ping')
    return Response(
        event_generator(),
        mimetype='text/event-stream',
        headers={
            'Cache-Control': 'no-cache',
            'Connection': 'keep-alive',
            'X-Accel-Buffering': 'no',
        }
    )
@bt_locate_bp.route('/resolve_rpa', methods=['POST'])
 def test_resolve_rpa():
    """
    Test if an IRK resolves to a given address.
    Request JSON:
        - irk_hex: 16-byte IRK as hex string
        - address: BLE address string
    Returns:
        JSON with resolution result.
    """
    data = request.get_json() or {}
    irk_hex = data.get('irk_hex', '')
    address = data.get('address', '')
    if not irk_hex or not address:
        return jsonify({'error': 'irk_hex and address are required'}), 400
    try:
        irk = bytes.fromhex(irk_hex)
    except ValueError:
        return jsonify({'error': 'Invalid IRK hex string'}), 400
    if len(irk) != 16:
        return jsonify({'error': 'IRK must be exactly 16 bytes (32 hex characters)'}), 400
    result = resolve_rpa(irk, address)
    return jsonify({
        'resolved': result,
        'irk_hex': irk_hex,
        'address': address,
    })
@bt_locate_bp.route('/environment', methods=['POST'])
 def set_environment():
    """Update the environment on the active session."""
    session = get_locate_session()
    if not session:
        return jsonify({'error': 'no active session'}), 400
    data = request.get_json() or {}
    env_str = data.get('environment', '').upper()
    try:
        environment = Environment[env_str]
    except KeyError:
        return jsonify({'error': f'Invalid environment: {env_str}'}), 400
    custom_exponent = data.get('custom_exponent')
    if custom_exponent is not None:
        try:
            custom_exponent = float(custom_exponent)
        except (ValueError, TypeError):
            custom_exponent = None
    session.set_environment(environment, custom_exponent)
    return jsonify({
        'status': 'updated',
        'environment': environment.name,
        'path_loss_exponent': session.estimator.n,
    })
@bt_locate_bp.route('/debug', methods=['GET'])
 def debug_matching():
    """Debug endpoint showing scanner devices and match results."""
    session = get_locate_session()
    if not session:
        return jsonify({'error': 'no session'})
    scanner = session._scanner
    if not scanner:
        return jsonify({'error': 'no scanner'})
    devices = scanner.get_devices(max_age_seconds=30)
    return jsonify({
        'target': session.target.to_dict(),
        'device_count': len(devices),
        'devices': [
            {
                'device_id': d.device_id,
                'address': d.address,
                'name': d.name,
                'rssi': d.rssi_current,
                'matches': session.target.matches(d),
            }
            for d in devices
        ],
    })
@bt_locate_bp.route('/paired_irks', methods=['GET'])
 def paired_irks():
    """Return paired Bluetooth devices that have IRKs."""
    try:
        devices = get_paired_irks()
    except Exception as e:
        logger.exception("Failed to read paired IRKs")
        return jsonify({'devices': [], 'error': str(e)})
    return jsonify({'devices': devices})
@bt_locate_bp.route('/clear_trail', methods=['POST'])
 def clear_trail():
    """Clear the detection trail."""
    session = get_locate_session()
    if not session:
        return jsonify({'status': 'no_session'})
    session.clear_trail()
    return jsonify({'status': 'cleared'})
@@ -13,7 +13,6 @@ from __future__ import annotations
 import json
 import logging
 import queue
 import threading
 import time
 from datetime import datetime, timezone
 from typing import Generator
@@ -39,26 +38,8 @@ logger = logging.getLogger('intercept.controller')
 controller_bp = Blueprint('controller', __name__, url_prefix='/controller')
-# Multi-agent SSE fanout state (per-client queues).
+# Multi-agent data queue for combined SSE stream
-_agent_stream_subscribers: set[queue.Queue] = set()
+agent_data_queue: queue.Queue = queue.Queue(maxsize=1000)
 _agent_stream_subscribers_lock = threading.Lock()
 _AGENT_STREAM_CLIENT_QUEUE_SIZE = 500
 def _broadcast_agent_data(payload: dict) -> None:
    """Fan out an ingested payload to all active /controller/stream/all clients."""
    with _agent_stream_subscribers_lock:
        subscribers = tuple(_agent_stream_subscribers)
    for subscriber in subscribers:
        try:
            subscriber.put_nowait(payload)
        except queue.Full:
            try:
                subscriber.get_nowait()
                subscriber.put_nowait(payload)
            except (queue.Empty, queue.Full):
                continue
 # =============================================================================
@@ -644,8 +625,9 @@ def ingest_push_data():
            received_at=data.get('received_at')
        )
-        # Emit to SSE stream (fanout to all connected clients)
+        # Emit to SSE stream
-        _broadcast_agent_data({
+        try:
            agent_data_queue.put_nowait({
                'type': 'agent_data',
                'agent_id': agent['id'],
                'agent_name': agent_name,
@@ -654,6 +636,8 @@ def ingest_push_data():
                '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',
@@ -697,18 +681,13 @@ def stream_all_agents():
    This endpoint streams push data as it arrives from agents.
    Each message is tagged with agent_id and agent_name.
    """
    client_queue: queue.Queue = queue.Queue(maxsize=_AGENT_STREAM_CLIENT_QUEUE_SIZE)
    with _agent_stream_subscribers_lock:
        _agent_stream_subscribers.add(client_queue)
    def generate() -> Generator[str, None, None]:
        last_keepalive = time.time()
        keepalive_interval = 30.0
        try:
        while True:
            try:
-                    msg = client_queue.get(timeout=1.0)
+                msg = agent_data_queue.get(timeout=1.0)
                last_keepalive = time.time()
                yield format_sse(msg)
            except queue.Empty:
@@ -716,9 +695,6 @@ def stream_all_agents():
                if now - last_keepalive >= keepalive_interval:
                    yield format_sse({'type': 'keepalive'})
                    last_keepalive = now
        finally:
            with _agent_stream_subscribers_lock:
                _agent_stream_subscribers.discard(client_queue)
    response = Response(generate(), mimetype='text/event-stream')
    response.headers['Cache-Control'] = 'no-cache'
@@ -17,11 +17,8 @@ from flask import Blueprint, jsonify, request, Response
 import app as app_module
 from utils.logging import get_logger
-from utils.sse import sse_stream_fanout
+from utils.sse import format_sse
 from utils.event_pipeline import process_event
 from utils.process import register_process, unregister_process
 from utils.validation import validate_frequency, validate_gain, validate_device_index, validate_ppm
 from utils.sdr import SDRFactory, SDRType
 from utils.constants import (
    SSE_QUEUE_TIMEOUT,
    SSE_KEEPALIVE_INTERVAL,
@@ -40,18 +37,10 @@ dmr_rtl_process: Optional[subprocess.Popen] = None
 dmr_dsd_process: Optional[subprocess.Popen] = None
 dmr_thread: Optional[threading.Thread] = None
 dmr_running = False
 dmr_has_audio = False  # True when ffmpeg available and dsd outputs audio
 dmr_lock = threading.Lock()
 dmr_queue: queue.Queue = queue.Queue(maxsize=QUEUE_MAX_SIZE)
 dmr_active_device: Optional[int] = None
 # Audio mux: the sole reader of dsd-fme stdout.  Fans out bytes to all
 # active ffmpeg stdin sinks when streaming clients are connected.
 # This prevents dsd-fme from blocking on stdout (which would also
 # freeze stderr / text data output).
 _ffmpeg_sinks: set[object] = set()
 _ffmpeg_sinks_lock = threading.Lock()
 VALID_PROTOCOLS = ['auto', 'dmr', 'p25', 'nxdn', 'dstar', 'provoice']
 # Classic dsd flags
@@ -64,25 +53,14 @@ _DSD_PROTOCOL_FLAGS = {
    'provoice': ['-fv'],
 }
-# dsd-fme remapped several flags from classic DSD:
+# dsd-fme uses different flag names
 #   -fs = DMR Simplex (NOT -fd which is D-STAR!),
 #   -fd = D-STAR (NOT DMR!), -fp = ProVoice (NOT P25),
 #   -fi = NXDN48 (NOT D-Star), -f1 = P25 Phase 1,
 #   -ft = XDMA multi-protocol decoder
 _DSD_FME_PROTOCOL_FLAGS = {
-    'auto': ['-fa'],       # Broad auto: P25 (P1/P2), DMR, D-STAR, YSF, X2-TDMA
+    'auto': ['-ft'],
-    'dmr': ['-fs'],        # DMR Simplex (-fd is D-STAR in dsd-fme!)
+    'dmr': ['-fs'],
-    'p25': ['-ft'],        # P25 P1/P2 coverage (also includes DMR in dsd-fme)
+    'p25': ['-f1'],
-    'nxdn': ['-fn'],       # NXDN96
+    'nxdn': ['-fi'],
-    'dstar': ['-fd'],      # D-STAR (-fd in dsd-fme, NOT DMR!)
+    'dstar': [],
-    'provoice': ['-fp'],   # ProVoice (-fp in dsd-fme, not -fv)
+    'provoice': ['-fp'],
 }
 # Modulation hints: force C4FM for protocols that use it, improving
 # sync reliability vs letting dsd-fme auto-detect modulation type.
 _DSD_FME_MODULATION = {
    'dmr': ['-mc'],        # C4FM
    'nxdn': ['-mc'],       # C4FM
 }
 # ============================================
@@ -110,16 +88,6 @@ def find_rtl_fm() -> str | None:
    return shutil.which('rtl_fm')
 def find_rx_fm() -> str | None:
    """Find SoapySDR rx_fm binary."""
    return shutil.which('rx_fm')
 def find_ffmpeg() -> str | None:
    """Find ffmpeg for audio encoding."""
    return shutil.which('ffmpeg')
 def parse_dsd_output(line: str) -> dict | None:
    """Parse a line of DSD stderr output into a structured event.
@@ -131,11 +99,8 @@ def parse_dsd_output(line: str) -> dict | None:
        return None
    # Skip DSD/dsd-fme startup banner lines (ASCII art, version info, etc.)
-    # Only filter lines that are purely decorative — dsd-fme uses box-drawing
+    # These contain box-drawing characters or are pure decoration.
-    # characters (│, ─) as column separators in DATA lines, so we must not
+    if re.search(r'[╔╗╚╝║═██▀▄╗╝╩╦╠╣╬│┤├┘└┐┌─┼█▓▒░]', line):
    # discard lines that also contain alphanumeric content.
    stripped_of_box = re.sub(r'[╔╗╚╝║═██▀▄╗╝╩╦╠╣╬│┤├┘└┐┌─┼█▓▒░\s]', '', line)
    if not stripped_of_box:
        return None
    if re.match(r'^\s*(Build Version|MBElib|CODEC2|Audio (Out|In)|Decoding )', line):
        return None
@@ -155,9 +120,8 @@ def parse_dsd_output(line: str) -> dict | None:
    # is captured as a call event rather than a bare slot event.
    # Classic dsd:   "TG: 12345  Src: 67890"
    # dsd-fme:       "TG: 12345, Src: 67890"  or  "Talkgroup: 12345, Source: 67890"
    #                "TGT: 12345 | SRC: 67890" (pipe-delimited variant)
    tg_match = re.search(
-        r'(?:TGT?|Talkgroup)[:\s]+(\d+)[,|│\s]+(?:Src|Source|SRC)[:\s]+(\d+)', line, re.IGNORECASE
+        r'(?:TG|Talkgroup)[:\s]+(\d+)[,\s]+(?:Src|Source)[:\s]+(\d+)', line, re.IGNORECASE
    )
    if tg_match:
        result = {
@@ -216,97 +180,6 @@ def parse_dsd_output(line: str) -> dict | None:
 _HEARTBEAT_INTERVAL = 3.0  # seconds between heartbeats when decoder is idle
 # 100ms of silence at 8kHz 16-bit mono = 1600 bytes
 _SILENCE_CHUNK = b'\x00' * 1600
 def _register_audio_sink(sink: object) -> None:
    """Register an ffmpeg stdin sink for mux fanout."""
    with _ffmpeg_sinks_lock:
        _ffmpeg_sinks.add(sink)
 def _unregister_audio_sink(sink: object) -> None:
    """Remove an ffmpeg stdin sink from mux fanout."""
    with _ffmpeg_sinks_lock:
        _ffmpeg_sinks.discard(sink)
 def _get_audio_sinks() -> tuple[object, ...]:
    """Snapshot current audio sinks for lock-free iteration."""
    with _ffmpeg_sinks_lock:
        return tuple(_ffmpeg_sinks)
 def _stop_process(proc: Optional[subprocess.Popen]) -> None:
    """Terminate and unregister a subprocess if present."""
    if not proc:
        return
    if proc.poll() is None:
        try:
            proc.terminate()
            proc.wait(timeout=2)
        except Exception:
            try:
                proc.kill()
            except Exception:
                pass
    unregister_process(proc)
 def _reset_runtime_state(*, release_device: bool) -> None:
    """Reset process + runtime state and optionally release SDR ownership."""
    global dmr_rtl_process, dmr_dsd_process
    global dmr_running, dmr_has_audio, dmr_active_device
    _stop_process(dmr_dsd_process)
    _stop_process(dmr_rtl_process)
    dmr_rtl_process = None
    dmr_dsd_process = None
    dmr_running = False
    dmr_has_audio = False
    with _ffmpeg_sinks_lock:
        _ffmpeg_sinks.clear()
    if release_device and dmr_active_device is not None:
        app_module.release_sdr_device(dmr_active_device)
        dmr_active_device = None
 def _dsd_audio_mux(dsd_stdout):
    """Mux thread: sole reader of dsd-fme stdout.
    Always drains dsd-fme's audio output to prevent the process from
    blocking on stdout writes (which would also freeze stderr / text
    data). When streaming clients are connected, forwards data to all
    active ffmpeg stdin sinks with silence fill during voice gaps.
    """
    try:
        while dmr_running:
            ready, _, _ = select.select([dsd_stdout], [], [], 0.1)
            if ready:
                data = os.read(dsd_stdout.fileno(), 4096)
                if not data:
                    break
                sinks = _get_audio_sinks()
                for sink in sinks:
                    try:
                        sink.write(data)
                        sink.flush()
                    except (BrokenPipeError, OSError, ValueError):
                        _unregister_audio_sink(sink)
            else:
                # No audio from decoder — feed silence if client connected
                sinks = _get_audio_sinks()
                for sink in sinks:
                    try:
                        sink.write(_SILENCE_CHUNK)
                        sink.flush()
                    except (BrokenPipeError, OSError, ValueError):
                        _unregister_audio_sink(sink)
    except (OSError, ValueError):
        pass
 def _queue_put(event: dict):
    """Put an event on the DMR queue, dropping oldest if full."""
@@ -354,7 +227,6 @@ def stream_dsd_output(rtl_process: subprocess.Popen, dsd_process: subprocess.Pop
                if not text:
                    continue
                logger.debug("DSD raw: %s", text)
                parsed = parse_dsd_output(text)
                if parsed:
                    _queue_put(parsed)
@@ -374,11 +246,7 @@ def stream_dsd_output(rtl_process: subprocess.Popen, dsd_process: subprocess.Pop
        logger.error(f"DSD stream error: {e}")
    finally:
        global dmr_active_device, dmr_rtl_process, dmr_dsd_process
        global dmr_has_audio
        dmr_running = False
        dmr_has_audio = False
        with _ffmpeg_sinks_lock:
            _ffmpeg_sinks.clear()
        # Capture exit info for diagnostics
        rc = dsd_process.poll()
        reason = 'stopped'
@@ -392,9 +260,19 @@ def stream_dsd_output(rtl_process: subprocess.Popen, dsd_process: subprocess.Pop
            except Exception:
                pass
            logger.warning(f"DSD process exited with code {rc}: {detail}")
-        # Cleanup decoder + demod processes
+        # Cleanup both processes
-        _stop_process(dsd_process)
+        for proc in [dsd_process, rtl_process]:
-        _stop_process(rtl_process)
+            if proc and proc.poll() is None:
                try:
                    proc.terminate()
                    proc.wait(timeout=2)
                except Exception:
                    try:
                        proc.kill()
                    except Exception:
                        pass
            if proc:
                unregister_process(proc)
        dmr_rtl_process = None
        dmr_dsd_process = None
        _queue_put({'type': 'status', 'text': reason, 'exit_code': rc, 'detail': detail})
@@ -414,14 +292,10 @@ def check_tools() -> Response:
    """Check for required tools."""
    dsd_path, _ = find_dsd()
    rtl_fm = find_rtl_fm()
    rx_fm = find_rx_fm()
    ffmpeg = find_ffmpeg()
    return jsonify({
        'dsd': dsd_path is not None,
        'rtl_fm': rtl_fm is not None,
-        'rx_fm': rx_fm is not None,
+        'available': dsd_path is not None and rtl_fm is not None,
        'ffmpeg': ffmpeg is not None,
        'available': dsd_path is not None and (rtl_fm is not None or rx_fm is not None),
        'protocols': VALID_PROTOCOLS,
    })
@@ -429,43 +303,36 @@ def check_tools() -> Response:
@dmr_bp.route('/start', methods=['POST'])
 def start_dmr() -> Response:
    """Start digital voice decoding."""
-    global dmr_rtl_process, dmr_dsd_process, dmr_thread
+    global dmr_rtl_process, dmr_dsd_process, dmr_thread, dmr_running, dmr_active_device
-    global dmr_running, dmr_has_audio, 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 = validate_frequency(data.get('frequency', 462.5625))
+        frequency = float(data.get('frequency', 462.5625))
-        gain = int(validate_gain(data.get('gain', 40)))
+        gain = int(data.get('gain', 40))
-        device = validate_device_index(data.get('device', 0))
+        device = int(data.get('device', 0))
        protocol = str(data.get('protocol', 'auto')).lower()
        ppm = validate_ppm(data.get('ppm', 0))
    except (ValueError, TypeError) as e:
        return jsonify({'status': 'error', 'message': f'Invalid parameter: {e}'}), 400
-    sdr_type_str = str(data.get('sdr_type', 'rtlsdr')).lower()
+    if frequency <= 0:
-    try:
+        return jsonify({'status': 'error', 'message': 'Frequency must be positive'}), 400
        sdr_type = SDRType(sdr_type_str)
    except ValueError:
        sdr_type = SDRType.RTL_SDR
    if protocol not in VALID_PROTOCOLS:
        return jsonify({'status': 'error', 'message': f'Invalid protocol. Use: {", ".join(VALID_PROTOCOLS)}'}), 400
    if sdr_type == SDRType.RTL_SDR:
        if not find_rtl_fm():
            return jsonify({'status': 'error', 'message': 'rtl_fm not found. Install rtl-sdr tools.'}), 503
    else:
        if not find_rx_fm():
            return jsonify({
                'status': 'error',
                'message': f'rx_fm not found. Install SoapySDR tools for {sdr_type.value}.'
            }), 503
    # Clear stale queue
    try:
        while True:
@@ -473,67 +340,32 @@ def start_dmr() -> Response:
    except queue.Empty:
        pass
-    # Reserve running state before we start claiming resources/processes
+    # Claim SDR device
-    # so concurrent /start requests cannot race each other.
+    error = app_module.claim_sdr_device(device, 'dmr')
    with dmr_lock:
        if dmr_running:
            return jsonify({'status': 'error', 'message': 'Already running'}), 409
        dmr_running = True
        dmr_has_audio = False
    # Claim SDR device — use protocol name so the device panel shows
    # "D-STAR", "P25", etc. instead of always "DMR"
    mode_label = protocol.upper() if protocol != 'auto' else 'DMR'
    error = app_module.claim_sdr_device(device, mode_label)
    if error:
        with dmr_lock:
            dmr_running = False
        return jsonify({'status': 'error', 'error_type': 'DEVICE_BUSY', 'message': error}), 409
    dmr_active_device = device
-    # Build FM demodulation command via SDR abstraction.
+    freq_hz = int(frequency * 1e6)
-    try:
+
-        sdr_device = SDRFactory.create_default_device(sdr_type, index=device)
+    # Build rtl_fm command (48kHz sample rate for DSD)
-        builder = SDRFactory.get_builder(sdr_type)
+    rtl_cmd = [
-        rtl_cmd = builder.build_fm_demod_command(
+        rtl_fm_path,
-            device=sdr_device,
+        '-M', 'fm',
-            frequency_mhz=frequency,
+        '-f', str(freq_hz),
-            sample_rate=48000,
+        '-s', '48000',
-            gain=float(gain) if gain > 0 else None,
+        '-g', str(gain),
-            ppm=int(ppm) if ppm != 0 else None,
+        '-d', str(device),
-            modulation='fm',
+        '-l', '1',  # squelch level
-            squelch=None,
+    ]
            bias_t=bool(data.get('bias_t', False)),
        )
        if sdr_type == SDRType.RTL_SDR:
            # Keep squelch fully open for digital bitstreams.
            rtl_cmd.extend(['-l', '0'])
    except Exception as e:
        _reset_runtime_state(release_device=True)
        return jsonify({'status': 'error', 'message': f'Failed to build SDR command: {e}'}), 500
    # Build DSD command
-    # Audio output: pipe decoded audio (8kHz s16le PCM) to stdout for
+    # Use -o - to send decoded audio to stdout (piped to DEVNULL)
-    # ffmpeg transcoding.  Both dsd-fme and classic dsd support '-o -'.
+    # instead of PulseAudio which may not be available under sudo
-    # If ffmpeg is unavailable, fall back to discarding audio.
+    dsd_cmd = [dsd_path, '-i', '-', '-o', '-']
    ffmpeg_path = find_ffmpeg()
    if ffmpeg_path:
        audio_out = '-'
    else:
        audio_out = 'null' if is_fme else '-'
        logger.warning("ffmpeg not found — audio streaming disabled, data-only mode")
    dsd_cmd = [dsd_path, '-i', '-', '-o', audio_out]
    if is_fme:
        dsd_cmd.extend(_DSD_FME_PROTOCOL_FLAGS.get(protocol, []))
        dsd_cmd.extend(_DSD_FME_MODULATION.get(protocol, []))
        # Event log to stderr so we capture TG/Source/Voice data that
        # dsd-fme may not output on stderr by default.
        dsd_cmd.extend(['-J', '/dev/stderr'])
        # Relax CRC checks for marginal signals — lets more frames
        # through at the cost of occasional decode errors.
        if data.get('relaxCrc', False):
            dsd_cmd.append('-F')
    else:
        dsd_cmd.extend(_DSD_PROTOCOL_FLAGS.get(protocol, []))
@@ -545,13 +377,10 @@ def start_dmr() -> Response:
        )
        register_process(dmr_rtl_process)
        # DSD stdout → PIPE when ffmpeg available (audio pipeline),
        # otherwise DEVNULL (data-only mode)
        dsd_stdout = subprocess.PIPE if ffmpeg_path else subprocess.DEVNULL
        dmr_dsd_process = subprocess.Popen(
            dsd_cmd,
            stdin=dmr_rtl_process.stdout,
-            stdout=dsd_stdout,
+            stdout=subprocess.DEVNULL,
            stderr=subprocess.PIPE,
        )
        register_process(dmr_dsd_process)
@@ -559,17 +388,6 @@ def start_dmr() -> Response:
        # Allow rtl_fm to send directly to dsd
        dmr_rtl_process.stdout.close()
        # Start mux thread: always drains dsd-fme stdout to prevent the
        # process from blocking (which would freeze stderr / text data).
        # ffmpeg is started lazily per-client in /dmr/audio/stream.
        if ffmpeg_path and dmr_dsd_process.stdout:
            dmr_has_audio = True
            threading.Thread(
                target=_dsd_audio_mux,
                args=(dmr_dsd_process.stdout,),
                daemon=True,
            ).start()
        time.sleep(0.3)
        rtl_rc = dmr_rtl_process.poll()
@@ -583,8 +401,9 @@ def start_dmr() -> Response:
            if dmr_dsd_process.stderr:
                dsd_err = dmr_dsd_process.stderr.read().decode('utf-8', errors='replace')[:500]
            logger.error(f"DSD pipeline died: rtl_fm rc={rtl_rc} err={rtl_err!r}, dsd rc={dsd_rc} err={dsd_err!r}")
-            # Terminate surviving processes and release resources.
+            if dmr_active_device is not None:
-            _reset_runtime_state(release_device=True)
+                app_module.release_sdr_device(dmr_active_device)
                dmr_active_device = None
            # Surface a clear error to the user
            detail = rtl_err.strip() or dsd_err.strip()
            if 'usb_claim_interface' in rtl_err or 'Failed to open' in rtl_err:
@@ -605,6 +424,7 @@ def start_dmr() -> Response:
        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),
@@ -616,21 +436,43 @@ def start_dmr() -> Response:
            'status': 'started',
            'frequency': frequency,
            'protocol': protocol,
            'sdr_type': sdr_type.value,
            'has_audio': dmr_has_audio,
        })
    except Exception as e:
        logger.error(f"Failed to start DMR: {e}")
-        _reset_runtime_state(release_device=True)
+        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
    with dmr_lock:
-        _reset_runtime_state(release_device=True)
+        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
            if proc:
                unregister_process(proc)
        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'})
@@ -641,113 +483,26 @@ def dmr_status() -> Response:
    return jsonify({
        'running': dmr_running,
        'device': dmr_active_device,
        'has_audio': dmr_has_audio,
    })
@dmr_bp.route('/audio/stream')
 def stream_dmr_audio() -> Response:
    """Stream decoded digital voice audio as WAV.
    Starts a per-client ffmpeg encoder.  The global mux thread
    (_dsd_audio_mux) forwards DSD audio to this ffmpeg's stdin while
    the client is connected, and discards audio otherwise.  This avoids
    the pipe-buffer deadlock that occurs when ffmpeg is started at
    decoder launch (its stdout fills up before any HTTP client reads
    it, back-pressuring the entire pipeline and freezing stderr/text
    data output).
    """
    if not dmr_running or not dmr_has_audio:
        return Response(b'', mimetype='audio/wav', status=204)
    ffmpeg_path = find_ffmpeg()
    if not ffmpeg_path:
        return Response(b'', mimetype='audio/wav', status=503)
    encoder_cmd = [
        ffmpeg_path, '-hide_banner', '-loglevel', 'error',
        '-fflags', 'nobuffer', '-flags', 'low_delay',
        '-probesize', '32', '-analyzeduration', '0',
        '-f', 's16le', '-ar', '8000', '-ac', '1', '-i', 'pipe:0',
        '-acodec', 'pcm_s16le', '-ar', '44100', '-f', 'wav', 'pipe:1',
    ]
    audio_proc = subprocess.Popen(
        encoder_cmd,
        stdin=subprocess.PIPE,
        stdout=subprocess.PIPE,
        stderr=subprocess.PIPE,
    )
    # Drain ffmpeg stderr to prevent blocking
    threading.Thread(
        target=lambda p: [None for _ in p.stderr],
        args=(audio_proc,), daemon=True,
    ).start()
    if audio_proc.stdin:
        _register_audio_sink(audio_proc.stdin)
    def generate():
        try:
            while dmr_running and audio_proc.poll() is None:
                ready, _, _ = select.select([audio_proc.stdout], [], [], 2.0)
                if ready:
                    chunk = audio_proc.stdout.read(4096)
                    if chunk:
                        yield chunk
                    else:
                        break
                else:
                    if audio_proc.poll() is not None:
                        break
        except GeneratorExit:
            pass
        except Exception as e:
            logger.error(f"DMR audio stream error: {e}")
        finally:
            # Disconnect mux → ffmpeg, then clean up
            if audio_proc.stdin:
                _unregister_audio_sink(audio_proc.stdin)
            try:
                audio_proc.stdin.close()
            except Exception:
                pass
            try:
                audio_proc.terminate()
                audio_proc.wait(timeout=2)
            except Exception:
                try:
                    audio_proc.kill()
                except Exception:
                    pass
    return Response(
        generate(),
        mimetype='audio/wav',
        headers={
            'Content-Type': 'audio/wav',
            'Cache-Control': 'no-cache, no-store',
            'X-Accel-Buffering': 'no',
            'Transfer-Encoding': 'chunked',
        },
    )
@dmr_bp.route('/stream')
 def stream_dmr() -> Response:
    """SSE stream for DMR decoder events."""
-    def _on_msg(msg: dict[str, Any]) -> None:
+    def generate() -> Generator[str, None, None]:
-        process_event('dmr', msg, msg.get('type'))
+        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(
+    response = Response(generate(), mimetype='text/event-stream')
        sse_stream_fanout(
            source_queue=dmr_queue,
            channel_key='dmr',
            timeout=SSE_QUEUE_TIMEOUT,
            keepalive_interval=SSE_KEEPALIVE_INTERVAL,
            on_message=_on_msg,
        ),
        mimetype='text/event-stream',
    )
    response.headers['Cache-Control'] = 'no-cache'
    response.headers['X-Accel-Buffering'] = 'no'
    return response
@@ -35,8 +35,7 @@ from utils.database import (
    get_dsc_alert_summary,
 )
 from utils.dsc.parser import parse_dsc_message
-from utils.sse import sse_stream_fanout
+from utils.sse import format_sse
 from utils.event_pipeline import process_event
 from utils.validation import validate_device_index, validate_gain
 from utils.sdr import SDRFactory, SDRType
 from utils.dependencies import get_tool_path
@@ -518,19 +517,22 @@ def stop_decoding() -> Response:
@dsc_bp.route('/stream')
 def stream() -> Response:
    """SSE stream for real-time DSC messages."""
-    def _on_msg(msg: dict[str, Any]) -> None:
+    def generate() -> Generator[str, None, None]:
-        process_event('dsc', msg, msg.get('type'))
+        last_keepalive = time.time()
        keepalive_interval = 30.0
-    response = Response(
+        while True:
-        sse_stream_fanout(
+            try:
-            source_queue=app_module.dsc_queue,
+                msg = app_module.dsc_queue.get(timeout=1)
-            channel_key='dsc',
+                last_keepalive = time.time()
-            timeout=1.0,
+                yield format_sse(msg)
-            keepalive_interval=30.0,
+            except queue.Empty:
-            on_message=_on_msg,
+                now = time.time()
-        ),
+                if now - last_keepalive >= keepalive_interval:
-        mimetype='text/event-stream',
+                    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'
@@ -4,24 +4,19 @@ from __future__ import annotations
 import queue
 import time
-from collections.abc import Generator
+from typing import Generator
-from flask import Blueprint, Response, jsonify
+from flask import Blueprint, jsonify, request, Response
 from utils.gps import (
    GPSPosition,
    GPSSkyData,
    detect_gps_devices,
    get_current_position,
    get_gps_reader,
    is_gpsd_running,
    start_gpsd,
    start_gpsd_daemon,
    stop_gps,
    stop_gpsd_daemon,
 )
 from utils.logging import get_logger
-from utils.sse import sse_stream_fanout
+from utils.sse import format_sse
 from utils.gps import (
    get_gps_reader,
    start_gpsd,
    stop_gps,
    get_current_position,
    GPSPosition,
 )
 logger = get_logger('intercept.gps')
@@ -34,24 +29,12 @@ _gps_queue: queue.Queue = queue.Queue(maxsize=100)
 def _position_callback(position: GPSPosition) -> None:
    """Callback to queue position updates for SSE stream."""
    try:
-        _gps_queue.put_nowait({'type': 'position', **position.to_dict()})
+        _gps_queue.put_nowait(position.to_dict())
    except queue.Full:
        # Discard oldest if queue is full
        try:
            _gps_queue.get_nowait()
-            _gps_queue.put_nowait({'type': 'position', **position.to_dict()})
+            _gps_queue.put_nowait(position.to_dict())
        except queue.Empty:
            pass
 def _sky_callback(sky: GPSSkyData) -> None:
    """Callback to queue sky data updates for SSE stream."""
    try:
        _gps_queue.put_nowait({'type': 'sky', **sky.to_dict()})
    except queue.Full:
        try:
            _gps_queue.get_nowait()
            _gps_queue.put_nowait({'type': 'sky', **sky.to_dict()})
        except queue.Empty:
            pass
@@ -62,45 +45,37 @@ def auto_connect_gps():
    Automatically connect to gpsd if available.
    Called on page load to seamlessly enable GPS if gpsd is running.
    If gpsd is not running, attempts to detect GPS devices and start gpsd.
    Returns current status if already connected.
    """
    import socket
    # Check if already running
    reader = get_gps_reader()
    if reader and reader.is_running:
        position = reader.position
        sky = reader.sky
        return jsonify({
            'status': 'connected',
            'source': 'gpsd',
            'has_fix': position is not None,
-            'position': position.to_dict() if position else None,
+            'position': position.to_dict() if position else None
            'sky': sky.to_dict() if sky else None,
        })
    # Try to connect to gpsd on localhost:2947
    host = 'localhost'
    port = 2947
-    # If gpsd isn't running, try to detect a device and start it
+    # First check if gpsd is reachable
-    if not is_gpsd_running(host, port):
+    try:
-        devices = detect_gps_devices()
+        sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
-        if not devices:
+        sock.settimeout(1.0)
        sock.connect((host, port))
        sock.close()
    except Exception:
        return jsonify({
            'status': 'unavailable',
-                'message': 'No GPS device detected'
+            'message': 'gpsd not running'
        })
        # Try to start gpsd with the first detected device
        device_path = devices[0]['path']
        success, msg = start_gpsd_daemon(device_path, host, port)
        if not success:
            return jsonify({
                'status': 'unavailable',
                'message': msg,
                'devices': devices,
            })
        logger.info(f"Auto-started gpsd on {device_path}")
    # Clear the queue
    while not _gps_queue.empty():
        try:
@@ -109,17 +84,14 @@ def auto_connect_gps():
            break
    # Start the gpsd client
-    success = start_gpsd(host, port,
+    success = start_gpsd(host, port, callback=_position_callback)
                         callback=_position_callback,
                         sky_callback=_sky_callback)
    if success:
        return jsonify({
            'status': 'connected',
            'source': 'gpsd',
            'has_fix': False,
-            'position': None,
+            'position': None
            'sky': None,
        })
    else:
        return jsonify({
@@ -128,26 +100,14 @@ def auto_connect_gps():
        })
@gps_bp.route('/devices')
 def list_gps_devices():
    """List detected GPS serial devices."""
    devices = detect_gps_devices()
    return jsonify({
        'devices': devices,
        'gpsd_running': is_gpsd_running(),
    })
@gps_bp.route('/stop', methods=['POST'])
 def stop_gps_reader():
-    """Stop GPS client and gpsd daemon if we started it."""
+    """Stop GPS client."""
    reader = get_gps_reader()
    if reader:
        reader.remove_callback(_position_callback)
        reader.remove_sky_callback(_sky_callback)
    stop_gps()
    stop_gpsd_daemon()
    return jsonify({'status': 'stopped'})
@@ -162,18 +122,15 @@ def get_gps_status():
            'running': False,
            'device': None,
            'position': None,
            'sky': None,
            'error': None,
            'message': 'GPS client not started'
        })
    position = reader.position
    sky = reader.sky
    return jsonify({
        'running': reader.is_running,
        'device': reader.device_path,
        'position': position.to_dict() if position else None,
        'sky': sky.to_dict() if sky else None,
        'last_update': reader.last_update.isoformat() if reader.last_update else None,
        'error': reader.error,
        'message': 'Waiting for GPS fix - ensure GPS has clear view of sky' if reader.is_running and not position else None
@@ -204,42 +161,25 @@ def get_position():
            })
@gps_bp.route('/satellites')
 def get_satellites():
    """Get current satellite sky view data."""
    reader = get_gps_reader()
    if not reader or not reader.is_running:
        return jsonify({
            'status': 'error',
            'message': 'GPS client not running'
        }), 400
    sky = reader.sky
    if sky:
        return jsonify({
            'status': 'ok',
            'sky': sky.to_dict()
        })
    else:
        return jsonify({
            'status': 'waiting',
            'message': 'Waiting for satellite data'
        })
@gps_bp.route('/stream')
 def stream_gps():
-    """SSE stream of GPS position and sky updates."""
+    """SSE stream of GPS position updates."""
-    response = Response(
+    def generate() -> Generator[str, None, None]:
-        sse_stream_fanout(
+        last_keepalive = time.time()
-            source_queue=_gps_queue,
+        keepalive_interval = 30.0
-            channel_key='gps',
+
-            timeout=1.0,
+        while True:
-            keepalive_interval=30.0,
+            try:
-        ),
+                position = _gps_queue.get(timeout=1)
-        mimetype='text/event-stream',
+                last_keepalive = time.time()
-    )
+                yield format_sse({'type': 'position', **position})
            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'
@@ -19,8 +19,7 @@ from flask import Blueprint, jsonify, request, Response
 import app as app_module
 from utils.logging import get_logger
-from utils.sse import sse_stream_fanout
+from utils.sse import format_sse
 from utils.event_pipeline import process_event
 from utils.constants import (
    SSE_QUEUE_TIMEOUT,
    SSE_KEEPALIVE_INTERVAL,
@@ -113,12 +112,6 @@ def normalize_modulation(value: str) -> str:
    return mod
 def _rtl_fm_demod_mode(modulation: str) -> str:
    """Map UI modulation names to rtl_fm demod tokens."""
    mod = str(modulation or '').lower().strip()
    return 'wbfm' if mod == 'wfm' else mod
 def add_activity_log(event_type: str, frequency: float, details: str = ''):
@@ -215,7 +208,7 @@ def scanner_loop():
            # Don't use squelch in rtl_fm - we want to analyze raw audio
            rtl_cmd = [
                rtl_fm_path,
-                '-M', _rtl_fm_demod_mode(mod),
+                '-M', mod,
                '-f', str(freq_hz),
                '-s', str(sample_rate),
                '-r', str(resample_rate),
@@ -687,7 +680,7 @@ def _start_audio_stream(frequency: float, modulation: str):
            freq_hz = int(frequency * 1e6)
            sdr_cmd = [
                rtl_fm_path,
-                '-M', _rtl_fm_demod_mode(modulation),
+                '-M', modulation,
                '-f', str(freq_hz),
                '-s', str(sample_rate),
                '-r', str(resample_rate),
@@ -846,13 +839,9 @@ def _start_audio_stream(frequency: float, modulation: str):
            try:
                ready, _, _ = select.select([audio_process.stdout], [], [], 4.0)
                if not ready:
-                    logger.warning("Audio pipeline produced no data in startup window — killing stalled pipeline")
+                    logger.warning("Audio pipeline produced no data in startup window")
                    _stop_audio_stream_internal()
                    return
            except Exception as e:
                logger.warning(f"Audio startup check failed: {e}")
                _stop_audio_stream_internal()
                return
            audio_running = True
            audio_frequency = frequency
@@ -877,8 +866,6 @@ def _stop_audio_stream_internal():
    audio_running = False
    audio_frequency = 0.0
    had_processes = audio_process is not None or audio_rtl_process is not None
    # Kill the pipeline processes and their groups
    if audio_process:
        try:
@@ -905,7 +892,6 @@ def _stop_audio_stream_internal():
    audio_rtl_process = None
    # Pause for SDR device USB interface to be released by kernel
    if had_processes:
    time.sleep(1.0)
@@ -1182,19 +1168,21 @@ def scanner_status() -> Response:
@listening_post_bp.route('/scanner/stream')
 def stream_scanner_events() -> Response:
    """SSE stream for scanner events."""
-    def _on_msg(msg: dict[str, Any]) -> None:
+    def generate() -> Generator[str, None, None]:
-        process_event('listening_scanner', msg, msg.get('type'))
+        last_keepalive = time.time()
-    response = Response(
+        while True:
-        sse_stream_fanout(
+            try:
-            source_queue=scanner_queue,
+                msg = scanner_queue.get(timeout=SSE_QUEUE_TIMEOUT)
-            channel_key='listening_scanner',
+                last_keepalive = time.time()
-            timeout=SSE_QUEUE_TIMEOUT,
+                yield format_sse(msg)
-            keepalive_interval=SSE_KEEPALIVE_INTERVAL,
+            except queue.Empty:
-            on_message=_on_msg,
+                now = time.time()
-        ),
+                if now - last_keepalive >= SSE_KEEPALIVE_INTERVAL:
-        mimetype='text/event-stream',
+                    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
@@ -1305,40 +1293,11 @@ def start_audio() -> Response:
    scanner_config['device'] = device
    scanner_config['sdr_type'] = sdr_type
-    # Stop waterfall if it's using the same SDR (SSE path)
+    # Claim device for listening audio
    if waterfall_running and waterfall_active_device == device:
        _stop_waterfall_internal()
        time.sleep(0.2)
    # Claim device for listening audio.  The WebSocket waterfall handler
    # may still be tearing down its IQ capture process (thread join +
    # safe_terminate can take several seconds), so we retry with back-off
    # to give the USB device time to be fully released.
    if listening_active_device is None or listening_active_device != device:
        if listening_active_device is not None:
            app_module.release_sdr_device(listening_active_device)
            listening_active_device = None
        error = None
        max_claim_attempts = 6
        for attempt in range(max_claim_attempts):
            # Force-release a stale waterfall registry entry on each
            # attempt — the WebSocket handler may not have finished
            # cleanup yet.
            device_status = app_module.get_sdr_device_status()
            if device_status.get(device) == 'waterfall':
                app_module.release_sdr_device(device)
        error = app_module.claim_sdr_device(device, 'listening')
            if not error:
                break
            if attempt < max_claim_attempts - 1:
                logger.debug(
                    f"Device claim attempt {attempt + 1}/{max_claim_attempts} "
                    f"failed, retrying in 0.5s: {error}"
                )
                time.sleep(0.5)
        if error:
            return jsonify({
                'status': 'error',
@@ -1441,6 +1400,13 @@ def audio_probe() -> Response:
@listening_post_bp.route('/audio/stream')
 def stream_audio() -> Response:
    """Stream WAV audio."""
    # Optionally restart pipeline so the stream starts with a fresh header
    if request.args.get('fresh') == '1' and audio_running:
        try:
            _start_audio_stream(audio_frequency or 0.0, audio_modulation or 'fm')
        except Exception as e:
            logger.error(f"Audio stream restart failed: {e}")
    # Wait for audio to be ready (up to 2 seconds for modulation/squelch changes)
    for _ in range(40):
        if audio_running and audio_process:
@@ -1456,30 +1422,13 @@ def stream_audio() -> Response:
        if not proc or not proc.stdout:
            return
        try:
-            # Drain stale audio that accumulated in the pipe buffer
+            # First byte timeout to avoid hanging clients forever
            # between pipeline start and stream connection.  Keep the
            # first chunk (contains WAV header) and discard the rest
            # so the browser starts close to real-time.
            header_chunk = None
            while True:
                ready, _, _ = select.select([proc.stdout], [], [], 0)
                if not ready:
                    break
                chunk = proc.stdout.read(8192)
                if not chunk:
                    break
                if header_chunk is None:
                    header_chunk = chunk
            if header_chunk:
                yield header_chunk
            # Stream real-time audio
            first_chunk_deadline = time.time() + 3.0
            while audio_running and proc.poll() is None:
                # Use select to avoid blocking forever
                ready, _, _ = select.select([proc.stdout], [], [], 2.0)
                if ready:
-                    chunk = proc.stdout.read(8192)
+                    chunk = proc.stdout.read(4096)
                    if chunk:
                        yield chunk
                    else:
@@ -1572,51 +1521,9 @@ waterfall_config = {
    'bin_size': 10000,
    'gain': 40,
    'device': 0,
    'max_bins': 1024,
    'interval': 0.4,
 }
 def _parse_rtl_power_line(line: str) -> tuple[str | None, float | None, float | None, list[float]]:
    """Parse a single rtl_power CSV line into bins."""
    if not line or line.startswith('#'):
        return None, None, None, []
    parts = [p.strip() for p in line.split(',')]
    if len(parts) < 6:
        return None, None, None, []
    # Timestamp in first two fields (YYYY-MM-DD, HH:MM:SS)
    timestamp = f"{parts[0]} {parts[1]}" if len(parts) >= 2 else parts[0]
    start_idx = None
    for i, tok in enumerate(parts):
        try:
            val = float(tok)
        except ValueError:
            continue
        if val > 1e5:
            start_idx = i
            break
    if start_idx is None or len(parts) < start_idx + 4:
        return timestamp, None, None, []
    try:
        seg_start = float(parts[start_idx])
        seg_end = float(parts[start_idx + 1])
        raw_values = []
        for v in parts[start_idx + 3:]:
            try:
                raw_values.append(float(v))
            except ValueError:
                continue
        if raw_values and raw_values[0] >= 0 and any(val < 0 for val in raw_values[1:]):
            raw_values = raw_values[1:]
        return timestamp, seg_start, seg_end, raw_values
    except ValueError:
        return timestamp, None, None, []
 def _waterfall_loop():
    """Continuous rtl_power sweep loop emitting waterfall data."""
    global waterfall_running, waterfall_process
@@ -1627,59 +1534,84 @@ def _waterfall_loop():
        waterfall_running = False
        return
    try:
        while waterfall_running:
            start_hz = int(waterfall_config['start_freq'] * 1e6)
            end_hz = int(waterfall_config['end_freq'] * 1e6)
            bin_hz = int(waterfall_config['bin_size'])
            gain = waterfall_config['gain']
            device = waterfall_config['device']
    interval = float(waterfall_config.get('interval', 0.4))
            cmd = [
                rtl_power_path,
                '-f', f'{start_hz}:{end_hz}:{bin_hz}',
-        '-i', str(interval),
+                '-i', '0.5',
                '-1',
                '-g', str(gain),
                '-d', str(device),
            ]
            try:
-        waterfall_process = subprocess.Popen(
+                proc = subprocess.Popen(cmd, stdout=subprocess.PIPE, stderr=subprocess.DEVNULL)
-            cmd,
+                waterfall_process = proc
-            stdout=subprocess.PIPE,
+                stdout, _ = proc.communicate(timeout=15)
-            stderr=subprocess.DEVNULL,
+            except subprocess.TimeoutExpired:
-            bufsize=1,
+                proc.kill()
-            text=True,
+                stdout = b''
-        )
+            finally:
                waterfall_process = None
        current_ts = None
        all_bins: list[float] = []
        sweep_start_hz = start_hz
        sweep_end_hz = end_hz
        if not waterfall_process.stdout:
            return
        for line in waterfall_process.stdout:
            if not waterfall_running:
                break
-            ts, seg_start, seg_end, bins = _parse_rtl_power_line(line)
+            if not stdout:
-            if ts is None or not bins:
+                time.sleep(0.2)
                continue
-            if current_ts is None:
+            # Parse rtl_power CSV output
-                current_ts = ts
+            all_bins = []
            sweep_start_hz = start_hz
            sweep_end_hz = end_hz
-            if ts != current_ts and all_bins:
+            for line in stdout.decode(errors='ignore').splitlines():
-                max_bins = int(waterfall_config.get('max_bins') or 0)
+                if not line or line.startswith('#'):
-                bins_to_send = all_bins
+                    continue
-                if max_bins > 0 and len(bins_to_send) > max_bins:
+                parts = [p.strip() for p in line.split(',')]
-                    bins_to_send = _downsample_bins(bins_to_send, max_bins)
+                start_idx = None
                for i, tok in enumerate(parts):
                    try:
                        val = float(tok)
                    except ValueError:
                        continue
                    if val > 1e5:
                        start_idx = i
                        break
                if start_idx is None or len(parts) < start_idx + 4:
                    continue
                try:
                    seg_start = float(parts[start_idx])
                    seg_end = float(parts[start_idx + 1])
                    seg_bin = float(parts[start_idx + 2])
                    raw_values = []
                    for v in parts[start_idx + 3:]:
                        try:
                            raw_values.append(float(v))
                        except ValueError:
                            continue
                    if raw_values and raw_values[0] >= 0 and any(val < 0 for val in raw_values[1:]):
                        raw_values = raw_values[1:]
                    all_bins.extend(raw_values)
                    sweep_start_hz = min(sweep_start_hz, seg_start)
                    sweep_end_hz = max(sweep_end_hz, seg_end)
                except ValueError:
                    continue
            if all_bins:
                msg = {
                    'type': 'waterfall_sweep',
                    'start_freq': sweep_start_hz / 1e6,
                    'end_freq': sweep_end_hz / 1e6,
-                    'bins': bins_to_send,
+                    'bins': all_bins,
                    'timestamp': datetime.now().isoformat(),
                }
                try:
@@ -1694,73 +1626,15 @@ def _waterfall_loop():
                    except queue.Full:
                        pass
-                all_bins = []
+            time.sleep(0.1)
                sweep_start_hz = start_hz
                sweep_end_hz = end_hz
                current_ts = ts
            all_bins.extend(bins)
            if seg_start is not None:
                sweep_start_hz = min(sweep_start_hz, seg_start)
            if seg_end is not None:
                sweep_end_hz = max(sweep_end_hz, seg_end)
        # Flush any remaining bins
        if all_bins and waterfall_running:
            max_bins = int(waterfall_config.get('max_bins') or 0)
            bins_to_send = all_bins
            if max_bins > 0 and len(bins_to_send) > max_bins:
                bins_to_send = _downsample_bins(bins_to_send, max_bins)
            msg = {
                'type': 'waterfall_sweep',
                'start_freq': sweep_start_hz / 1e6,
                'end_freq': sweep_end_hz / 1e6,
                'bins': bins_to_send,
                'timestamp': datetime.now().isoformat(),
            }
            try:
                waterfall_queue.put_nowait(msg)
            except queue.Full:
                pass
    except Exception as e:
        logger.error(f"Waterfall loop error: {e}")
    finally:
        waterfall_running = False
        if waterfall_process and waterfall_process.poll() is None:
            try:
                waterfall_process.terminate()
                waterfall_process.wait(timeout=1)
            except Exception:
                try:
                    waterfall_process.kill()
                except Exception:
                    pass
        waterfall_process = None
        logger.info("Waterfall loop stopped")
 def _stop_waterfall_internal() -> None:
    """Stop the waterfall display and release resources."""
    global waterfall_running, waterfall_process, waterfall_active_device
    waterfall_running = False
    if waterfall_process and waterfall_process.poll() is None:
        try:
            waterfall_process.terminate()
            waterfall_process.wait(timeout=1)
        except Exception:
            try:
                waterfall_process.kill()
            except Exception:
                pass
        waterfall_process = None
    if waterfall_active_device is not None:
        app_module.release_sdr_device(waterfall_active_device)
        waterfall_active_device = None
@listening_post_bp.route('/waterfall/start', methods=['POST'])
 def start_waterfall() -> Response:
    """Start the waterfall/spectrogram display."""
@@ -1781,16 +1655,6 @@ def start_waterfall() -> Response:
        waterfall_config['bin_size'] = int(data.get('bin_size', 10000))
        waterfall_config['gain'] = int(data.get('gain', 40))
        waterfall_config['device'] = int(data.get('device', 0))
        if data.get('interval') is not None:
            interval = float(data.get('interval', waterfall_config['interval']))
            if interval < 0.1 or interval > 5:
                return jsonify({'status': 'error', 'message': 'interval must be between 0.1 and 5 seconds'}), 400
            waterfall_config['interval'] = interval
        if data.get('max_bins') is not None:
            max_bins = int(data.get('max_bins', waterfall_config['max_bins']))
            if max_bins < 64 or max_bins > 4096:
                return jsonify({'status': 'error', 'message': 'max_bins must be between 64 and 4096'}), 400
            waterfall_config['max_bins'] = max_bins
    except (ValueError, TypeError) as e:
        return jsonify({'status': 'error', 'message': f'Invalid parameter: {e}'}), 400
@@ -1820,7 +1684,23 @@ def start_waterfall() -> Response:
@listening_post_bp.route('/waterfall/stop', methods=['POST'])
 def stop_waterfall() -> Response:
    """Stop the waterfall display."""
-    _stop_waterfall_internal()
+    global waterfall_running, waterfall_process, waterfall_active_device
    waterfall_running = False
    if waterfall_process and waterfall_process.poll() is None:
        try:
            waterfall_process.terminate()
            waterfall_process.wait(timeout=1)
        except Exception:
            try:
                waterfall_process.kill()
            except Exception:
                pass
        waterfall_process = None
    if waterfall_active_device is not None:
        app_module.release_sdr_device(waterfall_active_device)
        waterfall_active_device = None
    return jsonify({'status': 'stopped'})
@@ -1828,36 +1708,20 @@ def stop_waterfall() -> Response:
@listening_post_bp.route('/waterfall/stream')
 def stream_waterfall() -> Response:
    """SSE stream for waterfall data."""
-    def _on_msg(msg: dict[str, Any]) -> None:
+    def generate() -> Generator[str, None, None]:
-        process_event('waterfall', msg, msg.get('type'))
+        last_keepalive = time.time()
        while True:
            try:
                msg = waterfall_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(
+    response = Response(generate(), mimetype='text/event-stream')
        sse_stream_fanout(
            source_queue=waterfall_queue,
            channel_key='listening_waterfall',
            timeout=SSE_QUEUE_TIMEOUT,
            keepalive_interval=SSE_KEEPALIVE_INTERVAL,
            on_message=_on_msg,
        ),
        mimetype='text/event-stream',
    )
    response.headers['Cache-Control'] = 'no-cache'
    response.headers['X-Accel-Buffering'] = 'no'
    return response
 def _downsample_bins(values: list[float], target: int) -> list[float]:
    """Downsample bins to a target length using simple averaging."""
    if target <= 0 or len(values) <= target:
        return values
    out: list[float] = []
    step = len(values) / target
    for i in range(target):
        start = int(i * step)
        end = int((i + 1) * step)
        if end <= start:
            end = min(start + 1, len(values))
        chunk = values[start:end]
        if not chunk:
            continue
        out.append(sum(chunk) / len(chunk))
    return out
@@ -17,7 +17,7 @@ from typing import Generator
 from flask import Blueprint, jsonify, request, Response
 from utils.logging import get_logger
-from utils.sse import sse_stream_fanout
+from utils.sse import format_sse
 from utils.meshtastic import (
    get_meshtastic_client,
    start_meshtastic,
@@ -469,15 +469,22 @@ def stream_messages():
    Returns:
        SSE stream (text/event-stream)
    """
-    response = Response(
+    def generate() -> Generator[str, None, None]:
-        sse_stream_fanout(
+        last_keepalive = time.time()
-            source_queue=_mesh_queue,
+        keepalive_interval = 30.0
-            channel_key='meshtastic',
+
-            timeout=1.0,
+        while True:
-            keepalive_interval=30.0,
+            try:
-        ),
+                msg = _mesh_queue.get(timeout=1)
-        mimetype='text/event-stream',
+                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'
@@ -1044,19 +1051,3 @@ def request_store_forward():
            'status': 'error',
            'message': error or 'Failed to request S&F history'
        }), 500
@meshtastic_bp.route('/topology')
 def mesh_topology():
    """Return mesh network topology graph."""
    if not is_meshtastic_available():
        return jsonify({'status': 'error', 'message': 'Meshtastic SDK not installed'}), 400
    client = get_meshtastic_client()
    if not client or not client.is_running:
        return jsonify({'status': 'error', 'message': 'Not connected'}), 400
    return jsonify({
        'status': 'success',
        'topology': client.get_topology(),
    })
@@ -44,9 +44,6 @@ ASSET_PATHS = {
        'static/vendor/leaflet/images/marker-shadow.png',
        'static/vendor/leaflet/images/layers.png',
        'static/vendor/leaflet/images/layers-2x.png'
    ],
    'leaflet_heat': [
        'static/vendor/leaflet-heat/leaflet-heat.js'
    ]
 }
@@ -2,14 +2,12 @@
 from __future__ import annotations
 import math
 import os
 import pathlib
 import re
 import pty
 import queue
 import select
 import struct
 import subprocess
 import threading
 import time
@@ -24,8 +22,7 @@ from utils.validation import (
    validate_frequency, validate_device_index, validate_gain, validate_ppm,
    validate_rtl_tcp_host, validate_rtl_tcp_port
 )
-from utils.sse import sse_stream_fanout
+from utils.sse import format_sse
 from utils.event_pipeline import process_event
 from utils.process import safe_terminate, register_process, unregister_process
 from utils.sdr import SDRFactory, SDRType, SDRValidationError
 from utils.dependencies import get_tool_path
@@ -108,62 +105,6 @@ def log_message(msg: dict[str, Any]) -> None:
        logger.error(f"Failed to log message: {e}")
 def audio_relay_thread(
    rtl_stdout,
    multimon_stdin,
    output_queue: queue.Queue,
    stop_event: threading.Event,
 ) -> None:
    """Relay audio from rtl_fm to multimon-ng while computing signal levels.
    Reads raw 16-bit LE PCM from *rtl_stdout*, writes every chunk straight
    through to *multimon_stdin*, and every ~100 ms pushes an RMS / peak scope
    event onto *output_queue*.
    """
    CHUNK = 4096  # bytes – 2048 samples at 16-bit mono
    INTERVAL = 0.1  # seconds between scope updates
    last_scope = time.monotonic()
    try:
        while not stop_event.is_set():
            data = rtl_stdout.read(CHUNK)
            if not data:
                break
            # Forward audio untouched
            try:
                multimon_stdin.write(data)
                multimon_stdin.flush()
            except (BrokenPipeError, OSError):
                break
            # Compute scope levels every ~100 ms
            now = time.monotonic()
            if now - last_scope >= INTERVAL:
                last_scope = now
                try:
                    n_samples = len(data) // 2
                    if n_samples == 0:
                        continue
                    samples = struct.unpack(f'<{n_samples}h', data[:n_samples * 2])
                    peak = max(abs(s) for s in samples)
                    rms = int(math.sqrt(sum(s * s for s in samples) / n_samples))
                    output_queue.put_nowait({
                        'type': 'scope',
                        'rms': rms,
                        'peak': peak,
                    })
                except (struct.error, ValueError, queue.Full):
                    pass
    except Exception as e:
        logger.debug(f"Audio relay error: {e}")
    finally:
        try:
            multimon_stdin.close()
        except OSError:
            pass
 def stream_decoder(master_fd: int, process: subprocess.Popen[bytes]) -> None:
    """Stream decoder output to queue using PTY for unbuffered output."""
    try:
@@ -210,11 +151,6 @@ def stream_decoder(master_fd: int, process: subprocess.Popen[bytes]) -> None:
            os.close(master_fd)
        except OSError:
            pass
        # Signal relay thread to stop
        with app_module.process_lock:
            stop_relay = getattr(app_module.current_process, '_stop_relay', None)
        if stop_relay:
            stop_relay.set()
        # Cleanup companion rtl_fm process and decoder
        with app_module.process_lock:
            rtl_proc = getattr(app_module.current_process, '_rtl_process', None)
@@ -382,7 +318,7 @@ def start_decoding() -> Response:
            multimon_process = subprocess.Popen(
                multimon_cmd,
-                stdin=subprocess.PIPE,
+                stdin=rtl_process.stdout,
                stdout=slave_fd,
                stderr=slave_fd,
                close_fds=True
@@ -390,22 +326,11 @@ def start_decoding() -> Response:
            register_process(multimon_process)
            os.close(slave_fd)
-
+            rtl_process.stdout.close()
            # Spawn audio relay thread between rtl_fm and multimon-ng
            stop_relay = threading.Event()
            relay = threading.Thread(
                target=audio_relay_thread,
                args=(rtl_process.stdout, multimon_process.stdin,
                      app_module.output_queue, stop_relay),
            )
            relay.daemon = True
            relay.start()
            app_module.current_process = multimon_process
            app_module.current_process._rtl_process = rtl_process
            app_module.current_process._master_fd = master_fd
            app_module.current_process._stop_relay = stop_relay
            app_module.current_process._relay_thread = relay
            # Start output thread with PTY master fd
            thread = threading.Thread(target=stream_decoder, args=(master_fd, multimon_process))
@@ -454,10 +379,6 @@ def stop_decoding() -> Response:
    with app_module.process_lock:
        if app_module.current_process:
            # Signal audio relay thread to stop
            if hasattr(app_module.current_process, '_stop_relay'):
                app_module.current_process._stop_relay.set()
            # Kill rtl_fm process first
            if hasattr(app_module.current_process, '_rtl_process'):
                try:
@@ -540,19 +461,24 @@ def toggle_logging() -> Response:
@pager_bp.route('/stream')
 def stream() -> Response:
-    def _on_msg(msg: dict[str, Any]) -> None:
+    import json
        process_event('pager', msg, msg.get('type'))
-    response = Response(
+    def generate() -> Generator[str, None, None]:
-        sse_stream_fanout(
+        last_keepalive = time.time()
-            source_queue=app_module.output_queue,
+        keepalive_interval = 30.0  # Send keepalive every 30 seconds instead of 1 second
-            channel_key='pager',
+
-            timeout=1.0,
+        while True:
-            keepalive_interval=30.0,
+            try:
-            on_message=_on_msg,
+                msg = app_module.output_queue.get(timeout=1)
-        ),
+                last_keepalive = time.time()
-        mimetype='text/event-stream',
+                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'
@@ -1,166 +0,0 @@
 """Session recording API endpoints."""
 from __future__ import annotations
 import json
 from pathlib import Path
 from flask import Blueprint, jsonify, request, send_file
 from utils.recording import get_recording_manager, RECORDING_ROOT
 recordings_bp = Blueprint('recordings', __name__, url_prefix='/recordings')
@recordings_bp.route('/start', methods=['POST'])
 def start_recording():
    data = request.get_json() or {}
    mode = (data.get('mode') or '').strip()
    if not mode:
        return jsonify({'status': 'error', 'message': 'mode is required'}), 400
    label = data.get('label')
    metadata = data.get('metadata') if isinstance(data.get('metadata'), dict) else {}
    manager = get_recording_manager()
    session = manager.start_recording(mode=mode, label=label, metadata=metadata)
    return jsonify({
        'status': 'success',
        'session': {
            'id': session.id,
            'mode': session.mode,
            'label': session.label,
            'started_at': session.started_at.isoformat(),
            'file_path': str(session.file_path),
        }
    })
@recordings_bp.route('/stop', methods=['POST'])
 def stop_recording():
    data = request.get_json() or {}
    mode = data.get('mode')
    session_id = data.get('id')
    manager = get_recording_manager()
    session = manager.stop_recording(mode=mode, session_id=session_id)
    if not session:
        return jsonify({'status': 'error', 'message': 'No active recording found'}), 404
    return jsonify({
        'status': 'success',
        'session': {
            'id': session.id,
            'mode': session.mode,
            'label': session.label,
            'started_at': session.started_at.isoformat(),
            'stopped_at': session.stopped_at.isoformat() if session.stopped_at else None,
            'event_count': session.event_count,
            'size_bytes': session.size_bytes,
            'file_path': str(session.file_path),
        }
    })
@recordings_bp.route('', methods=['GET'])
 def list_recordings():
    manager = get_recording_manager()
    limit = request.args.get('limit', default=50, type=int)
    return jsonify({
        'status': 'success',
        'recordings': manager.list_recordings(limit=limit),
        'active': manager.get_active(),
    })
@recordings_bp.route('/<session_id>', methods=['GET'])
 def get_recording(session_id: str):
    manager = get_recording_manager()
    rec = manager.get_recording(session_id)
    if not rec:
        return jsonify({'status': 'error', 'message': 'Recording not found'}), 404
    return jsonify({'status': 'success', 'recording': rec})
@recordings_bp.route('/<session_id>/download', methods=['GET'])
 def download_recording(session_id: str):
    manager = get_recording_manager()
    rec = manager.get_recording(session_id)
    if not rec:
        return jsonify({'status': 'error', 'message': 'Recording not found'}), 404
    file_path = Path(rec['file_path'])
    try:
        resolved_root = RECORDING_ROOT.resolve()
        resolved_file = file_path.resolve()
        if resolved_root not in resolved_file.parents:
            return jsonify({'status': 'error', 'message': 'Invalid recording path'}), 400
    except Exception:
        return jsonify({'status': 'error', 'message': 'Invalid recording path'}), 400
    if not file_path.exists():
        return jsonify({'status': 'error', 'message': 'Recording file missing'}), 404
    return send_file(
        file_path,
        mimetype='application/x-ndjson',
        as_attachment=True,
        download_name=file_path.name,
    )
@recordings_bp.route('/<session_id>/events', methods=['GET'])
 def get_recording_events(session_id: str):
    """Return parsed events from a recording for in-app replay."""
    manager = get_recording_manager()
    rec = manager.get_recording(session_id)
    if not rec:
        return jsonify({'status': 'error', 'message': 'Recording not found'}), 404
    file_path = Path(rec['file_path'])
    try:
        resolved_root = RECORDING_ROOT.resolve()
        resolved_file = file_path.resolve()
        if resolved_root not in resolved_file.parents:
            return jsonify({'status': 'error', 'message': 'Invalid recording path'}), 400
    except Exception:
        return jsonify({'status': 'error', 'message': 'Invalid recording path'}), 400
    if not file_path.exists():
        return jsonify({'status': 'error', 'message': 'Recording file missing'}), 404
    limit = max(1, min(5000, request.args.get('limit', default=500, type=int)))
    offset = max(0, request.args.get('offset', default=0, type=int))
    events: list[dict] = []
    seen = 0
    with file_path.open('r', encoding='utf-8', errors='replace') as fh:
        for idx, line in enumerate(fh):
            if idx < offset:
                continue
            if seen >= limit:
                break
            line = line.strip()
            if not line:
                continue
            try:
                events.append(json.loads(line))
                seen += 1
            except json.JSONDecodeError:
                continue
    return jsonify({
        'status': 'success',
        'recording': {
            'id': rec['id'],
            'mode': rec['mode'],
            'started_at': rec['started_at'],
            'stopped_at': rec['stopped_at'],
            'event_count': rec['event_count'],
        },
        'offset': offset,
        'limit': limit,
        'returned': len(events),
        'events': events,
    })
@@ -17,8 +17,7 @@ from utils.logging import sensor_logger as logger
 from utils.validation import (
    validate_frequency, validate_device_index, validate_gain, validate_ppm
 )
-from utils.sse import sse_stream_fanout
+from utils.sse import format_sse
 from utils.event_pipeline import process_event
 from utils.process import safe_terminate, register_process, unregister_process
 rtlamr_bp = Blueprint('rtlamr', __name__)
@@ -288,19 +287,22 @@ def stop_rtlamr() -> Response:
@rtlamr_bp.route('/stream_rtlamr')
 def stream_rtlamr() -> Response:
-    def _on_msg(msg: dict[str, Any]) -> None:
+    def generate() -> Generator[str, None, None]:
-        process_event('rtlamr', msg, msg.get('type'))
+        last_keepalive = time.time()
        keepalive_interval = 30.0
-    response = Response(
+        while True:
-        sse_stream_fanout(
+            try:
-            source_queue=app_module.rtlamr_queue,
+                msg = app_module.rtlamr_queue.get(timeout=1)
-            channel_key='rtlamr',
+                last_keepalive = time.time()
-            timeout=1.0,
+                yield format_sse(msg)
-            keepalive_interval=30.0,
+            except queue.Empty:
-            on_message=_on_msg,
+                now = time.time()
-        ),
+                if now - last_keepalive >= keepalive_interval:
-        mimetype='text/event-stream',
+                    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'
@@ -16,13 +16,6 @@ from flask import Blueprint, jsonify, request, render_template, Response
 from config import SHARED_OBSERVER_LOCATION_ENABLED
 from data.satellites import TLE_SATELLITES
 from utils.database import (
    get_tracked_satellites,
    add_tracked_satellite,
    bulk_add_tracked_satellites,
    update_tracked_satellite,
    remove_tracked_satellite,
 )
 from utils.logging import satellite_logger as logger
 from utils.validation import validate_latitude, validate_longitude, validate_hours, validate_elevation
@@ -38,43 +31,6 @@ ALLOWED_TLE_HOSTS = ['celestrak.org', 'celestrak.com', 'www.celestrak.org', 'www
 _tle_cache = dict(TLE_SATELLITES)
 def _load_db_satellites_into_cache():
    """Load user-tracked satellites from DB into the TLE cache."""
    global _tle_cache
    try:
        db_sats = get_tracked_satellites()
        loaded = 0
        for sat in db_sats:
            if sat['tle_line1'] and sat['tle_line2']:
                # Use a cache key derived from name (sanitised)
                cache_key = sat['name'].replace(' ', '-').upper()
                if cache_key not in _tle_cache:
                    _tle_cache[cache_key] = (sat['name'], sat['tle_line1'], sat['tle_line2'])
                    loaded += 1
        if loaded:
            logger.info(f"Loaded {loaded} user-tracked satellites into TLE cache")
    except Exception as e:
        logger.warning(f"Failed to load DB satellites into TLE cache: {e}")
 def init_tle_auto_refresh():
    """Initialize TLE auto-refresh. Called by app.py after initialization."""
    import threading
    def _auto_refresh_tle():
        try:
            _load_db_satellites_into_cache()
            updated = refresh_tle_data()
            if updated:
                logger.info(f"Auto-refreshed TLE data for: {', '.join(updated)}")
        except Exception as e:
            logger.warning(f"Auto TLE refresh failed: {e}")
    # Start auto-refresh in background
    threading.Timer(2.0, _auto_refresh_tle).start()
    logger.info("TLE auto-refresh scheduled")
 def _fetch_iss_realtime(observer_lat: Optional[float] = None, observer_lon: Optional[float] = None) -> Optional[dict]:
    """
    Fetch real-time ISS position from external APIs.
@@ -197,11 +153,15 @@ def predict_passes():
    norad_to_name = {
        25544: 'ISS',
        25338: 'NOAA-15',
        28654: 'NOAA-18',
        33591: 'NOAA-19',
        43013: 'NOAA-20',
        40069: 'METEOR-M2',
        57166: 'METEOR-M2-3'
    }
-    sat_input = data.get('satellites', ['ISS', 'METEOR-M2', 'METEOR-M2-3'])
+    sat_input = data.get('satellites', ['ISS', 'NOAA-15', 'NOAA-18', 'NOAA-19'])
    satellites = []
    for sat in sat_input:
        if isinstance(sat, int) and sat in norad_to_name:
@@ -212,6 +172,10 @@ def predict_passes():
    passes = []
    colors = {
        'ISS': '#00ffff',
        'NOAA-15': '#00ff00',
        'NOAA-18': '#ff6600',
        'NOAA-19': '#ff3366',
        'NOAA-20': '#00ffaa',
        'METEOR-M2': '#9370DB',
        'METEOR-M2-3': '#ff00ff'
    }
@@ -348,6 +312,10 @@ def get_satellite_position():
    norad_to_name = {
        25544: 'ISS',
        25338: 'NOAA-15',
        28654: 'NOAA-18',
        33591: 'NOAA-19',
        43013: 'NOAA-20',
        40069: 'METEOR-M2',
        57166: 'METEOR-M2-3'
    }
@@ -513,8 +481,7 @@ def update_tle():
            'updated': updated
        })
    except Exception as e:
-        logger.error(f"Error updating TLE data: {e}")
+        return jsonify({'status': 'error', 'message': str(e)})
        return jsonify({'status': 'error', 'message': 'TLE update failed'})
@satellite_bp.route('/celestrak/<category>')
@@ -568,77 +535,4 @@ def fetch_celestrak(category):
        })
    except Exception as e:
-        logger.error(f"Error fetching CelesTrak data: {e}")
+        return jsonify({'status': 'error', 'message': str(e)})
        return jsonify({'status': 'error', 'message': 'Failed to fetch satellite data'})
 # =============================================================================
 # Tracked Satellites CRUD
 # =============================================================================
@satellite_bp.route('/tracked', methods=['GET'])
 def list_tracked_satellites():
    """Return all tracked satellites from the database."""
    enabled_only = request.args.get('enabled', '').lower() == 'true'
    sats = get_tracked_satellites(enabled_only=enabled_only)
    return jsonify({'status': 'success', 'satellites': sats})
@satellite_bp.route('/tracked', methods=['POST'])
 def add_tracked_satellites_endpoint():
    """Add one or more tracked satellites."""
    global _tle_cache
    data = request.json
    if not data:
        return jsonify({'status': 'error', 'message': 'No data provided'}), 400
    # Accept a single satellite dict or a list
    sat_list = data if isinstance(data, list) else [data]
    added = 0
    for sat in sat_list:
        norad_id = str(sat.get('norad_id', sat.get('norad', '')))
        name = sat.get('name', '')
        if not norad_id or not name:
            continue
        tle1 = sat.get('tle_line1', sat.get('tle1'))
        tle2 = sat.get('tle_line2', sat.get('tle2'))
        enabled = sat.get('enabled', True)
        if add_tracked_satellite(norad_id, name, tle1, tle2, enabled):
            added += 1
        # Also inject into TLE cache if we have TLE data
        if tle1 and tle2:
            cache_key = name.replace(' ', '-').upper()
            _tle_cache[cache_key] = (name, tle1, tle2)
    return jsonify({
        'status': 'success',
        'added': added,
        'satellites': get_tracked_satellites(),
    })
@satellite_bp.route('/tracked/<norad_id>', methods=['PUT'])
 def update_tracked_satellite_endpoint(norad_id):
    """Update the enabled state of a tracked satellite."""
    data = request.json or {}
    enabled = data.get('enabled')
    if enabled is None:
        return jsonify({'status': 'error', 'message': 'Missing enabled field'}), 400
    ok = update_tracked_satellite(str(norad_id), bool(enabled))
    if ok:
        return jsonify({'status': 'success'})
    return jsonify({'status': 'error', 'message': 'Satellite not found'}), 404
@satellite_bp.route('/tracked/<norad_id>', methods=['DELETE'])
 def delete_tracked_satellite_endpoint(norad_id):
    """Remove a tracked satellite by NORAD ID."""
    ok, msg = remove_tracked_satellite(str(norad_id))
    if ok:
        return jsonify({'status': 'success', 'message': msg})
    status_code = 403 if 'builtin' in msg.lower() else 404
    return jsonify({'status': 'error', 'message': msg}), status_code
@@ -18,8 +18,7 @@ from utils.validation import (
    validate_frequency, validate_device_index, validate_gain, validate_ppm,
    validate_rtl_tcp_host, validate_rtl_tcp_port
 )
-from utils.sse import sse_stream_fanout
+from utils.sse import format_sse
 from utils.event_pipeline import process_event
 from utils.process import safe_terminate, register_process, unregister_process
 from utils.sdr import SDRFactory, SDRType
@@ -28,10 +27,6 @@ sensor_bp = Blueprint('sensor', __name__)
 # Track which device is being used
 sensor_active_device: int | None = None
 # RSSI history per device (model_id -> list of (timestamp, rssi))
 sensor_rssi_history: dict[str, list[tuple[float, float]]] = {}
 _MAX_RSSI_HISTORY = 60
 def stream_sensor_output(process: subprocess.Popen[bytes]) -> None:
    """Stream rtl_433 JSON output to queue."""
@@ -49,32 +44,6 @@ def stream_sensor_output(process: subprocess.Popen[bytes]) -> None:
                data['type'] = 'sensor'
                app_module.sensor_queue.put(data)
                # Track RSSI history per device
                _model = data.get('model', '')
                _dev_id = data.get('id', '')
                _rssi_val = data.get('rssi')
                if _rssi_val is not None and _model:
                    _hist_key = f"{_model}_{_dev_id}"
                    hist = sensor_rssi_history.setdefault(_hist_key, [])
                    hist.append((time.time(), float(_rssi_val)))
                    if len(hist) > _MAX_RSSI_HISTORY:
                        del hist[: len(hist) - _MAX_RSSI_HISTORY]
                # Push scope event when signal level data is present
                rssi = data.get('rssi')
                snr = data.get('snr')
                noise = data.get('noise')
                if rssi is not None or snr is not None:
                    try:
                        app_module.sensor_queue.put_nowait({
                            'type': 'scope',
                            'rssi': rssi if rssi is not None else 0,
                            'snr': snr if snr is not None else 0,
                            'noise': noise if noise is not None else 0,
                        })
                    except queue.Full:
                        pass
                # Log if enabled
                if app_module.logging_enabled:
                    try:
@@ -110,14 +79,6 @@ def stream_sensor_output(process: subprocess.Popen[bytes]) -> None:
            sensor_active_device = None
@sensor_bp.route('/sensor/status')
 def sensor_status() -> Response:
    """Check if sensor decoder is currently running."""
    with app_module.sensor_lock:
        running = app_module.sensor_process is not None and app_module.sensor_process.poll() is None
    return jsonify({'running': running})
@sensor_bp.route('/start_sensor', methods=['POST'])
 def start_sensor() -> Response:
    global sensor_active_device
@@ -196,10 +157,6 @@ def start_sensor() -> Response:
        full_cmd = ' '.join(cmd)
        logger.info(f"Running: {full_cmd}")
        # Add signal level metadata so the frontend scope can display RSSI/SNR
        # Disable stats reporting to suppress "row count limit 50 reached" warnings
        cmd.extend(['-M', 'level', '-M', 'stats:0'])
        try:
            app_module.sensor_process = subprocess.Popen(
                cmd,
@@ -214,16 +171,10 @@ def start_sensor() -> Response:
            thread.start()
            # Monitor stderr
            # Filter noisy rtl_433 diagnostics that aren't useful to display
            _stderr_noise = (
                'bitbuffer_add_bit',
                'row count limit',
            )
            def monitor_stderr():
                for line in app_module.sensor_process.stderr:
                    err = line.decode('utf-8', errors='replace').strip()
-                    if err and not any(noise in err for noise in _stderr_noise):
+                    if err:
                        logger.debug(f"[rtl_433] {err}")
                        app_module.sensor_queue.put({'type': 'info', 'text': f'[rtl_433] {err}'})
@@ -274,29 +225,23 @@ def stop_sensor() -> Response:
@sensor_bp.route('/stream_sensor')
 def stream_sensor() -> Response:
-    def _on_msg(msg: dict[str, Any]) -> None:
+    def generate() -> Generator[str, None, None]:
-        process_event('sensor', msg, msg.get('type'))
+        last_keepalive = time.time()
        keepalive_interval = 30.0
-    response = Response(
+        while True:
-        sse_stream_fanout(
+            try:
-            source_queue=app_module.sensor_queue,
+                msg = app_module.sensor_queue.get(timeout=1)
-            channel_key='sensor',
+                last_keepalive = time.time()
-            timeout=1.0,
+                yield format_sse(msg)
-            keepalive_interval=30.0,
+            except queue.Empty:
-            on_message=_on_msg,
+                now = time.time()
-        ),
+                if now - last_keepalive >= keepalive_interval:
-        mimetype='text/event-stream',
+                    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
@sensor_bp.route('/sensor/rssi_history')
 def get_rssi_history() -> Response:
    """Return RSSI history for all tracked sensor devices."""
    result = {}
    for key, entries in sensor_rssi_history.items():
        result[key] = [{'t': round(t, 1), 'rssi': rssi} for t, rssi in entries]
    return jsonify({'status': 'success', 'devices': result})
@@ -1,300 +0,0 @@
 """Space Weather routes - proxies NOAA SWPC, NASA SDO, and HamQSL data."""
 from __future__ import annotations
 import json
 import time
 import urllib.error
 import urllib.request
 import xml.etree.ElementTree as ET
 from typing import Any
 from flask import Blueprint, Response, jsonify
 from utils.logging import get_logger
 logger = get_logger('intercept.space_weather')
 space_weather_bp = Blueprint('space_weather', __name__, url_prefix='/space-weather')
 # ---------------------------------------------------------------------------
 # TTL Cache
 # ---------------------------------------------------------------------------
 _cache: dict[str, dict[str, Any]] = {}
 # Cache TTLs in seconds
 TTL_REALTIME = 300       # 5 min for real-time data
 TTL_FORECAST = 1800      # 30 min for forecasts
 TTL_DAILY = 3600         # 1 hr for daily summaries
 TTL_IMAGE = 600          # 10 min for images
 def _cache_get(key: str) -> Any | None:
    entry = _cache.get(key)
    if entry and time.time() < entry['expires']:
        return entry['data']
    return None
 def _cache_set(key: str, data: Any, ttl: int) -> None:
    _cache[key] = {'data': data, 'expires': time.time() + ttl}
 # ---------------------------------------------------------------------------
 # HTTP helpers
 # ---------------------------------------------------------------------------
 _TIMEOUT = 15  # seconds
 SWPC_BASE = 'https://services.swpc.noaa.gov'
 SWPC_JSON = f'{SWPC_BASE}/products'
 def _fetch_json(url: str, timeout: int = _TIMEOUT) -> Any | None:
    try:
        req = urllib.request.Request(url, headers={'User-Agent': 'INTERCEPT/1.0'})
        with urllib.request.urlopen(req, timeout=timeout) as resp:
            return json.loads(resp.read().decode())
    except Exception as exc:
        logger.warning('Failed to fetch %s: %s', url, exc)
        return None
 def _fetch_text(url: str, timeout: int = _TIMEOUT) -> str | None:
    try:
        req = urllib.request.Request(url, headers={'User-Agent': 'INTERCEPT/1.0'})
        with urllib.request.urlopen(req, timeout=timeout) as resp:
            return resp.read().decode()
    except Exception as exc:
        logger.warning('Failed to fetch %s: %s', url, exc)
        return None
 def _fetch_bytes(url: str, timeout: int = _TIMEOUT) -> bytes | None:
    try:
        req = urllib.request.Request(url, headers={'User-Agent': 'INTERCEPT/1.0'})
        with urllib.request.urlopen(req, timeout=timeout) as resp:
            return resp.read()
    except Exception as exc:
        logger.warning('Failed to fetch %s: %s', url, exc)
        return None
 # ---------------------------------------------------------------------------
 # Data source fetchers
 # ---------------------------------------------------------------------------
 def _fetch_cached_json(cache_key: str, url: str, ttl: int) -> Any | None:
    cached = _cache_get(cache_key)
    if cached is not None:
        return cached
    data = _fetch_json(url)
    if data is not None:
        _cache_set(cache_key, data, ttl)
    return data
 def _fetch_kp_index() -> Any | None:
    return _fetch_cached_json('kp_index', f'{SWPC_JSON}/noaa-planetary-k-index.json', TTL_REALTIME)
 def _fetch_kp_forecast() -> Any | None:
    return _fetch_cached_json('kp_forecast', f'{SWPC_JSON}/noaa-planetary-k-index-forecast.json', TTL_FORECAST)
 def _fetch_scales() -> Any | None:
    return _fetch_cached_json('scales', f'{SWPC_JSON}/noaa-scales.json', TTL_REALTIME)
 def _fetch_flux() -> Any | None:
    return _fetch_cached_json('flux', f'{SWPC_JSON}/10cm-flux-30-day.json', TTL_DAILY)
 def _fetch_alerts() -> Any | None:
    return _fetch_cached_json('alerts', f'{SWPC_JSON}/alerts.json', TTL_REALTIME)
 def _fetch_solar_wind_plasma() -> Any | None:
    return _fetch_cached_json('sw_plasma', f'{SWPC_JSON}/solar-wind/plasma-6-hour.json', TTL_REALTIME)
 def _fetch_solar_wind_mag() -> Any | None:
    return _fetch_cached_json('sw_mag', f'{SWPC_JSON}/solar-wind/mag-6-hour.json', TTL_REALTIME)
 def _fetch_xrays() -> Any | None:
    return _fetch_cached_json('xrays', f'{SWPC_BASE}/json/goes/primary/xrays-1-day.json', TTL_REALTIME)
 def _fetch_xray_flares() -> Any | None:
    return _fetch_cached_json('xray_flares', f'{SWPC_BASE}/json/goes/primary/xray-flares-7-day.json', TTL_REALTIME)
 def _fetch_flare_probability() -> Any | None:
    return _fetch_cached_json('flare_prob', f'{SWPC_BASE}/json/solar_probabilities.json', TTL_FORECAST)
 def _fetch_solar_regions() -> Any | None:
    return _fetch_cached_json('solar_regions', f'{SWPC_BASE}/json/solar_regions.json', TTL_DAILY)
 def _fetch_sunspot_report() -> Any | None:
    return _fetch_cached_json('sunspot_report', f'{SWPC_BASE}/json/sunspot_report.json', TTL_DAILY)
 def _parse_hamqsl_xml(xml_text: str) -> dict[str, Any] | None:
    """Parse HamQSL solar XML into a dict of band conditions."""
    try:
        root = ET.fromstring(xml_text)
        solar = root.find('.//solardata')
        if solar is None:
            return None
        result: dict[str, Any] = {}
        # Scalar fields
        for tag in ('sfi', 'aindex', 'kindex', 'kindexnt', 'xray', 'sunspots',
                     'heliumline', 'protonflux', 'electonflux', 'aurora',
                     'normalization', 'latdegree', 'solarwind', 'magneticfield',
                     'calculatedconditions', 'calculatedvhfconditions',
                     'geomagfield', 'signalnoise', 'fof2', 'muffactor', 'muf'):
            el = solar.find(tag)
            if el is not None and el.text:
                result[tag] = el.text.strip()
        # Band conditions
        bands: list[dict[str, str]] = []
        for band_el in solar.findall('.//calculatedconditions/band'):
            bands.append({
                'name': band_el.get('name', ''),
                'time': band_el.get('time', ''),
                'condition': band_el.text.strip() if band_el.text else ''
            })
        result['bands'] = bands
        # VHF conditions
        vhf: list[dict[str, str]] = []
        for phen_el in solar.findall('.//calculatedvhfconditions/phenomenon'):
            vhf.append({
                'name': phen_el.get('name', ''),
                'location': phen_el.get('location', ''),
                'condition': phen_el.text.strip() if phen_el.text else ''
            })
        result['vhf'] = vhf
        return result
    except ET.ParseError as exc:
        logger.warning('Failed to parse HamQSL XML: %s', exc)
        return None
 def _fetch_band_conditions() -> dict[str, Any] | None:
    cached = _cache_get('band_conditions')
    if cached is not None:
        return cached
    xml_text = _fetch_text('https://www.hamqsl.com/solarxml.php')
    if xml_text is None:
        return None
    data = _parse_hamqsl_xml(xml_text)
    if data is not None:
        _cache_set('band_conditions', data, TTL_FORECAST)
    return data
 # ---------------------------------------------------------------------------
 # Image proxy whitelist
 # ---------------------------------------------------------------------------
 IMAGE_WHITELIST: dict[str, dict[str, str]] = {
    # D-RAP absorption maps
    'drap_global': {
        'url': f'{SWPC_BASE}/images/animations/d-rap/global/latest.png',
        'content_type': 'image/png',
    },
    'drap_5': {
        'url': f'{SWPC_BASE}/images/d-rap/global_f05.png',
        'content_type': 'image/png',
    },
    'drap_10': {
        'url': f'{SWPC_BASE}/images/d-rap/global_f10.png',
        'content_type': 'image/png',
    },
    'drap_15': {
        'url': f'{SWPC_BASE}/images/d-rap/global_f15.png',
        'content_type': 'image/png',
    },
    'drap_20': {
        'url': f'{SWPC_BASE}/images/d-rap/global_f20.png',
        'content_type': 'image/png',
    },
    'drap_25': {
        'url': f'{SWPC_BASE}/images/d-rap/global_f25.png',
        'content_type': 'image/png',
    },
    'drap_30': {
        'url': f'{SWPC_BASE}/images/d-rap/global_f30.png',
        'content_type': 'image/png',
    },
    # Aurora forecast
    'aurora_north': {
        'url': f'{SWPC_BASE}/images/animations/ovation/north/latest.jpg',
        'content_type': 'image/jpeg',
    },
    # SDO solar imagery
    'sdo_193': {
        'url': 'https://sdo.gsfc.nasa.gov/assets/img/latest/latest_512_0193.jpg',
        'content_type': 'image/jpeg',
    },
    'sdo_304': {
        'url': 'https://sdo.gsfc.nasa.gov/assets/img/latest/latest_512_0304.jpg',
        'content_type': 'image/jpeg',
    },
    'sdo_magnetogram': {
        'url': 'https://sdo.gsfc.nasa.gov/assets/img/latest/latest_512_HMIBC.jpg',
        'content_type': 'image/jpeg',
    },
 }
 # ---------------------------------------------------------------------------
 # Routes
 # ---------------------------------------------------------------------------
@space_weather_bp.route('/data')
 def get_data():
    """Return aggregated space weather data from all sources."""
    data = {
        'kp_index': _fetch_kp_index(),
        'kp_forecast': _fetch_kp_forecast(),
        'scales': _fetch_scales(),
        'flux': _fetch_flux(),
        'alerts': _fetch_alerts(),
        'solar_wind_plasma': _fetch_solar_wind_plasma(),
        'solar_wind_mag': _fetch_solar_wind_mag(),
        'xrays': _fetch_xrays(),
        'xray_flares': _fetch_xray_flares(),
        'flare_probability': _fetch_flare_probability(),
        'solar_regions': _fetch_solar_regions(),
        'sunspot_report': _fetch_sunspot_report(),
        'band_conditions': _fetch_band_conditions(),
        'timestamp': time.time(),
    }
    return jsonify(data)
@space_weather_bp.route('/image/<key>')
 def get_image(key: str):
    """Proxy and cache whitelisted space weather images."""
    entry = IMAGE_WHITELIST.get(key)
    if not entry:
        return jsonify({'error': 'Unknown image key'}), 404
    cache_key = f'img_{key}'
    cached = _cache_get(cache_key)
    if cached is not None:
        return Response(cached, content_type=entry['content_type'],
                        headers={'Cache-Control': 'public, max-age=300'})
    img_data = _fetch_bytes(entry['url'])
    if img_data is None:
        return jsonify({'error': 'Failed to fetch image'}), 502
    _cache_set(cache_key, img_data, TTL_IMAGE)
    return Response(img_data, content_type=entry['content_type'],
                    headers={'Cache-Control': 'public, max-age=300'})
@@ -15,24 +15,19 @@ from flask import Blueprint, jsonify, request, Response, send_file
 import app as app_module
 from utils.logging import get_logger
-from utils.sse import sse_stream_fanout
+from utils.sse import format_sse
 from utils.event_pipeline import process_event
 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')
 # ISS SSTV runs on a fixed downlink; allow a small entry tolerance so users
 # can type nearby values and still land on the canonical center frequency.
 ISS_SSTV_MODULATION = 'fm'
 ISS_SSTV_FREQUENCIES = (ISS_SSTV_FREQ,)
 ISS_SSTV_FREQ_TOLERANCE_MHZ = 0.05
 # Queue for SSE progress streaming
 _sstv_queue: queue.Queue = queue.Queue(maxsize=100)
@@ -40,26 +35,18 @@ _sstv_queue: queue.Queue = queue.Queue(maxsize=100)
 sstv_active_device: int | None = None
-def _progress_callback(data: dict) -> None:
+def _progress_callback(progress: DecodeProgress) -> None:
-    """Callback to queue progress/scope updates for SSE stream."""
+    """Callback to queue progress updates for SSE stream."""
    try:
-        _sstv_queue.put_nowait(data)
+        _sstv_queue.put_nowait(progress.to_dict())
    except queue.Full:
        try:
            _sstv_queue.get_nowait()
-            _sstv_queue.put_nowait(data)
+            _sstv_queue.put_nowait(progress.to_dict())
        except queue.Empty:
            pass
 def _normalize_iss_frequency(frequency_mhz: float) -> float | None:
    """Snap near-match user input to a supported ISS SSTV center frequency."""
    for supported in ISS_SSTV_FREQUENCIES:
        if abs(frequency_mhz - supported) <= ISS_SSTV_FREQ_TOLERANCE_MHZ:
            return supported
    return None
@sstv_bp.route('/status')
 def get_status():
    """
@@ -76,7 +63,6 @@ def get_status():
        'decoder': decoder.decoder_available,
        'running': decoder.is_running,
        'iss_frequency': ISS_SSTV_FREQ,
        'modulation': ISS_SSTV_MODULATION,
        'image_count': len(decoder.get_images()),
        'doppler_enabled': decoder.doppler_enabled,
    }
@@ -97,7 +83,6 @@ def start_decoder():
    JSON body (optional):
        {
            "frequency": 145.800,  // Frequency in MHz (default: ISS 145.800)
            "modulation": "fm",    // ISS mode is FM-only
            "device": 0,           // RTL-SDR device index
            "latitude": 40.7128,   // Observer latitude for Doppler correction
            "longitude": -74.0060  // Observer longitude for Doppler correction
@@ -122,7 +107,6 @@ def start_decoder():
        return jsonify({
            'status': 'already_running',
            'frequency': ISS_SSTV_FREQ,
            'modulation': ISS_SSTV_MODULATION,
            'doppler_enabled': decoder.doppler_enabled
        })
@@ -136,29 +120,18 @@ def start_decoder():
    # Get parameters
    data = request.get_json(silent=True) or {}
    frequency = data.get('frequency', ISS_SSTV_FREQ)
    modulation = str(data.get('modulation', ISS_SSTV_MODULATION)).strip().lower()
    device_index = data.get('device', 0)
    latitude = data.get('latitude')
    longitude = data.get('longitude')
    # Validate modulation (ISS mode is FM-only)
    if modulation != ISS_SSTV_MODULATION:
        return jsonify({
            'status': 'error',
            'message': f'Modulation must be {ISS_SSTV_MODULATION} for ISS SSTV mode'
        }), 400
    # Validate frequency
    try:
        frequency = float(frequency)
-        normalized_frequency = _normalize_iss_frequency(frequency)
+        if not (100 <= frequency <= 500):  # VHF range
        if normalized_frequency is None:
            supported = ', '.join(f'{freq:.3f}' for freq in ISS_SSTV_FREQUENCIES)
            return jsonify({
                'status': 'error',
-                'message': f'Supported ISS SSTV frequency: {supported} MHz FM'
+                'message': 'Frequency must be between 100-500 MHz'
            }), 400
        frequency = normalized_frequency
    except (TypeError, ValueError):
        return jsonify({
            'status': 'error',
@@ -206,8 +179,7 @@ def start_decoder():
        frequency=frequency,
        device_index=device_index,
        latitude=latitude,
-        longitude=longitude,
+        longitude=longitude
        modulation=ISS_SSTV_MODULATION,
    )
    if success:
@@ -216,7 +188,6 @@ def start_decoder():
        result = {
            'status': 'started',
            'frequency': frequency,
            'modulation': ISS_SSTV_MODULATION,
            'device': device_index,
            'doppler_enabled': decoder.doppler_enabled
        }
@@ -422,19 +393,22 @@ def stream_progress():
    Returns:
        SSE stream (text/event-stream)
    """
-    def _on_msg(msg: dict[str, Any]) -> None:
+    def generate() -> Generator[str, None, None]:
-        process_event('sstv', msg, msg.get('type'))
+        last_keepalive = time.time()
        keepalive_interval = 30.0
-    response = Response(
+        while True:
-        sse_stream_fanout(
+            try:
-            source_queue=_sstv_queue,
+                progress = _sstv_queue.get(timeout=1)
-            channel_key='sstv',
+                last_keepalive = time.time()
-            timeout=1.0,
+                yield format_sse(progress)
-            keepalive_interval=30.0,
+            except queue.Empty:
-            on_message=_on_msg,
+                now = time.time()
-        ),
+                if now - last_keepalive >= keepalive_interval:
-        mimetype='text/event-stream',
+                    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'
@@ -13,11 +13,10 @@ from pathlib import Path
 from flask import Blueprint, Response, jsonify, request, send_file
 import app as app_module
 from utils.logging import get_logger
-from utils.sse import sse_stream_fanout
+from utils.sse import format_sse
 from utils.event_pipeline import process_event
 from utils.sstv import (
    DecodeProgress,
    get_general_sstv_decoder,
 )
@@ -28,9 +27,6 @@ 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)
 # Track which device is being used
 _sstv_general_active_device: int | None = None
 # Predefined SSTV frequencies
 SSTV_FREQUENCIES = [
    {'band': '80 m', 'frequency': 3.845, 'modulation': 'lsb', 'notes': 'Common US SSTV calling frequency', 'type': 'Terrestrial HF'},
@@ -44,7 +40,7 @@ SSTV_FREQUENCIES = [
    {'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.500, 'modulation': 'fm', 'notes': 'Australia/common simplex (FM sometimes used)', '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'},
 ]
@@ -52,14 +48,14 @@ SSTV_FREQUENCIES = [
 _FREQ_MODULATION_MAP = {entry['frequency']: entry['modulation'] for entry in SSTV_FREQUENCIES}
-def _progress_callback(data: dict) -> None:
+def _progress_callback(progress: DecodeProgress) -> None:
-    """Callback to queue progress/scope updates for SSE stream."""
+    """Callback to queue progress updates for SSE stream."""
    try:
-        _sstv_general_queue.put_nowait(data)
+        _sstv_general_queue.put_nowait(progress.to_dict())
    except queue.Full:
        try:
            _sstv_general_queue.get_nowait()
-            _sstv_general_queue.put_nowait(data)
+            _sstv_general_queue.put_nowait(progress.to_dict())
        except queue.Empty:
            pass
@@ -154,17 +150,6 @@ def start_decoder():
            'message': 'Modulation must be fm, usb, or lsb',
        }), 400
    # Claim SDR device
    global _sstv_general_active_device
    device_int = int(device_index)
    error = app_module.claim_sdr_device(device_int, 'sstv_general')
    if error:
        return jsonify({
            'status': 'error',
            'error_type': 'DEVICE_BUSY',
            'message': error,
        }), 409
    # Set callback and start
    decoder.set_callback(_progress_callback)
    success = decoder.start(
@@ -174,7 +159,6 @@ def start_decoder():
    )
    if success:
        _sstv_general_active_device = device_int
        return jsonify({
            'status': 'started',
            'frequency': frequency,
@@ -182,7 +166,6 @@ def start_decoder():
            'device': device_index,
        })
    else:
        app_module.release_sdr_device(device_int)
        return jsonify({
            'status': 'error',
            'message': 'Failed to start decoder',
@@ -192,14 +175,8 @@ def start_decoder():
@sstv_general_bp.route('/stop', methods=['POST'])
 def stop_decoder():
    """Stop general SSTV decoder."""
    global _sstv_general_active_device
    decoder = get_general_sstv_decoder()
    decoder.stop()
    if _sstv_general_active_device is not None:
        app_module.release_sdr_device(_sstv_general_active_device)
        _sstv_general_active_device = None
    return jsonify({'status': 'stopped'})
@@ -289,19 +266,22 @@ def delete_all_images():
@sstv_general_bp.route('/stream')
 def stream_progress():
    """SSE stream of SSTV decode progress."""
-    def _on_msg(msg: dict[str, Any]) -> None:
+    def generate() -> Generator[str, None, None]:
-        process_event('sstv_general', msg, msg.get('type'))
+        last_keepalive = time.time()
        keepalive_interval = 30.0
-    response = Response(
+        while True:
-        sse_stream_fanout(
+            try:
-            source_queue=_sstv_general_queue,
+                progress = _sstv_general_queue.get(timeout=1)
-            channel_key='sstv_general',
+                last_keepalive = time.time()
-            timeout=1.0,
+                yield format_sse(progress)
-            keepalive_interval=30.0,
+            except queue.Empty:
-            on_message=_on_msg,
+                now = time.time()
-        ),
+                if now - last_keepalive >= keepalive_interval:
-        mimetype='text/event-stream',
+                    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'
@@ -1,424 +0,0 @@
 """SubGHz transceiver routes.
 Provides endpoints for HackRF-based SubGHz signal capture, protocol decoding,
 signal replay/transmit, and wideband spectrum analysis.
 """
 from __future__ import annotations
 import queue
 from flask import Blueprint, jsonify, request, Response, send_file
 from utils.logging import get_logger
 from utils.sse import sse_stream
 from utils.subghz import get_subghz_manager
 from utils.constants import (
    SUBGHZ_FREQ_MIN_MHZ,
    SUBGHZ_FREQ_MAX_MHZ,
    SUBGHZ_LNA_GAIN_MAX,
    SUBGHZ_VGA_GAIN_MAX,
    SUBGHZ_TX_VGA_GAIN_MAX,
    SUBGHZ_TX_MAX_DURATION,
    SUBGHZ_SAMPLE_RATES,
    SUBGHZ_PRESETS,
 )
 logger = get_logger('intercept.subghz')
 subghz_bp = Blueprint('subghz', __name__, url_prefix='/subghz')
 # SSE queue for streaming events to frontend
 _subghz_queue: queue.Queue = queue.Queue(maxsize=200)
 def _event_callback(event: dict) -> None:
    """Forward SubGhzManager events to the SSE queue."""
    try:
        _subghz_queue.put_nowait(event)
    except queue.Full:
        try:
            _subghz_queue.get_nowait()
            _subghz_queue.put_nowait(event)
        except queue.Empty:
            pass
 def _validate_frequency_hz(data: dict, key: str = 'frequency_hz') -> tuple[int | None, str | None]:
    """Validate frequency in Hz from request data. Returns (freq_hz, error_msg)."""
    raw = data.get(key)
    if raw is None:
        return None, f'{key} is required'
    try:
        freq_hz = int(raw)
        freq_mhz = freq_hz / 1_000_000
        if not (SUBGHZ_FREQ_MIN_MHZ <= freq_mhz <= SUBGHZ_FREQ_MAX_MHZ):
            return None, f'Frequency must be between {SUBGHZ_FREQ_MIN_MHZ}-{SUBGHZ_FREQ_MAX_MHZ} MHz'
        return freq_hz, None
    except (ValueError, TypeError):
        return None, f'Invalid {key}'
 def _validate_serial(data: dict) -> str | None:
    """Extract and validate optional HackRF device serial."""
    serial = data.get('device_serial', '')
    if not serial or not isinstance(serial, str):
        return None
    # HackRF serials are hex strings
    serial = serial.strip()
    if serial and all(c in '0123456789abcdefABCDEF' for c in serial):
        return serial
    return None
 def _validate_int(data: dict, key: str, default: int, min_val: int, max_val: int) -> int:
    """Validate integer parameter with bounds clamping."""
    try:
        val = int(data.get(key, default))
        return max(min_val, min(max_val, val))
    except (ValueError, TypeError):
        return default
 def _validate_decode_profile(data: dict, default: str = 'weather') -> str:
    profile = data.get('decode_profile', default)
    if not isinstance(profile, str):
        return default
    profile = profile.strip().lower()
    if profile in {'weather', 'all'}:
        return profile
    return default
 def _validate_optional_float(data: dict, key: str) -> tuple[float | None, str | None]:
    raw = data.get(key)
    if raw is None or raw == '':
        return None, None
    try:
        return float(raw), None
    except (ValueError, TypeError):
        return None, f'Invalid {key}'
 def _validate_bool(data: dict, key: str, default: bool = False) -> bool:
    raw = data.get(key, default)
    if isinstance(raw, bool):
        return raw
    if isinstance(raw, (int, float)):
        return bool(raw)
    if isinstance(raw, str):
        return raw.strip().lower() in {'1', 'true', 'yes', 'on', 'enabled'}
    return default
 # ------------------------------------------------------------------
 # STATUS
 # ------------------------------------------------------------------
@subghz_bp.route('/status')
 def get_status():
    manager = get_subghz_manager()
    return jsonify(manager.get_status())
@subghz_bp.route('/presets')
 def get_presets():
    return jsonify({'presets': SUBGHZ_PRESETS, 'sample_rates': SUBGHZ_SAMPLE_RATES})
 # ------------------------------------------------------------------
 # RECEIVE
 # ------------------------------------------------------------------
@subghz_bp.route('/receive/start', methods=['POST'])
 def start_receive():
    data = request.get_json(silent=True) or {}
    freq_hz, err = _validate_frequency_hz(data)
    if err:
        return jsonify({'status': 'error', 'message': err}), 400
    sample_rate = _validate_int(data, 'sample_rate', 2000000, 2000000, 20000000)
    lna_gain = _validate_int(data, 'lna_gain', 32, 0, SUBGHZ_LNA_GAIN_MAX)
    vga_gain = _validate_int(data, 'vga_gain', 20, 0, SUBGHZ_VGA_GAIN_MAX)
    trigger_enabled = _validate_bool(data, 'trigger_enabled', False)
    trigger_pre_ms = _validate_int(data, 'trigger_pre_ms', 350, 50, 5000)
    trigger_post_ms = _validate_int(data, 'trigger_post_ms', 700, 100, 10000)
    device_serial = _validate_serial(data)
    manager = get_subghz_manager()
    manager.set_callback(_event_callback)
    result = manager.start_receive(
        frequency_hz=freq_hz,
        sample_rate=sample_rate,
        lna_gain=lna_gain,
        vga_gain=vga_gain,
        trigger_enabled=trigger_enabled,
        trigger_pre_ms=trigger_pre_ms,
        trigger_post_ms=trigger_post_ms,
        device_serial=device_serial,
    )
    status_code = 200 if result.get('status') != 'error' else 409
    return jsonify(result), status_code
@subghz_bp.route('/receive/stop', methods=['POST'])
 def stop_receive():
    manager = get_subghz_manager()
    result = manager.stop_receive()
    return jsonify(result)
 # ------------------------------------------------------------------
 # DECODE
 # ------------------------------------------------------------------
@subghz_bp.route('/decode/start', methods=['POST'])
 def start_decode():
    data = request.get_json(silent=True) or {}
    freq_hz, err = _validate_frequency_hz(data)
    if err:
        return jsonify({'status': 'error', 'message': err}), 400
    sample_rate = _validate_int(data, 'sample_rate', 2000000, 2000000, 20000000)
    lna_gain = _validate_int(data, 'lna_gain', 32, 0, SUBGHZ_LNA_GAIN_MAX)
    vga_gain = _validate_int(data, 'vga_gain', 20, 0, SUBGHZ_VGA_GAIN_MAX)
    decode_profile = _validate_decode_profile(data)
    device_serial = _validate_serial(data)
    manager = get_subghz_manager()
    manager.set_callback(_event_callback)
    result = manager.start_decode(
        frequency_hz=freq_hz,
        sample_rate=sample_rate,
        lna_gain=lna_gain,
        vga_gain=vga_gain,
        decode_profile=decode_profile,
        device_serial=device_serial,
    )
    status_code = 200 if result.get('status') != 'error' else 409
    return jsonify(result), status_code
@subghz_bp.route('/decode/stop', methods=['POST'])
 def stop_decode():
    manager = get_subghz_manager()
    result = manager.stop_decode()
    return jsonify(result)
 # ------------------------------------------------------------------
 # TRANSMIT
 # ------------------------------------------------------------------
@subghz_bp.route('/transmit', methods=['POST'])
 def start_transmit():
    data = request.get_json(silent=True) or {}
    capture_id = data.get('capture_id')
    if not capture_id or not isinstance(capture_id, str):
        return jsonify({'status': 'error', 'message': 'capture_id is required'}), 400
    # Sanitize capture_id
    if not capture_id.isalnum():
        return jsonify({'status': 'error', 'message': 'Invalid capture_id'}), 400
    tx_gain = _validate_int(data, 'tx_gain', 20, 0, SUBGHZ_TX_VGA_GAIN_MAX)
    max_duration = _validate_int(data, 'max_duration', 10, 1, SUBGHZ_TX_MAX_DURATION)
    start_seconds, start_err = _validate_optional_float(data, 'start_seconds')
    if start_err:
        return jsonify({'status': 'error', 'message': start_err}), 400
    duration_seconds, duration_err = _validate_optional_float(data, 'duration_seconds')
    if duration_err:
        return jsonify({'status': 'error', 'message': duration_err}), 400
    device_serial = _validate_serial(data)
    manager = get_subghz_manager()
    manager.set_callback(_event_callback)
    result = manager.transmit(
        capture_id=capture_id,
        tx_gain=tx_gain,
        max_duration=max_duration,
        start_seconds=start_seconds,
        duration_seconds=duration_seconds,
        device_serial=device_serial,
    )
    status_code = 200 if result.get('status') != 'error' else 400
    return jsonify(result), status_code
@subghz_bp.route('/transmit/stop', methods=['POST'])
 def stop_transmit():
    manager = get_subghz_manager()
    result = manager.stop_transmit()
    return jsonify(result)
 # ------------------------------------------------------------------
 # SWEEP
 # ------------------------------------------------------------------
@subghz_bp.route('/sweep/start', methods=['POST'])
 def start_sweep():
    data = request.get_json(silent=True) or {}
    try:
        freq_start = float(data.get('freq_start_mhz', 300))
        freq_end = float(data.get('freq_end_mhz', 928))
        if freq_start >= freq_end:
            return jsonify({'status': 'error', 'message': 'freq_start must be less than freq_end'}), 400
        if freq_start < SUBGHZ_FREQ_MIN_MHZ or freq_end > SUBGHZ_FREQ_MAX_MHZ:
            return jsonify({'status': 'error', 'message': f'Frequency range: {SUBGHZ_FREQ_MIN_MHZ}-{SUBGHZ_FREQ_MAX_MHZ} MHz'}), 400
    except (ValueError, TypeError):
        return jsonify({'status': 'error', 'message': 'Invalid frequency range'}), 400
    bin_width = _validate_int(data, 'bin_width', 100000, 10000, 5000000)
    device_serial = _validate_serial(data)
    manager = get_subghz_manager()
    manager.set_callback(_event_callback)
    result = manager.start_sweep(
        freq_start_mhz=freq_start,
        freq_end_mhz=freq_end,
        bin_width=bin_width,
        device_serial=device_serial,
    )
    status_code = 200 if result.get('status') != 'error' else 409
    return jsonify(result), status_code
@subghz_bp.route('/sweep/stop', methods=['POST'])
 def stop_sweep():
    manager = get_subghz_manager()
    result = manager.stop_sweep()
    return jsonify(result)
 # ------------------------------------------------------------------
 # CAPTURES LIBRARY
 # ------------------------------------------------------------------
@subghz_bp.route('/captures')
 def list_captures():
    manager = get_subghz_manager()
    captures = manager.list_captures()
    return jsonify({
        'status': 'ok',
        'captures': [c.to_dict() for c in captures],
        'count': len(captures),
    })
@subghz_bp.route('/captures/<capture_id>')
 def get_capture(capture_id: str):
    if not capture_id.isalnum():
        return jsonify({'status': 'error', 'message': 'Invalid capture_id'}), 400
    manager = get_subghz_manager()
    capture = manager.get_capture(capture_id)
    if not capture:
        return jsonify({'status': 'error', 'message': 'Capture not found'}), 404
    return jsonify({'status': 'ok', 'capture': capture.to_dict()})
@subghz_bp.route('/captures/<capture_id>/download')
 def download_capture(capture_id: str):
    if not capture_id.isalnum():
        return jsonify({'status': 'error', 'message': 'Invalid capture_id'}), 400
    manager = get_subghz_manager()
    path = manager.get_capture_path(capture_id)
    if not path:
        return jsonify({'status': 'error', 'message': 'Capture not found'}), 404
    return send_file(
        path,
        mimetype='application/octet-stream',
        as_attachment=True,
        download_name=path.name,
    )
@subghz_bp.route('/captures/<capture_id>/trim', methods=['POST'])
 def trim_capture(capture_id: str):
    if not capture_id.isalnum():
        return jsonify({'status': 'error', 'message': 'Invalid capture_id'}), 400
    data = request.get_json(silent=True) or {}
    start_seconds, start_err = _validate_optional_float(data, 'start_seconds')
    if start_err:
        return jsonify({'status': 'error', 'message': start_err}), 400
    duration_seconds, duration_err = _validate_optional_float(data, 'duration_seconds')
    if duration_err:
        return jsonify({'status': 'error', 'message': duration_err}), 400
    label = data.get('label', '')
    if label is None:
        label = ''
    if not isinstance(label, str) or len(label) > 100:
        return jsonify({'status': 'error', 'message': 'Label must be a string (max 100 chars)'}), 400
    manager = get_subghz_manager()
    result = manager.trim_capture(
        capture_id=capture_id,
        start_seconds=start_seconds,
        duration_seconds=duration_seconds,
        label=label,
    )
    if result.get('status') == 'ok':
        return jsonify(result), 200
    message = str(result.get('message') or 'Trim failed')
    status_code = 404 if 'not found' in message.lower() else 400
    return jsonify(result), status_code
@subghz_bp.route('/captures/<capture_id>', methods=['DELETE'])
 def delete_capture(capture_id: str):
    if not capture_id.isalnum():
        return jsonify({'status': 'error', 'message': 'Invalid capture_id'}), 400
    manager = get_subghz_manager()
    if manager.delete_capture(capture_id):
        return jsonify({'status': 'deleted', 'id': capture_id})
    return jsonify({'status': 'error', 'message': 'Capture not found'}), 404
@subghz_bp.route('/captures/<capture_id>', methods=['PATCH'])
 def update_capture(capture_id: str):
    if not capture_id.isalnum():
        return jsonify({'status': 'error', 'message': 'Invalid capture_id'}), 400
    data = request.get_json(silent=True) or {}
    label = data.get('label', '')
    if not isinstance(label, str) or len(label) > 100:
        return jsonify({'status': 'error', 'message': 'Label must be a string (max 100 chars)'}), 400
    manager = get_subghz_manager()
    if manager.update_capture_label(capture_id, label):
        return jsonify({'status': 'updated', 'id': capture_id, 'label': label})
    return jsonify({'status': 'error', 'message': 'Capture not found'}), 404
 # ------------------------------------------------------------------
 # SSE STREAM
 # ------------------------------------------------------------------
@subghz_bp.route('/stream')
 def stream():
    response = Response(sse_stream(_subghz_queue), mimetype='text/event-stream')
    response.headers['Cache-Control'] = 'no-cache'
    response.headers['X-Accel-Buffering'] = 'no'
    response.headers['Connection'] = 'keep-alive'
    return response
@@ -60,8 +60,6 @@ from utils.tscm.device_identity import (
    ingest_ble_dict,
    ingest_wifi_dict,
 )
 from utils.event_pipeline import process_event
 from utils.sse import sse_stream_fanout
 # Import unified Bluetooth scanner helper for TSCM integration
 try:
@@ -552,12 +550,6 @@ def _start_sweep_internal(
    }
@tscm_bp.route('/status')
 def tscm_status():
    """Check if any TSCM operation is currently running."""
    return jsonify({'running': _sweep_running})
@tscm_bp.route('/sweep/start', methods=['POST'])
 def start_sweep():
    """Start a TSCM sweep."""
@@ -630,17 +622,20 @@ def sweep_status():
@tscm_bp.route('/sweep/stream')
 def sweep_stream():
    """SSE stream for real-time sweep updates."""
-    def _on_msg(msg: dict[str, Any]) -> None:
+    def generate():
-        process_event('tscm', msg, msg.get('type'))
+        while True:
            try:
                if tscm_queue:
                    msg = tscm_queue.get(timeout=1)
                    yield f"data: {json.dumps(msg)}\n\n"
                else:
                    time.sleep(1)
                    yield f"data: {json.dumps({'type': 'keepalive'})}\n\n"
            except queue.Empty:
                yield f"data: {json.dumps({'type': 'keepalive'})}\n\n"
    return Response(
-        sse_stream_fanout(
+        generate(),
            source_queue=tscm_queue,
            channel_key='tscm',
            timeout=1.0,
            keepalive_interval=30.0,
            on_message=_on_msg,
        ),
        mimetype='text/event-stream',
        headers={
            'Cache-Control': 'no-cache',
@@ -1077,32 +1072,6 @@ def _scan_wifi_networks(interface: str) -> list[dict]:
        return []
 def _scan_wifi_clients(interface: str) -> list[dict]:
    """
    Get WiFi client observations from the unified WiFi scanner.
    Clients are only available when monitor-mode scanning is active.
    """
    try:
        from utils.wifi import get_wifi_scanner
        scanner = get_wifi_scanner()
        if interface:
            try:
                if not scanner._is_monitor_mode_interface(interface):
                    return []
            except Exception:
                return []
        return [client.to_dict() for client in scanner.clients]
    except ImportError as e:
        logger.error(f"Failed to import wifi scanner: {e}")
        return []
    except Exception as e:
        logger.exception(f"WiFi client scan failed: {e}")
        return []
 def _scan_bluetooth_devices(interface: str, duration: int = 10) -> list[dict]:
    """
    Scan for Bluetooth devices with manufacturer data detection.
@@ -1637,7 +1606,6 @@ def _run_sweep(
        threats_found = 0
        severity_counts = {'critical': 0, 'high': 0, 'medium': 0, 'low': 0}
        all_wifi = {}  # Use dict for deduplication by BSSID
        all_wifi_clients = {}  # Use dict for deduplication by client MAC
        all_bt = {}    # Use dict for deduplication by MAC
        all_rf = []
@@ -1734,7 +1702,6 @@ def _run_sweep(
                                    'channel': network.get('channel', ''),
                                    'signal': network.get('power', ''),
                                    'security': network.get('privacy', ''),
                                    'vendor': network.get('vendor'),
                                    'is_threat': is_threat,
                                    'is_new': not classification.get('in_baseline', False),
                                    'classification': profile.risk_level.value,
@@ -1748,77 +1715,6 @@ def _run_sweep(
                                })
                        except Exception as e:
                            logger.error(f"WiFi device processing error for {network.get('bssid', '?')}: {e}")
                    # WiFi clients (monitor mode only)
                    try:
                        wifi_clients = _scan_wifi_clients(wifi_interface)
                        for client in wifi_clients:
                            mac = (client.get('mac') or '').upper()
                            if not mac or mac in all_wifi_clients:
                                continue
                            all_wifi_clients[mac] = client
                            rssi_val = client.get('rssi_current')
                            if rssi_val is None:
                                rssi_val = client.get('rssi_median') or client.get('rssi_ema')
                            client_device = {
                                'mac': mac,
                                'vendor': client.get('vendor'),
                                'name': client.get('vendor') or 'WiFi Client',
                                'rssi': rssi_val,
                                'associated_bssid': client.get('associated_bssid'),
                                'probed_ssids': client.get('probed_ssids', []),
                                'probe_count': client.get('probe_count', len(client.get('probed_ssids', []))),
                                'is_client': True,
                            }
                            try:
                                timeline_manager.add_observation(
                                    identifier=mac,
                                    protocol='wifi',
                                    rssi=rssi_val,
                                    name=client_device.get('vendor') or f'WiFi Client {mac[-5:]}',
                                    attributes={'client': True, 'associated_bssid': client_device.get('associated_bssid')}
                                )
                            except Exception as e:
                                logger.debug(f"WiFi client timeline observation error: {e}")
                            _maybe_store_timeline(
                                identifier=mac,
                                protocol='wifi',
                                rssi=rssi_val,
                                attributes={'client': True, 'associated_bssid': client_device.get('associated_bssid')}
                            )
                            profile = correlation.analyze_wifi_device(client_device)
                            client_device['classification'] = profile.risk_level.value
                            client_device['score'] = profile.total_score
                            client_device['score_modifier'] = profile.score_modifier
                            client_device['known_device'] = profile.known_device
                            client_device['known_device_name'] = profile.known_device_name
                            client_device['indicators'] = [
                                {'type': i.type.value, 'desc': i.description}
                                for i in profile.indicators
                            ]
                            client_device['recommended_action'] = profile.recommended_action
                            # Feed to identity engine for MAC-randomization resistant clustering
                            try:
                                wifi_obs = {
                                    'timestamp': datetime.now().isoformat(),
                                    'src_mac': mac,
                                    'bssid': client_device.get('associated_bssid'),
                                    'rssi': rssi_val,
                                    'frame_type': 'probe_request',
                                    'probed_ssids': client_device.get('probed_ssids', []),
                                }
                                ingest_wifi_dict(wifi_obs)
                            except Exception as e:
                                logger.debug(f"Identity engine WiFi client ingest error: {e}")
                            _emit_event('wifi_client', client_device)
                    except Exception as e:
                        logger.debug(f"WiFi client scan error: {e}")
                except Exception as e:
                    last_wifi_scan = current_time
                    logger.error(f"WiFi scan error: {e}")
@@ -1897,9 +1793,6 @@ def _run_sweep(
                                    'name': device.get('name', 'Unknown'),
                                    'device_type': device.get('type', ''),
                                    'rssi': device.get('rssi', ''),
                                    'manufacturer': device.get('manufacturer'),
                                    'tracker': device.get('tracker'),
                                    'tracker_type': device.get('tracker_type'),
                                    'is_threat': is_threat,
                                    'is_new': not classification.get('in_baseline', False),
                                    'classification': profile.risk_level.value,
@@ -2028,7 +1921,6 @@ def _run_sweep(
                comparator = BaselineComparator(baseline)
                baseline_comparison = comparator.compare_all(
                    wifi_devices=list(all_wifi.values()),
                    wifi_clients=list(all_wifi_clients.values()),
                    bt_devices=list(all_bt.values()),
                    rf_signals=all_rf
                )
@@ -2044,7 +1936,6 @@ def _run_sweep(
            if verbose_results:
                wifi_payload = list(all_wifi.values())
                wifi_client_payload = list(all_wifi_clients.values())
                bt_payload = list(all_bt.values())
                rf_payload = list(all_rf)
            else:
@@ -2060,28 +1951,6 @@ def _run_sweep(
                    }
                    for d in all_wifi.values()
                ]
                wifi_client_payload = []
                for client in all_wifi_clients.values():
                    mac = client.get('mac') or client.get('address')
                    if isinstance(mac, str):
                        mac = mac.upper()
                    probed_ssids = client.get('probed_ssids') or []
                    rssi = client.get('rssi')
                    if rssi is None:
                        rssi = client.get('rssi_current')
                    if rssi is None:
                        rssi = client.get('rssi_median')
                    if rssi is None:
                        rssi = client.get('rssi_ema')
                    wifi_client_payload.append({
                        'mac': mac,
                        'vendor': client.get('vendor'),
                        'rssi': rssi,
                        'associated_bssid': client.get('associated_bssid'),
                        'is_associated': client.get('is_associated'),
                        'probed_ssids': probed_ssids,
                        'probe_count': client.get('probe_count', len(probed_ssids)),
                    })
                bt_payload = [
                    {
                        'mac': d.get('mac') or d.get('address'),
@@ -2106,11 +1975,9 @@ def _run_sweep(
                status='completed',
                results={
                    'wifi_devices': wifi_payload,
                    'wifi_clients': wifi_client_payload,
                    'bt_devices': bt_payload,
                    'rf_signals': rf_payload,
                    'wifi_count': len(all_wifi),
                    'wifi_client_count': len(all_wifi_clients),
                    'bt_count': len(all_bt),
                    'rf_count': len(all_rf),
                    'severity_counts': severity_counts,
@@ -2138,7 +2005,6 @@ def _run_sweep(
                    'total_new': baseline_comparison['total_new'],
                    'total_missing': baseline_comparison['total_missing'],
                    'wifi': baseline_comparison.get('wifi'),
                    'wifi_clients': baseline_comparison.get('wifi_clients'),
                    'bluetooth': baseline_comparison.get('bluetooth'),
                    'rf': baseline_comparison.get('rf'),
                })
@@ -2156,7 +2022,6 @@ def _run_sweep(
                'sweep_id': _current_sweep_id,
                'threats_found': threats_found,
                'wifi_count': len(all_wifi),
                'wifi_client_count': len(all_wifi_clients),
                'bt_count': len(all_bt),
                'rf_count': len(all_rf),
                'severity_counts': severity_counts,
@@ -2304,7 +2169,6 @@ def compare_against_baseline():
    Expects JSON body with:
    - wifi_devices: list of WiFi devices (optional)
    - wifi_clients: list of WiFi clients (optional)
    - bt_devices: list of Bluetooth devices (optional)
    - rf_signals: list of RF signals (optional)
@@ -2313,14 +2177,12 @@ def compare_against_baseline():
    data = request.get_json() or {}
    wifi_devices = data.get('wifi_devices')
    wifi_clients = data.get('wifi_clients')
    bt_devices = data.get('bt_devices')
    rf_signals = data.get('rf_signals')
    # Use the convenience function that gets active baseline
    comparison = get_comparison_for_active_baseline(
        wifi_devices=wifi_devices,
        wifi_clients=wifi_clients,
        bt_devices=bt_devices,
        rf_signals=rf_signals
    )
@@ -2414,9 +2276,6 @@ def feed_wifi():
    """Feed WiFi device data for baseline recording."""
    data = request.get_json()
    if data:
        if data.get('is_client'):
            _baseline_recorder.add_wifi_client(data)
        else:
        _baseline_recorder.add_wifi_device(data)
    return jsonify({'status': 'success'})
@@ -3069,14 +2928,12 @@ def get_baseline_diff(baseline_id: int, sweep_id: int):
            results = json.loads(results)
        current_wifi = results.get('wifi_devices', [])
        current_wifi_clients = results.get('wifi_clients', [])
        current_bt = results.get('bt_devices', [])
        current_rf = results.get('rf_signals', [])
        diff = calculate_baseline_diff(
            baseline=baseline,
            current_wifi=current_wifi,
            current_wifi_clients=current_wifi_clients,
            current_bt=current_bt,
            current_rf=current_rf,
            sweep_id=sweep_id
@@ -1,383 +0,0 @@
 """VDL2 aircraft datalink routes."""
 from __future__ import annotations
 import io
 import json
 import os
 import platform
 import pty
 import queue
 import shutil
 import subprocess
 import threading
 import time
 from datetime import datetime
 from typing import Generator
 from flask import Blueprint, jsonify, request, Response
 import app as app_module
 from utils.logging import sensor_logger as logger
 from utils.validation import validate_device_index, validate_gain, validate_ppm
 from utils.sdr import SDRFactory, SDRType
 from utils.sse import sse_stream_fanout
 from utils.event_pipeline import process_event
 from utils.constants import (
    PROCESS_TERMINATE_TIMEOUT,
    SSE_KEEPALIVE_INTERVAL,
    SSE_QUEUE_TIMEOUT,
    PROCESS_START_WAIT,
 )
 from utils.process import register_process, unregister_process
 vdl2_bp = Blueprint('vdl2', __name__, url_prefix='/vdl2')
 # Default VDL2 frequencies (MHz) - common worldwide
 DEFAULT_VDL2_FREQUENCIES = [
    '136975000',  # Primary worldwide
    '136725000',  # Europe
    '136775000',  # Europe
    '136800000',  # Multi-region
    '136875000',  # Multi-region
 ]
 # Message counter for statistics
 vdl2_message_count = 0
 vdl2_last_message_time = None
 # Track which device is being used
 vdl2_active_device: int | None = None
 def find_dumpvdl2():
    """Find dumpvdl2 binary."""
    return shutil.which('dumpvdl2')
 def stream_vdl2_output(process: subprocess.Popen, is_text_mode: bool = False) -> None:
    """Stream dumpvdl2 JSON output to queue."""
    global vdl2_message_count, vdl2_last_message_time
    try:
        app_module.vdl2_queue.put({'type': 'status', 'status': 'started'})
        # Use appropriate sentinel based on mode (text mode for pty on macOS)
        sentinel = '' if is_text_mode else b''
        for line in iter(process.stdout.readline, sentinel):
            if is_text_mode:
                line = line.strip()
            else:
                line = line.decode('utf-8', errors='replace').strip()
            if not line:
                continue
            try:
                data = json.loads(line)
                # Add our metadata
                data['type'] = 'vdl2'
                data['timestamp'] = datetime.utcnow().isoformat() + 'Z'
                # Update stats
                vdl2_message_count += 1
                vdl2_last_message_time = time.time()
                app_module.vdl2_queue.put(data)
                # Feed flight correlator
                try:
                    from utils.flight_correlator import get_flight_correlator
                    get_flight_correlator().add_vdl2_message(data)
                except Exception:
                    pass
                # Log if enabled
                if app_module.logging_enabled:
                    try:
                        with open(app_module.log_file_path, 'a') as f:
                            ts = datetime.now().strftime('%Y-%m-%d %H:%M:%S')
                            f.write(f"{ts} | VDL2 | {json.dumps(data)}\n")
                    except Exception:
                        pass
            except json.JSONDecodeError:
                # Not JSON - could be status message
                if line:
                    logger.debug(f"dumpvdl2 non-JSON: {line[:100]}")
    except Exception as e:
        logger.error(f"VDL2 stream error: {e}")
        app_module.vdl2_queue.put({'type': 'error', 'message': str(e)})
    finally:
        global vdl2_active_device
        # Ensure process is terminated
        try:
            process.terminate()
            process.wait(timeout=2)
        except Exception:
            try:
                process.kill()
            except Exception:
                pass
        unregister_process(process)
        app_module.vdl2_queue.put({'type': 'status', 'status': 'stopped'})
        with app_module.vdl2_lock:
            app_module.vdl2_process = None
        # Release SDR device
        if vdl2_active_device is not None:
            app_module.release_sdr_device(vdl2_active_device)
            vdl2_active_device = None
@vdl2_bp.route('/tools')
 def check_vdl2_tools() -> Response:
    """Check for VDL2 decoding tools."""
    has_dumpvdl2 = find_dumpvdl2() is not None
    return jsonify({
        'dumpvdl2': has_dumpvdl2,
        'ready': has_dumpvdl2
    })
@vdl2_bp.route('/status')
 def vdl2_status() -> Response:
    """Get VDL2 decoder status."""
    running = False
    if app_module.vdl2_process:
        running = app_module.vdl2_process.poll() is None
    return jsonify({
        'running': running,
        'message_count': vdl2_message_count,
        'last_message_time': vdl2_last_message_time,
        'queue_size': app_module.vdl2_queue.qsize()
    })
@vdl2_bp.route('/start', methods=['POST'])
 def start_vdl2() -> Response:
    """Start VDL2 decoder."""
    global vdl2_message_count, vdl2_last_message_time, vdl2_active_device
    with app_module.vdl2_lock:
        if app_module.vdl2_process and app_module.vdl2_process.poll() is None:
            return jsonify({
                'status': 'error',
                'message': 'VDL2 decoder already running'
            }), 409
    # Check for dumpvdl2
    dumpvdl2_path = find_dumpvdl2()
    if not dumpvdl2_path:
        return jsonify({
            'status': 'error',
            'message': 'dumpvdl2 not found. Install from: https://github.com/szpajder/dumpvdl2'
        }), 400
    data = request.json or {}
    # Validate inputs
    try:
        device = validate_device_index(data.get('device', '0'))
        gain = validate_gain(data.get('gain', '40'))
        ppm = validate_ppm(data.get('ppm', '0'))
    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, 'vdl2')
    if error:
        return jsonify({
            'status': 'error',
            'error_type': 'DEVICE_BUSY',
            'message': error
        }), 409
    vdl2_active_device = device_int
    # Get frequencies - use provided or defaults
    # dumpvdl2 expects frequencies in Hz (integers)
    frequencies = data.get('frequencies', DEFAULT_VDL2_FREQUENCIES)
    if isinstance(frequencies, str):
        frequencies = [f.strip() for f in frequencies.split(',')]
    # Clear queue
    while not app_module.vdl2_queue.empty():
        try:
            app_module.vdl2_queue.get_nowait()
        except queue.Empty:
            break
    # Reset stats
    vdl2_message_count = 0
    vdl2_last_message_time = None
    # Resolve SDR type for device selection
    sdr_type_str = data.get('sdr_type', 'rtlsdr')
    try:
        sdr_type = SDRType(sdr_type_str)
    except ValueError:
        sdr_type = SDRType.RTL_SDR
    is_soapy = sdr_type not in (SDRType.RTL_SDR,)
    # Build dumpvdl2 command
    # dumpvdl2 --output decoded:json --rtlsdr <device> --gain <gain> --correction <ppm> <freq1> <freq2> ...
    cmd = [dumpvdl2_path]
    cmd.extend(['--output', 'decoded:json:file:path=-'])
    if is_soapy:
        # SoapySDR device
        sdr_device = SDRFactory.create_default_device(sdr_type, index=device_int)
        builder = SDRFactory.get_builder(sdr_type)
        device_str = builder._build_device_string(sdr_device)
        cmd.extend(['--soapysdr', device_str])
    else:
        cmd.extend(['--rtlsdr', str(device)])
    # Add gain
    if gain and str(gain) != '0':
        cmd.extend(['--gain', str(gain)])
    # Add PPM correction if specified
    if ppm and str(ppm) != '0':
        cmd.extend(['--correction', str(ppm)])
    # Add frequencies (dumpvdl2 takes them as positional args in Hz)
    cmd.extend(frequencies)
    logger.info(f"Starting VDL2 decoder: {' '.join(cmd)}")
    try:
        is_text_mode = False
        # On macOS, use pty to avoid stdout buffering issues
        if platform.system() == 'Darwin':
            master_fd, slave_fd = pty.openpty()
            process = subprocess.Popen(
                cmd,
                stdout=slave_fd,
                stderr=subprocess.PIPE,
                start_new_session=True
            )
            os.close(slave_fd)
            # Wrap master_fd as a text file for line-buffered reading
            process.stdout = io.open(master_fd, 'r', buffering=1)
            is_text_mode = True
        else:
            process = subprocess.Popen(
                cmd,
                stdout=subprocess.PIPE,
                stderr=subprocess.PIPE,
                start_new_session=True
            )
        # Wait briefly to check if process started
        time.sleep(PROCESS_START_WAIT)
        if process.poll() is not None:
            # Process died - release device
            if vdl2_active_device is not None:
                app_module.release_sdr_device(vdl2_active_device)
                vdl2_active_device = None
            stderr = ''
            if process.stderr:
                stderr = process.stderr.read().decode('utf-8', errors='replace')
            error_msg = 'dumpvdl2 failed to start'
            if stderr:
                error_msg += f': {stderr[:200]}'
            logger.error(error_msg)
            return jsonify({'status': 'error', 'message': error_msg}), 500
        app_module.vdl2_process = process
        register_process(process)
        # Start output streaming thread
        thread = threading.Thread(
            target=stream_vdl2_output,
            args=(process, is_text_mode),
            daemon=True
        )
        thread.start()
        return jsonify({
            'status': 'started',
            'frequencies': frequencies,
            'device': device,
            'gain': gain
        })
    except Exception as e:
        # Release device on failure
        if vdl2_active_device is not None:
            app_module.release_sdr_device(vdl2_active_device)
            vdl2_active_device = None
        logger.error(f"Failed to start VDL2 decoder: {e}")
        return jsonify({'status': 'error', 'message': str(e)}), 500
@vdl2_bp.route('/stop', methods=['POST'])
 def stop_vdl2() -> Response:
    """Stop VDL2 decoder."""
    global vdl2_active_device
    with app_module.vdl2_lock:
        if not app_module.vdl2_process:
            return jsonify({
                'status': 'error',
                'message': 'VDL2 decoder not running'
            }), 400
        try:
            app_module.vdl2_process.terminate()
            app_module.vdl2_process.wait(timeout=PROCESS_TERMINATE_TIMEOUT)
        except subprocess.TimeoutExpired:
            app_module.vdl2_process.kill()
        except Exception as e:
            logger.error(f"Error stopping VDL2: {e}")
        app_module.vdl2_process = None
    # Release device from registry
    if vdl2_active_device is not None:
        app_module.release_sdr_device(vdl2_active_device)
        vdl2_active_device = None
    return jsonify({'status': 'stopped'})
@vdl2_bp.route('/stream')
 def stream_vdl2() -> Response:
    """SSE stream for VDL2 messages."""
    def _on_msg(msg: dict[str, Any]) -> None:
        process_event('vdl2', msg, msg.get('type'))
    response = Response(
        sse_stream_fanout(
            source_queue=app_module.vdl2_queue,
            channel_key='vdl2',
            timeout=SSE_QUEUE_TIMEOUT,
            keepalive_interval=SSE_KEEPALIVE_INTERVAL,
            on_message=_on_msg,
        ),
        mimetype='text/event-stream',
    )
    response.headers['Cache-Control'] = 'no-cache'
    response.headers['X-Accel-Buffering'] = 'no'
    return response
@vdl2_bp.route('/frequencies')
 def get_frequencies() -> Response:
    """Get default VDL2 frequencies."""
    return jsonify({
        'default': DEFAULT_VDL2_FREQUENCIES,
        'regions': {
            'north_america': ['136975000', '136100000', '136650000', '136700000', '136800000'],
            'europe': ['136975000', '136675000', '136725000', '136775000', '136825000'],
            'asia_pacific': ['136975000', '136900000'],
        }
    })
@@ -1,386 +0,0 @@
 """WebSocket-based waterfall streaming with I/Q capture and server-side FFT."""
 import json
 import queue
 import socket
 import subprocess
 import threading
 import time
 from flask import Flask
 try:
    from flask_sock import Sock
    WEBSOCKET_AVAILABLE = True
 except ImportError:
    WEBSOCKET_AVAILABLE = False
    Sock = None
 from utils.logging import get_logger
 from utils.process import safe_terminate, register_process, unregister_process
 from utils.waterfall_fft import (
    build_binary_frame,
    compute_power_spectrum,
    cu8_to_complex,
    quantize_to_uint8,
 )
 from utils.sdr import SDRFactory, SDRType
 from utils.sdr.base import SDRCapabilities, SDRDevice
 logger = get_logger('intercept.waterfall_ws')
 # Maximum bandwidth per SDR type (Hz)
 MAX_BANDWIDTH = {
    SDRType.RTL_SDR: 2400000,
    SDRType.HACKRF: 20000000,
    SDRType.LIME_SDR: 20000000,
    SDRType.AIRSPY: 10000000,
    SDRType.SDRPLAY: 2000000,
 }
 def _resolve_sdr_type(sdr_type_str: str) -> SDRType:
    """Convert client sdr_type string to SDRType enum."""
    mapping = {
        'rtlsdr': SDRType.RTL_SDR,
        'rtl_sdr': SDRType.RTL_SDR,
        'hackrf': SDRType.HACKRF,
        'limesdr': SDRType.LIME_SDR,
        'lime_sdr': SDRType.LIME_SDR,
        'airspy': SDRType.AIRSPY,
        'sdrplay': SDRType.SDRPLAY,
    }
    return mapping.get(sdr_type_str.lower(), SDRType.RTL_SDR)
 def _build_dummy_device(device_index: int, sdr_type: SDRType) -> SDRDevice:
    """Build a minimal SDRDevice for command building."""
    builder = SDRFactory.get_builder(sdr_type)
    caps = builder.get_capabilities()
    return SDRDevice(
        sdr_type=sdr_type,
        index=device_index,
        name=f'{sdr_type.value}-{device_index}',
        serial='N/A',
        driver=sdr_type.value,
        capabilities=caps,
    )
 def init_waterfall_websocket(app: Flask):
    """Initialize WebSocket waterfall streaming."""
    if not WEBSOCKET_AVAILABLE:
        logger.warning("flask-sock not installed, WebSocket waterfall disabled")
        return
    sock = Sock(app)
    @sock.route('/ws/waterfall')
    def waterfall_stream(ws):
        """WebSocket endpoint for real-time waterfall streaming."""
        logger.info("WebSocket waterfall client connected")
        # Import app module for device claiming
        import app as app_module
        iq_process = None
        reader_thread = None
        stop_event = threading.Event()
        claimed_device = None
        # Queue for outgoing messages — only the main loop touches ws.send()
        send_queue = queue.Queue(maxsize=120)
        try:
            while True:
                # Drain send queue first (non-blocking)
                while True:
                    try:
                        outgoing = send_queue.get_nowait()
                    except queue.Empty:
                        break
                    try:
                        ws.send(outgoing)
                    except Exception:
                        stop_event.set()
                        break
                try:
                    msg = ws.receive(timeout=0.1)
                except Exception as e:
                    err = str(e).lower()
                    if "closed" in err:
                        break
                    if "timed out" not in err:
                        logger.error(f"WebSocket receive error: {e}")
                    continue
                if msg is None:
                    # simple-websocket returns None on timeout AND on
                    # close; check ws.connected to tell them apart.
                    if not ws.connected:
                        break
                    if stop_event.is_set():
                        break
                    continue
                try:
                    data = json.loads(msg)
                except (json.JSONDecodeError, TypeError):
                    continue
                cmd = data.get('cmd')
                if cmd == 'start':
                    # Stop any existing capture
                    was_restarting = iq_process is not None
                    stop_event.set()
                    if reader_thread and reader_thread.is_alive():
                        reader_thread.join(timeout=2)
                    if iq_process:
                        safe_terminate(iq_process)
                        unregister_process(iq_process)
                        iq_process = None
                    if claimed_device is not None:
                        app_module.release_sdr_device(claimed_device)
                        claimed_device = None
                    stop_event.clear()
                    # Flush stale frames from previous capture
                    while not send_queue.empty():
                        try:
                            send_queue.get_nowait()
                        except queue.Empty:
                            break
                    # Allow USB device to be released by the kernel
                    if was_restarting:
                        time.sleep(0.5)
                    # Parse config
                    center_freq = float(data.get('center_freq', 100.0))
                    span_mhz = float(data.get('span_mhz', 2.0))
                    gain = data.get('gain')
                    if gain is not None:
                        gain = float(gain)
                    device_index = int(data.get('device', 0))
                    sdr_type_str = data.get('sdr_type', 'rtlsdr')
                    fft_size = int(data.get('fft_size', 1024))
                    fps = int(data.get('fps', 25))
                    avg_count = int(data.get('avg_count', 4))
                    ppm = data.get('ppm')
                    if ppm is not None:
                        ppm = int(ppm)
                    bias_t = bool(data.get('bias_t', False))
                    # Clamp FFT size to valid powers of 2
                    fft_size = max(256, min(8192, fft_size))
                    # Resolve SDR type and bandwidth
                    sdr_type = _resolve_sdr_type(sdr_type_str)
                    max_bw = MAX_BANDWIDTH.get(sdr_type, 2400000)
                    span_hz = int(span_mhz * 1e6)
                    sample_rate = min(span_hz, max_bw)
                    # Compute effective frequency range
                    effective_span_mhz = sample_rate / 1e6
                    start_freq = center_freq - effective_span_mhz / 2
                    end_freq = center_freq + effective_span_mhz / 2
                    # Claim the device
                    claim_err = app_module.claim_sdr_device(device_index, 'waterfall')
                    if claim_err:
                        ws.send(json.dumps({
                            'status': 'error',
                            'message': claim_err,
                            'error_type': 'DEVICE_BUSY',
                        }))
                        continue
                    claimed_device = device_index
                    # Build I/Q capture command
                    try:
                        builder = SDRFactory.get_builder(sdr_type)
                        device = _build_dummy_device(device_index, sdr_type)
                        iq_cmd = builder.build_iq_capture_command(
                            device=device,
                            frequency_mhz=center_freq,
                            sample_rate=sample_rate,
                            gain=gain,
                            ppm=ppm,
                            bias_t=bias_t,
                        )
                    except NotImplementedError as e:
                        app_module.release_sdr_device(device_index)
                        claimed_device = None
                        ws.send(json.dumps({
                            'status': 'error',
                            'message': str(e),
                        }))
                        continue
                    # Spawn I/Q capture process (retry to handle USB release lag)
                    max_attempts = 3 if was_restarting else 1
                    try:
                        for attempt in range(max_attempts):
                            logger.info(
                                f"Starting I/Q capture: {center_freq} MHz, "
                                f"span={effective_span_mhz:.1f} MHz, "
                                f"sr={sample_rate}, fft={fft_size}"
                            )
                            iq_process = subprocess.Popen(
                                iq_cmd,
                                stdout=subprocess.PIPE,
                                stderr=subprocess.DEVNULL,
                                bufsize=0,
                            )
                            register_process(iq_process)
                            # Brief check that process started
                            time.sleep(0.3)
                            if iq_process.poll() is not None:
                                unregister_process(iq_process)
                                iq_process = None
                                if attempt < max_attempts - 1:
                                    logger.info(
                                        f"I/Q process exited immediately, "
                                        f"retrying ({attempt + 1}/{max_attempts})..."
                                    )
                                    time.sleep(0.5)
                                    continue
                                raise RuntimeError(
                                    "I/Q capture process exited immediately"
                                )
                            break  # Process started successfully
                    except Exception as e:
                        logger.error(f"Failed to start I/Q capture: {e}")
                        if iq_process:
                            safe_terminate(iq_process)
                            unregister_process(iq_process)
                            iq_process = None
                        app_module.release_sdr_device(device_index)
                        claimed_device = None
                        ws.send(json.dumps({
                            'status': 'error',
                            'message': f'Failed to start I/Q capture: {e}',
                        }))
                        continue
                    # Send started confirmation
                    ws.send(json.dumps({
                        'status': 'started',
                        'start_freq': start_freq,
                        'end_freq': end_freq,
                        'fft_size': fft_size,
                        'sample_rate': sample_rate,
                    }))
                    # Start reader thread — puts frames on queue, never calls ws.send()
                    def fft_reader(
                        proc, _send_q, stop_evt,
                        _fft_size, _avg_count, _fps,
                        _start_freq, _end_freq,
                    ):
                        """Read I/Q from subprocess, compute FFT, enqueue binary frames."""
                        bytes_per_frame = _fft_size * _avg_count * 2
                        frame_interval = 1.0 / _fps
                        try:
                            while not stop_evt.is_set():
                                if proc.poll() is not None:
                                    break
                                frame_start = time.monotonic()
                                # Read raw I/Q bytes
                                raw = b''
                                remaining = bytes_per_frame
                                while remaining > 0 and not stop_evt.is_set():
                                    chunk = proc.stdout.read(min(remaining, 65536))
                                    if not chunk:
                                        break
                                    raw += chunk
                                    remaining -= len(chunk)
                                if len(raw) < _fft_size * 2:
                                    break
                                # Process FFT pipeline
                                samples = cu8_to_complex(raw)
                                power_db = compute_power_spectrum(
                                    samples,
                                    fft_size=_fft_size,
                                    avg_count=_avg_count,
                                )
                                quantized = quantize_to_uint8(power_db)
                                frame = build_binary_frame(
                                    _start_freq, _end_freq, quantized,
                                )
                                try:
                                    _send_q.put_nowait(frame)
                                except queue.Full:
                                    # Drop frame if main loop can't keep up
                                    pass
                                # Pace to target FPS
                                elapsed = time.monotonic() - frame_start
                                sleep_time = frame_interval - elapsed
                                if sleep_time > 0:
                                    stop_evt.wait(sleep_time)
                        except Exception as e:
                            logger.debug(f"FFT reader stopped: {e}")
                    reader_thread = threading.Thread(
                        target=fft_reader,
                        args=(
                            iq_process, send_queue, stop_event,
                            fft_size, avg_count, fps,
                            start_freq, end_freq,
                        ),
                        daemon=True,
                    )
                    reader_thread.start()
                elif cmd == 'stop':
                    stop_event.set()
                    if reader_thread and reader_thread.is_alive():
                        reader_thread.join(timeout=2)
                        reader_thread = None
                    if iq_process:
                        safe_terminate(iq_process)
                        unregister_process(iq_process)
                        iq_process = None
                    if claimed_device is not None:
                        app_module.release_sdr_device(claimed_device)
                        claimed_device = None
                    stop_event.clear()
                    ws.send(json.dumps({'status': 'stopped'}))
        except Exception as e:
            logger.info(f"WebSocket waterfall closed: {e}")
        finally:
            # Cleanup
            stop_event.set()
            if reader_thread and reader_thread.is_alive():
                reader_thread.join(timeout=2)
            if iq_process:
                safe_terminate(iq_process)
                unregister_process(iq_process)
            if claimed_device is not None:
                app_module.release_sdr_device(claimed_device)
            # Complete WebSocket close handshake, then shut down the
            # raw socket so Werkzeug cannot write its HTTP 200 response
            # on top of the WebSocket stream (which browsers see as
            # "Invalid frame header").
            try:
                ws.close()
            except Exception:
                pass
            try:
                ws.sock.shutdown(socket.SHUT_RDWR)
            except Exception:
                pass
            try:
                ws.sock.close()
            except Exception:
                pass
            logger.info("WebSocket waterfall client disconnected")
@@ -1,633 +0,0 @@
 """Weather Satellite decoder routes.
 Provides endpoints for capturing and decoding weather satellite images
 from NOAA (APT) and Meteor (LRPT) satellites using SatDump.
 """
 from __future__ import annotations
 import queue
 from flask import Blueprint, jsonify, request, Response, send_file
 from utils.logging import get_logger
 from utils.sse import sse_stream
 from utils.validation import validate_device_index, validate_gain, validate_latitude, validate_longitude, validate_elevation
 from utils.weather_sat import (
    get_weather_sat_decoder,
    is_weather_sat_available,
    CaptureProgress,
    WEATHER_SATELLITES,
 )
 logger = get_logger('intercept.weather_sat')
 weather_sat_bp = Blueprint('weather_sat', __name__, url_prefix='/weather-sat')
 # Queue for SSE progress streaming
 _weather_sat_queue: queue.Queue = queue.Queue(maxsize=100)
 def _progress_callback(progress: CaptureProgress) -> None:
    """Callback to queue progress updates for SSE stream."""
    try:
        _weather_sat_queue.put_nowait(progress.to_dict())
    except queue.Full:
        try:
            _weather_sat_queue.get_nowait()
            _weather_sat_queue.put_nowait(progress.to_dict())
        except queue.Empty:
            pass
@weather_sat_bp.route('/status')
 def get_status():
    """Get weather satellite decoder status.
    Returns:
        JSON with decoder availability and current status.
    """
    decoder = get_weather_sat_decoder()
    return jsonify(decoder.get_status())
@weather_sat_bp.route('/satellites')
 def list_satellites():
    """Get list of supported weather satellites with frequencies.
    Returns:
        JSON with satellite definitions.
    """
    satellites = []
    for key, info in WEATHER_SATELLITES.items():
        satellites.append({
            'key': key,
            'name': info['name'],
            'frequency': info['frequency'],
            'mode': info['mode'],
            'description': info['description'],
            'active': info['active'],
        })
    return jsonify({
        'status': 'ok',
        'satellites': satellites,
    })
@weather_sat_bp.route('/start', methods=['POST'])
 def start_capture():
    """Start weather satellite capture and decode.
    JSON body:
        {
            "satellite": "NOAA-18",    // Required: satellite key
            "device": 0,               // RTL-SDR device index (default: 0)
            "gain": 40.0,              // SDR gain in dB (default: 40)
            "bias_t": false            // Enable bias-T for LNA (default: false)
        }
    Returns:
        JSON with start status.
    """
    if not is_weather_sat_available():
        return jsonify({
            'status': 'error',
            'message': 'SatDump not installed. Build from source: https://github.com/SatDump/SatDump'
        }), 400
    decoder = get_weather_sat_decoder()
    if decoder.is_running:
        return jsonify({
            'status': 'already_running',
            'satellite': decoder.current_satellite,
            'frequency': decoder.current_frequency,
        })
    data = request.get_json(silent=True) or {}
    # Validate satellite
    satellite = data.get('satellite')
    if not satellite or satellite not in WEATHER_SATELLITES:
        return jsonify({
            'status': 'error',
            'message': f'Invalid satellite. Must be one of: {", ".join(WEATHER_SATELLITES.keys())}'
        }), 400
    # Validate device index and gain
    try:
        device_index = validate_device_index(data.get('device', 0))
        gain = validate_gain(data.get('gain', 40.0))
    except ValueError as e:
        logger.warning('Invalid parameter in start_capture: %s', e)
        return jsonify({
            'status': 'error',
            'message': 'Invalid parameter value'
        }), 400
    bias_t = bool(data.get('bias_t', False))
    # Claim SDR device
    try:
        import app as app_module
        error = app_module.claim_sdr_device(device_index, 'weather_sat')
        if error:
            return jsonify({
                'status': 'error',
                'error_type': 'DEVICE_BUSY',
                'message': error,
            }), 409
    except ImportError:
        pass
    # Clear queue
    while not _weather_sat_queue.empty():
        try:
            _weather_sat_queue.get_nowait()
        except queue.Empty:
            break
    # Set callback and on-complete handler for SDR release
    decoder.set_callback(_progress_callback)
    def _release_device():
        try:
            import app as app_module
            app_module.release_sdr_device(device_index)
        except ImportError:
            pass
    decoder.set_on_complete(_release_device)
    success = decoder.start(
        satellite=satellite,
        device_index=device_index,
        gain=gain,
        bias_t=bias_t,
    )
    if success:
        sat_info = WEATHER_SATELLITES[satellite]
        return jsonify({
            'status': 'started',
            'satellite': satellite,
            'frequency': sat_info['frequency'],
            'mode': sat_info['mode'],
            'device': device_index,
        })
    else:
        # Release device on failure
        _release_device()
        return jsonify({
            'status': 'error',
            'message': 'Failed to start capture'
        }), 500
@weather_sat_bp.route('/test-decode', methods=['POST'])
 def test_decode():
    """Start weather satellite decode from a pre-recorded file.
    No SDR hardware is required — decodes an IQ baseband or WAV file
    using SatDump offline mode.
    JSON body:
        {
            "satellite": "NOAA-18",       // Required: satellite key
            "input_file": "/path/to/file", // Required: server-side file path
            "sample_rate": 1000000         // Sample rate in Hz (default: 1000000)
        }
    Returns:
        JSON with start status.
    """
    if not is_weather_sat_available():
        return jsonify({
            'status': 'error',
            'message': 'SatDump not installed. Build from source: https://github.com/SatDump/SatDump'
        }), 400
    decoder = get_weather_sat_decoder()
    if decoder.is_running:
        return jsonify({
            'status': 'already_running',
            'satellite': decoder.current_satellite,
            'frequency': decoder.current_frequency,
        })
    data = request.get_json(silent=True) or {}
    # Validate satellite
    satellite = data.get('satellite')
    if not satellite or satellite not in WEATHER_SATELLITES:
        return jsonify({
            'status': 'error',
            'message': f'Invalid satellite. Must be one of: {", ".join(WEATHER_SATELLITES.keys())}'
        }), 400
    # Validate input file
    input_file = data.get('input_file')
    if not input_file:
        return jsonify({
            'status': 'error',
            'message': 'input_file is required'
        }), 400
    from pathlib import Path
    input_path = Path(input_file)
    # Security: restrict to data directory (anchored to app root, not CWD)
    allowed_base = Path(__file__).resolve().parent.parent / 'data'
    try:
        resolved = input_path.resolve()
        if not resolved.is_relative_to(allowed_base):
            return jsonify({
                'status': 'error',
                'message': 'input_file must be under the data/ directory'
            }), 403
    except (OSError, ValueError):
        return jsonify({
            'status': 'error',
            'message': 'Invalid file path'
        }), 400
    if not input_path.is_file():
        logger.warning("Test-decode file not found")
        return jsonify({
            'status': 'error',
            'message': 'File not found'
        }), 404
    # Validate sample rate
    sample_rate = data.get('sample_rate', 1000000)
    try:
        sample_rate = int(sample_rate)
        if sample_rate < 1000 or sample_rate > 20000000:
            raise ValueError
    except (TypeError, ValueError):
        return jsonify({
            'status': 'error',
            'message': 'Invalid sample_rate (1000-20000000)'
        }), 400
    # Clear queue
    while not _weather_sat_queue.empty():
        try:
            _weather_sat_queue.get_nowait()
        except queue.Empty:
            break
    # Set callback — no on_complete needed (no SDR to release)
    decoder.set_callback(_progress_callback)
    decoder.set_on_complete(None)
    success = decoder.start_from_file(
        satellite=satellite,
        input_file=input_file,
        sample_rate=sample_rate,
    )
    if success:
        sat_info = WEATHER_SATELLITES[satellite]
        return jsonify({
            'status': 'started',
            'satellite': satellite,
            'frequency': sat_info['frequency'],
            'mode': sat_info['mode'],
            'source': 'file',
            'input_file': str(input_file),
        })
    else:
        return jsonify({
            'status': 'error',
            'message': 'Failed to start file decode'
        }), 500
@weather_sat_bp.route('/stop', methods=['POST'])
 def stop_capture():
    """Stop weather satellite capture.
    Returns:
        JSON confirmation.
    """
    decoder = get_weather_sat_decoder()
    device_index = decoder.device_index
    decoder.stop()
    # Release SDR device
    try:
        import app as app_module
        app_module.release_sdr_device(device_index)
    except ImportError:
        pass
    return jsonify({'status': 'stopped'})
@weather_sat_bp.route('/images')
 def list_images():
    """Get list of decoded weather satellite images.
    Query parameters:
        limit: Maximum number of images (default: all)
        satellite: Filter by satellite key (optional)
    Returns:
        JSON with list of decoded images.
    """
    decoder = get_weather_sat_decoder()
    images = decoder.get_images()
    # Filter by satellite if specified
    satellite_filter = request.args.get('satellite')
    if satellite_filter:
        images = [img for img in images if img.satellite == satellite_filter]
    # Apply limit
    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),
    })
@weather_sat_bp.route('/images/<filename>')
 def get_image(filename: str):
    """Serve a decoded weather satellite image file.
    Args:
        filename: Image filename
    Returns:
        Image file or 404.
    """
    decoder = get_weather_sat_decoder()
    # Security: only allow safe filenames
    if not filename.replace('_', '').replace('-', '').replace('.', '').isalnum():
        return jsonify({'status': 'error', 'message': 'Invalid filename'}), 400
    if not (filename.endswith('.png') or filename.endswith('.jpg') or filename.endswith('.jpeg')):
        return jsonify({'status': 'error', 'message': 'Only PNG/JPG files supported'}), 400
    image_path = decoder._output_dir / filename
    if not image_path.exists():
        return jsonify({'status': 'error', 'message': 'Image not found'}), 404
    mimetype = 'image/png' if filename.endswith('.png') else 'image/jpeg'
    return send_file(image_path, mimetype=mimetype)
@weather_sat_bp.route('/images/<filename>', methods=['DELETE'])
 def delete_image(filename: str):
    """Delete a decoded image.
    Args:
        filename: Image filename
    Returns:
        JSON confirmation.
    """
    decoder = get_weather_sat_decoder()
    if not filename.replace('_', '').replace('-', '').replace('.', '').isalnum():
        return jsonify({'status': 'error', 'message': 'Invalid filename'}), 400
    if decoder.delete_image(filename):
        return jsonify({'status': 'deleted', 'filename': filename})
    else:
        return jsonify({'status': 'error', 'message': 'Image not found'}), 404
@weather_sat_bp.route('/images', methods=['DELETE'])
 def delete_all_images():
    """Delete all decoded weather satellite images.
    Returns:
        JSON with count of deleted images.
    """
    decoder = get_weather_sat_decoder()
    count = decoder.delete_all_images()
    return jsonify({'status': 'ok', 'deleted': count})
@weather_sat_bp.route('/stream')
 def stream_progress():
    """SSE stream of capture/decode progress.
    Returns:
        SSE stream (text/event-stream)
    """
    response = Response(sse_stream(_weather_sat_queue), mimetype='text/event-stream')
    response.headers['Cache-Control'] = 'no-cache'
    response.headers['X-Accel-Buffering'] = 'no'
    response.headers['Connection'] = 'keep-alive'
    return response
@weather_sat_bp.route('/passes')
 def get_passes():
    """Get upcoming weather satellite passes for observer location.
    Query parameters:
        latitude: Observer latitude (required)
        longitude: Observer longitude (required)
        hours: Hours to predict ahead (default: 24, max: 72)
        min_elevation: Minimum elevation in degrees (default: 15)
        trajectory: Include az/el trajectory points (default: false)
        ground_track: Include lat/lon ground track points (default: false)
    Returns:
        JSON with upcoming passes for all weather satellites.
    """
    include_trajectory = request.args.get('trajectory', 'false').lower() in ('true', '1')
    include_ground_track = request.args.get('ground_track', 'false').lower() in ('true', '1')
    raw_lat = request.args.get('latitude')
    raw_lon = request.args.get('longitude')
    if raw_lat is None or raw_lon is None:
        return jsonify({
            'status': 'error',
            'message': 'latitude and longitude parameters required'
        }), 400
    try:
        lat = validate_latitude(raw_lat)
        lon = validate_longitude(raw_lon)
    except ValueError as e:
        logger.warning('Invalid coordinates in get_passes: %s', e)
        return jsonify({'status': 'error', 'message': 'Invalid coordinates'}), 400
    hours = max(1, min(request.args.get('hours', 24, type=int), 72))
    min_elevation = max(0, min(request.args.get('min_elevation', 15, type=float), 90))
    try:
        from utils.weather_sat_predict import predict_passes
        all_passes = predict_passes(
            lat=lat,
            lon=lon,
            hours=hours,
            min_elevation=min_elevation,
            include_trajectory=include_trajectory,
            include_ground_track=include_ground_track,
        )
        return jsonify({
            'status': 'ok',
            'passes': all_passes,
            'count': len(all_passes),
            'observer': {'latitude': lat, 'longitude': lon},
            'prediction_hours': hours,
            'min_elevation': min_elevation,
        })
    except ImportError:
        return jsonify({
            'status': 'error',
            'message': 'skyfield library not installed'
        }), 503
    except Exception as e:
        logger.error(f"Error predicting passes: {e}")
        return jsonify({
            'status': 'error',
            'message': 'Pass prediction failed'
        }), 500
 # ========================
 # Auto-Scheduler Endpoints
 # ========================
 def _scheduler_event_callback(event: dict) -> None:
    """Forward scheduler events to the SSE queue."""
    try:
        _weather_sat_queue.put_nowait(event)
    except queue.Full:
        try:
            _weather_sat_queue.get_nowait()
            _weather_sat_queue.put_nowait(event)
        except queue.Empty:
            pass
@weather_sat_bp.route('/schedule/enable', methods=['POST'])
 def enable_schedule():
    """Enable auto-scheduling of weather satellite captures.
    JSON body:
        {
            "latitude": 51.5,         // Required
            "longitude": -0.1,        // Required
            "min_elevation": 15,      // Minimum pass elevation (default: 15)
            "device": 0,              // RTL-SDR device index (default: 0)
            "gain": 40.0,             // SDR gain (default: 40)
            "bias_t": false           // Enable bias-T (default: false)
        }
    Returns:
        JSON with scheduler status.
    """
    from utils.weather_sat_scheduler import get_weather_sat_scheduler
    data = request.get_json(silent=True) or {}
    if data.get('latitude') is None or data.get('longitude') is None:
        return jsonify({
            'status': 'error',
            'message': 'latitude and longitude required'
        }), 400
    try:
        lat = validate_latitude(data.get('latitude'))
        lon = validate_longitude(data.get('longitude'))
        min_elev = validate_elevation(data.get('min_elevation', 15))
        device = validate_device_index(data.get('device', 0))
        gain_val = validate_gain(data.get('gain', 40.0))
    except ValueError as e:
        logger.warning('Invalid parameter in enable_schedule: %s', e)
        return jsonify({
            'status': 'error',
            'message': 'Invalid parameter value'
        }), 400
    scheduler = get_weather_sat_scheduler()
    scheduler.set_callbacks(_progress_callback, _scheduler_event_callback)
    try:
        result = scheduler.enable(
            lat=lat,
            lon=lon,
            min_elevation=min_elev,
            device=device,
            gain=gain_val,
            bias_t=bool(data.get('bias_t', False)),
        )
    except Exception as e:
        logger.exception("Failed to enable weather sat scheduler")
        return jsonify({
            'status': 'error',
            'message': 'Failed to enable scheduler'
        }), 500
    return jsonify({'status': 'ok', **result})
@weather_sat_bp.route('/schedule/disable', methods=['POST'])
 def disable_schedule():
    """Disable auto-scheduling."""
    from utils.weather_sat_scheduler import get_weather_sat_scheduler
    scheduler = get_weather_sat_scheduler()
    result = scheduler.disable()
    return jsonify(result)
@weather_sat_bp.route('/schedule/status')
 def schedule_status():
    """Get current scheduler state."""
    from utils.weather_sat_scheduler import get_weather_sat_scheduler
    scheduler = get_weather_sat_scheduler()
    return jsonify(scheduler.get_status())
@weather_sat_bp.route('/schedule/passes')
 def schedule_passes():
    """List scheduled passes."""
    from utils.weather_sat_scheduler import get_weather_sat_scheduler
    scheduler = get_weather_sat_scheduler()
    passes = scheduler.get_passes()
    return jsonify({
        'status': 'ok',
        'passes': passes,
        'count': len(passes),
    })
@weather_sat_bp.route('/schedule/skip/<pass_id>', methods=['POST'])
 def skip_pass(pass_id: str):
    """Skip a scheduled pass."""
    from utils.weather_sat_scheduler import get_weather_sat_scheduler
    if not pass_id.replace('_', '').replace('-', '').isalnum():
        return jsonify({'status': 'error', 'message': 'Invalid pass ID'}), 400
    scheduler = get_weather_sat_scheduler()
    if scheduler.skip_pass(pass_id):
        return jsonify({'status': 'skipped', 'pass_id': pass_id})
    else:
        return jsonify({'status': 'error', 'message': 'Pass not found or already processed'}), 404
@@ -20,8 +20,7 @@ from utils.dependencies import check_tool, get_tool_path
 from utils.logging import wifi_logger as logger
 from utils.process import is_valid_mac, is_valid_channel
 from utils.validation import validate_wifi_channel, validate_mac_address, validate_network_interface
-from utils.sse import format_sse, sse_stream_fanout
+from utils.sse import format_sse
 from utils.event_pipeline import process_event
 from data.oui import get_manufacturer
 from utils.constants import (
    WIFI_TERMINATE_TIMEOUT,
@@ -51,31 +50,6 @@ pmkid_process = None
 pmkid_lock = threading.Lock()
 def _parse_channel_list(raw_channels: Any) -> list[int] | None:
    """Parse a channel list from string/list input."""
    if raw_channels in (None, '', []):
        return None
    if isinstance(raw_channels, str):
        parts = [p.strip() for p in re.split(r'[\s,]+', raw_channels) if p.strip()]
    elif isinstance(raw_channels, (list, tuple, set)):
        parts = list(raw_channels)
    else:
        parts = [raw_channels]
    channels: list[int] = []
    seen = set()
    for part in parts:
        if part in (None, ''):
            continue
        ch = validate_wifi_channel(part)
        if ch not in seen:
            channels.append(ch)
            seen.add(ch)
    return channels or None
 def detect_wifi_interfaces():
    """Detect available WiFi interfaces."""
    interfaces = []
@@ -634,7 +608,6 @@ def start_wifi_scan():
        data = request.json
        channel = data.get('channel')
        channels = data.get('channels')
        band = data.get('band', 'abg')
        # Use provided interface or fall back to stored monitor interface
@@ -685,16 +658,7 @@ def start_wifi_scan():
            interface
        ]
-        channel_list = None
+        if channel:
        if channels:
            try:
                channel_list = _parse_channel_list(channels)
            except ValueError as e:
                return jsonify({'status': 'error', 'message': str(e)}), 400
        if channel_list:
            cmd.extend(['-c', ','.join(str(c) for c in channel_list)])
        elif channel:
            cmd.extend(['-c', str(channel)])
        logger.info(f"Running: {' '.join(cmd)}")
@@ -888,9 +852,6 @@ def check_handshake_status():
    file_size = os.path.getsize(capture_file)
    handshake_found = False
    handshake_valid: bool | None = None
    handshake_checked = False
    handshake_reason: str | None = None
    try:
        if target_bssid and is_valid_mac(target_bssid):
@@ -901,38 +862,20 @@ def check_handshake_status():
                    capture_output=True, text=True, timeout=10
                )
                output = result.stdout + result.stderr
-                output_lower = output.lower()
+                if '1 handshake' in output or ('handshake' in output.lower() and 'wpa' in output.lower()):
-                handshake_checked = True
+                    if '0 handshake' not in output:
-
+                        handshake_found = True
                if 'no valid wpa handshakes found' in output_lower:
                    handshake_valid = False
                    handshake_reason = 'No valid WPA handshake found'
                elif '0 handshake' in output_lower:
                    handshake_valid = False
                elif '1 handshake' in output_lower or ('handshake' in output_lower and 'wpa' in output_lower):
                    handshake_valid = True
                else:
                    handshake_valid = False
    except subprocess.TimeoutExpired:
        pass
    except Exception as e:
        logger.error(f"Error checking handshake: {e}")
    if handshake_valid:
        handshake_found = True
        normalized_bssid = target_bssid.upper() if target_bssid else None
        if normalized_bssid and normalized_bssid not in app_module.wifi_handshakes:
            app_module.wifi_handshakes.append(normalized_bssid)
    return jsonify({
        'status': 'running' if app_module.wifi_process and app_module.wifi_process.poll() is None else 'stopped',
        'file_exists': True,
        'file_size': file_size,
        'file': capture_file,
-        'handshake_found': handshake_found,
+        'handshake_found': handshake_found
        'handshake_valid': handshake_valid,
        'handshake_checked': handshake_checked,
        'handshake_reason': handshake_reason
    })
@@ -1135,19 +1078,22 @@ def get_wifi_networks():
@wifi_bp.route('/stream')
 def stream_wifi():
    """SSE stream for WiFi events."""
-    def _on_msg(msg: dict[str, Any]) -> None:
+    def generate():
-        process_event('wifi', msg, msg.get('type'))
+        last_keepalive = time.time()
        keepalive_interval = 30.0
-    response = Response(
+        while True:
-        sse_stream_fanout(
+            try:
-            source_queue=app_module.wifi_queue,
+                msg = app_module.wifi_queue.get(timeout=1)
-            channel_key='wifi',
+                last_keepalive = time.time()
-            timeout=1.0,
+                yield format_sse(msg)
-            keepalive_interval=30.0,
+            except queue.Empty:
-            on_message=_on_msg,
+                now = time.time()
-        ),
+                if now - last_keepalive >= keepalive_interval:
-        mimetype='text/event-stream',
+                    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'
@@ -1550,15 +1496,23 @@ def v2_deauth_stream():
        - deauth_error: An error occurred
        - keepalive: Periodic keepalive
    """
-    response = Response(
+    def generate():
-        sse_stream_fanout(
+        last_keepalive = time.time()
-            source_queue=app_module.deauth_detector_queue,
+        keepalive_interval = SSE_KEEPALIVE_INTERVAL
-            channel_key='wifi_deauth',
+
-            timeout=SSE_QUEUE_TIMEOUT,
+        while True:
-            keepalive_interval=SSE_KEEPALIVE_INTERVAL,
+            try:
-        ),
+                # Try to get from the dedicated deauth queue
-        mimetype='text/event-stream',
+                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'
@@ -24,8 +24,6 @@ from utils.wifi import (
    SCAN_MODE_DEEP,
 )
 from utils.sse import format_sse
 from utils.validation import validate_wifi_channel
 from utils.event_pipeline import process_event
 logger = logging.getLogger(__name__)
@@ -91,30 +89,15 @@ def start_deep_scan():
        interface: Monitor mode interface (e.g., 'wlan0mon')
        band: Band to scan ('2.4', '5', 'all')
        channel: Optional specific channel to monitor
        channels: Optional list or comma-separated channels to monitor
    """
    data = request.get_json() or {}
    interface = data.get('interface')
    band = data.get('band', 'all')
    channel = data.get('channel')
    channels = data.get('channels')
    channel_list = None
    if channels:
        if isinstance(channels, str):
            channel_list = [c.strip() for c in channels.split(',') if c.strip()]
        elif isinstance(channels, (list, tuple, set)):
            channel_list = list(channels)
        else:
            channel_list = [channels]
        try:
            channel_list = [validate_wifi_channel(c) for c in channel_list]
        except (TypeError, ValueError):
            return jsonify({'error': 'Invalid channels'}), 400
    if channel:
        try:
-            channel = validate_wifi_channel(channel)
+            channel = int(channel)
        except ValueError:
            return jsonify({'error': 'Invalid channel'}), 400
@@ -123,7 +106,6 @@ def start_deep_scan():
        interface=interface,
        band=band,
        channel=channel,
        channels=channel_list,
    )
    if success:
@@ -409,10 +391,6 @@ def event_stream():
        scanner = get_wifi_scanner()
        for event in scanner.get_event_stream():
            try:
                process_event('wifi', event, event.get('type'))
            except Exception:
                pass
            yield format_sse(event)
    response = Response(generate(), mimetype='text/event-stream')
@@ -137,14 +137,6 @@ need_sudo() {
  fi
 }
 # Refresh sudo credential cache so long-running builds don't trigger
 # mid-compilation password prompts (which can fail due to TTY issues
 # inside subshells). Safe to call multiple times.
 refresh_sudo() {
  [[ -z "${SUDO:-}" ]] && return 0
  sudo -v 2>/dev/null || true
 }
 detect_os() {
  if [[ "${OSTYPE:-}" == "darwin"* ]]; then
    OS="macos"
@@ -173,7 +165,6 @@ detect_dragonos() {
 # Required tool checks (with alternates)
 # ----------------------------
 missing_required=()
 missing_recommended=()
 check_required() {
  local label="$1"; shift
@@ -187,18 +178,6 @@ check_required() {
  fi
 }
 check_recommended() {
  local label="$1"; shift
  local desc="$1"; shift
  if have_any "$@"; then
    ok "${label} - ${desc}"
  else
    warn "${label} - ${desc} (missing, recommended)"
    missing_recommended+=("$label")
  fi
 }
 check_optional() {
  local label="$1"; shift
  local desc="$1"; shift
@@ -222,13 +201,9 @@ check_tools() {
  check_required "multimon-ng" "Pager decoder" multimon-ng
  check_required "rtl_433"     "433MHz sensor decoder" rtl_433 rtl433
  check_optional "rtlamr"      "Utility meter decoder (requires Go)" rtlamr
  check_optional "hackrf_transfer" "HackRF SubGHz transceiver" hackrf_transfer
  check_optional "hackrf_sweep"    "HackRF spectrum analyzer" hackrf_sweep
  check_required "dump1090"    "ADS-B decoder" dump1090
  check_required "acarsdec"    "ACARS decoder" acarsdec
  check_optional "dumpvdl2"    "VDL2 decoder" dumpvdl2
  check_required "AIS-catcher" "AIS vessel decoder" AIS-catcher aiscatcher
  check_optional "satdump" "Weather satellite decoder (NOAA/Meteor)" satdump
  echo
  info "GPS:"
  check_required "gpsd" "GPS daemon" gpsd
@@ -313,40 +288,28 @@ install_python_deps() {
  # shellcheck disable=SC1091
  source venv/bin/activate
  local PIP="venv/bin/python -m pip"
  local PY="venv/bin/python"
-  $PIP install --upgrade pip setuptools wheel >/dev/null 2>&1 || true
+  python -m pip install --upgrade pip setuptools wheel >/dev/null 2>&1 || true
  ok "Upgraded pip tooling"
  progress "Installing Python dependencies"
-
+  # Try pip install, but don't fail if apt packages already satisfied deps
-  # Install critical packages first to avoid all-or-nothing failures
+  if ! python -m pip install -r requirements.txt 2>/dev/null; then
-  # (C extension packages like scipy/numpy can fail on newer Python versions
+    warn "Some pip packages failed - checking if apt packages cover them..."
-  #  and cause pip to roll back pure-Python packages like flask)
+    # Verify critical packages are available
-  info "Installing core packages..."
+    python -c "import flask; import requests; from flask_limiter import Limiter" 2>/dev/null || {
  $PIP install --quiet "flask>=3.0.0" "flask-limiter>=2.5.4" "requests>=2.28.0" \
    "Werkzeug>=3.1.5" "pyserial>=3.5" "flask-sock" "websocket-client>=1.6.0" 2>/dev/null || true
  # Verify critical packages
  $PY -c "import flask; import requests; from flask_limiter import Limiter" 2>/dev/null || {
      fail "Critical Python packages (flask, requests, flask-limiter) not installed"
-    echo "Try: venv/bin/pip install flask requests flask-limiter"
+      echo "Try: pip install flask requests flask-limiter"
      exit 1
    }
-  ok "Core Python packages installed"
+    ok "Core Python dependencies available"
-
+  else
-  # Install optional packages individually (some may fail on newer Python)
+    ok "Python dependencies installed"
  info "Installing optional packages..."
  for pkg in "numpy>=1.24.0" "scipy>=1.10.0" "Pillow>=9.0.0" "skyfield>=1.45" \
             "bleak>=0.21.0" "psycopg2-binary>=2.9.9" "meshtastic>=2.0.0" \
             "scapy>=2.4.5" "qrcode[pil]>=7.4" "cryptography>=41.0.0"; do
    pkg_name="${pkg%%>=*}"
    if ! $PIP install "$pkg" 2>/dev/null; then
      warn "${pkg_name} failed to install (optional - related features may be unavailable)"
  fi
-  done
+
-  ok "Optional packages processed"
+  # 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
 }
@@ -409,7 +372,7 @@ install_rtlamr_from_source() {
        if [[ -w /usr/local/bin ]]; then
          ln -sf "$GOPATH/bin/rtlamr" /usr/local/bin/rtlamr
        else
-          $SUDO ln -sf "$GOPATH/bin/rtlamr" /usr/local/bin/rtlamr
+          sudo ln -sf "$GOPATH/bin/rtlamr" /usr/local/bin/rtlamr
        fi
      else
        $SUDO ln -sf "$GOPATH/bin/rtlamr" /usr/local/bin/rtlamr
@@ -451,8 +414,7 @@ install_multimon_ng_from_source_macos() {
    if [[ -w /usr/local/bin ]]; then
      install -m 0755 multimon-ng /usr/local/bin/multimon-ng
    else
-      refresh_sudo
+      sudo install -m 0755 multimon-ng /usr/local/bin/multimon-ng
      $SUDO install -m 0755 multimon-ng /usr/local/bin/multimon-ng
    fi
    ok "multimon-ng installed successfully from source"
  )
@@ -493,8 +455,7 @@ install_dsd_from_source() {
        if [[ -w /usr/local/lib ]]; then
          make install >/dev/null 2>&1
        else
-          refresh_sudo
+          sudo make install >/dev/null 2>&1
          $SUDO make install >/dev/null 2>&1
        fi
      else
        $SUDO make install >/dev/null 2>&1
@@ -530,8 +491,7 @@ install_dsd_from_source() {
        if [[ -w /usr/local/bin ]]; then
          install -m 0755 dsd-fme /usr/local/bin/dsd 2>/dev/null || install -m 0755 dsd /usr/local/bin/dsd 2>/dev/null || true
        else
-          refresh_sudo
+          sudo install -m 0755 dsd-fme /usr/local/bin/dsd 2>/dev/null || sudo install -m 0755 dsd /usr/local/bin/dsd 2>/dev/null || true
          $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 \
@@ -569,8 +529,7 @@ install_dump1090_from_source_macos() {
      if [[ -w /usr/local/bin ]]; then
        install -m 0755 dump1090 /usr/local/bin/dump1090
      else
-        refresh_sudo
+        sudo install -m 0755 dump1090 /usr/local/bin/dump1090
        $SUDO install -m 0755 dump1090 /usr/local/bin/dump1090
      fi
      ok "dump1090 installed successfully from source"
    else
@@ -596,129 +555,18 @@ install_acarsdec_from_source_macos() {
      || { warn "Failed to clone acarsdec"; exit 1; }
    cd "$tmp_dir/acarsdec"
    # Fix compiler flags for macOS Apple Silicon (ARM64)
    # -march=native can fail with Apple Clang on M-series chips
    # -Ofast is deprecated in modern Clang
    if [[ "$(uname -m)" == "arm64" ]]; then
      sed -i '' 's/-Ofast -march=native/-O3 -ffast-math/g' CMakeLists.txt
      info "Patched compiler flags for Apple Silicon (arm64)"
    fi
    # Fix pthread_tryjoin_np (Linux-only GNU extension) for macOS
    # Replace with pthread_join which provides equivalent behavior
    if grep -q 'pthread_tryjoin_np' rtl.c 2>/dev/null; then
      sed -i '' 's/pthread_tryjoin_np(\([^,]*\), NULL)/pthread_join(\1, NULL)/g' rtl.c
      info "Patched pthread_tryjoin_np for macOS compatibility"
    fi
    # Fix libacars linking on macOS (upstream issue #112)
    # Use LIBACARS_LINK_LIBRARIES (full path) instead of LIBACARS_LIBRARIES (name only)
    if grep -q 'LIBACARS_LIBRARIES' CMakeLists.txt 2>/dev/null; then
      sed -i '' 's/${LIBACARS_LIBRARIES}/${LIBACARS_LINK_LIBRARIES}/g' CMakeLists.txt
      info "Patched libacars linking for macOS"
    fi
    mkdir -p build && cd build
    # Set Homebrew paths for Apple Silicon (/opt/homebrew) or Intel (/usr/local)
    HOMEBREW_PREFIX="$(brew --prefix)"
    export PKG_CONFIG_PATH="${HOMEBREW_PREFIX}/lib/pkgconfig:${PKG_CONFIG_PATH:-}"
    export CMAKE_PREFIX_PATH="${HOMEBREW_PREFIX}"
    info "Compiling acarsdec..."
-    build_log="$tmp_dir/acarsdec-build.log"
+    if cmake .. -Drtl=ON >/dev/null 2>&1 && make >/dev/null 2>&1; then
    if cmake .. -Drtl=ON \
         -DCMAKE_POLICY_VERSION_MINIMUM=3.5 \
         -DCMAKE_C_FLAGS="-I${HOMEBREW_PREFIX}/include" \
         -DCMAKE_EXE_LINKER_FLAGS="-L${HOMEBREW_PREFIX}/lib" \
         >"$build_log" 2>&1 \
       && make >>"$build_log" 2>&1; then
      if [[ -w /usr/local/bin ]]; then
        install -m 0755 acarsdec /usr/local/bin/acarsdec
      else
-        refresh_sudo
+        sudo install -m 0755 acarsdec /usr/local/bin/acarsdec
        $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."
      warn "Build log (last 30 lines):"
      tail -30 "$build_log" | while IFS= read -r line; do warn "  $line"; done
    fi
  )
 }
 install_dumpvdl2_from_source_macos() {
  info "Building dumpvdl2 from source (with libacars dependency)..."
  brew_install cmake
  brew_install librtlsdr
  brew_install pkg-config
  brew_install glib
  (
    tmp_dir="$(mktemp -d)"
    trap 'rm -rf "$tmp_dir"' EXIT
    HOMEBREW_PREFIX="$(brew --prefix)"
    export PKG_CONFIG_PATH="${HOMEBREW_PREFIX}/lib/pkgconfig:${PKG_CONFIG_PATH:-}"
    export CMAKE_PREFIX_PATH="${HOMEBREW_PREFIX}"
    # Build libacars first
    info "Cloning libacars..."
    git clone --depth 1 https://github.com/szpajder/libacars.git "$tmp_dir/libacars" >/dev/null 2>&1 \
      || { warn "Failed to clone libacars"; exit 1; }
    cd "$tmp_dir/libacars"
    mkdir -p build && cd build
    info "Compiling libacars..."
    build_log="$tmp_dir/libacars-build.log"
    if cmake .. \
         -DCMAKE_C_FLAGS="-I${HOMEBREW_PREFIX}/include" \
         -DCMAKE_EXE_LINKER_FLAGS="-L${HOMEBREW_PREFIX}/lib" \
         >"$build_log" 2>&1 \
       && make >>"$build_log" 2>&1; then
      if [[ -w /usr/local/lib ]]; then
        make install >>"$build_log" 2>&1
      else
        refresh_sudo
        $SUDO make install >>"$build_log" 2>&1
      fi
      ok "libacars installed"
    else
      warn "Failed to build libacars."
      tail -20 "$build_log" | while IFS= read -r line; do warn "  $line"; done
      exit 1
    fi
    # Build dumpvdl2
    info "Cloning dumpvdl2..."
    git clone --depth 1 https://github.com/szpajder/dumpvdl2.git "$tmp_dir/dumpvdl2" >/dev/null 2>&1 \
      || { warn "Failed to clone dumpvdl2"; exit 1; }
    cd "$tmp_dir/dumpvdl2"
    mkdir -p build && cd build
    info "Compiling dumpvdl2..."
    build_log="$tmp_dir/dumpvdl2-build.log"
    if cmake .. \
         -DCMAKE_C_FLAGS="-I${HOMEBREW_PREFIX}/include" \
         -DCMAKE_EXE_LINKER_FLAGS="-L${HOMEBREW_PREFIX}/lib" \
         >"$build_log" 2>&1 \
       && make >>"$build_log" 2>&1; then
      if [[ -w /usr/local/bin ]]; then
        install -m 0755 src/dumpvdl2 /usr/local/bin/dumpvdl2
      else
        refresh_sudo
        $SUDO install -m 0755 src/dumpvdl2 /usr/local/bin/dumpvdl2
      fi
      ok "dumpvdl2 installed successfully from source"
    else
      warn "Failed to build dumpvdl2. VDL2 decoding will not be available."
      warn "Build log (last 30 lines):"
      tail -30 "$build_log" | while IFS= read -r line; do warn "  $line"; done
    fi
  )
 }
@@ -747,8 +595,7 @@ install_aiscatcher_from_source_macos() {
      if [[ -w /usr/local/bin ]]; then
        install -m 0755 AIS-catcher /usr/local/bin/AIS-catcher
      else
-        refresh_sudo
+        sudo install -m 0755 AIS-catcher /usr/local/bin/AIS-catcher
        $SUDO install -m 0755 AIS-catcher /usr/local/bin/AIS-catcher
      fi
      ok "AIS-catcher installed successfully from source"
    else
@@ -757,168 +604,8 @@ install_aiscatcher_from_source_macos() {
  )
 }
 install_satdump_from_source_debian() {
  info "Building SatDump v1.2.2 from source (weather satellite decoder)..."
  # Core deps — hard-fail if missing
  apt_install build-essential git cmake pkg-config \
    libpng-dev libtiff-dev libzstd-dev \
    libsqlite3-dev libcurl4-openssl-dev zlib1g-dev libzmq3-dev libfftw3-dev
  # libvolk: package name differs between distros
  #   Ubuntu / Debian Trixie+: libvolk-dev
  #   Raspberry Pi OS Bookworm / Debian Bookworm: libvolk2-dev
  apt_try_install_any libvolk-dev libvolk2-dev \
    || warn "libvolk not found — SatDump will build without VOLK acceleration"
  # Optional SDR hardware libs — soft-fail so missing hardware doesn't abort
  for pkg in libjemalloc-dev libnng-dev libsoapysdr-dev libhackrf-dev liblimesuite-dev; do
    $SUDO apt-get install -y --no-install-recommends "$pkg" >/dev/null 2>&1 \
      || warn "${pkg} not available — skipping (SatDump can build without it)"
  done
  # Run in subshell to isolate EXIT trap
  (
    tmp_dir="$(mktemp -d)"
    trap 'rm -rf "$tmp_dir"' EXIT
    info "Cloning SatDump v1.2.2..."
    git clone --depth 1 --branch 1.2.2 https://github.com/SatDump/SatDump.git "$tmp_dir/SatDump" >/dev/null 2>&1 \
      || { warn "Failed to clone SatDump"; exit 1; }
    cd "$tmp_dir/SatDump"
    # Patch: fix deprecated std::allocator usage for newer compilers
    # GCC 13+ errors on deprecated allocator members in sol2.
    # Pragmas must go in lua_utils.cpp (the instantiation site), not sol.hpp (definition site).
    lua_utils="src-core/common/lua/lua_utils.cpp"
    if [ -f "$lua_utils" ]; then
      {
        echo '#pragma GCC diagnostic push'
        echo '#pragma GCC diagnostic ignored "-Wdeprecated"'
        echo '#pragma GCC diagnostic ignored "-Wdeprecated-declarations"'
        cat "$lua_utils"
        echo  # ensure the file ends with a newline before the closing pragma
        echo '#pragma GCC diagnostic pop'
      } > "${lua_utils}.patched" && mv "${lua_utils}.patched" "$lua_utils"
    fi
    mkdir -p build && cd build
    info "Compiling SatDump (this is a large C++ project and may take 10-30 minutes)..."
    build_log="$tmp_dir/satdump-build.log"
    # Show periodic progress while building so the user knows it's not hung
    (
      while true; do
        sleep 30
        if [ -f "$build_log" ]; then
          local_lines=$(wc -l < "$build_log" 2>/dev/null || echo 0)
          printf "  [*] Still compiling SatDump... (%s lines of build output so far)\n" "$local_lines"
        fi
      done
    ) &
    progress_pid=$!
    if cmake -DCMAKE_BUILD_TYPE=Release -DBUILD_GUI=OFF -DCMAKE_INSTALL_LIBDIR=lib .. >"$build_log" 2>&1 \
        && make -j "$(nproc)" >>"$build_log" 2>&1; then
      kill $progress_pid 2>/dev/null; wait $progress_pid 2>/dev/null
      $SUDO make install >/dev/null 2>&1
      $SUDO ldconfig
      # Ensure plugins are in the expected path (handles multiarch differences)
      $SUDO mkdir -p /usr/local/lib/satdump/plugins
      if [ -z "$(ls /usr/local/lib/satdump/plugins/*.so 2>/dev/null)" ]; then
        for dir in /usr/local/lib/*/satdump/plugins /usr/lib/*/satdump/plugins /usr/lib/satdump/plugins; do
          if [ -d "$dir" ] && [ -n "$(ls "$dir"/*.so 2>/dev/null)" ]; then
            $SUDO ln -sf "$dir"/*.so /usr/local/lib/satdump/plugins/
            break
          fi
        done
      fi
      ok "SatDump installed successfully."
    else
      kill $progress_pid 2>/dev/null; wait $progress_pid 2>/dev/null
      warn "Failed to build SatDump from source. Weather satellite decoding will not be available."
      warn "Build log (last 30 lines):"
      tail -30 "$build_log" | while IFS= read -r line; do warn "  $line"; done
    fi
  )
 }
 install_satdump_macos() {
  info "Installing SatDump v1.2.2 from pre-built release (weather satellite decoder)..."
  # Determine architecture
  local arch
  arch="$(uname -m)"
  local dmg_name
  if [ "$arch" = "arm64" ]; then
    dmg_name="SatDump-macOS-Silicon.dmg"
  else
    dmg_name="SatDump-macOS-Intel.dmg"
  fi
  local dmg_url="https://github.com/SatDump/SatDump/releases/download/1.2.2/${dmg_name}"
  local install_dir="/usr/local/lib/satdump"
  # Run in subshell to isolate EXIT trap
  (
    tmp_dir="$(mktemp -d)"
    trap 'hdiutil detach "$tmp_dir/mnt" -quiet 2>/dev/null || true; rm -rf "$tmp_dir"' EXIT
    info "Downloading ${dmg_name}..."
    if ! curl -sL -o "$tmp_dir/satdump.dmg" "$dmg_url"; then
      warn "Failed to download SatDump. Weather satellite decoding will not be available."
      exit 1
    fi
    info "Installing SatDump..."
    # Mount the DMG
    hdiutil attach "$tmp_dir/satdump.dmg" -nobrowse -quiet -mountpoint "$tmp_dir/mnt" \
      || { warn "Failed to mount SatDump DMG"; exit 1; }
    local app_dir="$tmp_dir/mnt/SatDump.app"
    if [ ! -d "$app_dir" ]; then
      warn "SatDump.app not found in DMG"
      exit 1
    fi
    # Install: copy app contents to /usr/local/lib/satdump
    refresh_sudo
    $SUDO mkdir -p "$install_dir"
    $SUDO cp -R "$app_dir/Contents/MacOS/"* "$install_dir/"
    $SUDO cp -R "$app_dir/Contents/Resources/"* "$install_dir/"
    # Create wrapper script so satdump can find its resources via @executable_path
    $SUDO tee /usr/local/bin/satdump >/dev/null <<'WRAPPER'
 #!/bin/sh
 exec /usr/local/lib/satdump/satdump "$@"
 WRAPPER
    $SUDO chmod +x /usr/local/bin/satdump
    hdiutil detach "$tmp_dir/mnt" -quiet 2>/dev/null
    # Verify installation
    if /usr/local/lib/satdump/satdump 2>&1 | grep -q "Usage"; then
      ok "SatDump v1.2.2 installed successfully."
    else
      warn "SatDump installed but may not work correctly."
    fi
  )
 }
 install_macos_packages() {
-  need_sudo
+  TOTAL_STEPS=17
  # Prime sudo credentials upfront so builds don't prompt mid-compilation
  if [[ -n "${SUDO:-}" ]]; then
    info "Some tools require sudo to install. You may be prompted for your password."
    sudo -v || { fail "sudo authentication failed"; exit 1; }
  fi
  TOTAL_STEPS=22
  CURRENT_STEP=0
  progress "Checking Homebrew"
@@ -960,9 +647,6 @@ install_macos_packages() {
  progress "Installing rtl_433"
  brew_install rtl_433
  progress "Installing HackRF tools"
  brew_install hackrf
  progress "Installing rtlamr (optional)"
  # rtlamr is optional - used for utility meter monitoring
  if ! cmd_exists rtlamr; then
@@ -991,13 +675,6 @@ install_macos_packages() {
    ok "acarsdec already installed"
  fi
  progress "Installing dumpvdl2"
  if ! cmd_exists dumpvdl2; then
    install_dumpvdl2_from_source_macos || warn "dumpvdl2 not available. VDL2 decoding will not be available."
  else
    ok "dumpvdl2 already installed"
  fi
  progress "Installing AIS-catcher"
  if ! cmd_exists AIS-catcher && ! cmd_exists aiscatcher; then
    (brew_install aiscatcher) || install_aiscatcher_from_source_macos || warn "AIS-catcher not available"
@@ -1005,19 +682,6 @@ install_macos_packages() {
    ok "AIS-catcher already installed"
  fi
  progress "Installing SatDump (optional)"
  if ! cmd_exists satdump; then
    echo
    info "SatDump is used for weather satellite imagery (NOAA APT & Meteor LRPT)."
    if ask_yes_no "Do you want to install SatDump?"; then
      install_satdump_macos || warn "SatDump installation failed. Weather satellite decoding will not be available."
    else
      warn "Skipping SatDump installation. You can install it later if needed."
    fi
  else
    ok "SatDump already installed"
  fi
  progress "Installing aircrack-ng"
  brew_install aircrack-ng
@@ -1091,13 +755,10 @@ install_dump1090_from_source_debian() {
    librtlsdr-dev libusb-1.0-0-dev \
    libncurses-dev tcl-dev python3-dev
  local JOBS
  JOBS="$(nproc 2>/dev/null || echo 1)"
  # Run in subshell to isolate EXIT trap
  (
    tmp_dir="$(mktemp -d)"
-    trap '{ [[ -n "${progress_pid:-}" ]] && kill "$progress_pid" 2>/dev/null && wait "$progress_pid" 2>/dev/null || true; }; rm -rf "$tmp_dir"' EXIT
+    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 \
@@ -1105,45 +766,23 @@ install_dump1090_from_source_debian() {
    cd "$tmp_dir/dump1090"
    # Remove -Werror to prevent build failures on newer GCC versions
-    sed -i 's/-Werror//g' Makefile 2>/dev/null || true
+    sed -i 's/-Werror//g' Makefile 2>/dev/null || sed -i '' 's/-Werror//g' Makefile
-    info "Compiling FlightAware dump1090 (using ${JOBS} CPU cores)..."
+    info "Compiling FlightAware dump1090..."
-    build_log="$tmp_dir/dump1090-build.log"
+    if make BLADERF=no RTLSDR=yes >/dev/null 2>&1; then
    (while true; do sleep 20; printf "  [*] Still compiling dump1090...\n"; done) &
    progress_pid=$!
    if make -j "$JOBS" BLADERF=no RTLSDR=yes >"$build_log" 2>&1; then
      kill "$progress_pid" 2>/dev/null; wait "$progress_pid" 2>/dev/null || true; progress_pid=
      $SUDO install -m 0755 dump1090 /usr/local/bin/dump1090
      ok "dump1090 installed successfully (FlightAware)."
      exit 0
    fi
    kill "$progress_pid" 2>/dev/null; wait "$progress_pid" 2>/dev/null || true; progress_pid=
    warn "FlightAware build failed. Falling back to wiedehopf/readsb..."
    warn "Build log (last 20 lines):"
    tail -20 "$build_log" | while IFS= read -r line; do warn "  $line"; done
    rm -rf "$tmp_dir/dump1090"
    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 readsb (using ${JOBS} CPU cores)..."
+    info "Compiling readsb..."
-    build_log="$tmp_dir/readsb-build.log"
+    make RTLSDR=yes >/dev/null 2>&1 || { fail "Failed to build readsb from source (required)."; exit 1; }
    (while true; do sleep 20; printf "  [*] Still compiling readsb...\n"; done) &
    progress_pid=$!
    if ! make -j "$JOBS" RTLSDR=yes >"$build_log" 2>&1; then
      kill "$progress_pid" 2>/dev/null; wait "$progress_pid" 2>/dev/null || true; progress_pid=
      warn "Build log (last 20 lines):"
      tail -20 "$build_log" | while IFS= read -r line; do warn "  $line"; done
      fail "Failed to build readsb from source (required)."
      exit 1
    fi
    kill "$progress_pid" 2>/dev/null; wait "$progress_pid" 2>/dev/null || true; progress_pid=
    $SUDO install -m 0755 readsb /usr/local/bin/dump1090
    ok "dump1090 installed successfully (via readsb)."
  )
@@ -1168,7 +807,7 @@ install_acarsdec_from_source_debian() {
    mkdir -p build && cd build
    info "Compiling acarsdec..."
-    if cmake .. -Drtl=ON -DCMAKE_POLICY_VERSION_MINIMUM=3.5 >/dev/null 2>&1 && make >/dev/null 2>&1; then
+    if cmake .. -Drtl=ON >/dev/null 2>&1 && make >/dev/null 2>&1; then
      $SUDO install -m 0755 acarsdec /usr/local/bin/acarsdec
      ok "acarsdec installed successfully."
    else
@@ -1177,52 +816,6 @@ install_acarsdec_from_source_debian() {
  )
 }
 install_dumpvdl2_from_source_debian() {
  info "Building dumpvdl2 from source (with libacars dependency)..."
  apt_install build-essential git cmake \
    librtlsdr-dev libusb-1.0-0-dev libglib2.0-dev libxml2-dev
  (
    tmp_dir="$(mktemp -d)"
    trap 'rm -rf "$tmp_dir"' EXIT
    # Build libacars first
    info "Cloning libacars..."
    git clone --depth 1 https://github.com/szpajder/libacars.git "$tmp_dir/libacars" >/dev/null 2>&1 \
      || { warn "Failed to clone libacars"; exit 1; }
    cd "$tmp_dir/libacars"
    mkdir -p build && cd build
    info "Compiling libacars..."
    if cmake .. >/dev/null 2>&1 && make >/dev/null 2>&1; then
      $SUDO make install >/dev/null 2>&1
      $SUDO ldconfig
      ok "libacars installed"
    else
      warn "Failed to build libacars."
      exit 1
    fi
    # Build dumpvdl2
    info "Cloning dumpvdl2..."
    git clone --depth 1 https://github.com/szpajder/dumpvdl2.git "$tmp_dir/dumpvdl2" >/dev/null 2>&1 \
      || { warn "Failed to clone dumpvdl2"; exit 1; }
    cd "$tmp_dir/dumpvdl2"
    mkdir -p build && cd build
    info "Compiling dumpvdl2..."
    if cmake .. >/dev/null 2>&1 && make >/dev/null 2>&1; then
      $SUDO install -m 0755 src/dumpvdl2 /usr/local/bin/dumpvdl2
      ok "dumpvdl2 installed successfully."
    else
      warn "Failed to build dumpvdl2 from source. VDL2 decoding will not be available."
    fi
  )
 }
 install_aiscatcher_from_source_debian() {
  info "AIS-catcher not available via APT. Building from source..."
@@ -1315,17 +908,6 @@ install_rtlsdr_blog_drivers_debian() {
        $SUDO udevadm trigger || true
      fi
      # Make the Blog drivers' library take priority over the apt-installed
      # librtlsdr.  Removing apt packages is too destructive (dump1090-mutability
      # and other tools depend on librtlsdr0 and get swept out).  Instead,
      # prepend /usr/local/lib to ldconfig's search path — files named 00-*
      # sort before the distro's aarch64-linux-gnu.conf — so ldconfig lists
      # /usr/local/lib/librtlsdr.so.0 first and the dynamic linker uses it.
      if [[ -d /etc/ld.so.conf.d ]]; then
        echo '/usr/local/lib' | $SUDO tee /etc/ld.so.conf.d/00-local-first.conf >/dev/null
      fi
      $SUDO ldconfig
      ok "RTL-SDR Blog drivers installed successfully."
      info "These drivers provide improved support for RTL-SDR Blog V4 and other devices."
      warn "Unplug and replug your RTL-SDR devices for the new drivers to take effect."
@@ -1335,7 +917,6 @@ install_rtlsdr_blog_drivers_debian() {
      warn "See: https://github.com/rtlsdrblog/rtl-sdr-blog"
    fi
  )
 }
 setup_udev_rules_debian() {
@@ -1360,7 +941,9 @@ blacklist_kernel_drivers_debian() {
  if [[ -f "$blacklist_file" ]]; then
    ok "RTL-SDR kernel driver blacklist already present"
-  else
+    return 0
  fi
  info "Blacklisting conflicting DVB kernel drivers..."
  $SUDO tee "$blacklist_file" >/dev/null <<'EOF'
 # Blacklist DVB-T drivers to allow rtl-sdr to access RTL2832U devices
@@ -1369,26 +952,13 @@ blacklist rtl2832
 blacklist rtl2830
 blacklist r820t
 EOF
  fi
-  # Always unload modules if currently loaded — this must happen even on
+  # Unload modules if currently loaded
  # re-runs where the blacklist file already exists, since the modules may
  # still be live from the current boot (e.g. blacklist wasn't in initramfs).
  local unloaded=false
  for mod in dvb_usb_rtl28xxu rtl2832 rtl2830 r820t; do
    if lsmod | grep -q "^$mod"; then
      $SUDO modprobe -r "$mod" 2>/dev/null || true
      unloaded=true
    fi
  done
  $unloaded && info "Unloaded conflicting DVB kernel modules from current session."
  # Bake the blacklist into the initramfs so it survives reboots on
  # Raspberry Pi OS / Debian (without this the modules can reload on boot).
  if cmd_exists update-initramfs; then
    info "Updating initramfs to persist driver blacklist across reboots..."
    $SUDO update-initramfs -u >/dev/null 2>&1 || true
  fi
  ok "Kernel drivers blacklisted. Unplug/replug your RTL-SDR if connected."
  echo
@@ -1409,7 +979,7 @@ install_debian_packages() {
    export NEEDRESTART_MODE=a
  fi
-  TOTAL_STEPS=28
+  TOTAL_STEPS=22
  CURRENT_STEP=0
  progress "Updating APT package lists"
@@ -1451,18 +1021,12 @@ install_debian_packages() {
  apt_install_if_missing rtl-sdr
-  progress "RTL-SDR Blog drivers (V4 support)"
+  progress "RTL-SDR Blog drivers"
-  if $IS_DRAGONOS; then
+  if cmd_exists rtl_test; then
-    info "DragonOS: skipping RTL-SDR Blog driver install (pre-configured)."
+    ok "RTL-SDR drivers already installed"
  else
-    echo
+    info "RTL-SDR drivers not found, installing RTL-SDR Blog drivers..."
    info "RTL-SDR Blog drivers add V4 (R828D tuner) support and bias-tee improvements."
    info "They are backward-compatible with all RTL-SDR devices."
    if ask_yes_no "Install RTL-SDR Blog drivers? (recommended for V4 users, safe for all)" "y"; then
    install_rtlsdr_blog_drivers_debian
    else
      warn "Skipping RTL-SDR Blog drivers. V4 devices may not work correctly."
    fi
  fi
  progress "Installing multimon-ng"
@@ -1493,9 +1057,6 @@ install_debian_packages() {
  progress "Installing rtl_433"
  apt_try_install_any rtl-433 rtl433 || warn "rtl-433 not available"
  progress "Installing HackRF tools"
  apt_install hackrf || warn "hackrf tools not available"
  progress "Installing rtlamr (optional)"
  # rtlamr is optional - used for utility meter monitoring
  if ! cmd_exists rtlamr; then
@@ -1552,21 +1113,12 @@ install_debian_packages() {
  $SUDO apt-get install -y python3-bleak >/dev/null 2>&1 || true
  progress "Installing dump1090"
  # Remove any stale symlink left from a previous run where dump1090-mutability
  # was later uninstalled — cmd_exists finds the broken symlink and skips the
  # real install, leaving dump1090 seemingly present but non-functional.
  local dump1090_path
  dump1090_path="$(command -v dump1090 2>/dev/null || true)"
  if [[ -n "$dump1090_path" ]] && [[ ! -x "$dump1090_path" ]]; then
    info "Removing broken dump1090 symlink: $dump1090_path"
    $SUDO rm -f "$dump1090_path"
  fi
  if ! cmd_exists dump1090 && ! cmd_exists dump1090-mutability; then
    apt_try_install_any dump1090-fa dump1090-mutability dump1090 || true
  fi
  if ! cmd_exists dump1090; then
    if cmd_exists dump1090-mutability; then
-      $SUDO ln -s "$(which dump1090-mutability)" /usr/local/sbin/dump1090
+      $SUDO ln -s $(which dump1090-mutability) /usr/local/sbin/dump1090
    fi
  fi
  cmd_exists dump1090 || install_dump1090_from_source_debian
@@ -1577,13 +1129,6 @@ install_debian_packages() {
  fi
  cmd_exists acarsdec || install_acarsdec_from_source_debian
  progress "Installing dumpvdl2"
  if ! cmd_exists dumpvdl2; then
    install_dumpvdl2_from_source_debian || warn "dumpvdl2 not available. VDL2 decoding will not be available."
  else
    ok "dumpvdl2 already installed"
  fi
  progress "Installing AIS-catcher"
  if ! cmd_exists AIS-catcher && ! cmd_exists aiscatcher; then
    install_aiscatcher_from_source_debian
@@ -1591,19 +1136,6 @@ install_debian_packages() {
    ok "AIS-catcher already installed"
  fi
  progress "Installing SatDump (optional)"
  if ! cmd_exists satdump; then
    echo
    info "SatDump is used for weather satellite imagery (NOAA APT & Meteor LRPT)."
    if ask_yes_no "Do you want to install SatDump?"; then
      install_satdump_from_source_debian || warn "SatDump build failed. Weather satellite decoding will not be available."
    else
      warn "Skipping SatDump installation. You can install it later if needed."
    fi
  else
    ok "SatDump already installed"
  fi
  progress "Configuring udev rules"
  setup_udev_rules_debian
@@ -1653,14 +1185,6 @@ final_summary_and_hard_fail() {
      exit 1
    fi
  fi
  if [[ "${#missing_recommended[@]}" -gt 0 ]]; then
    echo
    warn "Missing RECOMMENDED tools (some features will not work):"
    for t in "${missing_recommended[@]}"; do echo "  - $t"; done
    echo
    warn "Install these for full functionality"
  fi
 }
 # ----------------------------
@@ -1707,19 +1231,6 @@ main() {
  fi
  install_python_deps
  # Download leaflet-heat plugin (offline mode)
  if [ ! -f "static/vendor/leaflet-heat/leaflet-heat.js" ]; then
    info "Downloading leaflet-heat plugin..."
    mkdir -p static/vendor/leaflet-heat
    if curl -sL "https://unpkg.com/leaflet.heat@0.2.0/dist/leaflet-heat.js" \
        -o static/vendor/leaflet-heat/leaflet-heat.js; then
      ok "leaflet-heat plugin downloaded"
    else
      warn "Failed to download leaflet-heat plugin. Heatmap will use CDN."
    fi
  fi
  final_summary_and_hard_fail
 }
@@ -5,8 +5,8 @@
 }
 :root {
-    --font-sans: 'Roboto Condensed', 'Arial Narrow', Roboto, 'Helvetica Neue', Arial, sans-serif;
+    --font-sans: 'IBM Plex Mono', 'Space Mono', ui-monospace, 'SF Mono', 'Consolas', 'Menlo', monospace;
-    --font-mono: 'Roboto Condensed', 'Arial Narrow', Roboto, 'Helvetica Neue', Arial, sans-serif;
+    --font-mono: 'IBM Plex Mono', 'Space Mono', ui-monospace, 'SF Mono', 'Consolas', 'Menlo', monospace;
    --bg-dark: #0b1118;
    --bg-panel: #101823;
    --bg-card: #151f2b;
@@ -27,36 +27,12 @@
    --radar-bg: #101823;
 }
 [data-theme="light"] {
    --bg-dark: #f4f7fb;
    --bg-panel: #e9eef5;
    --bg-card: #ffffff;
    --border-color: #d1d9e6;
    --border-glow: #1f5fa8;
    --text-primary: #122034;
    --text-secondary: #3a4a5f;
    --text-dim: #6b7c93;
    --accent-green: #1f8a57;
    --accent-cyan: #1f5fa8;
    --accent-orange: #b5863a;
    --accent-red: #c74444;
    --accent-yellow: #b5863a;
    --accent-amber: #b5863a;
    --grid-line: rgba(31, 95, 168, 0.12);
    --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");
    --radar-cyan: #1f5fa8;
    --radar-bg: #e9eef5;
 }
 body {
    font-family: var(--font-sans);
    background: var(--bg-dark);
    color: var(--text-primary);
-    height: 100dvh;
+    min-height: 100vh;
-    height: 100vh; /* Fallback */
+    overflow-x: hidden;
    display: flex;
    flex-direction: column;
    overflow: hidden;
 }
 /* Animated radar sweep background */
@@ -251,14 +227,16 @@ body {
 }
 /* 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;
-    flex: 1;
+    height: calc(100dvh - 160px);
-    min-height: 0;
+    height: calc(100vh - 160px); /* Fallback */
    min-height: 400px;
 }
 /* Tablet: Two-column layout */
@@ -271,29 +249,13 @@ body {
    }
 }
-/* Desktop: Full layout with ACARS/VDL2 + map + sidebar */
+/* Desktop: Full layout with ACARS */
@media (min-width: 1024px) {
    .dashboard {
        grid-template-columns: auto 1fr 300px;
    }
 }
 /* Left sidebars wrapper (ACARS + VDL2) */
 .left-sidebars {
    display: none;
 }
@media (min-width: 1024px) {
    .left-sidebars {
        display: flex;
        flex-direction: row;
        grid-column: 1;
        grid-row: 1;
        height: 100%;
        overflow: hidden;
    }
 }
 /* ACARS sidebar (left of map) - Collapsible */
 .acars-sidebar {
    display: none;
@@ -305,10 +267,12 @@ body {
    min-height: 0;
 }
-/* Show ACARS sidebar inside wrapper */
+/* Show ACARS sidebar on desktop */
-.left-sidebars .acars-sidebar {
+@media (min-width: 1024px) {
    .acars-sidebar {
        display: flex;
-    height: 100%;
+        max-height: calc(100dvh - 160px);
    }
 }
 .acars-collapse-btn {
@@ -455,335 +419,6 @@ body {
    to { opacity: 1; transform: translateY(0); }
 }
 /* VDL2 sidebar (left of map, after ACARS) - Collapsible */
 .vdl2-sidebar {
    display: none;
    background: var(--bg-panel);
    border-right: 1px solid var(--border-color);
    flex-direction: row;
    overflow: hidden;
    height: 100%;
    min-height: 0;
 }
 /* Show VDL2 sidebar inside wrapper */
 .left-sidebars .vdl2-sidebar {
    display: flex;
    height: 100%;
 }
 .vdl2-collapse-btn {
    width: 28px;
    min-width: 28px;
    background: var(--bg-card);
    border: none;
    border-left: 1px solid var(--border-color);
    color: var(--accent-cyan);
    cursor: pointer;
    display: flex;
    flex-direction: column;
    align-items: center;
    justify-content: center;
    gap: 6px;
    padding: 8px 0;
    transition: background 0.2s;
 }
 .vdl2-collapse-btn:hover {
    background: rgba(74, 158, 255, 0.2);
 }
 .vdl2-collapse-label {
    writing-mode: vertical-rl;
    text-orientation: mixed;
    font-size: 9px;
    font-weight: 600;
    letter-spacing: 1px;
    text-transform: uppercase;
 }
 .vdl2-sidebar.collapsed .vdl2-collapse-label {
    display: block;
 }
 .vdl2-sidebar:not(.collapsed) .vdl2-collapse-label {
    display: none;
 }
 #vdl2CollapseIcon {
    font-size: 10px;
    transition: transform 0.3s;
 }
 .vdl2-sidebar.collapsed #vdl2CollapseIcon {
    transform: rotate(180deg);
 }
 .vdl2-sidebar-content {
    width: 300px;
    display: flex;
    flex-direction: column;
    overflow: hidden;
    transition: width 0.3s ease, opacity 0.2s ease;
    height: 100%;
    min-height: 0;
 }
 .vdl2-sidebar.collapsed .vdl2-sidebar-content {
    width: 0;
    opacity: 0;
    pointer-events: none;
 }
 .vdl2-sidebar .panel {
    flex: 1;
    display: flex;
    flex-direction: column;
    border: none;
    border-radius: 0;
    min-height: 0;
    overflow: hidden;
 }
 .vdl2-sidebar .panel::before {
    display: none;
 }
 .vdl2-sidebar .panel-header {
    flex-shrink: 0;
 }
 .vdl2-sidebar #vdl2PanelContent {
    display: flex;
    flex-direction: column;
    flex: 1;
    min-height: 0;
    overflow: hidden;
 }
 .vdl2-sidebar .vdl2-info,
 .vdl2-sidebar .vdl2-controls {
    flex-shrink: 0;
 }
 .vdl2-sidebar .vdl2-messages {
    flex: 1;
    overflow-y: auto;
    min-height: 0;
 }
 .vdl2-sidebar .vdl2-btn {
    background: var(--accent-green);
    border: none;
    color: #fff;
    padding: 6px 10px;
    font-size: 10px;
    font-weight: 600;
    cursor: pointer;
    transition: all 0.2s;
    text-transform: uppercase;
    letter-spacing: 1px;
    border-radius: 4px;
 }
 .vdl2-sidebar .vdl2-btn:hover {
    background: #1db954;
    box-shadow: 0 0 10px rgba(34, 197, 94, 0.3);
 }
 .vdl2-sidebar .vdl2-btn.active {
    background: var(--accent-red);
 }
 .vdl2-sidebar .vdl2-btn.active:hover {
    background: #dc2626;
    box-shadow: 0 0 10px rgba(239, 68, 68, 0.3);
 }
 .vdl2-message-item {
    padding: 8px 10px;
    border-bottom: 1px solid var(--border-color);
    font-size: 10px;
    animation: fadeIn 0.3s ease;
    cursor: pointer;
    transition: background 0.2s;
 }
 .vdl2-message-item:hover {
    background: rgba(74, 158, 255, 0.08);
 }
 /* VDL2 Message Modal */
 .vdl2-modal-overlay {
    position: fixed;
    inset: 0;
    background: rgba(0, 0, 0, 0.6);
    backdrop-filter: blur(4px);
    z-index: 10000;
    display: flex;
    align-items: center;
    justify-content: center;
    animation: vdl2ModalFadeIn 0.15s ease;
 }
@keyframes vdl2ModalFadeIn {
    from { opacity: 0; }
    to { opacity: 1; }
 }
 .vdl2-modal {
    background: var(--bg-panel, #1a1a2e);
    border: 1px solid var(--accent-cyan, #4a9eff);
    border-radius: 8px;
    width: 520px;
    max-width: 90vw;
    max-height: 80vh;
    display: flex;
    flex-direction: column;
    box-shadow: 0 8px 32px rgba(0, 0, 0, 0.5), 0 0 1px var(--accent-cyan, #4a9eff);
    animation: vdl2ModalSlideIn 0.15s ease;
 }
@keyframes vdl2ModalSlideIn {
    from { opacity: 0; transform: scale(0.95) translateY(10px); }
    to { opacity: 1; transform: scale(1) translateY(0); }
 }
 .vdl2-modal-header {
    display: flex;
    justify-content: space-between;
    align-items: center;
    padding: 14px 18px;
    border-bottom: 1px solid var(--border-color);
    flex-shrink: 0;
 }
 .vdl2-modal-title {
    font-size: 14px;
    font-weight: 700;
    color: var(--accent-cyan, #4a9eff);
    letter-spacing: 0.5px;
 }
 .vdl2-modal-time {
    font-size: 11px;
    color: var(--text-muted);
 }
 .vdl2-modal-close {
    background: none;
    border: 1px solid var(--border-color);
    color: var(--text-muted);
    width: 28px;
    height: 28px;
    border-radius: 4px;
    cursor: pointer;
    font-size: 14px;
    display: flex;
    align-items: center;
    justify-content: center;
    transition: all 0.15s;
    margin-left: 12px;
 }
 .vdl2-modal-close:hover {
    background: rgba(239, 68, 68, 0.15);
    border-color: var(--accent-red, #ef4444);
    color: var(--accent-red, #ef4444);
 }
 .vdl2-modal-body {
    padding: 16px 18px;
    overflow-y: auto;
    flex: 1;
    min-height: 0;
 }
 .vdl2-modal-section {
    margin-bottom: 14px;
 }
 .vdl2-modal-section:last-child {
    margin-bottom: 0;
 }
 .vdl2-modal-section-title {
    font-size: 9px;
    font-weight: 700;
    color: var(--text-muted);
    text-transform: uppercase;
    letter-spacing: 1.5px;
    margin-bottom: 8px;
 }
 .vdl2-modal-grid {
    display: grid;
    grid-template-columns: 1fr 1fr;
    gap: 6px 16px;
 }
 .vdl2-modal-field {
    display: flex;
    flex-direction: column;
    gap: 1px;
 }
 .vdl2-modal-field-label {
    font-size: 10px;
    color: var(--text-dim);
 }
 .vdl2-modal-field-value {
    font-size: 12px;
    color: var(--text-primary);
    font-weight: 500;
 }
 .vdl2-modal-msg-body {
    padding: 10px 12px;
    background: rgba(0, 0, 0, 0.25);
    border-radius: 4px;
    font-family: var(--font-mono);
    font-size: 12px;
    color: var(--text-primary);
    white-space: pre-wrap;
    word-break: break-word;
    line-height: 1.5;
    max-height: 250px;
    overflow-y: auto;
 }
 .vdl2-modal-raw-toggle {
    display: inline-block;
    margin-top: 10px;
    font-size: 10px;
    color: var(--accent-cyan, #4a9eff);
    cursor: pointer;
    opacity: 0.7;
    transition: opacity 0.15s;
 }
 .vdl2-modal-raw-toggle:hover {
    opacity: 1;
 }
 .vdl2-modal-raw-json {
    display: none;
    margin-top: 8px;
    padding: 10px 12px;
    background: rgba(0, 0, 0, 0.3);
    border: 1px solid var(--border-color);
    border-radius: 4px;
    font-family: var(--font-mono);
    font-size: 11px;
    color: var(--text-dim);
    white-space: pre-wrap;
    word-break: break-all;
    max-height: 300px;
    overflow-y: auto;
    line-height: 1.4;
 }
 /* Panels */
 .panel {
    background: var(--bg-panel);
@@ -860,8 +495,6 @@ body {
    position: relative;
    flex: 1;
    min-height: 300px;
    min-width: 0;
    overflow: hidden;
 }
@media (min-width: 768px) {
@@ -893,6 +526,42 @@ body {
    display: block;
 }
 #radarOverlayCanvas {
    position: absolute;
    top: 0;
    left: 0;
    width: 100%;
    height: 100%;
    pointer-events: none;
    z-index: 500;
    display: none;
 }
 #radarOverlayCanvas.active {
    display: block;
 }
 #radarScope {
    position: absolute;
    top: 0;
    left: 0;
    width: 100%;
    height: 100%;
    display: none;
    background: var(--radar-bg);
 }
 #radarScope.active {
    display: flex;
    justify-content: center;
    align-items: center;
 }
 #radarCanvas {
    max-width: 100%;
    max-height: 100%;
 }
 /* Right sidebar - Mobile first */
 .sidebar {
    display: flex;
@@ -919,21 +588,51 @@ body {
    }
 }
 /* View toggle */
 .view-toggle {
    display: flex;
    padding: 10px;
    gap: 8px;
    background: var(--bg-panel);
    border-bottom: 1px solid rgba(74, 158, 255, 0.2);
 }
 .view-btn {
    flex: 1;
    padding: 10px;
    border: 1px solid rgba(74, 158, 255, 0.3);
    background: transparent;
    color: var(--text-secondary);
    font-family: 'Orbitron', monospace;
    font-size: 11px;
    font-weight: 600;
    text-transform: uppercase;
    letter-spacing: 2px;
    border-radius: 4px;
    cursor: pointer;
    transition: all 0.2s ease;
 }
 .view-btn:hover {
    border-color: var(--accent-cyan);
    color: var(--accent-cyan);
 }
 .view-btn.active {
    background: var(--accent-cyan);
    border-color: var(--accent-cyan);
    color: var(--bg-dark);
 }
 /* Selected aircraft panel */
 .selected-aircraft {
    flex-shrink: 0;
-    max-height: 280px;
+    max-height: 480px;
    overflow-y: auto;
 }
@media (min-height: 900px) {
    .selected-aircraft {
        max-height: 340px;
    }
 }
 .selected-info {
-    padding: 8px;
+    padding: 12px;
 }
 #aircraftPhotoContainer {
@@ -941,7 +640,7 @@ body {
 }
 #aircraftPhotoContainer img {
-    max-height: 100px;
+    max-height: 140px;
    width: 100%;
    object-fit: cover;
    border-radius: 6px;
@@ -950,24 +649,24 @@ body {
 .selected-callsign {
    font-family: 'Orbitron', monospace;
-    font-size: 16px;
+    font-size: 20px;
    font-weight: 700;
    color: var(--accent-cyan);
    text-shadow: 0 0 15px var(--accent-cyan);
    text-align: center;
-    margin-bottom: 6px;
+    margin-bottom: 12px;
 }
 .telemetry-grid {
    display: grid;
    grid-template-columns: repeat(2, 1fr);
-    gap: 4px;
+    gap: 6px;
 }
 .telemetry-item {
    background: rgba(0, 0, 0, 0.3);
    border-radius: 4px;
-    padding: 5px 8px;
+    padding: 8px;
    border-left: 2px solid var(--accent-cyan);
 }
@@ -1077,10 +776,9 @@ body {
    gap: 8px;
    padding: 8px 15px;
    background: var(--bg-panel);
-    border-top: none;
+    border-top: 1px solid rgba(74, 158, 255, 0.3);
    font-size: 11px;
-    overflow-x: auto;
+    overflow: hidden;
    overflow-y: hidden;
 }
 .controls-bar > .control-group {
@@ -1209,15 +907,6 @@ body {
 .control-group.airband-group {
    background: rgba(245, 158, 11, 0.05);
    border-color: rgba(245, 158, 11, 0.2);
    flex: 1 1 auto;
    min-width: 0;
 }
 .control-group.airband-group > .control-group-items {
    display: flex;
    flex-wrap: wrap;
    align-items: center;
    gap: 5px;
 }
 .control-group.airband-group .control-group-label {
@@ -1321,7 +1010,6 @@ body {
 /* Custom scrollbar */
 ::-webkit-scrollbar {
    width: 6px;
    height: 6px;
 }
 ::-webkit-scrollbar-track {
@@ -1333,15 +1021,6 @@ body {
    border-radius: 3px;
 }
 /* Hide scrollbar on controls bar */
 .controls-bar::-webkit-scrollbar {
    display: none;
 }
 .controls-bar {
    scrollbar-width: none;
 }
 /* No aircraft message */
 .no-aircraft {
    text-align: center;
@@ -1610,7 +1289,7 @@ body {
        display: flex !important;
        flex-direction: column !important;
        height: auto !important;
-        min-height: 400px;
+        min-height: calc(100dvh - 160px);
        overflow-y: auto !important;
        overflow-x: hidden;
        -webkit-overflow-scrolling: touch;
@@ -1810,10 +1489,6 @@ body {
    margin-top: 1px;
 }
 .strip-stat.source-stat .strip-value {
    font-size: 14px;
 }
 .strip-stat.session-stat {
    background: rgba(34, 197, 94, 0.05);
    border-color: rgba(34, 197, 94, 0.2);
@@ -2104,9 +1779,6 @@ body {
 .strip-btn {
    position: relative;
    z-index: 10;
    display: inline-flex;
    align-items: center;
    gap: 4px;
    background: rgba(74, 158, 255, 0.1);
    border: 1px solid rgba(74, 158, 255, 0.2);
    color: var(--text-primary);
@@ -2117,12 +1789,6 @@ body {
    cursor: pointer;
    transition: all 0.2s;
    white-space: nowrap;
    text-decoration: none;
 }
 .strip-btn svg {
    flex-shrink: 0;
    opacity: 0.7;
 }
 .strip-btn:hover:not(:disabled) {
@@ -5,8 +5,8 @@
 }
 :root {
-    --font-sans: 'Roboto Condensed', 'Arial Narrow', Roboto, 'Helvetica Neue', Arial, sans-serif;
+    --font-sans: 'IBM Plex Mono', 'Space Mono', ui-monospace, 'SF Mono', 'Consolas', 'Menlo', monospace;
-    --font-mono: 'Roboto Condensed', 'Arial Narrow', Roboto, 'Helvetica Neue', Arial, sans-serif;
+    --font-mono: 'IBM Plex Mono', 'Space Mono', ui-monospace, 'SF Mono', 'Consolas', 'Menlo', monospace;
    --bg-dark: #0b1118;
    --bg-panel: #101823;
    --bg-card: #151f2b;
@@ -8,8 +8,8 @@
 }
 :root {
-    --font-sans: 'Roboto Condensed', 'Arial Narrow', Roboto, 'Helvetica Neue', Arial, sans-serif;
+    --font-sans: 'IBM Plex Mono', 'Space Mono', ui-monospace, 'SF Mono', 'Consolas', 'Menlo', monospace;
-    --font-mono: 'Roboto Condensed', 'Arial Narrow', Roboto, 'Helvetica Neue', Arial, sans-serif;
+    --font-mono: 'IBM Plex Mono', 'Space Mono', ui-monospace, 'SF Mono', 'Consolas', 'Menlo', monospace;
    --bg-dark: #0b1118;
    --bg-panel: #101823;
    --bg-card: #151f2b;
@@ -30,27 +30,6 @@
    --radar-bg: #101823;
 }
 [data-theme="light"] {
    --bg-dark: #f4f7fb;
    --bg-panel: #e9eef5;
    --bg-card: #ffffff;
    --border-color: #d1d9e6;
    --border-glow: #1f5fa8;
    --text-primary: #122034;
    --text-secondary: #3a4a5f;
    --text-dim: #6b7c93;
    --accent-green: #1f8a57;
    --accent-cyan: #1f5fa8;
    --accent-orange: #b5863a;
    --accent-red: #c74444;
    --accent-yellow: #b5863a;
    --accent-amber: #b5863a;
    --grid-line: rgba(31, 95, 168, 0.12);
    --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");
    --radar-cyan: #1f5fa8;
    --radar-bg: #e9eef5;
 }
 body {
    font-family: var(--font-sans);
    background: var(--bg-dark);
@@ -517,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: 'Roboto Condensed', 'Arial Narrow', sans-serif;
+    font-family: 'Orbitron', 'Space Mono', monospace;
    font-size: 11px;
    font-weight: 500;
    letter-spacing: 2px;
@@ -589,7 +568,7 @@ body {
 }
 .vessel-name {
-    font-family: 'Roboto Condensed', 'Arial Narrow', sans-serif;
+    font-family: 'Orbitron', 'Space Mono', monospace;
    font-size: 16px;
    font-weight: 700;
    color: var(--accent-cyan);
@@ -683,7 +662,7 @@ body {
 }
 .vessel-item-name {
-    font-family: 'Roboto Condensed', 'Arial Narrow', sans-serif;
+    font-family: 'Orbitron', 'Space Mono', monospace;
    font-size: 12px;
    font-weight: 600;
    color: var(--accent-cyan);
@@ -1244,7 +1223,7 @@ body {
 }
 .dsc-distress-alert .dsc-alert-header {
-    font-family: 'Roboto Condensed', 'Arial Narrow', sans-serif;
+    font-family: 'Orbitron', 'Space Mono', monospace;
    font-size: 24px;
    font-weight: 700;
    color: var(--accent-red);
@@ -19,17 +19,6 @@
    min-width: max-content;
 }
 /* Strip title badge */
 .function-strip .strip-title {
    font-size: 9px;
    font-weight: 700;
    letter-spacing: 1.5px;
    text-transform: uppercase;
    color: var(--text-muted);
    white-space: nowrap;
    padding: 4px 0;
 }
 /* Stats */
 .function-strip .strip-stat {
    display: flex;
@@ -1,440 +0,0 @@
 /* Shared UX platform components: run-state strip, command palette, setup assistant, and toasts */
 .run-state-strip {
    display: flex;
    align-items: center;
    justify-content: space-between;
    gap: 10px;
    padding: 8px 14px;
    margin: 6px 12px 0;
    border: 1px solid rgba(74, 163, 255, 0.32);
    border-radius: 8px;
    background: linear-gradient(180deg, rgba(19, 30, 44, 0.96), rgba(11, 18, 28, 0.97));
    box-shadow: 0 12px 24px rgba(0, 0, 0, 0.28), inset 0 1px 0 rgba(255, 255, 255, 0.04);
 }
 .run-state-left {
    display: flex;
    align-items: center;
    gap: 8px;
    flex-wrap: wrap;
    min-width: 0;
 }
 #runStateChips {
    display: flex;
    align-items: center;
    gap: 6px;
    flex-wrap: wrap;
 }
 .run-state-label {
    font-size: 10px;
    text-transform: uppercase;
    letter-spacing: 0.06em;
    color: var(--text-dim, #8697aa);
    font-weight: 600;
 }
 .run-state-chip {
    display: inline-flex;
    align-items: center;
    gap: 6px;
    padding: 3px 7px;
    border-radius: 999px;
    border: 1px solid rgba(74, 163, 255, 0.25);
    background: linear-gradient(180deg, rgba(17, 26, 38, 0.82), rgba(12, 18, 28, 0.84));
    font-size: 10px;
    color: var(--text-secondary, #b1c2d4);
    white-space: nowrap;
 }
 .run-state-chip .dot {
    width: 6px;
    height: 6px;
    border-radius: 50%;
    background: #667788;
    box-shadow: 0 0 0 0 rgba(102, 119, 136, 0.45);
 }
 .run-state-chip.running .dot {
    background: var(--accent-green, #28c27a);
    box-shadow: 0 0 0 4px rgba(40, 194, 122, 0.16), 0 0 12px rgba(40, 194, 122, 0.35);
 }
 .run-state-chip.active {
    border-color: rgba(74, 163, 255, 0.65);
    color: var(--text-primary, #e6edf5);
    box-shadow: inset 0 0 0 1px rgba(74, 163, 255, 0.18);
 }
 .run-state-right {
    display: inline-flex;
    align-items: center;
    gap: 8px;
 }
 .run-state-value {
    font-size: 10px;
    color: var(--text-dim, #8697aa);
 }
 .run-state-btn {
    background: linear-gradient(180deg, rgba(17, 27, 41, 0.9), rgba(10, 16, 25, 0.92));
    color: var(--accent-cyan, #4aa3ff);
    border: 1px solid rgba(74, 163, 255, 0.45);
    border-radius: 6px;
    font-size: 10px;
    padding: 4px 8px;
    cursor: pointer;
    transition: background 0.16s ease, border-color 0.16s ease, transform 0.16s ease;
 }
 .run-state-btn:hover {
    background: rgba(74, 163, 255, 0.14);
    border-color: rgba(74, 163, 255, 0.7);
    transform: translateY(-1px);
 }
 .command-palette-overlay {
    position: fixed;
    inset: 0;
    display: none;
    align-items: flex-start;
    justify-content: center;
    padding: 10vh 18px 0;
    z-index: 25000;
    background: rgba(4, 8, 14, 0.65);
    backdrop-filter: blur(3px);
 }
 .command-palette-overlay.open {
    display: flex;
 }
 .command-palette {
    width: min(760px, 100%);
    border: 1px solid rgba(74, 163, 255, 0.32);
    border-radius: 12px;
    background: linear-gradient(180deg, rgba(16, 26, 39, 0.98), rgba(10, 17, 27, 0.98));
    box-shadow: 0 26px 60px rgba(0, 0, 0, 0.56), inset 0 1px 0 rgba(255, 255, 255, 0.04);
    overflow: hidden;
 }
 .command-palette-header {
    display: flex;
    align-items: center;
    gap: 10px;
    padding: 10px 12px;
    border-bottom: 1px solid var(--border-color, #1e2d3d);
 }
 .command-palette-input {
    width: 100%;
    border: none;
    outline: none;
    background: transparent;
    color: var(--text-primary, #e6edf5);
    font-size: 14px;
    padding: 2px 0;
 }
 .command-palette-hint {
    font-size: 10px;
    color: var(--text-dim, #8697aa);
    white-space: nowrap;
 }
 .command-palette-list {
    max-height: min(62vh, 520px);
    overflow-y: auto;
 }
 .command-palette-item {
    width: 100%;
    display: flex;
    align-items: center;
    justify-content: space-between;
    gap: 8px;
    padding: 10px 12px;
    border: none;
    border-bottom: 1px solid rgba(255, 255, 255, 0.04);
    background: transparent;
    color: var(--text-secondary, #b1c2d4);
    cursor: pointer;
    text-align: left;
 }
 .command-palette-item:last-child {
    border-bottom: none;
 }
 .command-palette-item .meta {
    display: flex;
    flex-direction: column;
    gap: 2px;
    min-width: 0;
 }
 .command-palette-item .title {
    color: var(--text-primary, #e6edf5);
    font-size: 12px;
    font-weight: 600;
 }
 .command-palette-item .desc {
    color: var(--text-dim, #8697aa);
    font-size: 10px;
 }
 .command-palette-item .kbd {
    font-size: 9px;
    color: var(--text-dim, #8697aa);
    border: 1px solid rgba(255, 255, 255, 0.15);
    border-radius: 4px;
    padding: 1px 5px;
 }
 .command-palette-item.active,
 .command-palette-item:hover,
 .command-palette-item:focus-visible {
    background: rgba(74, 163, 255, 0.12);
    outline: none;
 }
 .command-palette-empty {
    padding: 22px 16px;
    color: var(--text-dim, #8697aa);
    font-size: 11px;
    text-align: center;
 }
 .setup-overlay {
    position: fixed;
    inset: 0;
    display: none;
    align-items: center;
    justify-content: center;
    z-index: 26000;
    background: rgba(4, 8, 14, 0.72);
    backdrop-filter: blur(4px);
    padding: 14px;
 }
 .setup-overlay.open {
    display: flex;
 }
 .setup-modal {
    width: min(760px, 100%);
    max-height: 84vh;
    overflow-y: auto;
    border: 1px solid var(--border-color, #1e2d3d);
    border-radius: 12px;
    background: #101926;
    box-shadow: 0 20px 50px rgba(0, 0, 0, 0.6);
 }
 .setup-header {
    display: flex;
    align-items: flex-start;
    justify-content: space-between;
    gap: 8px;
    border-bottom: 1px solid var(--border-color, #1e2d3d);
    padding: 14px;
 }
 .setup-title {
    font-size: 16px;
    margin: 0;
    color: var(--text-primary, #e6edf5);
 }
 .setup-subtitle {
    margin: 4px 0 0;
    font-size: 11px;
    color: var(--text-dim, #8697aa);
 }
 .setup-close {
    background: transparent;
    border: none;
    color: var(--text-dim, #8697aa);
    font-size: 22px;
    cursor: pointer;
    line-height: 1;
 }
 .setup-content {
    padding: 14px;
    display: grid;
    gap: 10px;
 }
 .setup-step {
    border: 1px solid var(--border-color, #1e2d3d);
    border-radius: 8px;
    padding: 10px;
    background: rgba(255, 255, 255, 0.02);
 }
 .setup-step-header {
    display: flex;
    justify-content: space-between;
    gap: 8px;
    margin-bottom: 6px;
 }
 .setup-step-title {
    font-size: 12px;
    color: var(--text-primary, #e6edf5);
    font-weight: 600;
 }
 .setup-step-status {
    font-size: 10px;
    color: var(--text-dim, #8697aa);
 }
 .setup-step-status.done {
    color: var(--accent-green, #28c27a);
 }
 .setup-step-desc {
    font-size: 11px;
    color: var(--text-secondary, #b1c2d4);
    margin: 0 0 8px;
 }
 .setup-step-actions {
    display: flex;
    gap: 8px;
    flex-wrap: wrap;
 }
 .setup-btn {
    padding: 6px 10px;
    border-radius: 6px;
    border: 1px solid var(--border-color, #1e2d3d);
    background: var(--bg-tertiary, #121f2d);
    color: var(--text-secondary, #b1c2d4);
    font-size: 11px;
    cursor: pointer;
 }
 .setup-btn.primary {
    color: #fff;
    background: var(--accent-cyan, #4aa3ff);
    border-color: var(--accent-cyan, #4aa3ff);
 }
 .setup-footer {
    padding: 12px 14px;
    border-top: 1px solid var(--border-color, #1e2d3d);
    display: flex;
    justify-content: space-between;
    gap: 8px;
    flex-wrap: wrap;
    align-items: center;
 }
 .setup-footer-note {
    color: var(--text-dim, #8697aa);
    font-size: 10px;
 }
 .app-toast-stack {
    position: fixed;
    right: 14px;
    bottom: 16px;
    z-index: 25500;
    display: flex;
    flex-direction: column;
    gap: 8px;
    max-width: min(380px, calc(100vw - 24px));
 }
 .app-toast {
    border: 1px solid var(--border-color, #1e2d3d);
    border-left: 3px solid var(--accent-cyan, #4aa3ff);
    border-radius: 8px;
    background: rgba(15, 24, 35, 0.97);
    color: var(--text-secondary, #b1c2d4);
    box-shadow: 0 10px 20px rgba(0, 0, 0, 0.35);
    padding: 8px 10px;
    font-size: 11px;
 }
 .app-toast.error {
    border-left-color: var(--accent-red, #e25d5d);
 }
 .app-toast.warning {
    border-left-color: var(--accent-orange, #d6a85e);
 }
 .app-toast-title {
    font-size: 11px;
    color: var(--text-primary, #e6edf5);
    font-weight: 600;
    margin-bottom: 4px;
 }
 .app-toast-msg {
    color: var(--text-secondary, #b1c2d4);
 }
 .app-toast-actions {
    margin-top: 7px;
    display: flex;
    gap: 6px;
    flex-wrap: wrap;
 }
 .app-toast-actions button {
    border: 1px solid var(--border-color, #1e2d3d);
    border-radius: 4px;
    background: var(--bg-tertiary, #132133);
    color: var(--text-secondary, #b1c2d4);
    font-size: 10px;
    padding: 3px 6px;
    cursor: pointer;
 }
 .app-toast-actions button:hover {
    border-color: rgba(74, 163, 255, 0.5);
    color: var(--text-primary, #e6edf5);
 }
@media (max-width: 920px) {
    .run-state-strip {
        flex-direction: column;
        align-items: stretch;
    }
    .run-state-right {
        justify-content: space-between;
    }
 }
@media (max-width: 640px) {
    .command-palette-overlay {
        padding: 8vh 10px 0;
    }
    .command-palette-item {
        padding: 9px 10px;
    }
    .setup-header,
    .setup-content,
    .setup-footer {
        padding: 10px;
    }
    .app-toast-stack {
        left: 10px;
        right: 10px;
        max-width: none;
    }
 }
@@ -28,16 +28,14 @@ body {
    color: var(--text-primary);
    background-color: var(--bg-primary);
    background-image:
        radial-gradient(1200px 620px at 8% -12%, var(--ambient-top-left), transparent 62%),
        radial-gradient(980px 560px at 92% -16%, var(--ambient-top-right), transparent 64%),
        radial-gradient(900px 520px at 50% 126%, var(--ambient-bottom), transparent 68%),
        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: auto, auto, auto, 40px 40px, 48px 48px, 48px 48px;
+    background-size: 40px 40px, auto, auto, 48px 48px, 48px 48px;
    background-attachment: fixed;
    min-height: 100vh;
    font-variant-numeric: tabular-nums;
    -webkit-font-smoothing: antialiased;
    -moz-osx-font-smoothing: grayscale;
 }
@@ -123,12 +123,11 @@
   CARDS / PANELS
   ============================================ */
 .card {
-    background: var(--surface-panel-gradient);
+    background: linear-gradient(180deg, var(--bg-card) 0%, var(--bg-secondary) 100%);
-    border: 1px solid rgba(74, 163, 255, 0.24);
+    border: 1px solid var(--border-color);
    border-radius: var(--radius-lg);
    overflow: hidden;
-    box-shadow: var(--shadow-sm), inset 0 1px 0 rgba(255, 255, 255, 0.04);
+    box-shadow: var(--shadow-sm);
    backdrop-filter: blur(5px);
 }
 .card-header {
@@ -136,8 +135,8 @@
    align-items: center;
    justify-content: space-between;
    padding: var(--space-3) var(--space-4);
-    border-bottom: 1px solid rgba(74, 163, 255, 0.18);
+    border-bottom: 1px solid var(--border-color);
-    background: linear-gradient(180deg, rgba(25, 38, 55, 0.88) 0%, rgba(17, 27, 40, 0.9) 100%);
+    background: var(--bg-secondary);
    position: relative;
 }
@@ -161,12 +160,11 @@
 /* Panel variant (used in dashboards) */
 .panel {
-    background: var(--surface-panel-gradient);
+    background: linear-gradient(180deg, var(--bg-card) 0%, var(--bg-secondary) 100%);
-    border: 1px solid rgba(74, 163, 255, 0.24);
+    border: 1px solid var(--border-color);
    border-radius: var(--radius-lg);
    overflow: hidden;
-    box-shadow: var(--shadow-sm), inset 0 1px 0 rgba(255, 255, 255, 0.04);
+    box-shadow: var(--shadow-sm);
    backdrop-filter: blur(5px);
 }
@supports (clip-path: polygon(0 0)) {
@@ -192,8 +190,8 @@
    align-items: center;
    justify-content: space-between;
    padding: var(--space-2) var(--space-3);
-    border-bottom: 1px solid rgba(74, 163, 255, 0.18);
+    border-bottom: 1px solid var(--border-color);
-    background: linear-gradient(180deg, rgba(25, 38, 55, 0.88) 0%, rgba(17, 27, 40, 0.9) 100%);
+    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;
@@ -724,20 +722,7 @@
 .card:hover,
 .panel:hover {
-    border-color: var(--border-glow);
+    border-color: var(--border-light);
    box-shadow: var(--shadow-md), var(--shadow-glow), inset 0 1px 0 rgba(255, 255, 255, 0.06);
    transform: translateY(-1px);
 }
 [data-theme="light"] .card,
 [data-theme="light"] .panel {
    border-color: rgba(31, 95, 168, 0.24);
 }
 [data-theme="light"] .card-header,
 [data-theme="light"] .panel-header {
    border-bottom-color: rgba(31, 95, 168, 0.2);
    background: linear-gradient(180deg, rgba(243, 247, 252, 0.96) 0%, rgba(233, 239, 247, 0.95) 100%);
 }
 /* Stats strip value highlight on hover */
@@ -16,11 +16,6 @@
    --bg-card: #121a25;
    --bg-elevated: #1b2734;
    --bg-overlay: rgba(8, 13, 20, 0.75);
    --surface-glass: rgba(16, 25, 37, 0.82);
    --surface-panel-gradient: linear-gradient(160deg, rgba(20, 32, 47, 0.94) 0%, rgba(11, 18, 27, 0.96) 100%);
    --ambient-top-left: rgba(74, 163, 255, 0.14);
    --ambient-top-right: rgba(56, 193, 128, 0.09);
    --ambient-bottom: rgba(214, 168, 94, 0.06);
    /* Background aliases for components */
    --bg-dark: var(--bg-primary);
@@ -83,8 +78,8 @@
    /* ============================================
       TYPOGRAPHY
       ============================================ */
-    --font-sans: 'Roboto Condensed', 'Arial Narrow', Roboto, 'Helvetica Neue', Arial, sans-serif;
+    --font-sans: 'IBM Plex Mono', 'Space Mono', ui-monospace, 'SF Mono', 'Consolas', 'Menlo', monospace;
-    --font-mono: 'Roboto Condensed', 'Arial Narrow', Roboto, 'Helvetica Neue', Arial, sans-serif;
+    --font-mono: 'IBM Plex Mono', 'Space Mono', ui-monospace, 'SF Mono', 'Consolas', 'Menlo', monospace;
    /* Font sizes */
    --text-xs: 10px;
@@ -163,11 +158,6 @@
    --bg-card: #ffffff;
    --bg-elevated: #f1f4f9;
    --bg-overlay: rgba(244, 247, 251, 0.92);
    --surface-glass: rgba(255, 255, 255, 0.84);
    --surface-panel-gradient: linear-gradient(160deg, rgba(255, 255, 255, 0.96) 0%, rgba(241, 245, 251, 0.97) 100%);
    --ambient-top-left: rgba(31, 95, 168, 0.1);
    --ambient-top-right: rgba(31, 138, 87, 0.06);
    --ambient-bottom: rgba(181, 134, 58, 0.05);
    /* Background aliases for components */
    --bg-dark: var(--bg-primary);
@@ -1,20 +1,18 @@
 /* Local font declarations for offline mode */
 /* Roboto Condensed - variable font, one file covers all weights */
 /* Space Mono - Console font */
@font-face {
-    font-family: 'Roboto Condensed';
+    font-family: 'Space Mono';
    font-style: normal;
-    font-weight: 300 700;
+    font-weight: 400;
    font-display: swap;
-    src: url('/static/vendor/fonts/RobotoCondensed-Latin.woff2') format('woff2');
+    src: url('/static/vendor/fonts/SpaceMono-Regular.woff2') format('woff2');
    unicode-range: U+0000-00FF, U+0131, U+0152-0153, U+02BB-02BC, U+02C6, U+02DA, U+02DC, U+0304, U+0308, U+0329, U+2000-206F, U+20AC, U+2122, U+2191, U+2193, U+2212, U+2215, U+FEFF, U+FFFD;
 }
@font-face {
-    font-family: 'Roboto Condensed';
+    font-family: 'Space Mono';
    font-style: normal;
-    font-weight: 300 700;
+    font-weight: 700;
    font-display: swap;
-    src: url('/static/vendor/fonts/RobotoCondensed-LatinExt.woff2') format('woff2');
+    src: url('/static/vendor/fonts/SpaceMono-Bold.woff2') format('woff2');
    unicode-range: U+0100-02BA, U+02BD-02C5, U+02C7-02CC, U+02CE-02D7, U+02DD-02FF, U+0304, U+0308, U+0329, U+1D00-1DBF, U+1E00-1E9F, U+1EF2-1EFF, U+2020, U+20A0-20AB, U+20AD-20C0, U+2113, U+2C60-2C7F, U+A720-A7FF;
 }
@@ -30,7 +30,7 @@
    border-bottom: 1px solid var(--border-color, #202833);
    padding: 0 20px;
    position: relative;
-    z-index: 1100;
+    z-index: 100;
    backdrop-filter: blur(10px);
 }
@@ -434,6 +434,6 @@ a.nav-dashboard-btn:hover {
 }
 .nav-dashboard-btn .nav-label {
-    font-family: var(--font-mono, 'Roboto Condensed', 'Arial Narrow', sans-serif);
+    font-family: var(--font-mono, 'JetBrains Mono', monospace);
    letter-spacing: 0.5px;
 }
@@ -14,7 +14,6 @@
    z-index: 10000;
    overflow-y: auto;
    padding: 40px 20px;
    font-family: var(--font-mono, 'Roboto Condensed', 'Arial Narrow', sans-serif);
 }
 .help-modal.active {
@@ -27,41 +26,37 @@
    background: var(--bg-card, var(--bg-secondary, #0f1218));
    border: 1px solid var(--border-color, #1f2937);
    border-radius: 8px;
-    padding: 24px;
+    padding: 30px;
    position: relative;
 }
 .help-content h2 {
    color: var(--accent-cyan, #4a9eff);
-    margin-bottom: 16px;
+    margin-bottom: 20px;
-    font-size: 15px;
+    font-size: 24px;
    letter-spacing: 2px;
    text-transform: uppercase;
    font-weight: 600;
 }
 .help-content h3 {
    color: var(--text-primary, #e8eaed);
-    margin: 20px 0 10px 0;
+    margin: 25px 0 15px 0;
-    font-size: 11px;
+    font-size: 14px;
    text-transform: uppercase;
    letter-spacing: 1px;
    border-bottom: 1px solid var(--border-color, #1f2937);
-    padding-bottom: 6px;
+    padding-bottom: 8px;
    font-weight: 600;
 }
 .help-close {
    position: absolute;
-    top: 12px;
+    top: 15px;
-    right: 12px;
+    right: 15px;
    background: none;
    border: none;
    color: var(--text-dim, #4b5563);
-    font-size: 20px;
+    font-size: 24px;
    cursor: pointer;
    transition: color 0.2s;
    line-height: 1;
 }
 .help-close:hover {
@@ -71,54 +66,43 @@
 .help-modal .icon-grid {
    display: grid;
    grid-template-columns: repeat(auto-fill, minmax(200px, 1fr));
-    gap: 8px;
+    gap: 12px;
-    margin: 10px 0;
+    margin: 15px 0;
 }
 .help-modal .icon-item {
    display: flex;
    align-items: center;
-    gap: 8px;
+    gap: 10px;
-    padding: 6px 8px;
+    padding: 10px;
    background: var(--bg-primary, #0a0c10);
    border: 1px solid var(--border-color, #1f2937);
    border-radius: 4px;
-    font-size: 11px;
+    font-size: 12px;
 }
 .help-modal .icon-item .icon {
-    width: 20px;
+    font-size: 18px;
-    height: 20px;
+    width: 30px;
-    flex-shrink: 0;
+    text-align: center;
    display: flex;
    align-items: center;
    justify-content: center;
 }
 .help-modal .icon-item .icon svg {
    width: 16px;
    height: 16px;
 }
 .help-modal .icon-item .desc {
    color: var(--text-secondary, #9ca3af);
    font-size: 10.5px;
    line-height: 1.3;
 }
 .help-modal .tip-list {
    list-style: none;
    padding: 0;
-    margin: 10px 0;
+    margin: 15px 0;
 }
 .help-modal .tip-list li {
-    padding: 5px 0;
+    padding: 8px 0;
-    padding-left: 16px;
+    padding-left: 20px;
    position: relative;
    color: var(--text-secondary, #9ca3af);
-    font-size: 11px;
+    font-size: 13px;
    line-height: 1.5;
    border-bottom: 1px solid var(--border-color, #1f2937);
 }
@@ -134,15 +118,10 @@
    font-weight: bold;
 }
 .help-modal .tip-list li strong {
    color: var(--text-primary, #e8eaed);
    font-weight: 600;
 }
 .help-tabs {
    display: flex;
    gap: 0;
-    margin-bottom: 16px;
+    margin-bottom: 20px;
    border: 1px solid var(--border-color, #1f2937);
    border-radius: 4px;
    overflow: hidden;
@@ -150,13 +129,12 @@
 .help-tab {
    flex: 1;
-    padding: 8px;
+    padding: 10px;
    background: var(--bg-primary, #0a0c10);
    border: none;
    color: var(--text-secondary, #9ca3af);
    cursor: pointer;
-    font-family: var(--font-mono, 'Roboto Condensed', 'Arial Narrow', sans-serif);
+    font-size: 11px;
    font-size: 10px;
    text-transform: uppercase;
    letter-spacing: 1px;
    transition: all 0.15s ease;
@@ -198,9 +176,9 @@
 /* Ensure code tags are styled */
 .help-modal code {
    background: var(--bg-tertiary, #151a23);
-    padding: 1px 5px;
+    padding: 2px 6px;
    border-radius: 3px;
-    font-family: var(--font-mono, 'Roboto Condensed', 'Arial Narrow', sans-serif);
+    font-family: var(--font-mono, 'JetBrains Mono', monospace);
-    font-size: 10.5px;
+    font-size: 11px;
    color: var(--accent-cyan, #4a9eff);
 }
@@ -1,500 +0,0 @@
 /* Analytics Dashboard Styles */
 /* Analytics is a sidebar-only mode — hide the output panel and expand the sidebar */
@media (min-width: 1024px) {
    .main-content.analytics-active {
        grid-template-columns: 1fr !important;
    }
    .main-content.analytics-active > .output-panel {
        display: none !important;
    }
    .main-content.analytics-active > .sidebar {
        max-width: 100% !important;
        width: 100% !important;
    }
    .main-content.analytics-active .sidebar-collapse-btn {
        display: none !important;
    }
 }
@media (max-width: 1023px) {
    .main-content.analytics-active > .output-panel {
        display: none !important;
    }
 }
 .analytics-grid {
    display: grid;
    grid-template-columns: repeat(auto-fill, minmax(140px, 1fr));
    gap: var(--space-3, 12px);
    margin-bottom: var(--space-4, 16px);
 }
 .analytics-insight-grid {
    display: grid;
    grid-template-columns: repeat(auto-fill, minmax(210px, 1fr));
    gap: var(--space-3, 12px);
 }
 .analytics-insight-card {
    background: var(--bg-card, #151f2b);
    border: 1px solid var(--border-color, #1e2d3d);
    border-radius: var(--radius-md, 8px);
    padding: 10px;
    display: flex;
    flex-direction: column;
    gap: 4px;
 }
 .analytics-insight-card.low {
    border-color: rgba(90, 106, 122, 0.5);
 }
 .analytics-insight-card.medium {
    border-color: rgba(74, 163, 255, 0.45);
 }
 .analytics-insight-card.high {
    border-color: rgba(214, 168, 94, 0.55);
 }
 .analytics-insight-card.critical {
    border-color: rgba(226, 93, 93, 0.65);
 }
 .analytics-insight-card .insight-title {
    font-size: 10px;
    text-transform: uppercase;
    letter-spacing: 0.04em;
    color: var(--text-dim, #5a6a7a);
 }
 .analytics-insight-card .insight-value {
    font-size: 16px;
    font-weight: 700;
    color: var(--text-primary, #e0e6ed);
    line-height: 1.2;
 }
 .analytics-insight-card .insight-label {
    font-size: 10px;
    color: var(--text-secondary, #9aabba);
 }
 .analytics-insight-card .insight-detail {
    font-size: 10px;
    color: var(--text-dim, #5a6a7a);
 }
 .analytics-top-changes {
    margin-top: 12px;
 }
 .analytics-change-row {
    display: flex;
    align-items: center;
    gap: 10px;
    padding: 7px 0;
    border-bottom: 1px solid var(--border-color, #1e2d3d);
    font-size: 10px;
 }
 .analytics-change-row:last-child {
    border-bottom: none;
 }
 .analytics-change-row .mode {
    min-width: 84px;
    color: var(--text-primary, #e0e6ed);
    font-weight: 600;
 }
 .analytics-change-row .delta {
    min-width: 48px;
    font-family: var(--font-mono, monospace);
 }
 .analytics-change-row .delta.up {
    color: var(--accent-green, #38c180);
 }
 .analytics-change-row .delta.down {
    color: var(--accent-red, #e25d5d);
 }
 .analytics-change-row .delta.flat {
    color: var(--text-dim, #5a6a7a);
 }
 .analytics-change-row .avg {
    color: var(--text-dim, #5a6a7a);
 }
 .analytics-card {
    background: var(--bg-card, #151f2b);
    border: 1px solid var(--border-color, #1e2d3d);
    border-radius: var(--radius-md, 8px);
    padding: var(--space-3, 12px);
    text-align: center;
    transition: var(--transition-fast, 150ms ease);
 }
 .analytics-card:hover {
    border-color: var(--accent-cyan, #4aa3ff);
 }
 .analytics-card .card-count {
    font-size: var(--text-2xl, 24px);
    font-weight: 700;
    color: var(--text-primary, #e0e6ed);
    line-height: 1.2;
 }
 .analytics-card .card-label {
    font-size: var(--text-xs, 10px);
    color: var(--text-dim, #5a6a7a);
    text-transform: uppercase;
    letter-spacing: 0.05em;
    margin-top: var(--space-1, 4px);
 }
 .analytics-card .card-sparkline {
    height: 24px;
    margin-top: var(--space-2, 8px);
 }
 .analytics-card .card-sparkline svg {
    width: 100%;
    height: 100%;
 }
 .analytics-card .card-sparkline polyline {
    fill: none;
    stroke: var(--accent-cyan, #4aa3ff);
    stroke-width: 1.5;
    stroke-linecap: round;
    stroke-linejoin: round;
 }
 /* Health indicators */
 .analytics-health {
    display: flex;
    flex-wrap: wrap;
    gap: var(--space-2, 8px);
    margin-bottom: var(--space-4, 16px);
 }
 .health-item {
    display: flex;
    align-items: center;
    gap: var(--space-1, 4px);
    font-size: var(--text-xs, 10px);
    color: var(--text-dim, #5a6a7a);
    text-transform: uppercase;
 }
 .health-dot {
    width: 6px;
    height: 6px;
    border-radius: 50%;
    background: var(--accent-red, #e25d5d);
 }
 .health-dot.running {
    background: var(--accent-green, #38c180);
 }
 /* Emergency squawk panel */
 .squawk-emergency {
    background: rgba(226, 93, 93, 0.1);
    border: 1px solid var(--accent-red, #e25d5d);
    border-radius: var(--radius-md, 8px);
    padding: var(--space-3, 12px);
    margin-bottom: var(--space-3, 12px);
 }
 .squawk-emergency .squawk-title {
    color: var(--accent-red, #e25d5d);
    font-weight: 700;
    font-size: var(--text-sm, 12px);
    text-transform: uppercase;
    margin-bottom: var(--space-2, 8px);
 }
 .squawk-emergency .squawk-item {
    font-size: var(--text-sm, 12px);
    color: var(--text-primary, #e0e6ed);
    padding: var(--space-1, 4px) 0;
    border-bottom: 1px solid rgba(226, 93, 93, 0.2);
 }
 .squawk-emergency .squawk-item:last-child {
    border-bottom: none;
 }
 /* Alert feed */
 .analytics-alert-feed {
    max-height: 200px;
    overflow-y: auto;
    margin-bottom: var(--space-4, 16px);
 }
 .analytics-alert-item {
    display: flex;
    align-items: flex-start;
    gap: var(--space-2, 8px);
    padding: var(--space-2, 8px);
    border-bottom: 1px solid var(--border-color, #1e2d3d);
    font-size: var(--text-xs, 10px);
 }
 .analytics-alert-item .alert-severity {
    padding: 1px 6px;
    border-radius: var(--radius-sm, 4px);
    font-weight: 600;
    text-transform: uppercase;
    font-size: 9px;
    white-space: nowrap;
 }
 .alert-severity.critical { background: var(--accent-red, #e25d5d); color: #fff; }
 .alert-severity.high { background: var(--accent-orange, #d6a85e); color: #000; }
 .alert-severity.medium { background: var(--accent-cyan, #4aa3ff); color: #fff; }
 .alert-severity.low { background: var(--border-color, #1e2d3d); color: var(--text-dim, #5a6a7a); }
 /* Correlation panel */
 .analytics-correlation-pair {
    display: flex;
    align-items: center;
    gap: var(--space-2, 8px);
    padding: var(--space-2, 8px);
    border-bottom: 1px solid var(--border-color, #1e2d3d);
    font-size: var(--text-xs, 10px);
 }
 .analytics-correlation-pair .confidence-bar {
    height: 4px;
    background: var(--bg-secondary, #101823);
    border-radius: 2px;
    flex: 1;
    max-width: 60px;
 }
 .analytics-correlation-pair .confidence-fill {
    height: 100%;
    background: var(--accent-green, #38c180);
    border-radius: 2px;
 }
 .analytics-pattern-item {
    padding: 8px;
    border-bottom: 1px solid var(--border-color, #1e2d3d);
    display: flex;
    flex-direction: column;
    gap: 4px;
 }
 .analytics-pattern-item:last-child {
    border-bottom: none;
 }
 .analytics-pattern-item .pattern-main {
    display: flex;
    justify-content: space-between;
    align-items: center;
    gap: 8px;
 }
 .analytics-pattern-item .pattern-mode {
    font-size: 10px;
    font-weight: 600;
    color: var(--text-primary, #e0e6ed);
    text-transform: uppercase;
    letter-spacing: 0.04em;
 }
 .analytics-pattern-item .pattern-device {
    font-size: 10px;
    color: var(--text-dim, #5a6a7a);
    font-family: var(--font-mono, monospace);
 }
 .analytics-pattern-item .pattern-meta {
    display: flex;
    gap: 10px;
    font-size: 10px;
    color: var(--text-dim, #5a6a7a);
    flex-wrap: wrap;
 }
 .analytics-pattern-item .pattern-confidence {
    color: var(--accent-green, #38c180);
    font-weight: 600;
 }
 /* Geofence zone list */
 .geofence-zone-item {
    display: flex;
    align-items: center;
    justify-content: space-between;
    padding: var(--space-2, 8px);
    border-bottom: 1px solid var(--border-color, #1e2d3d);
    font-size: var(--text-xs, 10px);
 }
 .geofence-zone-item .zone-name {
    font-weight: 600;
    color: var(--text-primary, #e0e6ed);
 }
 .geofence-zone-item .zone-radius {
    color: var(--text-dim, #5a6a7a);
 }
 .geofence-zone-item .zone-delete {
    cursor: pointer;
    color: var(--accent-red, #e25d5d);
    padding: 2px 6px;
    border: 1px solid var(--accent-red, #e25d5d);
    border-radius: var(--radius-sm, 4px);
    background: transparent;
    font-size: 9px;
 }
 /* Export controls */
 .export-controls {
    display: flex;
    gap: var(--space-2, 8px);
    align-items: center;
    flex-wrap: wrap;
 }
 .export-controls select,
 .export-controls button {
    font-size: var(--text-xs, 10px);
    padding: var(--space-1, 4px) var(--space-2, 8px);
    background: var(--bg-card, #151f2b);
    color: var(--text-primary, #e0e6ed);
    border: 1px solid var(--border-color, #1e2d3d);
    border-radius: var(--radius-sm, 4px);
 }
 .export-controls button {
    cursor: pointer;
    background: var(--accent-cyan, #4aa3ff);
    color: #fff;
    border-color: var(--accent-cyan, #4aa3ff);
 }
 .export-controls button:hover {
    opacity: 0.9;
 }
 /* Section headers */
 .analytics-section-header {
    font-size: var(--text-xs, 10px);
    font-weight: 600;
    color: var(--text-dim, #5a6a7a);
    text-transform: uppercase;
    letter-spacing: 0.05em;
    margin-bottom: var(--space-2, 8px);
    padding-bottom: var(--space-1, 4px);
    border-bottom: 1px solid var(--border-color, #1e2d3d);
 }
 /* Empty state */
 .analytics-empty {
    text-align: center;
    color: var(--text-dim, #5a6a7a);
    font-size: var(--text-xs, 10px);
    padding: var(--space-4, 16px);
    font-style: italic;
 }
 .analytics-target-toolbar,
 .analytics-replay-toolbar {
    display: flex;
    gap: 8px;
    flex-wrap: wrap;
    align-items: center;
    margin-bottom: 10px;
 }
 .analytics-target-toolbar input {
    flex: 1;
    min-width: 220px;
    background: var(--bg-card, #151f2b);
    color: var(--text-primary, #e0e6ed);
    border: 1px solid var(--border-color, #1e2d3d);
    border-radius: 4px;
    padding: 6px 8px;
    font-size: 11px;
 }
 .analytics-target-toolbar button,
 .analytics-replay-toolbar button,
 .analytics-replay-toolbar select {
    font-size: 10px;
    padding: 5px 9px;
    border-radius: 4px;
    border: 1px solid var(--border-color, #1e2d3d);
    background: var(--bg-card, #151f2b);
    color: var(--text-primary, #e0e6ed);
 }
 .analytics-target-toolbar button,
 .analytics-replay-toolbar button {
    cursor: pointer;
    background: rgba(74, 163, 255, 0.2);
    border-color: rgba(74, 163, 255, 0.45);
 }
 .analytics-target-summary {
    font-size: 10px;
    color: var(--text-dim, #5a6a7a);
    margin-bottom: 8px;
 }
 .analytics-target-item,
 .analytics-replay-item {
    border-bottom: 1px solid var(--border-color, #1e2d3d);
    padding: 7px 0;
    display: grid;
    gap: 4px;
 }
 .analytics-target-item:last-child,
 .analytics-replay-item:last-child {
    border-bottom: none;
 }
 .analytics-target-item .title,
 .analytics-replay-item .title {
    display: flex;
    align-items: center;
    gap: 8px;
    flex-wrap: wrap;
    font-size: 11px;
    color: var(--text-primary, #e0e6ed);
    font-weight: 600;
 }
 .analytics-target-item .mode,
 .analytics-replay-item .mode {
    font-size: 9px;
    text-transform: uppercase;
    letter-spacing: 0.05em;
    border: 1px solid rgba(74, 163, 255, 0.35);
    color: var(--accent-cyan, #4aa3ff);
    border-radius: 4px;
    padding: 1px 6px;
 }
 .analytics-target-item .meta,
 .analytics-replay-item .meta {
    font-size: 10px;
    color: var(--text-dim, #5a6a7a);
    display: flex;
    gap: 10px;
    flex-wrap: wrap;
 }
@@ -326,50 +326,3 @@
 .aprs-meter-status.no-signal {
    color: var(--accent-yellow);
 }
 /* APRS map markers (flat SVG icons) */
 .aprs-map-marker-wrap {
    background: transparent;
    border: none;
 }
 .aprs-map-marker {
    display: inline-flex;
    align-items: center;
    gap: 5px;
    padding: 2px 7px 2px 5px;
    border-radius: 999px;
    border: 1px solid rgba(74, 158, 255, 0.35);
    background: rgba(10, 18, 28, 0.88);
    color: var(--text-primary);
    box-shadow: 0 2px 6px rgba(0, 0, 0, 0.35);
 }
 .aprs-map-marker-icon {
    display: inline-flex;
    width: 14px;
    height: 14px;
    color: var(--accent-cyan);
 }
 .aprs-map-marker-icon svg {
    width: 14px;
    height: 14px;
    display: block;
    fill: currentColor;
 }
 .aprs-map-marker-label {
    font-size: 9px;
    font-weight: 600;
    line-height: 1;
    letter-spacing: 0.02em;
 }
 .aprs-map-marker.vehicle .aprs-map-marker-icon {
    color: var(--accent-green);
 }
 .aprs-map-marker.tower .aprs-map-marker-icon {
    color: var(--accent-cyan);
 }
@@ -1,560 +0,0 @@
 /* BT Locate Mode Styles */
 /* Environment preset grid */
 .btl-env-grid {
    display: grid;
    grid-template-columns: 1fr 1fr 1fr;
    gap: 6px;
 }
 .btl-env-btn {
    display: flex;
    flex-direction: column;
    align-items: center;
    gap: 2px;
    padding: 8px 4px;
    background: rgba(255, 255, 255, 0.03);
    border: 1px solid rgba(255, 255, 255, 0.1);
    border-radius: 6px;
    cursor: pointer;
    transition: all 0.2s;
    color: var(--text-secondary);
 }
 .btl-env-btn:hover {
    background: rgba(255, 255, 255, 0.06);
    border-color: rgba(255, 255, 255, 0.2);
 }
 .btl-env-btn.active {
    background: rgba(0, 255, 136, 0.1);
    border-color: var(--accent-green, #00ff88);
    color: var(--text-primary);
 }
 .btl-env-icon {
    font-size: 18px;
    line-height: 1;
 }
 .btl-env-label {
    font-size: 10px;
    font-weight: 600;
    text-transform: uppercase;
 }
 .btl-env-n {
    font-size: 9px;
    font-family: var(--font-mono);
    color: var(--text-dim);
 }
 /* ============================================
   PROXIMITY HUD — main visuals area
   ============================================ */
 .btl-hud {
    display: flex;
    flex-direction: column;
    gap: 0;
    background: rgba(0, 0, 0, 0.5);
    border: 1px solid rgba(255, 255, 255, 0.08);
    border-radius: 8px;
    flex-shrink: 0;
    overflow: hidden;
 }
 .btl-hud-top {
    display: flex;
    align-items: center;
    gap: 20px;
    padding: 14px 20px;
 }
 .btl-hud-band {
    font-size: 22px;
    font-weight: 800;
    font-family: var(--font-mono);
    letter-spacing: 2px;
    padding: 14px 20px;
    border-radius: 8px;
    background: rgba(255, 255, 255, 0.03);
    border: 2px solid rgba(255, 255, 255, 0.1);
    color: var(--text-dim);
    text-align: center;
    min-width: 130px;
    transition: all 0.3s;
    flex-shrink: 0;
 }
 .btl-hud-band.immediate {
    color: #ef4444;
    border-color: #ef4444;
    background: rgba(239, 68, 68, 0.15);
    box-shadow: 0 0 20px rgba(239, 68, 68, 0.2);
    animation: btl-pulse 1s ease-in-out infinite;
 }
 .btl-hud-band.near {
    color: #f97316;
    border-color: #f97316;
    background: rgba(249, 115, 22, 0.12);
    box-shadow: 0 0 15px rgba(249, 115, 22, 0.15);
    animation: btl-pulse 2s ease-in-out infinite;
 }
 .btl-hud-band.far {
    color: #eab308;
    border-color: #eab308;
    background: rgba(234, 179, 8, 0.1);
    box-shadow: 0 0 10px rgba(234, 179, 8, 0.1);
 }
@keyframes btl-pulse {
    0%, 100% { opacity: 1; }
    50% { opacity: 0.6; }
 }
 .btl-hud-metrics {
    display: flex;
    gap: 20px;
    flex: 1;
    align-items: flex-start;
 }
 .btl-hud-separator {
    width: 1px;
    height: 40px;
    background: rgba(255, 255, 255, 0.08);
    align-self: center;
    flex-shrink: 0;
 }
 .btl-hud-metric {
    display: flex;
    flex-direction: column;
    align-items: center;
    min-width: 60px;
 }
 .btl-hud-metric-lg .btl-hud-value {
    font-size: 28px;
 }
 .btl-hud-value {
    font-size: 22px;
    font-weight: 700;
    font-family: var(--font-mono);
    color: var(--text-primary);
    line-height: 1.1;
 }
 .btl-hud-unit {
    font-size: 10px;
    color: var(--text-dim);
    font-family: var(--font-mono);
 }
 .btl-hud-label {
    font-size: 9px;
    color: var(--text-dim);
    text-transform: uppercase;
    letter-spacing: 0.5px;
    margin-top: 2px;
 }
 .btl-hud-controls {
    display: flex;
    flex-direction: column;
    gap: 6px;
    flex-shrink: 0;
 }
 .btl-hud-export-row {
    display: flex;
    gap: 5px;
    align-items: center;
 }
 .btl-hud-export-format {
    min-width: 62px;
    padding: 3px 6px;
    font-size: 10px;
    font-family: var(--font-mono);
    color: var(--text-secondary);
    background: rgba(0, 0, 0, 0.45);
    border: 1px solid rgba(255, 255, 255, 0.12);
    border-radius: 4px;
 }
 .btl-hud-audio-toggle {
    display: flex;
    align-items: center;
    gap: 5px;
    font-size: 11px;
    color: var(--text-secondary);
    cursor: pointer;
    white-space: nowrap;
 }
 .btl-hud-audio-toggle input[type="checkbox"] {
    margin: 0;
 }
 .btl-hud-clear-btn {
    padding: 4px 10px;
    font-size: 10px;
    background: rgba(255, 255, 255, 0.05);
    border: 1px solid rgba(255, 255, 255, 0.1);
    border-radius: 4px;
    color: var(--text-dim);
    cursor: pointer;
    transition: all 0.2s;
 }
 .btl-hud-clear-btn:hover {
    background: rgba(255, 255, 255, 0.1);
    color: var(--text-secondary);
 }
 /* Bottom info bar */
 .btl-hud-bottom {
    display: flex;
    justify-content: space-between;
    align-items: center;
    padding: 6px 20px;
    background: rgba(0, 0, 0, 0.3);
    border-top: 1px solid rgba(255, 255, 255, 0.05);
 }
 .btl-hud-info {
    display: flex;
    align-items: center;
    gap: 6px;
    flex-wrap: wrap;
 }
 .btl-hud-info-item {
    font-size: 10px;
    font-family: var(--font-mono);
    color: var(--text-dim);
 }
 .btl-hud-info-sep {
    color: rgba(255, 255, 255, 0.15);
    font-size: 10px;
 }
 .btl-hud-diag {
    display: none;
    font-size: 9px;
    color: var(--text-dim);
    font-family: var(--font-mono);
    opacity: 0.5;
    white-space: nowrap;
 }
 .btl-hud-diag:not(:empty) {
    display: block;
 }
 /* ============================================
   VISUALS AREA — map + chart
   ============================================ */
 .btl-visuals-container {
    display: flex;
    flex-direction: column;
    gap: 8px;
    height: 100%;
    padding: 8px;
 }
 .btl-map-container {
    flex: 1;
    min-height: 250px;
    position: relative;
    border-radius: 8px;
    overflow: hidden;
    border: 1px solid rgba(255, 255, 255, 0.1);
 }
 #btLocateMap {
    width: 100%;
    height: 100%;
    background: #1a1a2e;
 }
 .btl-map-overlay-controls {
    position: absolute;
    top: 10px;
    right: 10px;
    z-index: 450;
    display: flex;
    flex-direction: column;
    gap: 4px;
    padding: 7px 8px;
    border-radius: 7px;
    background: rgba(0, 0, 0, 0.6);
    border: 1px solid rgba(255, 255, 255, 0.15);
    backdrop-filter: blur(4px);
 }
 .btl-map-overlay-toggle {
    display: flex;
    align-items: center;
    gap: 5px;
    font-size: 10px;
    color: var(--text-secondary);
    font-family: var(--font-mono);
    cursor: pointer;
    white-space: nowrap;
 }
 .btl-map-overlay-toggle input[type="checkbox"] {
    margin: 0;
 }
 .btl-map-overlay-toggle input[type="checkbox"]:disabled + span {
    opacity: 0.45;
 }
 .btl-map-heat-legend {
    position: absolute;
    left: 10px;
    bottom: 10px;
    z-index: 430;
    min-width: 120px;
    padding: 6px 8px;
    border-radius: 7px;
    background: rgba(0, 0, 0, 0.6);
    border: 1px solid rgba(255, 255, 255, 0.14);
    backdrop-filter: blur(4px);
 }
 .btl-map-heat-label {
    display: block;
    font-size: 9px;
    color: var(--text-dim);
    text-transform: uppercase;
    letter-spacing: 0.7px;
    margin-bottom: 4px;
 }
 .btl-map-heat-bar {
    height: 7px;
    border-radius: 4px;
    background: linear-gradient(90deg, #2563eb 0%, #16a34a 40%, #f59e0b 70%, #ef4444 100%);
    border: 1px solid rgba(255, 255, 255, 0.15);
 }
 .btl-map-heat-scale {
    display: flex;
    justify-content: space-between;
    margin-top: 3px;
    font-size: 8px;
    color: var(--text-dim);
    text-transform: uppercase;
    letter-spacing: 0.5px;
 }
 .btl-map-track-stats {
    position: absolute;
    right: 10px;
    bottom: 10px;
    z-index: 430;
    padding: 5px 8px;
    border-radius: 7px;
    background: rgba(0, 0, 0, 0.6);
    border: 1px solid rgba(255, 255, 255, 0.14);
    color: var(--text-secondary);
    font-size: 10px;
    font-family: var(--font-mono);
    backdrop-filter: blur(4px);
 }
 .btl-rssi-chart-container {
    height: 100px;
    background: rgba(0, 0, 0, 0.3);
    border-radius: 8px;
    border: 1px solid rgba(255, 255, 255, 0.1);
    padding: 8px;
    position: relative;
    flex-shrink: 0;
 }
 .btl-rssi-chart-container .btl-chart-label {
    position: absolute;
    top: 4px;
    left: 8px;
    font-size: 9px;
    color: var(--text-dim);
    text-transform: uppercase;
    letter-spacing: 1px;
 }
 #btLocateRssiChart {
    width: 100%;
    height: 100%;
 }
 /* ============================================
   LOCATE BUTTON — Bluetooth device cards
   ============================================ */
 .bt-locate-btn {
    display: inline-flex;
    align-items: center;
    gap: 4px;
    padding: 3px 8px;
    font-size: 10px;
    font-weight: 600;
    text-transform: uppercase;
    letter-spacing: 0.5px;
    color: var(--accent-green, #00ff88);
    background: rgba(0, 255, 136, 0.1);
    border: 1px solid rgba(0, 255, 136, 0.3);
    border-radius: 3px;
    cursor: pointer;
    transition: all 0.2s;
 }
 .bt-locate-btn:hover {
    background: rgba(0, 255, 136, 0.2);
    border-color: var(--accent-green, #00ff88);
 }
 .bt-locate-btn svg {
    width: 10px;
    height: 10px;
 }
 /* ============================================
   IRK DETECT BUTTON + DEVICE PICKER
   ============================================ */
 .btl-detect-irk-btn {
    padding: 5px 10px;
    font-size: 10px;
    font-weight: 600;
    text-transform: uppercase;
    letter-spacing: 0.5px;
    color: var(--accent-cyan, #00d4ff);
    background: rgba(0, 212, 255, 0.1);
    border: 1px solid rgba(0, 212, 255, 0.3);
    border-radius: 4px;
    cursor: pointer;
    transition: all 0.2s;
    white-space: nowrap;
    flex-shrink: 0;
 }
 .btl-detect-irk-btn:hover {
    background: rgba(0, 212, 255, 0.2);
    border-color: var(--accent-cyan, #00d4ff);
 }
 .btl-detect-irk-btn:disabled {
    opacity: 0.5;
    cursor: wait;
 }
 .btl-irk-picker {
    margin-top: 6px;
    background: rgba(0, 0, 0, 0.3);
    border: 1px solid rgba(255, 255, 255, 0.1);
    border-radius: 6px;
    overflow: hidden;
 }
 .btl-irk-picker-status {
    padding: 8px 10px;
    font-size: 10px;
    color: var(--text-dim);
    text-align: center;
 }
 .btl-irk-picker-list {
    max-height: 160px;
    overflow-y: auto;
 }
 .btl-irk-picker-item {
    padding: 7px 10px;
    cursor: pointer;
    transition: background 0.15s;
    border-top: 1px solid rgba(255, 255, 255, 0.05);
 }
 .btl-irk-picker-item:first-child {
    border-top: none;
 }
 .btl-irk-picker-item:hover {
    background: rgba(0, 255, 136, 0.08);
 }
 .btl-irk-picker-name {
    font-size: 11px;
    font-weight: 600;
    color: var(--text-primary);
 }
 .btl-irk-picker-meta {
    font-size: 9px;
    font-family: var(--font-mono);
    color: var(--text-dim);
    margin-top: 1px;
 }
 /* ============================================
   RESPONSIVE — stack HUD vertically on narrow
   ============================================ */
@media (max-width: 900px) {
    .btl-hud {
        flex-wrap: wrap;
        gap: 10px;
    }
    .btl-hud-band {
        min-width: unset;
        width: 100%;
        font-size: 20px;
    }
    .btl-hud-metrics {
        width: 100%;
        justify-content: space-around;
    }
    .btl-hud-controls {
        flex-direction: row;
        width: 100%;
        justify-content: center;
        flex-wrap: wrap;
    }
    .btl-hud-export-row {
        width: 100%;
        justify-content: center;
    }
    .btl-map-overlay-controls {
        top: 8px;
        right: 8px;
        gap: 3px;
        padding: 6px 7px;
    }
    .btl-map-heat-legend {
        left: 8px;
        bottom: 8px;
    }
    .btl-map-track-stats {
        right: 8px;
        bottom: 8px;
        font-size: 9px;
    }
 }
@@ -1,337 +0,0 @@
 /* GPS Mode Styles */
 /* Sidebar info grid */
 .gps-info-grid {
    display: grid;
    grid-template-columns: 1fr 1fr;
    gap: 6px;
 }
 .gps-info-item {
    display: flex;
    flex-direction: column;
    gap: 2px;
    padding: 4px 6px;
    background: var(--bg-primary);
    border: 1px solid var(--border-color);
    border-radius: 3px;
 }
 .gps-info-label {
    font-size: 9px;
    color: var(--text-dim);
    text-transform: uppercase;
    letter-spacing: 0.5px;
 }
 .gps-info-value {
    font-size: 12px;
    color: var(--text-primary);
    font-weight: 600;
 }
 .gps-mono {
    font-family: var(--font-mono);
 }
 /* Connection status */
 .gps-connection-status {
    display: flex;
    align-items: center;
    gap: 6px;
 }
 .gps-status-dot {
    width: 8px;
    height: 8px;
    border-radius: 50%;
    background: var(--text-dim);
    flex-shrink: 0;
 }
 .gps-status-dot.connected {
    background: #00ff88;
    box-shadow: 0 0 6px rgba(0, 255, 136, 0.4);
 }
 .gps-status-dot.waiting {
    background: #ffaa00;
    box-shadow: 0 0 6px rgba(255, 170, 0, 0.4);
 }
 .gps-status-dot.error {
    background: #ff4444;
    box-shadow: 0 0 6px rgba(255, 68, 68, 0.4);
 }
 .gps-status-text {
    font-size: 11px;
    color: var(--text-secondary);
    font-family: var(--font-mono);
 }
 /* Fix badge */
 .gps-fix-badge {
    display: inline-block;
    padding: 1px 6px;
    border-radius: 3px;
    font-size: 10px;
    font-weight: 700;
    font-family: var(--font-mono);
 }
 .gps-fix-badge.no-fix {
    background: rgba(255, 68, 68, 0.2);
    color: #ff4444;
    border: 1px solid rgba(255, 68, 68, 0.3);
 }
 .gps-fix-badge.fix-2d {
    background: rgba(255, 170, 0, 0.2);
    color: #ffaa00;
    border: 1px solid rgba(255, 170, 0, 0.3);
 }
 .gps-fix-badge.fix-3d {
    background: rgba(0, 255, 136, 0.2);
    color: #00ff88;
    border: 1px solid rgba(0, 255, 136, 0.3);
 }
 /* DOP quality indicators */
 .gps-dop-good { color: #00ff88; }
 .gps-dop-moderate { color: #ffaa00; }
 .gps-dop-poor { color: #ff4444; }
 /* ===== Visuals Panel ===== */
 .gps-visuals-container {
    display: flex;
    flex-direction: column;
    gap: 16px;
    padding: 16px;
    height: 100%;
    overflow-y: auto;
 }
 /* Top row: sky view + position info */
 .gps-visuals-top {
    display: flex;
    gap: 16px;
    flex-wrap: wrap;
 }
 /* Sky View */
 .gps-skyview-panel {
    flex: 1;
    min-width: 320px;
    background: var(--bg-card);
    border: 1px solid var(--border-color);
    border-radius: 6px;
    padding: 12px;
 }
 .gps-skyview-panel h4 {
    margin: 0 0 8px 0;
    font-size: 11px;
    color: var(--text-dim);
    text-transform: uppercase;
    letter-spacing: 0.5px;
 }
 .gps-skyview-canvas-wrap {
    display: flex;
    justify-content: center;
    align-items: center;
 }
 #gpsSkyCanvas {
    max-width: 100%;
    height: auto;
 }
 /* Position info panel */
 .gps-position-panel {
    flex: 1;
    min-width: 280px;
    background: var(--bg-card);
    border: 1px solid var(--border-color);
    border-radius: 6px;
    padding: 12px;
    display: flex;
    flex-direction: column;
    gap: 12px;
 }
 .gps-position-panel h4 {
    margin: 0;
    font-size: 11px;
    color: var(--text-dim);
    text-transform: uppercase;
    letter-spacing: 0.5px;
 }
 .gps-pos-big {
    font-family: var(--font-mono);
    font-size: 20px;
    font-weight: 700;
    color: var(--accent-cyan);
    line-height: 1.3;
 }
 .gps-pos-row {
    display: flex;
    justify-content: space-between;
    align-items: center;
    padding: 4px 0;
    border-bottom: 1px solid var(--border-color);
 }
 .gps-pos-row:last-child {
    border-bottom: none;
 }
 .gps-pos-label {
    font-size: 10px;
    color: var(--text-dim);
    text-transform: uppercase;
 }
 .gps-pos-value {
    font-family: var(--font-mono);
    font-size: 13px;
    color: var(--text-primary);
    font-weight: 600;
 }
 /* Signal Strength Bars */
 .gps-signal-panel {
    background: var(--bg-card);
    border: 1px solid var(--border-color);
    border-radius: 6px;
    padding: 12px;
 }
 .gps-signal-panel h4 {
    margin: 0 0 8px 0;
    font-size: 11px;
    color: var(--text-dim);
    text-transform: uppercase;
    letter-spacing: 0.5px;
 }
 .gps-signal-bars {
    display: flex;
    align-items: flex-end;
    gap: 3px;
    height: 140px;
    padding: 0 4px;
    overflow-x: auto;
 }
 .gps-signal-bar-wrap {
    display: flex;
    flex-direction: column;
    align-items: center;
    gap: 2px;
    min-width: 18px;
    height: 100%;
    justify-content: flex-end;
 }
 .gps-signal-bar {
    width: 14px;
    border-radius: 2px 2px 0 0;
    min-height: 2px;
    transition: height 0.3s ease;
 }
 .gps-signal-bar.unused {
    opacity: 0.4;
 }
 .gps-signal-prn {
    font-size: 8px;
    font-family: var(--font-mono);
    color: var(--text-dim);
    writing-mode: horizontal-tb;
 }
 .gps-signal-snr {
    font-size: 7px;
    font-family: var(--font-mono);
    color: var(--text-secondary);
 }
 /* Constellation colors */
 .gps-const-gps { background-color: #00d4ff; }
 .gps-const-glonass { background-color: #00ff88; }
 .gps-const-galileo { background-color: #ff8800; }
 .gps-const-beidou { background-color: #ff4466; }
 .gps-const-sbas { background-color: #ffdd00; }
 .gps-const-qzss { background-color: #cc66ff; }
 /* Legend */
 .gps-legend {
    display: flex;
    gap: 12px;
    flex-wrap: wrap;
    margin-top: 8px;
    padding-top: 8px;
    border-top: 1px solid var(--border-color);
 }
 .gps-legend-item {
    display: flex;
    align-items: center;
    gap: 4px;
    font-size: 9px;
    color: var(--text-dim);
 }
 .gps-legend-dot {
    width: 8px;
    height: 8px;
    border-radius: 50%;
    flex-shrink: 0;
 }
 /* Empty state */
 .gps-empty-state {
    display: flex;
    flex-direction: column;
    align-items: center;
    justify-content: center;
    gap: 12px;
    padding: 40px;
    color: var(--text-dim);
    text-align: center;
 }
 .gps-empty-state svg {
    width: 48px;
    height: 48px;
    opacity: 0.3;
 }
 .gps-empty-state p {
    font-size: 12px;
    max-width: 300px;
    line-height: 1.5;
 }
 /* Responsive */
@media (max-width: 768px) {
    .gps-visuals-top {
        flex-direction: column;
    }
    .gps-skyview-panel,
    .gps-position-panel {
        min-width: unset;
    }
    .gps-pos-big {
        font-size: 16px;
    }
 }
@@ -1,467 +0,0 @@
 /* Space Weather Mode Styles */
 /* Main container */
 .sw-visuals-container {
    display: flex;
    flex-direction: column;
    gap: 12px;
    padding: 12px;
    height: 100%;
    overflow-y: auto;
 }
 /* Header metrics strip */
 .sw-header-strip {
    display: flex;
    align-items: center;
    gap: 2px;
    background: var(--bg-card);
    border: 1px solid var(--border-color);
    border-radius: 6px;
    padding: 8px 12px;
    flex-wrap: wrap;
 }
 .sw-header-stat {
    display: flex;
    flex-direction: column;
    align-items: center;
    padding: 4px 12px;
    min-width: 60px;
 }
 .sw-header-stat + .sw-header-stat {
    border-left: 1px solid var(--border-color);
 }
 .sw-header-value {
    font-family: var(--font-mono, 'Roboto Condensed', monospace);
    font-size: 18px;
    font-weight: 700;
    color: var(--text-primary);
    line-height: 1.2;
 }
 .sw-header-label {
    font-size: 9px;
    font-weight: 600;
    letter-spacing: 0.5px;
    color: var(--text-dim);
    text-transform: uppercase;
 }
 .sw-header-value.accent-cyan { color: var(--accent-cyan); }
 .sw-header-value.accent-green { color: #00ff88; }
 .sw-header-value.accent-yellow { color: #ffcc00; }
 .sw-header-value.accent-orange { color: #ff8800; }
 .sw-header-value.accent-red { color: #ff3366; }
 /* Refresh controls in strip */
 .sw-strip-controls {
    display: flex;
    align-items: center;
    gap: 8px;
    margin-left: auto;
    padding-left: 12px;
 }
 .sw-refresh-btn {
    background: transparent;
    border: 1px solid var(--border-color);
    color: var(--text-secondary);
    padding: 4px 10px;
    border-radius: 4px;
    font-size: 11px;
    cursor: pointer;
    font-family: var(--font-mono, 'Roboto Condensed', monospace);
    transition: border-color 0.2s, color 0.2s;
 }
 .sw-refresh-btn:hover {
    border-color: var(--accent-cyan);
    color: var(--accent-cyan);
 }
 .sw-last-update {
    font-size: 10px;
    color: var(--text-dim);
    font-family: var(--font-mono, 'Roboto Condensed', monospace);
 }
 /* NOAA G/S/R Scale cards */
 .sw-scales-row {
    display: grid;
    grid-template-columns: repeat(3, 1fr);
    gap: 8px;
 }
 .sw-scale-card {
    background: var(--bg-card);
    border: 1px solid var(--border-color);
    border-radius: 6px;
    padding: 10px;
    text-align: center;
 }
 .sw-scale-label {
    font-size: 10px;
    font-weight: 600;
    letter-spacing: 0.5px;
    color: var(--text-dim);
    text-transform: uppercase;
    margin-bottom: 4px;
 }
 .sw-scale-value {
    font-family: var(--font-mono, 'Roboto Condensed', monospace);
    font-size: 24px;
    font-weight: 700;
    line-height: 1.2;
 }
 .sw-scale-desc {
    font-size: 10px;
    color: var(--text-dim);
    margin-top: 2px;
 }
 /* Scale severity colors */
 .sw-scale-0 { color: #00ff88; border-color: #00ff8833; }
 .sw-scale-1 { color: #88ff00; border-color: #88ff0033; }
 .sw-scale-2 { color: #ffcc00; border-color: #ffcc0033; }
 .sw-scale-3 { color: #ff8800; border-color: #ff880033; }
 .sw-scale-4 { color: #ff4400; border-color: #ff440033; }
 .sw-scale-5 { color: #ff0044; border-color: #ff004433; }
 /* HF Band conditions grid */
 .sw-band-panel {
    background: var(--bg-card);
    border: 1px solid var(--border-color);
    border-radius: 6px;
    padding: 12px;
 }
 .sw-band-title {
    font-size: 11px;
    font-weight: 600;
    color: var(--text-secondary);
    text-transform: uppercase;
    letter-spacing: 0.5px;
    margin-bottom: 8px;
 }
 .sw-band-grid {
    display: grid;
    grid-template-columns: auto repeat(2, 1fr);
    gap: 4px 8px;
    font-size: 11px;
    font-family: var(--font-mono, 'Roboto Condensed', monospace);
 }
 .sw-band-header {
    font-size: 10px;
    font-weight: 600;
    color: var(--text-dim);
    text-transform: uppercase;
    padding-bottom: 4px;
    border-bottom: 1px solid var(--border-color);
 }
 .sw-band-name {
    color: var(--text-secondary);
    font-weight: 500;
 }
 .sw-band-cond {
    text-align: center;
    padding: 2px 6px;
    border-radius: 3px;
    font-size: 10px;
    font-weight: 600;
 }
 .sw-band-good { color: #00ff88; background: #00ff8815; }
 .sw-band-fair { color: #ffcc00; background: #ffcc0015; }
 .sw-band-poor { color: #ff3366; background: #ff336615; }
 /* 2-column dashboard grid */
 .sw-dashboard-grid {
    display: grid;
    grid-template-columns: 1fr 1fr;
    gap: 10px;
 }
 /* Chart containers */
 .sw-chart-card {
    background: var(--bg-card);
    border: 1px solid var(--border-color);
    border-radius: 6px;
    padding: 12px;
 }
 .sw-chart-title {
    font-size: 11px;
    font-weight: 600;
    color: var(--text-secondary);
    text-transform: uppercase;
    letter-spacing: 0.5px;
    margin-bottom: 8px;
 }
 .sw-chart-wrap {
    position: relative;
    height: 180px;
 }
 .sw-chart-wrap canvas {
    width: 100% !important;
    height: 100% !important;
 }
 /* Flare probability table */
 .sw-prob-table {
    width: 100%;
    border-collapse: collapse;
    font-size: 11px;
    font-family: var(--font-mono, 'Roboto Condensed', monospace);
 }
 .sw-prob-table th {
    font-size: 10px;
    font-weight: 600;
    color: var(--text-dim);
    text-transform: uppercase;
    text-align: left;
    padding: 4px 6px;
    border-bottom: 1px solid var(--border-color);
 }
 .sw-prob-table td {
    padding: 4px 6px;
    color: var(--text-secondary);
    border-bottom: 1px solid var(--border-color);
 }
 /* Solar image gallery */
 .sw-image-panel {
    background: var(--bg-card);
    border: 1px solid var(--border-color);
    border-radius: 6px;
    padding: 12px;
 }
 .sw-image-tabs {
    display: flex;
    gap: 4px;
    margin-bottom: 8px;
 }
 .sw-image-tab {
    background: transparent;
    border: 1px solid var(--border-color);
    color: var(--text-dim);
    padding: 4px 10px;
    border-radius: 4px;
    font-size: 10px;
    font-weight: 600;
    cursor: pointer;
    font-family: var(--font-mono, 'Roboto Condensed', monospace);
    transition: all 0.2s;
 }
 .sw-image-tab:hover {
    border-color: var(--text-secondary);
    color: var(--text-secondary);
 }
 .sw-image-tab.active {
    border-color: var(--accent-cyan);
    color: var(--accent-cyan);
    background: var(--accent-cyan)10;
 }
 .sw-image-frame {
    display: flex;
    align-items: center;
    justify-content: center;
    min-height: 200px;
    background: var(--bg-primary);
    border-radius: 4px;
    overflow: hidden;
 }
 .sw-image-frame img {
    max-width: 100%;
    max-height: 400px;
    object-fit: contain;
    border-radius: 4px;
 }
 /* D-RAP frequency selector */
 .sw-drap-freqs {
    display: flex;
    gap: 4px;
    margin-bottom: 8px;
    flex-wrap: wrap;
 }
 .sw-drap-freq-btn {
    background: transparent;
    border: 1px solid var(--border-color);
    color: var(--text-dim);
    padding: 3px 8px;
    border-radius: 3px;
    font-size: 10px;
    cursor: pointer;
    font-family: var(--font-mono, 'Roboto Condensed', monospace);
    transition: all 0.2s;
 }
 .sw-drap-freq-btn:hover {
    border-color: var(--text-secondary);
    color: var(--text-secondary);
 }
 .sw-drap-freq-btn.active {
    border-color: var(--accent-cyan);
    color: var(--accent-cyan);
 }
 /* Alerts list */
 .sw-alerts-panel {
    background: var(--bg-card);
    border: 1px solid var(--border-color);
    border-radius: 6px;
    padding: 12px;
    max-height: 300px;
    overflow-y: auto;
 }
 .sw-alert-item {
    padding: 8px;
    border-bottom: 1px solid var(--border-color);
    font-size: 11px;
    font-family: var(--font-mono, 'Roboto Condensed', monospace);
 }
 .sw-alert-item:last-child {
    border-bottom: none;
 }
 .sw-alert-type {
    font-weight: 600;
    color: var(--accent-cyan);
    font-size: 10px;
    text-transform: uppercase;
    margin-bottom: 2px;
 }
 .sw-alert-time {
    font-size: 10px;
    color: var(--text-dim);
    margin-bottom: 4px;
 }
 .sw-alert-msg {
    color: var(--text-secondary);
    line-height: 1.4;
    white-space: pre-wrap;
    font-size: 10px;
 }
 /* Active regions table */
 .sw-regions-panel {
    background: var(--bg-card);
    border: 1px solid var(--border-color);
    border-radius: 6px;
    padding: 12px;
    max-height: 300px;
    overflow-y: auto;
 }
 .sw-regions-table {
    width: 100%;
    border-collapse: collapse;
    font-size: 10px;
    font-family: var(--font-mono, 'Roboto Condensed', monospace);
 }
 .sw-regions-table th {
    font-weight: 600;
    color: var(--text-dim);
    text-transform: uppercase;
    text-align: left;
    padding: 4px 6px;
    border-bottom: 1px solid var(--border-color);
    position: sticky;
    top: 0;
    background: var(--bg-card);
 }
 .sw-regions-table td {
    padding: 4px 6px;
    color: var(--text-secondary);
    border-bottom: 1px solid var(--border-color);
 }
 /* Empty / loading states */
 .sw-empty {
    text-align: center;
    padding: 20px;
    color: var(--text-dim);
    font-size: 11px;
    font-family: var(--font-mono, 'Roboto Condensed', monospace);
 }
 .sw-loading {
    text-align: center;
    padding: 20px;
    color: var(--text-dim);
    font-size: 11px;
 }
 .sw-loading::after {
    content: '';
    display: inline-block;
    width: 12px;
    height: 12px;
    border: 2px solid var(--border-color);
    border-top-color: var(--accent-cyan);
    border-radius: 50%;
    animation: sw-spin 0.8s linear infinite;
    margin-left: 8px;
    vertical-align: middle;
 }
@keyframes sw-spin {
    to { transform: rotate(360deg); }
 }
 /* Full-width card */
 .sw-full-width {
    grid-column: 1 / -1;
 }
 /* Responsive */
@media (max-width: 768px) {
    .sw-dashboard-grid {
        grid-template-columns: 1fr;
    }
    .sw-scales-row {
        grid-template-columns: 1fr;
    }
    .sw-header-strip {
        gap: 0;
    }
    .sw-header-stat {
        padding: 4px 8px;
        min-width: 50px;
    }
    .sw-header-value {
        font-size: 14px;
    }
 }
@@ -340,9 +340,7 @@
   MODE VISIBILITY - Ensure sidebar shows when active
   ============================================ */
 #spystationsMode.active {
-    display: flex !important;
+    display: block !important;
    flex-direction: column;
    gap: 10px;
 }
 /* ============================================
@@ -7,9 +7,7 @@
   MODE VISIBILITY
   ============================================ */
 #sstvGeneralMode.active {
-    display: flex !important;
+    display: block !important;
    flex-direction: column;
    gap: 10px;
 }
 /* ============================================
@@ -7,9 +7,7 @@
   MODE VISIBILITY
   ============================================ */
 #sstvMode.active {
-    display: flex !important;
+    display: block !important;
    flex-direction: column;
    gap: 10px;
 }
 /* ============================================
@@ -196,28 +196,6 @@
    margin-left: 6px;
    font-size: 10px;
 }
 .tracker-badge {
    margin-left: 6px;
    font-size: 9px;
    padding: 1px 4px;
    border-radius: 3px;
    background: rgba(255, 51, 102, 0.2);
    color: #ff3366;
    border: 1px solid rgba(255, 51, 102, 0.4);
    text-transform: uppercase;
    letter-spacing: 0.4px;
 }
 .client-badge {
    margin-left: 6px;
    font-size: 9px;
    padding: 1px 4px;
    border-radius: 3px;
    background: rgba(74, 158, 255, 0.2);
    color: #4a9eff;
    border: 1px solid rgba(74, 158, 255, 0.4);
    text-transform: uppercase;
    letter-spacing: 0.4px;
 }
 .known-badge {
    margin-left: 6px;
    font-size: 9px;
@@ -1,31 +0,0 @@
 /* VDL2 Mode Styles */
 /* VDL2 Status Indicator */
 .vdl2-status-dot.listening {
    background: var(--accent-cyan) !important;
    animation: vdl2-pulse 1.5s ease-in-out infinite;
 }
 .vdl2-status-dot.receiving {
    background: var(--accent-green) !important;
 }
 .vdl2-status-dot.error {
    background: var(--accent-red) !important;
 }
@keyframes vdl2-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 6px 3px rgba(74, 158, 255, 0.3); }
 }
 /* VDL2 message animation */
 .vdl2-msg {
    padding: 6px 8px;
    border-bottom: 1px solid var(--border-color);
    animation: vdl2FadeIn 0.3s ease;
 }
 .vdl2-msg:hover {
    background: rgba(74, 158, 255, 0.05);
 }
@keyframes vdl2FadeIn {
    from { opacity: 0; transform: translateY(-3px); }
    to { opacity: 1; transform: translateY(0); }
 }
@@ -114,7 +114,7 @@
    position: fixed;
    top: 0;
    left: 0;
-    width: min(360px, 100vw);
+    width: min(320px, 85vw);
    height: 100dvh;
    height: 100vh; /* Fallback */
    background: var(--bg-secondary, #0f1218);
@@ -381,33 +381,6 @@
        -webkit-overflow-scrolling: touch;
    }
    .sidebar {
        padding: 10px;
        gap: 10px;
    }
    .output-panel {
        min-height: 58vh;
    }
    .output-header {
        flex-direction: column;
        align-items: flex-start;
        gap: 8px;
    }
    .header-controls {
        width: 100%;
        gap: 8px;
        overflow-x: auto;
        -webkit-overflow-scrolling: touch;
        padding-bottom: 2px;
    }
    .header-controls .stats {
        min-width: max-content;
    }
    /* Container should not clip content */
    .container {
        overflow: visible;
@@ -428,7 +401,7 @@
    /* Visual panels should be scrollable, not clipped */
    .wifi-visuals,
-    .bt-visuals-column {
+    .bt-visuals {
        max-height: none !important;
        overflow: visible !important;
        margin-bottom: 15px;
@@ -444,7 +417,7 @@
    /* Visual panels should stack in single column on mobile when visible */
    .wifi-visuals,
-    .bt-visuals-column {
+    .bt-visuals {
        display: flex;
        flex-direction: column;
        gap: 10px;
@@ -465,34 +438,6 @@
    .wifi-visual-panel {
        grid-column: auto !important;
    }
    .bt-main-area {
        flex-direction: column !important;
        min-height: auto !important;
    }
    .bt-side-panels {
        width: 100% !important;
        flex-direction: column !important;
    }
    .bt-detail-grid {
        grid-template-columns: repeat(2, minmax(0, 1fr)) !important;
    }
    .bt-row-secondary {
        padding-left: 0 !important;
        white-space: normal !important;
    }
    .bt-row-actions {
        padding-left: 0 !important;
        justify-content: flex-start !important;
    }
    .bt-list-summary {
        grid-template-columns: repeat(2, minmax(0, 1fr)) !important;
    }
 }
 /* ============== MOBILE MAP FIXES ============== */
@@ -5,8 +5,8 @@
 }
 :root {
-    --font-sans: 'Roboto Condensed', 'Arial Narrow', Roboto, 'Helvetica Neue', Arial, sans-serif;
+    --font-sans: 'IBM Plex Mono', 'Space Mono', ui-monospace, 'SF Mono', 'Consolas', 'Menlo', monospace;
-    --font-mono: 'Roboto Condensed', 'Arial Narrow', Roboto, 'Helvetica Neue', Arial, sans-serif;
+    --font-mono: 'IBM Plex Mono', 'Space Mono', ui-monospace, 'SF Mono', 'Consolas', 'Menlo', monospace;
    --bg-dark: #0b1118;
    --bg-panel: #101823;
    --bg-card: #151f2b;
@@ -24,11 +24,8 @@
    background: var(--bg-dark, #0a0a0f);
    border: 1px solid var(--border-color, #1a1a2e);
    border-radius: 8px;
-    max-width: 900px;
+    max-width: 600px;
    width: 100%;
    max-height: calc(100vh - 80px);
    display: flex;
    flex-direction: column;
    position: relative;
    box-shadow: 0 20px 60px rgba(0, 0, 0, 0.5);
 }
@@ -74,28 +71,22 @@
 /* Settings Tabs */
 .settings-tabs {
-    display: grid;
+    display: flex;
    grid-template-columns: repeat(8, minmax(0, 1fr));
    border-bottom: 1px solid var(--border-color, #1a1a2e);
    padding: 0 20px;
-    gap: 0;
+    gap: 4px;
 }
 .settings-tab {
    background: none;
    border: none;
-    padding: 12px 10px;
+    padding: 12px 16px;
    color: var(--text-muted, #666);
    font-size: 13px;
    font-weight: 500;
    cursor: pointer;
    position: relative;
    transition: color 0.2s;
    min-width: 0;
    text-align: center;
    white-space: nowrap;
    overflow: hidden;
    text-overflow: ellipsis;
 }
 .settings-tab:hover {
@@ -124,9 +115,6 @@
 .settings-section.active {
    display: block;
    overflow-y: auto;
    flex: 1;
    min-height: 0;
 }
 .settings-group {
@@ -175,47 +163,6 @@
    color: var(--text-muted, #666);
 }
 /* Settings Feed Lists */
 .settings-feed {
    background: var(--bg-tertiary, #12121f);
    border: 1px solid var(--border-color, #1a1a2e);
    border-radius: 6px;
    padding: 8px;
    max-height: 240px;
    overflow-y: auto;
 }
 .settings-feed-item {
    padding: 8px;
    border-bottom: 1px solid rgba(255, 255, 255, 0.05);
    font-size: 11px;
 }
 .settings-feed-item:last-child {
    border-bottom: none;
 }
 .settings-feed-title {
    display: flex;
    justify-content: space-between;
    align-items: center;
    font-weight: 600;
    color: var(--text-primary, #e0e0e0);
    margin-bottom: 4px;
 }
 .settings-feed-meta {
    color: var(--text-muted, #666);
    font-size: 10px;
 }
 .settings-feed-empty {
    color: var(--text-dim, #666);
    text-align: center;
    padding: 20px 10px;
    font-size: 11px;
 }
 /* Toggle Switch */
 .toggle-switch {
    position: relative;
@@ -479,61 +426,7 @@
    filter: sepia(0.35) hue-rotate(185deg) saturate(1.75) brightness(1.06) contrast(1.05);
 }
 /* Global Leaflet map theme: cyber overlay */
 .leaflet-container.map-theme-cyber {
    position: relative;
    background: #020813;
    isolation: isolate;
 }
 .leaflet-container.map-theme-cyber .leaflet-tile-pane {
    filter: sepia(0.74) hue-rotate(176deg) saturate(1.72) brightness(1.05) contrast(1.08);
    opacity: 1;
 }
 /* Hard global fallback: enforce cyber tint on all Leaflet tile images */
 html.map-cyber-enabled .leaflet-container .leaflet-tile {
    filter: sepia(0.74) hue-rotate(176deg) saturate(1.72) brightness(1.05) contrast(1.08) !important;
 }
 /* Hard global fallback: cyber glow + grid overlay */
 html.map-cyber-enabled .leaflet-container {
    position: relative;
    isolation: isolate;
 }
 html.map-cyber-enabled .leaflet-container::before {
    content: '';
    position: absolute;
    inset: 0;
    pointer-events: none;
    z-index: 620;
    background:
        radial-gradient(95% 78% at 50% 44%, rgba(18, 170, 255, 0.17), rgba(18, 170, 255, 0) 64%),
        linear-gradient(180deg, rgba(24, 118, 255, 0.045), rgba(24, 118, 255, 0));
 }
 html.map-cyber-enabled .leaflet-container::after {
    content: '';
    position: absolute;
    inset: 0;
    pointer-events: none;
    z-index: 621;
    opacity: 0.42;
    mix-blend-mode: screen;
    background-image:
        linear-gradient(rgba(78, 188, 255, 0.14) 1px, transparent 1px),
        linear-gradient(90deg, rgba(78, 188, 255, 0.14) 1px, transparent 1px);
    background-size: 52px 52px, 52px 52px;
 }
 /* Responsive */
@media (max-width: 960px) {
    .settings-tabs {
        grid-template-columns: repeat(4, minmax(0, 1fr));
    }
 }
@media (max-width: 640px) {
    .settings-modal.active {
        padding: 20px 10px;
@@ -543,18 +436,6 @@ html.map-cyber-enabled .leaflet-container::after {
        max-width: 100%;
    }
    .settings-tabs {
        padding: 0 10px;
        grid-template-columns: repeat(2, minmax(0, 1fr));
    }
    .settings-tab {
        padding: 10px 6px;
        font-size: 11px;
        white-space: normal;
        line-height: 1.2;
    }
    .settings-row {
        flex-direction: column;
        align-items: flex-start;
@@ -36,7 +36,6 @@ const ProximityRadar = (function() {
    let isHovered = false;
    let renderPending = false;
    let renderTimer = null;
    let interactionLockUntil = 0; // timestamp: suppress renders briefly after click
    /**
     * Initialize the radar component
@@ -120,36 +119,6 @@ const ProximityRadar = (function() {
        svg = container.querySelector('svg');
        // Event delegation on the devices group (survives innerHTML rebuilds)
        const devicesGroup = svg.querySelector('.radar-devices');
        devicesGroup.addEventListener('click', (e) => {
            const deviceEl = e.target.closest('.radar-device');
            if (!deviceEl) return;
            const deviceKey = deviceEl.getAttribute('data-device-key');
            if (onDeviceClick && deviceKey) {
                // Lock out re-renders briefly so the DOM stays stable after click
                interactionLockUntil = Date.now() + 500;
                onDeviceClick(deviceKey);
            }
        });
        devicesGroup.addEventListener('mouseenter', (e) => {
            if (e.target.closest('.radar-device')) {
                isHovered = true;
            }
        }, true); // capture phase so we catch enter on child elements
        devicesGroup.addEventListener('mouseleave', (e) => {
            if (e.target.closest('.radar-device')) {
                isHovered = false;
                if (renderPending) {
                    renderPending = false;
                    renderDevices();
                }
            }
        }, true);
        // Add sweep animation
        animateSweep();
    }
@@ -196,8 +165,8 @@ const ProximityRadar = (function() {
            devices.set(device.device_key, device);
        });
-        // Defer render while user is hovering or interacting to prevent DOM rebuild flicker
+        // Defer render while user is hovering to prevent DOM rebuild flicker
-        if (isHovered || Date.now() < interactionLockUntil) {
+        if (isHovered) {
            renderPending = true;
            return;
        }
@@ -260,7 +229,7 @@ const ProximityRadar = (function() {
                       style="cursor: pointer;">
                        <!-- Invisible hit area to prevent hover flicker -->
                        <circle class="radar-device-hitarea" r="${hitAreaSize}" fill="transparent" />
-                        ${isSelected ? `<circle class="radar-select-ring" r="${dotSize + 8}" fill="none" stroke="#00d4ff" stroke-width="2" stroke-opacity="0.8">
+                        ${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>` : ''}
@@ -275,6 +244,24 @@ const ProximityRadar = (function() {
        }).join('');
        devicesGroup.innerHTML = dots;
        // Attach event handlers
        devicesGroup.querySelectorAll('.radar-device').forEach(el => {
            el.addEventListener('click', (e) => {
                const deviceKey = el.getAttribute('data-device-key');
                if (onDeviceClick && deviceKey) {
                    onDeviceClick(deviceKey);
                }
            });
            el.addEventListener('mouseenter', () => { isHovered = true; });
            el.addEventListener('mouseleave', () => {
                isHovered = false;
                if (renderPending) {
                    renderPending = false;
                    renderDevices();
                }
            });
        });
    }
    /**
@@ -358,125 +345,19 @@ const ProximityRadar = (function() {
    }
    /**
-     * Highlight a specific device on the radar (in-place update, no full re-render)
+     * Highlight a specific device on the radar
     */
    function highlightDevice(deviceKey) {
        const prev = selectedDeviceKey;
        selectedDeviceKey = deviceKey;
        if (!svg) { return; }
        const devicesGroup = svg.querySelector('.radar-devices');
        if (!devicesGroup) { return; }
        // Remove highlight from previously selected node
        if (prev && prev !== deviceKey) {
            const oldEl = devicesGroup.querySelector(`.radar-device[data-device-key="${CSS.escape(prev)}"]`);
            if (oldEl) {
                oldEl.classList.remove('selected');
                // Remove animated selection ring
                const ring = oldEl.querySelector('.radar-select-ring');
                if (ring) ring.remove();
                // Restore dot opacity
                const dot = oldEl.querySelector('circle:not(.radar-device-hitarea):not(.radar-select-ring)');
                if (dot && dot.getAttribute('fill') !== 'none' && dot.getAttribute('fill') !== 'transparent') {
                    const device = devices.get(prev);
                    const confidence = device ? (device.distance_confidence || 0.5) : 0.5;
                    dot.setAttribute('fill-opacity', 0.4 + confidence * 0.5);
                    dot.setAttribute('stroke', dot.getAttribute('fill'));
                    dot.setAttribute('stroke-width', '1');
                }
            }
        }
        // Add highlight to newly selected node
        if (deviceKey) {
            const newEl = devicesGroup.querySelector(`.radar-device[data-device-key="${CSS.escape(deviceKey)}"]`);
            if (newEl) {
                applySelectionToElement(newEl, deviceKey);
            } else {
                // Node not in DOM yet; full render needed on next cycle
        renderDevices();
    }
        }
    }
    /**
-     * Apply selection styling to a radar device element in-place
+     * Clear device highlighting
     */
    function applySelectionToElement(el, deviceKey) {
        el.classList.add('selected');
        const device = devices.get(deviceKey);
        const confidence = device ? (device.distance_confidence || 0.5) : 0.5;
        const dotSize = CONFIG.dotMinSize + (CONFIG.dotMaxSize - CONFIG.dotMinSize) * confidence;
        // Update dot styling
        const dot = el.querySelector('circle:not(.radar-device-hitarea):not(.radar-select-ring)');
        if (dot && dot.getAttribute('fill') !== 'none' && dot.getAttribute('fill') !== 'transparent') {
            dot.setAttribute('fill-opacity', '1');
            dot.setAttribute('stroke', '#00d4ff');
            dot.setAttribute('stroke-width', '2');
        }
        // Add animated selection ring if not already present
        if (!el.querySelector('.radar-select-ring')) {
            const ns = 'http://www.w3.org/2000/svg';
            const ring = document.createElementNS(ns, 'circle');
            ring.classList.add('radar-select-ring');
            ring.setAttribute('r', dotSize + 8);
            ring.setAttribute('fill', 'none');
            ring.setAttribute('stroke', '#00d4ff');
            ring.setAttribute('stroke-width', '2');
            ring.setAttribute('stroke-opacity', '0.8');
            const animR = document.createElementNS(ns, 'animate');
            animR.setAttribute('attributeName', 'r');
            animR.setAttribute('values', `${dotSize + 6};${dotSize + 10};${dotSize + 6}`);
            animR.setAttribute('dur', '1.5s');
            animR.setAttribute('repeatCount', 'indefinite');
            ring.appendChild(animR);
            const animO = document.createElementNS(ns, 'animate');
            animO.setAttribute('attributeName', 'stroke-opacity');
            animO.setAttribute('values', '0.8;0.4;0.8');
            animO.setAttribute('dur', '1.5s');
            animO.setAttribute('repeatCount', 'indefinite');
            ring.appendChild(animO);
            // Insert after the hit area
            const hitArea = el.querySelector('.radar-device-hitarea');
            if (hitArea && hitArea.nextSibling) {
                el.insertBefore(ring, hitArea.nextSibling);
            } else {
                el.insertBefore(ring, el.firstChild);
            }
        }
    }
    /**
     * Clear device highlighting (in-place update, no full re-render)
     */
    function clearHighlight() {
        const prev = selectedDeviceKey;
        selectedDeviceKey = null;
-
+        renderDevices();
        if (!svg || !prev) { return; }
        const devicesGroup = svg.querySelector('.radar-devices');
        if (!devicesGroup) { return; }
        const oldEl = devicesGroup.querySelector(`.radar-device[data-device-key="${CSS.escape(prev)}"]`);
        if (oldEl) {
            oldEl.classList.remove('selected');
            const ring = oldEl.querySelector('.radar-select-ring');
            if (ring) ring.remove();
            const dot = oldEl.querySelector('circle:not(.radar-device-hitarea):not(.radar-select-ring)');
            if (dot && dot.getAttribute('fill') !== 'none' && dot.getAttribute('fill') !== 'transparent') {
                const device = devices.get(prev);
                const confidence = device ? (device.distance_confidence || 0.5) : 0.5;
                dot.setAttribute('fill-opacity', 0.4 + confidence * 0.5);
                dot.setAttribute('stroke', dot.getAttribute('fill'));
                dot.setAttribute('stroke-width', '1');
            }
        }
    }
    /**
@@ -302,13 +302,7 @@ const SignalCards = (function() {
     */
    function formatRelativeTime(timestamp) {
        if (!timestamp) return '';
-        let date = new Date(timestamp);
+        const date = new Date(timestamp);
        // Handle time-only strings like "HH:MM:SS" (from pager/sensor backends)
        if (isNaN(date.getTime()) && /^\d{1,2}:\d{2}(:\d{2})?$/.test(timestamp)) {
            const today = new Date();
            date = new Date(today.toDateString() + ' ' + timestamp);
        }
        if (isNaN(date.getTime())) return timestamp;
        const now = new Date();
        const diff = Math.floor((now - date) / 1000);
@@ -423,7 +423,7 @@ async function syncAgentModeStates(agentId) {
                });
                // Also check modes that might need to be marked as stopped
-                const allModes = ['sensor', 'pager', 'adsb', 'wifi', 'bluetooth', 'ais', 'dsc', 'acars', 'vdl2', 'aprs', 'rtlamr', 'tscm', 'satellite', 'listening_post'];
+                const allModes = ['sensor', 'pager', 'adsb', 'wifi', 'bluetooth', 'ais', 'dsc', 'acars', 'aprs', 'rtlamr', 'tscm', 'satellite', 'listening_post'];
                allModes.forEach(mode => {
                    if (!agentRunningModes.includes(mode)) {
                        syncModeUI(mode, false, agentId);
@@ -485,7 +485,7 @@ async function syncLocalModeStates() {
 */
 function showAgentModeWarnings(runningModes, modesDetail = {}) {
    // SDR modes that can't run simultaneously on same device
-    const sdrModes = ['sensor', 'pager', 'adsb', 'ais', 'acars', 'vdl2', 'aprs', 'rtlamr', 'listening_post', 'tscm', 'dsc'];
+    const sdrModes = ['sensor', 'pager', 'adsb', 'ais', 'acars', 'aprs', 'rtlamr', 'listening_post', 'tscm', 'dsc'];
    const runningSdrModes = runningModes.filter(m => sdrModes.includes(m));
    let warning = document.getElementById('agentModeWarning');
@@ -621,7 +621,7 @@ function checkAgentModeConflict(modeToStart, deviceToUse = null) {
        return false;
    }
-    const sdrModes = ['sensor', 'pager', 'adsb', 'ais', 'acars', 'vdl2', 'aprs', 'rtlamr', 'listening_post', 'tscm', 'dsc'];
+    const sdrModes = ['sensor', 'pager', 'adsb', 'ais', 'acars', 'aprs', 'rtlamr', 'listening_post', 'tscm', 'dsc'];
    // If we're trying to start an SDR mode
    if (sdrModes.includes(modeToStart)) {
@@ -704,7 +704,6 @@ function syncModeUI(mode, isRunning, agentId = null) {
        'wifi': 'setWiFiRunning',
        'bluetooth': 'setBluetoothRunning',
        'acars': 'setAcarsRunning',
        'vdl2': 'setVdl2Running',
        'listening_post': 'setListeningPostRunning'
    };
@@ -1,404 +0,0 @@
 const AlertCenter = (function() {
    'use strict';
    const TRACKER_RULE_NAME = 'Tracker Detected';
    let alerts = [];
    let rules = [];
    let eventSource = null;
    let reconnectTimer = null;
    function init() {
        loadRules();
        loadFeed();
        connect();
    }
    function connect() {
        if (eventSource) {
            eventSource.close();
        }
        eventSource = new EventSource('/alerts/stream');
        eventSource.onmessage = function(e) {
            try {
                const data = JSON.parse(e.data);
                if (data.type === 'keepalive') return;
                handleAlert(data);
            } catch (err) {
                console.error('[Alerts] SSE parse error', err);
            }
        };
        eventSource.onerror = function() {
            console.warn('[Alerts] SSE connection error');
            if (reconnectTimer) clearTimeout(reconnectTimer);
            reconnectTimer = setTimeout(connect, 2500);
        };
    }
    function handleAlert(alert) {
        alerts.unshift(alert);
        alerts = alerts.slice(0, 60);
        updateFeedUI();
        const severity = String(alert.severity || '').toLowerCase();
        if (typeof showNotification === 'function' && ['high', 'critical'].includes(severity)) {
            showNotification(alert.title || 'Alert', alert.message || 'Alert triggered');
        }
        if (typeof showAppToast === 'function' && ['high', 'critical'].includes(severity)) {
            showAppToast(alert.title || 'Alert', alert.message || 'Alert triggered', 'warning');
        }
    }
    function updateFeedUI() {
        const list = document.getElementById('alertsFeedList');
        const countEl = document.getElementById('alertsFeedCount');
        if (countEl) countEl.textContent = `(${alerts.length})`;
        if (!list) return;
        if (alerts.length === 0) {
            list.innerHTML = '<div class="settings-feed-empty">No alerts yet</div>';
            return;
        }
        list.innerHTML = alerts.map((alert) => {
            const title = escapeHtml(alert.title || 'Alert');
            const message = escapeHtml(alert.message || '');
            const severity = escapeHtml(alert.severity || 'medium');
            const createdAt = alert.created_at ? new Date(alert.created_at).toLocaleString() : '';
            return `
                <div class="settings-feed-item">
                    <div class="settings-feed-title">
                        <span>${title}</span>
                        <span style="color: var(--text-dim);">${severity.toUpperCase()}</span>
                    </div>
                    <div class="settings-feed-meta">${message}</div>
                    <div class="settings-feed-meta" style="margin-top: 4px;">${createdAt}</div>
                </div>
            `;
        }).join('');
    }
    function renderRulesUI() {
        const list = document.getElementById('alertsRulesList');
        if (!list) return;
        if (!rules.length) {
            list.innerHTML = '<div class="settings-feed-empty">No rules yet</div>';
            return;
        }
        list.innerHTML = rules.map((rule) => {
            const enabled = Boolean(rule.enabled);
            const mode = rule.mode || 'all';
            const eventType = rule.event_type || 'any';
            const severity = (rule.severity || 'medium').toUpperCase();
            const match = formatMatch(rule.match);
            const statusText = enabled ? 'ENABLED' : 'DISABLED';
            return `
                <div class="settings-feed-item" style="border-left: 2px solid ${enabled ? 'var(--accent-green)' : 'var(--text-dim)'};">
                    <div class="settings-feed-title" style="display:flex; gap:8px; align-items:center; justify-content:space-between;">
                        <span>${escapeHtml(rule.name || 'Rule')}</span>
                        <span style="color: var(--text-dim); font-size: 10px;">${statusText}</span>
                    </div>
                    <div class="settings-feed-meta">Mode: ${escapeHtml(mode)} | Event: ${escapeHtml(eventType)} | Severity: ${escapeHtml(severity)}</div>
                    <div class="settings-feed-meta">Match: ${escapeHtml(match)}</div>
                    <div style="display:flex; gap:8px; margin-top: 8px;">
                        <button class="preset-btn" style="font-size: 10px; padding: 3px 8px;" onclick="AlertCenter.editRule(${Number(rule.id)})">Edit</button>
                        <button class="preset-btn" style="font-size: 10px; padding: 3px 8px;" onclick="AlertCenter.toggleRule(${Number(rule.id)}, ${enabled ? 'false' : 'true'})">${enabled ? 'Disable' : 'Enable'}</button>
                        <button class="preset-btn" style="font-size: 10px; padding: 3px 8px; border-color: var(--accent-red); color: var(--accent-red);" onclick="AlertCenter.deleteRule(${Number(rule.id)})">Delete</button>
                    </div>
                </div>
            `;
        }).join('');
    }
    function formatMatch(match) {
        if (!match || typeof match !== 'object' || !Object.keys(match).length) {
            return 'none';
        }
        const [k, v] = Object.entries(match)[0];
        return `${k}=${v}`;
    }
    function loadFeed() {
        fetch('/alerts/events?limit=30')
            .then((r) => r.json())
            .then((data) => {
                if (data.status === 'success') {
                    alerts = data.events || [];
                    updateFeedUI();
                }
            })
            .catch((err) => console.error('[Alerts] Load feed failed', err));
    }
    function loadRules() {
        return fetch('/alerts/rules?all=1')
            .then((r) => r.json())
            .then((data) => {
                if (data.status === 'success') {
                    rules = data.rules || [];
                    renderRulesUI();
                }
            })
            .catch((err) => {
                console.error('[Alerts] Load rules failed', err);
                if (typeof reportActionableError === 'function') {
                    reportActionableError('Alert Rules', err, { onRetry: loadRules });
                }
            });
    }
    function saveRule() {
        const editingId = getEditingRuleId();
        const payload = buildRulePayload();
        if (!payload.name) {
            payload.name = payload.mode ? `${payload.mode} alert` : 'Alert Rule';
        }
        const url = editingId ? `/alerts/rules/${editingId}` : '/alerts/rules';
        const method = editingId ? 'PATCH' : 'POST';
        fetch(url, {
            method,
            headers: { 'Content-Type': 'application/json' },
            body: JSON.stringify(payload),
        })
            .then((r) => r.json())
            .then((data) => {
                if (data.status !== 'success') {
                    throw new Error(data.message || 'Failed to save rule');
                }
                clearRuleForm();
                return loadRules();
            })
            .then(() => {
                if (typeof showAppToast === 'function') {
                    showAppToast('Alerts', editingId ? 'Rule updated' : 'Rule created', 'info');
                }
            })
            .catch((err) => {
                if (typeof reportActionableError === 'function') {
                    reportActionableError('Save Alert Rule', err);
                }
            });
    }
    function buildRulePayload() {
        const nameEl = document.getElementById('alertsRuleName');
        const modeEl = document.getElementById('alertsRuleMode');
        const eventTypeEl = document.getElementById('alertsRuleEventType');
        const keyEl = document.getElementById('alertsRuleMatchKey');
        const valueEl = document.getElementById('alertsRuleMatchValue');
        const severityEl = document.getElementById('alertsRuleSeverity');
        const match = {};
        const key = keyEl ? String(keyEl.value || '').trim() : '';
        const value = valueEl ? String(valueEl.value || '').trim() : '';
        if (key && value) {
            match[key] = value;
        }
        return {
            name: nameEl ? String(nameEl.value || '').trim() : 'Alert Rule',
            mode: modeEl ? String(modeEl.value || '').trim() || null : null,
            event_type: eventTypeEl ? String(eventTypeEl.value || '').trim() || null : null,
            match,
            severity: severityEl ? String(severityEl.value || 'medium') : 'medium',
            enabled: true,
            notify: { webhook: true },
        };
    }
    function clearRuleForm() {
        setField('alertsRuleName', '');
        setField('alertsRuleMode', '');
        setField('alertsRuleEventType', '');
        setField('alertsRuleMatchKey', '');
        setField('alertsRuleMatchValue', '');
        setField('alertsRuleSeverity', 'medium');
        setField('alertsRuleEditingId', '');
    }
    function editRule(ruleId) {
        const rule = rules.find((r) => Number(r.id) === Number(ruleId));
        if (!rule) return;
        const matchEntries = Object.entries(rule.match || {});
        const firstMatch = matchEntries.length ? matchEntries[0] : ['', ''];
        setField('alertsRuleName', rule.name || '');
        setField('alertsRuleMode', rule.mode || '');
        setField('alertsRuleEventType', rule.event_type || '');
        setField('alertsRuleMatchKey', firstMatch[0] || '');
        setField('alertsRuleMatchValue', firstMatch[1] == null ? '' : String(firstMatch[1]));
        setField('alertsRuleSeverity', rule.severity || 'medium');
        setField('alertsRuleEditingId', String(rule.id));
    }
    function toggleRule(ruleId, enabled) {
        fetch(`/alerts/rules/${ruleId}`, {
            method: 'PATCH',
            headers: { 'Content-Type': 'application/json' },
            body: JSON.stringify({ enabled: Boolean(enabled) }),
        })
            .then((r) => r.json())
            .then((data) => {
                if (data.status !== 'success') {
                    throw new Error(data.message || 'Failed to update rule');
                }
                return loadRules();
            })
            .catch((err) => {
                if (typeof reportActionableError === 'function') {
                    reportActionableError('Toggle Alert Rule', err);
                }
            });
    }
    function deleteRule(ruleId) {
        if (!confirm('Delete this alert rule?')) return;
        fetch(`/alerts/rules/${ruleId}`, { method: 'DELETE' })
            .then((r) => r.json())
            .then((data) => {
                if (data.status !== 'success') {
                    throw new Error(data.message || 'Failed to delete rule');
                }
                if (Number(getEditingRuleId()) === Number(ruleId)) {
                    clearRuleForm();
                }
                return loadRules();
            })
            .catch((err) => {
                if (typeof reportActionableError === 'function') {
                    reportActionableError('Delete Alert Rule', err);
                }
            });
    }
    function getEditingRuleId() {
        const el = document.getElementById('alertsRuleEditingId');
        if (!el || !el.value) return null;
        const parsed = Number(el.value);
        return Number.isFinite(parsed) && parsed > 0 ? parsed : null;
    }
    function setField(id, value) {
        const el = document.getElementById(id);
        if (!el) return;
        el.value = value;
    }
    function enableTrackerAlerts() {
        ensureTrackerRule(true);
    }
    function disableTrackerAlerts() {
        ensureTrackerRule(false);
    }
    function ensureTrackerRule(enabled) {
        loadRules().then(() => {
            const existing = rules.find((r) => r.name === TRACKER_RULE_NAME);
            if (existing) {
                return fetch(`/alerts/rules/${existing.id}`, {
                    method: 'PATCH',
                    headers: { 'Content-Type': 'application/json' },
                    body: JSON.stringify({ enabled }),
                }).then(() => loadRules());
            }
            if (enabled) {
                return fetch('/alerts/rules', {
                    method: 'POST',
                    headers: { 'Content-Type': 'application/json' },
                    body: JSON.stringify({
                        name: TRACKER_RULE_NAME,
                        mode: 'bluetooth',
                        event_type: 'device_update',
                        match: { is_tracker: true },
                        severity: 'high',
                        enabled: true,
                        notify: { webhook: true },
                    }),
                }).then(() => loadRules());
            }
            return null;
        });
    }
    function addBluetoothWatchlist(address, name) {
        if (!address) return;
        const upper = String(address).toUpperCase();
        const existing = rules.find((r) => r.mode === 'bluetooth' && r.match && String(r.match.address || '').toUpperCase() === upper);
        if (existing) return;
        fetch('/alerts/rules', {
            method: 'POST',
            headers: { 'Content-Type': 'application/json' },
            body: JSON.stringify({
                name: name ? `Watchlist ${name}` : `Watchlist ${upper}`,
                mode: 'bluetooth',
                event_type: 'device_update',
                match: { address: upper },
                severity: 'medium',
                enabled: true,
                notify: { webhook: true },
            }),
        }).then(() => loadRules());
    }
    function removeBluetoothWatchlist(address) {
        if (!address) return;
        const upper = String(address).toUpperCase();
        const existing = rules.find((r) => r.mode === 'bluetooth' && r.match && String(r.match.address || '').toUpperCase() === upper);
        if (!existing) return;
        fetch(`/alerts/rules/${existing.id}`, { method: 'DELETE' })
            .then(() => loadRules());
    }
    function isWatchlisted(address) {
        if (!address) return false;
        const upper = String(address).toUpperCase();
        return rules.some((r) => r.mode === 'bluetooth' && r.match && String(r.match.address || '').toUpperCase() === upper && r.enabled);
    }
    function escapeHtml(str) {
        if (!str) return '';
        return String(str)
            .replace(/&/g, '&amp;')
            .replace(/</g, '&lt;')
            .replace(/>/g, '&gt;')
            .replace(/"/g, '&quot;')
            .replace(/'/g, '&#039;');
    }
    return {
        init,
        loadFeed,
        loadRules,
        saveRule,
        clearRuleForm,
        editRule,
        toggleRule,
        deleteRule,
        enableTrackerAlerts,
        disableTrackerAlerts,
        addBluetoothWatchlist,
        removeBluetoothWatchlist,
        isWatchlisted,
    };
 })();
 document.addEventListener('DOMContentLoaded', () => {
    if (typeof AlertCenter !== 'undefined') {
        AlertCenter.init();
    }
 });
@@ -39,7 +39,7 @@ let observerLocation = (function() {
    if (saved) {
        try {
            const parsed = JSON.parse(saved);
-                    if (parsed.lat !== undefined && parsed.lat !== null && parsed.lon !== undefined && parsed.lon !== null) return parsed;
+            if (parsed.lat && parsed.lon) return parsed;
        } catch (e) {}
    }
    return { lat: 51.5074, lon: -0.1278 };
@@ -373,7 +373,7 @@ function showInfo(text) {
    const infoEl = document.createElement('div');
    infoEl.className = 'info-msg';
-    infoEl.style.cssText = 'padding: 12px 15px; margin-bottom: 8px; background: #0a0a0a; border: 1px solid #1a1a1a; border-left: 2px solid #00d4ff; font-family: "Roboto Condensed", "Arial Narrow", sans-serif; font-size: 11px; color: #888; word-break: break-all;';
+    infoEl.style.cssText = 'padding: 12px 15px; margin-bottom: 8px; background: #0a0a0a; border: 1px solid #1a1a1a; border-left: 2px solid #00d4ff; font-family: "Space Mono", monospace; font-size: 11px; color: #888; word-break: break-all;';
    infoEl.textContent = text;
    output.insertBefore(infoEl, output.firstChild);
 }
@@ -387,7 +387,7 @@ function showError(text) {
    const errorEl = document.createElement('div');
    errorEl.className = 'error-msg';
-    errorEl.style.cssText = 'padding: 12px 15px; margin-bottom: 8px; background: #1a0a0a; border: 1px solid #2a1a1a; border-left: 2px solid #ff3366; font-family: "Roboto Condensed", "Arial Narrow", sans-serif; font-size: 11px; color: #ff6688; word-break: break-all;';
+    errorEl.style.cssText = 'padding: 12px 15px; margin-bottom: 8px; background: #1a0a0a; border: 1px solid #2a1a1a; border-left: 2px solid #ff3366; font-family: "Space Mono", monospace; font-size: 11px; color: #ff6688; word-break: break-all;';
    errorEl.textContent = '⚠ ' + text;
    output.insertBefore(errorEl, output.firstChild);
 }
@@ -488,12 +488,10 @@ function initApp() {
        });
    });
-    // Collapse sidebar menu sections by default, but skip headerless utility blocks.
+    // Collapse all sections by default (except SDR Device which is first)
-    document.querySelectorAll('.sidebar .section').forEach((section) => {
+    document.querySelectorAll('.section').forEach((section, index) => {
-        if (section.querySelector('h3')) {
+        if (index > 0) {
            section.classList.add('collapsed');
        } else {
            section.classList.remove('collapsed');
        }
    });
--- a/Show More
+++ b/Show More