chore: bump version to 4.4.7-ba7opf.12.1 (versionCode 487)

fix(mutual,passes): map Match prefill opens at time-range card; whats-new dialog scrollable
- Match prefill now positions the LazyColumn via its initial state (queryMutualPasses(initialScrollIndex = 1)) instead of a post-layout scrollToItem, so the page reliably opens with the time-range card at the top while the 24h query runs. - The install-time what's new dialog text now scrolls inside a bounded box (max 360dp) instead of overflowing the fixed dialog frame.
2026-10-02 03:15:37 +00:00 · 2026-09-22 11:05:50 +08:00 · 2026-09-22 11:05:47 +08:00 · 2026-09-22 10:47:00 +08:00 · 2026-09-22 10:46:56 +08:00 · 2026-09-21 16:51:50 +08:00
267 changed files with 38545 additions and 3490 deletions
@@ -0,0 +1,5 @@
+# GitHub Copilot Instructions
+
+Read `AGENTS.md` first, then `CLAUDE.md`.
+
+`AGENTS.md` contains the architecture, module boundaries, implementation details, conventions, and gotchas.
@@ -0,0 +1,6 @@
+version: 2
+updates:
+  - package-ecosystem: "github-actions"
+    directory: "/"
+    schedule:
+      interval: "weekly"
@@ -16,59 +16,64 @@ jobs:
      contents: write
    steps:
      - name: Checkout Repository
-        uses: actions/checkout@v6
+        uses: actions/checkout@v7

      - name: Setup Java
        uses: actions/setup-java@v5
        with:
          distribution: 'temurin'
-          java-version: '17'
+          java-version: '21'

      - name: Setup Gradle
-        uses: gradle/actions/setup-gradle@v5
+        uses: gradle/actions/setup-gradle@v6

      - name: Assemble Artifacts
-        run: |
-          ./gradlew assembleRelease
-          ./gradlew bundleRelease
+        run: ./gradlew assembleRelease bundleRelease

      - name: Sign APK
-        uses: r0adkll/sign-android-release@v1
-        id: sign_apk
-        with:
-          releaseDirectory: app/build/outputs/apk/release
-          signingKeyBase64: ${{ secrets.KEY_STORE }}
-          keyStorePassword: ${{ secrets.KEY_STORE_PASSWORD }}
-          alias: ${{ secrets.KEY_ALIAS }}
-          keyPassword: ${{ secrets.KEY_PASSWORD }}
-        env:
-          BUILD_TOOLS_VERSION: "36.0.0"
+        run: |
+          echo "${{ secrets.KEY_STORE }}" | base64 -d > keystore.jks
+          APK=$(find app/build/outputs/apk/release -name "*.apk" | head -1)
+          BUILD_TOOLS=$(ls -d ${ANDROID_HOME}/build-tools/*/ | sort -V | tail -1)
+          ${BUILD_TOOLS}apksigner sign \
+            --ks keystore.jks \
+            --ks-pass pass:${{ secrets.KEY_STORE_PASSWORD }} \
+            --ks-key-alias ${{ secrets.KEY_ALIAS }} \
+            --key-pass pass:${{ secrets.KEY_PASSWORD }} \
+            --out app/build/outputs/apk/release/look4sat.apk \
+            "$APK"
+          rm keystore.jks

      - name: Sign Bundle
-        uses: r0adkll/sign-android-release@v1
-        id: sign_bundle
-        with:
-          releaseDirectory: app/build/outputs/bundle/release
-          signingKeyBase64: ${{ secrets.KEY_STORE }}
-          keyStorePassword: ${{ secrets.KEY_STORE_PASSWORD }}
-          alias: ${{ secrets.KEY_ALIAS }}
-          keyPassword: ${{ secrets.KEY_PASSWORD }}
-        env:
-          BUILD_TOOLS_VERSION: "36.0.0"
-
-      - name: Rename Artifacts
        run: |
-          mv ${{steps.sign_apk.outputs.signedReleaseFile}} app/build/outputs/apk/release/look4sat.apk
-          mv ${{steps.sign_bundle.outputs.signedReleaseFile}} app/build/outputs/apk/release/look4sat.aab
+          echo "${{ secrets.KEY_STORE }}" | base64 -d > keystore.jks
+          AAB=$(find app/build/outputs/bundle/release -name "*.aab" | head -1)
+          jarsigner -verbose -sigalg SHA256withRSA -digestalg SHA-256 \
+            -keystore keystore.jks \
+            -storepass ${{ secrets.KEY_STORE_PASSWORD }} \
+            -keypass ${{ secrets.KEY_PASSWORD }} \
+            "$AAB" ${{ secrets.KEY_ALIAS }}
+          rm keystore.jks

-      - name: Deploy Bundle
-        uses: r0adkll/upload-google-play@v1
+      - name: Setup Ruby
+        uses: ruby/setup-ruby@v1
        with:
-          serviceAccountJsonPlainText: ${{secrets.SERVICE_ACCOUNT_JSON}}
-          packageName: com.rtbishop.look4sat
-          releaseFiles: app/build/outputs/apk/release/look4sat.aab
-          track: production
-          whatsNewDirectory: fastlane/metadata/android/en-US/whatsnew
+          ruby-version: '3.4'
+
+      - name: Deploy Bundle to Google Play
+        run: |
+          gem install multi_json
+          gem install fastlane --no-document
+          AAB=$(find app/build/outputs/bundle/release -name "*.aab" | head -1)
+          echo '${{ secrets.SERVICE_ACCOUNT_JSON }}' > service_account.json
+          fastlane supply \
+            --aab "$AAB" \
+            --json_key service_account.json \
+            --package_name com.rtbishop.look4sat \
+            --track production \
+            --skip_upload_images true \
+            --skip_upload_screenshots true \
+          rm service_account.json

      - name: Create Release
        run: |
@@ -1,6 +1,9 @@
 # Built application files
 *.ap_

+# Hermes AI plans and metadata
+.hermes/
+
 # Files for the ART/Dalvik VM
 *.dex

@@ -15,6 +18,7 @@ out/
 # Gradle files
 .gradle/
 build/
+.cxx/

 # Local configuration file (sdk path, etc)
 local.properties
@@ -64,3 +68,4 @@ fastlane/readme.md
 /app/release/output-metadata.json
 /app/release/
 /.kotlin/sessions/
+dist/
@@ -0,0 +1,122 @@
+# Look4Sat AI Agent Instructions
+
+This is the canonical project guide for all AI assistants working on Look4Sat.
+All assistant-specific files (`CLAUDE.md`, `.github/copilot-instructions.md`) point here.
+
+---
+
+## Project Overview
+
+Look4Sat is an open-source, fully offline Android satellite tracker and pass predictor. It tracks 9000+ active
+satellites using TLE/OMM data from Celestrak/SatNOGS, calculates orbital positions via SGP4/SDP4 models, and displays
+passes relative to the user's location. Features include polar radar visualization, SSTV image decoding, satellite
+ground track mapping, and pass predictions up to 10 days ahead. No ads, no tracking, no network required after initial
+data download.
+
+## Architecture
+
+**MVI (Model-View-Intent)** with unidirectional data flow:
+- `State` data class → exposed via `StateFlow` from ViewModel
+- `Action` sealed interface → user intents dispatched to ViewModel's `onAction()`
+- Jetpack Compose UI observes state and recomposes reactively
+
+**Clean Architecture layers:**
+
+| Module               | Responsibility                                                      |
+|----------------------|---------------------------------------------------------------------|
+| `app`                | Entry point. Aggregates all modules                                 |
+| `core:data`          | Android library. Room DB, OkHttp networking, repo implementations   |
+| `core:domain`        | Pure Kotlin (JVM). Orbital math (SGP4/SDP4), models, repo contracts |
+| `core:presentation`  | Android library. Compose theme, shared UI components, NavKeys       |
+| `feature:map`        | OSMDroid map with ground tracks                                     |
+| `feature:passes`     | Pass predictions and upcoming events                                |
+| `feature:radar`      | Polar radar view of satellite positions, SSTV image decoding        |
+| `feature:satellites` | Satellite list, filtering, selection                                |
+| `feature:settings`   | User preferences                                                    |
+
+- `feature:*` modules depend only on `core:domain` + `core:presentation`. Features never depend on each other.
+
+## Build & Run
+
+```shell
+# Debug build
+./gradlew assembleDebug
+
+# Release build (minified, shrunk resources)
+./gradlew assembleRelease
+
+# Run tests
+./gradlew test
+```
+
+- **Min SDK**: 24 | **Target SDK**: 36 | **JDK**: 17
+- **Gradle**: Uses version catalog (`gradle/libs.versions.toml`) + convention plugins in `build-logic/`
+
+## Key Libraries
+
+- **Compose** (BOM 2026.05.01) + Material3 Adaptive
+- **Navigation3** (type-safe, uses `@Serializable` NavKeys)
+- **Room** (KSP code generation) for local satellite/TLE storage
+- **OkHttp** 5.x for TLE downloads
+- **OSMDroid** for map rendering
+- **Kotlin Serialization** for navigation args and data parsing
+- **Coroutines** + `StateFlow` for async/reactive patterns
+
+## Conventions
+
+- **Minimal dependencies**: Avoid adding libraries when a simple manual solution exists. Fewer deps = less maintenance.
+- **DI**: Manual — ViewModels use companion `factory()` methods with `IMainContainer` interface.
+- **Navigation**: Type-safe Compose Navigation3 with `@Serializable` data classes as nav keys.
+- **State naming**: `<Feature>State` data class + `<Feature>Action` sealed interface per feature.
+- **No feature-to-feature deps**: All cross-feature communication goes through core layers.
+- **Localization**: 7 languages (en, es, ru, si, tr, uk, zh).
+
+## Data Formats & Migration
+
+**TLE vs. OMM/CSV format:**
+
+Look4Sat supports both TLE and OMM (Orbit Mean-Elements Message) formats for backward compatibility:
+
+- **TLE format**: Traditional 3-line element format (deprecated). NORAD catalog numbers are 5-digit integers, which
+  are running out of space. Celestrak has signaled that TLE format will eventually be phased out.
+- **OMM/CSV format**: The future standard. CSV files contain the same orbital parameters as TLE but use ISO 8601
+  timestamps and support larger NORAD IDs. Celestrak and SatNOGS already provide OMM data in CSV format.
+
+**Current implementation:**
+- `DataParser.kt` handles both `parseTLEStream()` and `parseCSVStream()` seamlessly
+- TLE data is downloaded from configured sources and stored in Room database
+- When downloading satellite data, the app automatically detects format and parses accordingly
+- Both formats produce identical `OrbitalData` objects, ensuring transparent format switching
+
+**Migration path:**
+As NORAD catalog space becomes constrained, OMM/CSV will become the primary format. Look4Sat is already positioned
+to handle this transition without code changes — existing users can continue using TLE files while new sources
+transition to OMM/CSV automatically.
+
+## Code Style
+
+- Prefer **short, focused functions** — single responsibility, easy to read.
+- **Exceptions**: Composable functions and math-heavy algorithms (SGP4/SDP4) may be longer.
+- Strict code style — no dead code, no unused imports, consistent formatting.
+
+## Roadmap
+
+- **KMP migration**: `core:domain` is to become a fully shareable KMM module. Keep it pure Kotlin/JVM.
+
+## Gotchas
+
+- Orbital math lives in `core:domain/predict/` — it's dense vector math (SGP4/SDP4). Tread carefully.
+- TLE/OMM data must be refreshed weekly for accurate predictions (satellite orbits decay). TLE format is legacy and
+  will eventually be deprecated in favor of OMM/CSV as NORAD catalog numbers approach the 5-digit limit.
+- SSTV decoding in `feature:radar` is experimental; image quality depends on signal strength during satellite pass.
+- `build-logic/convention/` contains all shared Gradle configuration — edit there, not in individual modules.
+- ProGuard is enabled for release builds — don't add reflection-based libs or any other dependencies without asking.
+
+## Copilot Working Mode: Code-Only
+
+- Default to code changes only. Provide explanations in chat only.
+- If documentation seems useful, ask first before creating files.
+- Do NOT create any `.md` documentation files unless explicitly requested.
+- Do NOT add README, guides, summaries, migration notes, or how-to files unless asked.
+- Prefer minimal diffs focused on requested implementation.
+- Default validation is static checks (`get_errors`). Do NOT run Gradle compile/test tasks unless explicitly requested.
@@ -0,0 +1,5 @@
+# CLAUDE.md
+
+Read `AGENTS.md` first, then follow the instructions there.
+
+`AGENTS.md` contains the architecture, module boundaries, implementation details, conventions, and gotchas.
@@ -1,35 +1,42 @@
-# Look4Sat: Satellite tracker
+# Look4Sat-BA7OPF

-[![Look4Sat CI](https://github.com/rt-bishop/Look4Sat/actions/workflows/release.yml/badge.svg)](https://github.com/rt-bishop/Look4Sat/actions/workflows/release.yml)
+[![Release](https://img.shields.io/github/v/release/atsunatsu/Look4Sat)](https://github.com/atsunatsu/Look4Sat/releases)

-[<img src="https://play.google.com/intl/en_gb/badges/static/images/badges/en_badge_web_generic.png" alt="Get it on Google Play" height="80">](https://play.google.com/store/apps/details?id=com.rtbishop.look4sat)
-[<img src="https://fdroid.gitlab.io/artwork/badge/get-it-on.png" alt="Get it on F-Droid" height="80">](https://f-droid.org/packages/com.rtbishop.look4sat/)
+**BA7OPF 定制版** — 基于 [rt-bishop/Look4Sat](https://github.com/rt-bishop/Look4Sat) 的业余无线电卫星追踪器，增加了线性卫星频率计算器等功能。

-### Radio satellite tracker and pass predictor for Android, inspired by Gpredict
+## 本仓库特色功能

-<p float="left">
-<img src="fastlane/metadata/android/en-US/images/phoneScreenshots/1.png" width="192"/>
-<img src="fastlane/metadata/android/en-US/images/phoneScreenshots/2.png" width="192"/>
-<img src="fastlane/metadata/android/en-US/images/phoneScreenshots/3.png" width="192"/>
-<img src="fastlane/metadata/android/en-US/images/phoneScreenshots/4.png" width="192">
-</p>
+- **网格地图模式（Grid Mode）** — 地图页内置 VUCC 网格覆盖图：已通联网格绿色填充、漫游网格蓝色 45° 斜纹（疏朗半透明样式）、当前所在方格淡黄加粗框；点击已通联网格弹出该网格内通联明细弹窗；进入网格模式默认 VUCC 视图
+- **奖状边界模式（Award Boundaries）** — 在网格地图上叠加 DXCC / WAPC / WAJA / WAZ / WAS 国界·省界·分区边界，已确认区域绿色填充
+- **LoTW 网格同步** — 直连 ARRL Logbook（账号密码验证）下载确认报告，worked / roamed 网格自动更新（兼容任意字段顺序的 ADIF 解析）；同步失败按凭据错误/限流/超时分类提示
+- **双站过境匹配（Mutual Pass）** — 输入友台经纬度/网格，筛选双方同时可见的卫星过境，在地图上同时显示双方仰角曲线和地面轨迹，支持一键跳转雷达页查看详情
+- **线性卫星转发器频率计算器** — 在雷达页的 Calculator 标签页中，支持 TX/RX 双向多普勒频率计算，以及下行频率偏移（offset）输入，方便操作带偏移的线性卫星
+- **CW 解码器** — 集成 Morse Expert 解码引擎，支持瀑布图、实时解码文本（arm64 + armeabi-v7a 双架构）
+- **AMSAT 状态页** — 实时查看卫星的业余无线电转发器状态（开启/关闭/待机），支持 72 小时历史记录回放，启动时预取缓存
+- **应用内更新检查** — 设置页一键检查 GitHub 最新 Release，展示版本说明并直接下载安装
+- **自定义 TLE 数据源** — 可添加自定义 TLE/Celestrak CSV 数据源，长按拖拽排序，数据源启停开关与 HTTP 状态码显示
+- **中文界面优化** — 翻译修正、UI 布局调整，系统语言自动切换

-### Track satellite passes with ease!
+## 上游仓库

-Thanks to [Celestrak](https://celestrak.com/) and [SatNOGS](https://satnogs.org/) you have access to over 9000 active satellites.\
-You can search the entire database by NORAD Catalog Number or the satellite's name.
+本仓库是 [rt-bishop/Look4Sat](https://github.com/rt-bishop/Look4Sat) 的分支，上游仓库的原始功能包括：

-Orbital positions and passes are calculated relative to your location.\
-To get reliable data make sure to set the station position via the app Settings.
+- 基于 Celestrak / SatNOGS 数据的 9000+ 活跃卫星追踪
+- SGP4/SDP4 轨道预测，10 天过境预报
+- 极坐标雷达图、地面轨迹图
+- SSTV 图像解码
+- 无广告、无跟踪、完全离线

-The application is built using Kotlin, Coroutines, Jetpack Compose and Navigation.\
-It is now and always will be completely ad-free and open-source.
+## 许可证

-## Main features:
+GNU General Public License v3.0。详见 [LICENSE](LICENSE)。

-*  Predicting satellite positions and passes for up to 10 days
-*  Showing the list of currently active and upcoming satellite passes
-*  Showing the active pass progress, polar trajectory and transceivers info
-*  Showing the satellite positional data, footprint and ground track on the map
-*  Custom TLE satellite data import is available via Three Line Element .txt files
-*  Offline first: calculations are made offline. Weekly TLE data update is recommended.
+## Star History
+
+<a href="https://star-history.dera.page/#atsunatsu/Look4Sat&type=timeline&legend=top-left">
+ <picture>
+   <source media="(prefers-color-scheme: dark)" srcset="https://star-history.dera.page/svg?repos=atsunatsu/Look4Sat&type=timeline&theme=dark&legend=top-left" />
+   <source media="(prefers-color-scheme: light)" srcset="https://star-history.dera.page/svg?repos=atsunatsu/Look4Sat&type=timeline&legend=top-left" />
+   <img alt="Star History Chart" src="https://star-history.dera.page/svg?repos=atsunatsu/Look4Sat&type=timeline&legend=top-left" />
+ </picture>
+</a>
@@ -1,3 +1,41 @@
+import java.io.FileInputStream
+import java.util.Properties
+
 plugins {
-    alias(libs.plugins.convention.androidAppPlugin)
+    alias(libs.plugins.convention.applicationPlugin)
 }
+
+// Release signing credentials live in local.properties (gitignored) or
+// environment variables — never hardcode passwords in VCS.
+val releaseProps = Properties().apply {
+    val propsFile = rootProject.file("local.properties")
+    if (propsFile.exists()) FileInputStream(propsFile).use { load(it) }
+}
+fun releaseCred(name: String): String =
+    releaseProps.getProperty(name) ?: System.getenv(name) ?: ""
+
+android {
+    namespace = libs.versions.packageName.get()
+    defaultConfig {
+        applicationId = "cn.ba7opf.look4sat"
+        // CW decoder ships for both ABIs (see feature/cw jniLibs); the APK must
+        // not be pinned to 32-bit only or 64-bit devices fall back to ARM32.
+        ndk {
+            abiFilters.add("armeabi-v7a")
+            abiFilters.add("arm64-v8a")
+        }
+    }
+    signingConfigs {
+        create("release") {
+            storeFile = file(System.getProperty("user.home") + "/my-release-key.jks")
+            storePassword = releaseCred("RELEASE_STORE_PASSWORD")
+            keyAlias = releaseCred("RELEASE_KEY_ALIAS").ifEmpty { "look4sat" }
+            keyPassword = releaseCred("RELEASE_KEY_PASSWORD")
+        }
+    }
+    buildTypes {
+        release {
+            signingConfig = signingConfigs.getByName("release")
+        }
+    }
+}
@@ -2,6 +2,7 @@
 <manifest xmlns:android="http://schemas.android.com/apk/res/android">

    <uses-permission android:name="android.permission.ACCESS_NETWORK_STATE" />
+    <uses-permission android:name="android.permission.ACCESS_LOCAL_NETWORK" />
    <uses-permission android:name="android.permission.ACCESS_COARSE_LOCATION" />
    <uses-permission android:name="android.permission.ACCESS_FINE_LOCATION" />
    <uses-permission
@@ -11,26 +12,49 @@
    <uses-permission android:name="android.permission.BLUETOOTH_CONNECT" />
    <uses-permission android:name="android.permission.BLUETOOTH_SCAN" />
    <uses-permission android:name="android.permission.INTERNET" />
+    <uses-permission android:name="android.permission.RECORD_AUDIO" />
+    <uses-permission android:name="android.permission.REQUEST_INSTALL_PACKAGES" />

    <application
        android:name=".MainApplication"
+        android:allowBackup="false"
        android:icon="@mipmap/ic_launcher"
        android:label="@string/app_name"
+        android:networkSecurityConfig="@xml/network_security_config"
        android:roundIcon="@mipmap/ic_launcher_round">

        <activity
            android:name=".MainActivity"
            android:exported="true"
+            android:screenOrientation="portrait"
            android:theme="@style/Theme.Look4Sat.SplashScreen">
            <intent-filter>
                <action android:name="android.intent.action.MAIN" />
                <category android:name="android.intent.category.LAUNCHER" />
            </intent-filter>
+<!--            <intent-filter android:autoVerify="true">-->
+<!--                <action android:name="android.intent.action.VIEW" />-->
+<!--                <category android:name="android.intent.category.DEFAULT" />-->
+<!--                <category android:name="android.intent.category.BROWSABLE" />-->
+<!--                <data android:scheme="https" />-->
+<!--                <data android:host="github.com" />-->
+<!--                <data android:pathPattern="/rt-bishop/Look4Sat/passes.*" />-->
+<!--            </intent-filter>-->
        </activity>

        <meta-data
            android:name="android.telephony.PROPERTY_SATELLITE_DATA_OPTIMIZED"
            android:value="com.rtbishop.look4sat" />

+        <provider
+            android:name="androidx.core.content.FileProvider"
+            android:authorities="${applicationId}.fileprovider"
+            android:exported="false"
+            android:grantUriPermissions="true">
+            <meta-data
+                android:name="android.support.FILE_PROVIDER_PATHS"
+                android:resource="@xml/file_paths" />
+        </provider>
+
    </application>
 </manifest>
@@ -19,12 +19,21 @@ package com.rtbishop.look4sat

 import android.content.Context
 import android.content.res.Configuration
+import android.graphics.ColorMatrix
+import android.graphics.ColorMatrixColorFilter
+import android.graphics.Paint
 import android.os.Bundle
+import android.view.View
 import androidx.activity.ComponentActivity
 import androidx.activity.compose.setContent
 import androidx.activity.enableEdgeToEdge
 import androidx.core.splashscreen.SplashScreen.Companion.installSplashScreen
+import androidx.lifecycle.lifecycleScope
+import com.rtbishop.look4sat.core.domain.repository.IContainerProvider
 import com.rtbishop.look4sat.core.presentation.MainTheme
+import kotlinx.coroutines.flow.distinctUntilChanged
+import kotlinx.coroutines.flow.map
+import kotlinx.coroutines.launch

 class MainActivity : ComponentActivity() {

@@ -38,8 +47,37 @@ class MainActivity : ComponentActivity() {
        installSplashScreen()
        enableEdgeToEdge()
        super.onCreate(savedInstanceState)
+        observeNightFilterState()
        setContent {
-            MainTheme(isDarkTheme = true) { MainScreen() }
+            MainTheme(isDarkTheme = true) { NavRoot() }
+        }
+    }
+
+    private fun observeNightFilterState() {
+        val mainContainer = (applicationContext as IContainerProvider).getMainContainer()
+        lifecycleScope.launch {
+            mainContainer.settingsRepo.otherSettings
+                .map { it.stateOfNightMode }
+                .distinctUntilChanged()
+                .collect { nightMode -> applyNightFilter(nightMode) }
+        }
+    }
+
+    private fun applyNightFilter(enabled: Boolean) {
+        if (enabled) {
+            val nightMatrix = ColorMatrix(
+                floatArrayOf(
+                    1f, 0f, 0f, 0f, 0f,   // R → R
+                    0f, 0f, 0f, 0f, 0f,   // G → 0
+                    0f, 0f, 0f, 0f, 0f,   // B → 0
+                    0f, 0f, 0f, 1f, 0f    // A → A
+                )
+            )
+            window.decorView.setLayerType(View.LAYER_TYPE_HARDWARE, Paint().apply {
+                colorFilter = ColorMatrixColorFilter(nightMatrix)
+            })
+        } else {
+            window.decorView.setLayerType(View.LAYER_TYPE_NONE, null)
        }
    }
 }
@@ -17,10 +17,20 @@
 */
 package com.rtbishop.look4sat

+import android.app.Activity
 import android.app.Application
+import android.app.Application.ActivityLifecycleCallbacks
+import android.os.Bundle
 import com.rtbishop.look4sat.core.data.injection.MainContainer
 import com.rtbishop.look4sat.core.domain.repository.IContainerProvider
 import com.rtbishop.look4sat.core.domain.repository.IMainContainer
+import com.rtbishop.look4sat.core.domain.repository.LoTWSyncMode
+import com.rtbishop.look4sat.core.domain.repository.LoTWResult
+import com.rtbishop.look4sat.core.domain.repository.applyLoTWGridResult
+import com.rtbishop.look4sat.core.domain.repository.lotwCursorApi
+import com.rtbishop.look4sat.core.domain.repository.lotwSyncToday
+import com.rtbishop.look4sat.core.domain.repository.resolveLoTWSyncMode
+import com.rtbishop.look4sat.core.domain.repository.shouldAutoSyncLoTW
 import kotlinx.coroutines.launch
 import java.text.SimpleDateFormat
 import java.util.Date
@@ -35,12 +45,39 @@ class MainApplication : Application(), IContainerProvider {
    override fun onCreate() {
        super.onCreate()
        container = MainContainer(this)
+        clearAmSatCacheOnAppBackground()
        // trigger automatic update every 48 hours
        container.appScope.launch { checkAutoUpdate() }
+        // automatic LoTW grid sync on every app start (gated, see checkLoTWAutoSync)
+        container.appScope.launch { checkLoTWAutoSync() }
        // load satellite data on every app start
        container.appScope.launch { container.satelliteRepo.initRepository() }
    }

+    private fun clearAmSatCacheOnAppBackground() {
+        registerActivityLifecycleCallbacks(object : ActivityLifecycleCallbacks {
+            private var startedActivityCount = 0
+
+            override fun onActivityStarted(activity: Activity) {
+                if (startedActivityCount == 0) {
+                    container.appScope.launch { container.amSatRepo.prefetchStatus() }
+                }
+                startedActivityCount += 1
+            }
+
+            override fun onActivityStopped(activity: Activity) {
+                startedActivityCount = (startedActivityCount - 1).coerceAtLeast(0)
+                if (startedActivityCount == 0) container.amSatRepo.clearStatusCache()
+            }
+
+            override fun onActivityCreated(activity: Activity, savedInstanceState: Bundle?) = Unit
+            override fun onActivityResumed(activity: Activity) = Unit
+            override fun onActivityPaused(activity: Activity) = Unit
+            override fun onActivitySaveInstanceState(activity: Activity, outState: Bundle) = Unit
+            override fun onActivityDestroyed(activity: Activity) = Unit
+        })
+    }
+
    private suspend fun checkAutoUpdate(timeNow: Long = System.currentTimeMillis()) {
        if (container.settingsRepo.otherSettings.value.stateOfAutoUpdate) {
            val timeDelta = timeNow - container.settingsRepo.databaseState.value.updateTimestamp
@@ -51,4 +88,37 @@ class MainApplication : Application(), IContainerProvider {
            }
        }
    }
+
+    /**
+     * Automatic LoTW grid sync, mirroring [checkAutoUpdate]: checked on every
+     * app start, but only pulls when due — LoTW credentials configured, the
+     * LoTW auto-sync toggle on, at least one prior (manual) sync, and not
+     * already synced today (ARRL limits report pulls, ~once a day per account).
+     * Incremental when the callsign is unchanged; a callsign change falls back
+     * to a full replace so no stale grids from another account linger.
+     * Failures are silent and simply retried on the next app start — the manual
+     * sync button still surfaces the explicit cause to the user.
+     */
+    private suspend fun checkLoTWAutoSync(timeNow: Long = System.currentTimeMillis()) {
+        val settingsRepo = container.settingsRepo
+        val lotwSettings = settingsRepo.lotwSettings.value
+        if (!shouldAutoSyncLoTW(
+                isConfigured = lotwSettings.isConfigured,
+                autoLotwSyncEnabled = settingsRepo.otherSettings.value.stateOfAutoLotwSync,
+                lastSyncDate = settingsRepo.getLastLotwSyncDate(),
+                today = lotwSyncToday(timeNow)
+            )
+        ) return
+        val callsign = lotwSettings.callsign.trim().uppercase()
+        val mode = resolveLoTWSyncMode(settingsRepo.getLastLotwSyncCallsign(), callsign, requested = null)
+        val since = if (mode == LoTWSyncMode.Incremental) lotwCursorApi(settingsRepo.getLastLotwSyncDate()) else ""
+        println("Started periodic LoTW grid sync (${mode.name.lowercase()})")
+        val result = container.lotwRepo.fetchConfirmedGridQsos(callsign, lotwSettings.password, since)
+        if (result is LoTWResult.Success) {
+            val count = applyLoTWGridResult(settingsRepo, result, mode, callsign, timeNow)
+            println("Periodic LoTW grid sync finished: $count worked grids")
+        } else {
+            println("Periodic LoTW grid sync skipped (${result::class.simpleName})")
+        }
+    }
 }
@@ -17,74 +17,309 @@
 */
 package com.rtbishop.look4sat

+import androidx.compose.animation.core.LinearEasing
+import androidx.compose.animation.core.RepeatMode
+import androidx.compose.animation.core.animateFloat
+import androidx.compose.animation.core.infiniteRepeatable
+import androidx.compose.animation.core.rememberInfiniteTransition
 import androidx.compose.animation.core.tween
 import androidx.compose.animation.fadeIn
 import androidx.compose.animation.fadeOut
+import androidx.compose.animation.slideInHorizontally
+import androidx.compose.animation.slideOutHorizontally
+import androidx.compose.animation.togetherWith
+import androidx.compose.foundation.background
+import androidx.compose.foundation.clickable
+import androidx.compose.foundation.layout.Box
+import androidx.compose.foundation.layout.Column
+import androidx.compose.foundation.layout.Row
+import androidx.compose.foundation.layout.Spacer
+import androidx.compose.foundation.layout.fillMaxSize
+import androidx.compose.foundation.layout.fillMaxWidth
+import androidx.compose.foundation.layout.padding
+import androidx.compose.foundation.layout.size
+import androidx.compose.foundation.layout.width
+import androidx.compose.foundation.shape.CircleShape
 import androidx.compose.material3.Icon
 import androidx.compose.material3.MaterialTheme
+import androidx.compose.material3.Surface
 import androidx.compose.material3.Text
 import androidx.compose.material3.adaptive.navigationsuite.NavigationSuiteDefaults
 import androidx.compose.material3.adaptive.navigationsuite.NavigationSuiteScaffold
 import androidx.compose.material3.adaptive.navigationsuite.NavigationSuiteType
 import androidx.compose.runtime.Composable
+import androidx.compose.runtime.CompositionLocalProvider
+import androidx.compose.runtime.LaunchedEffect
+import androidx.compose.runtime.getValue
+import androidx.compose.runtime.remember
+import androidx.compose.runtime.setValue
+import androidx.compose.ui.Alignment
+import androidx.compose.ui.Modifier
+import androidx.compose.ui.draw.clip
+import androidx.compose.ui.graphics.Color
+import androidx.compose.ui.platform.LocalContext
 import androidx.compose.ui.res.painterResource
 import androidx.compose.ui.res.stringResource
-import androidx.navigation.NavHostController
-import androidx.navigation.compose.NavHost
-import androidx.navigation.compose.currentBackStackEntryAsState
-import androidx.navigation.compose.rememberNavController
+import androidx.compose.ui.text.font.FontWeight
+import androidx.compose.ui.unit.dp
+import androidx.compose.ui.unit.sp
+import androidx.lifecycle.ViewModelStoreOwner
+import androidx.lifecycle.compose.collectAsStateWithLifecycle
+import androidx.lifecycle.viewmodel.compose.viewModel
+import androidx.lifecycle.viewmodel.navigation3.rememberViewModelStoreNavEntryDecorator
+import androidx.navigation3.runtime.entryProvider
+import androidx.navigation3.runtime.rememberNavBackStack
+import androidx.navigation3.runtime.rememberSaveableStateHolderNavEntryDecorator
+import androidx.navigation3.ui.NavDisplay
+import com.rtbishop.look4sat.core.domain.repository.IContainerProvider
+import com.rtbishop.look4sat.core.domain.repository.MutualPassData
+import com.rtbishop.look4sat.core.presentation.DeeplinkResolver
+import com.rtbishop.look4sat.core.presentation.ElevationThresholds
+import com.rtbishop.look4sat.core.presentation.LocalElevationThresholds
+import com.rtbishop.look4sat.core.presentation.RadarDestination
 import com.rtbishop.look4sat.core.presentation.Screen
 import com.rtbishop.look4sat.core.presentation.hasEnoughHeight
 import com.rtbishop.look4sat.core.presentation.hasEnoughWidth
-import com.rtbishop.look4sat.feature.map.mapDestination
-import com.rtbishop.look4sat.feature.passes.passesDestination
-import com.rtbishop.look4sat.feature.radar.radarDestination
-import com.rtbishop.look4sat.feature.satellites.satellitesDestination
-import com.rtbishop.look4sat.feature.settings.settingsDestination
+import com.rtbishop.look4sat.feature.map.MapDestination
+import com.rtbishop.look4sat.feature.map.MapFilterViewModel
+import com.rtbishop.look4sat.feature.mutual.MutualScreen
+import com.rtbishop.look4sat.feature.mutual.MutualViewModel
+import com.rtbishop.look4sat.feature.passes.PassesDestination
+import com.rtbishop.look4sat.feature.radar.RadarDestination
+import com.rtbishop.look4sat.feature.satellites.SatellitesDestination
+import com.rtbishop.look4sat.feature.settings.SettingsDestination
+import com.rtbishop.look4sat.feature.status.SatStatusDestination

@Composable
-fun MainScreen(navController: NavHostController = rememberNavController()) {
-    val items = listOf(Screen.Satellites, Screen.Passes, Screen.Radar, Screen.Map, Screen.Settings)
-    val currentDestination = navController.currentBackStackEntryAsState().value?.destination?.route
-    val startDestination = Screen.Passes.route
-    NavigationSuiteScaffold(
-        navigationSuiteItems = {
-            items.forEach {
-                item(
-                    icon = { Icon(painterResource(it.iconResId), stringResource(it.titleResId)) },
-                    label = { Text(stringResource(it.titleResId)) },
-                    selected = currentDestination?.contains(it.route) ?: false,
-                    onClick = {
-                        if (currentDestination?.contains(it.route) ?: false) return@item
-                        navController.navigate(it.route) {
-                            popUpTo(startDestination) { saveState = false }
-                            launchSingleTop = true
-                            restoreState = false
-                        }
-                    })
-            }
-        }, navigationSuiteColors = NavigationSuiteDefaults.colors(
-            navigationRailContainerColor = MaterialTheme.colorScheme.surfaceContainer
-        ), layoutType = when {
-            !hasEnoughHeight() && hasEnoughWidth() -> NavigationSuiteType.NavigationRail
-            !hasEnoughWidth() -> NavigationSuiteType.ShortNavigationBarCompact
-            else -> NavigationSuiteType.ShortNavigationBarMedium
-        }
+fun NavRoot(deeplink: String? = null) {
+    val rootBackStack = rememberNavBackStack(Screen.Passes)
+    val deeplinkResolver = DeeplinkResolver()
+    LaunchedEffect(deeplink) {
+        deeplink?.let { rootBackStack.add(deeplinkResolver.resolve(it)) }
+    }
+    val navigateBack: () -> Unit = { rootBackStack.removeLastOrNull() }
+    val navigateToRadar: () -> Unit = { rootBackStack.add(RadarDestination) }
+    // Incoming screen slides in from the right, outgoing drifts left at 1/3 speed (API35+ style)
+    val pushTransition = slideInHorizontally(tween(300)) { it } togetherWith
+        slideOutHorizontally(tween(300)) { -it / 3 }
+    // Reverse: outgoing slides out to the right, incoming drifts in from the left
+    val popTransition = slideInHorizontally(tween(300)) { -it / 3 } togetherWith
+        slideOutHorizontally(tween(300)) { it }
+    // Elevation color thresholds must be provided at the root level so that BOTH
+    // the tab content (MainScreen) and the root-level RadarDestination see the
+    // user's custom thresholds. RadarDestination is a sibling entry of MainScreen
+    // in this NavDisplay, so a provider inside MainScreen never reaches it.
+    val context = LocalContext.current
+    val container = (context.applicationContext as IContainerProvider).getMainContainer()
+    val otherSettings by container.settingsRepo.otherSettings.collectAsStateWithLifecycle()
+    CompositionLocalProvider(
+        LocalElevationThresholds provides ElevationThresholds(
+            low = otherSettings.lowElevation,
+            high = otherSettings.highElevation
+        )
    ) {
-        NavHost(
-            navController = navController,
-            startDestination = startDestination,
-            enterTransition =  { fadeIn(animationSpec = tween(350)) },
-            exitTransition = { fadeOut(animationSpec = tween(350)) }
-        ) {
-            satellitesDestination { navController.navigateUp() }
-            passesDestination { catNum: Int, aosTime: Long ->
-                val radarRoute = "${Screen.Radar.route}?catNum=${catNum}&aosTime=${aosTime}"
-                navController.navigate(radarRoute)
+        NavDisplay(
+            modifier = Modifier.fillMaxSize(),
+            backStack = rootBackStack,
+            onBack = navigateBack,
+            transitionSpec = { pushTransition },
+            popTransitionSpec = { popTransition },
+            predictivePopTransitionSpec = { popTransition },
+            entryDecorators = listOf(
+                rememberSaveableStateHolderNavEntryDecorator(),
+                rememberViewModelStoreNavEntryDecorator()
+            ),
+            entryProvider = entryProvider {
+                entry<Screen.Passes> {
+                    MainScreen(
+                        navigateToRadar = navigateToRadar
+                    )
+                }
+                entry<RadarDestination> {
+                    Surface(
+                        modifier = Modifier.fillMaxSize(),
+                        color = MaterialTheme.colorScheme.background
+                    ) {
+                        RadarDestination(navigateUp = navigateBack)
+                    }
+                }
+            }
+        )
+    }
+}
+
+@Composable
+fun MainScreen(
+    navigateToRadar: () -> Unit = {}
+) {
+    val backStack = rememberNavBackStack(Screen.Passes)
+    val currentKey = backStack.lastOrNull()
+    val navigateBack: () -> Unit = { backStack.removeLastOrNull() }
+    val fadeTransition = fadeIn(animationSpec = tween(350)) togetherWith fadeOut(animationSpec = tween(350))
+    // Map sits at position 4 from the left, matching the upstream nav order
+    // (Satellites, Passes, AMSAT/Status, Map, ...), with the fork's Mutual tab
+    // appended before Settings.
+    val navItems = listOf(Screen.Satellites, Screen.Passes, Screen.AMSAT, Screen.Map, Screen.Mutual, Screen.Settings)
+
+    val context = LocalContext.current
+    val container = (context.applicationContext as IContainerProvider).getMainContainer()
+    val trackingState by container.radioTrackingService.state.collectAsStateWithLifecycle()
+    val otherSettings by container.settingsRepo.otherSettings.collectAsStateWithLifecycle()
+    // Activity-scoped so the mutual query results survive navigation to Radar and back
+    val mutualViewModel: MutualViewModel = viewModel(
+        viewModelStoreOwner = context as ViewModelStoreOwner,
+        factory = MutualViewModel.factory(container)
+    )
+    // Activity-scoped so the map's award filter survives page switches;
+    // resets to VUCC only on cold start (fresh process).
+    val mapFilterViewModel: MapFilterViewModel = viewModel(
+        viewModelStoreOwner = context as ViewModelStoreOwner,
+        factory = MapFilterViewModel.factory()
+    )
+
+    CompositionLocalProvider(
+        LocalElevationThresholds provides ElevationThresholds(
+            low = otherSettings.lowElevation,
+            high = otherSettings.highElevation
+        )
+    ) {
+        NavigationSuiteScaffold(
+            navigationSuiteItems = {
+                navItems.forEach { screen ->
+                    val isSelected = when (currentKey) {
+                        is Screen.Satellites -> screen is Screen.Satellites
+                        is Screen.Passes -> screen is Screen.Passes
+                        is Screen.Map -> screen is Screen.Map
+                        is Screen.AMSAT -> screen is Screen.AMSAT
+                        is Screen.Mutual -> screen is Screen.Mutual
+                        is Screen.Settings -> screen is Screen.Settings
+                        else -> false
+                    }
+                    item(
+                        icon = { Icon(painterResource(screen.iconResId), stringResource(screen.titleResId)) },
+                        label = { Text(stringResource(screen.titleResId)) },
+                        selected = isSelected,
+                        onClick = {
+                            if (isSelected) return@item
+                            while (backStack.size > 1) backStack.removeAt(backStack.size - 1)
+                            if (screen !is Screen.Passes) backStack.add(screen)
+                        }
+                    )
+                }
+            },
+            navigationSuiteColors = NavigationSuiteDefaults.colors(
+                navigationRailContainerColor = MaterialTheme.colorScheme.surfaceContainer
+            ),
+            layoutType = when {
+                !hasEnoughHeight() && hasEnoughWidth() -> NavigationSuiteType.NavigationRail
+                !hasEnoughWidth() -> NavigationSuiteType.ShortNavigationBarCompact
+                else -> NavigationSuiteType.ShortNavigationBarMedium
+            }
+        ) {
+            Column {
+                NavDisplay(
+                    backStack = backStack,
+                    modifier = Modifier.weight(1f),
+                    onBack = navigateBack,
+                    transitionSpec = { fadeTransition },
+                    popTransitionSpec = { fadeTransition },
+                    predictivePopTransitionSpec = { fadeTransition },
+                    entryDecorators = listOf(
+                        // Required for saving Compose state per entry
+                        rememberSaveableStateHolderNavEntryDecorator(),
+                        // Required for ViewModel scoping per entry
+                        rememberViewModelStoreNavEntryDecorator()
+                    ),
+                    entryProvider = entryProvider {
+                        entry<Screen.Satellites> {
+                            SatellitesDestination(navigateUp = navigateBack)
+                        }
+                        entry<Screen.Passes> {
+                            PassesDestination(
+                                navigateToRadar = { catNum, aosTime ->
+                                    container.setMutualPassData(MutualPassData())
+                                    container.satelliteRepo.selectPass(catNum, aosTime)
+                                    navigateToRadar()
+                                }
+                            )
+                        }
+                        entry<Screen.Map> {
+                            MapDestination(
+                                mapFilterViewModel = mapFilterViewModel,
+                                onMatchGrid = { grid ->
+                                    // Grid-QSO dialog "Match" button: pre-fill the
+                                    // match page for that grid and switch to its tab.
+                                    mutualViewModel.prefillMatchFromGrid(grid)
+                                    while (backStack.size > 1) backStack.removeAt(backStack.size - 1)
+                                    backStack.add(Screen.Mutual)
+                                }
+                            )
+                        }
+                        entry<Screen.Mutual> {
+                            MutualScreen(
+                                viewModel = mutualViewModel,
+                                navigateToRadar = { catNum, aosTime, pass ->
+                                    container.setMutualPassData(pass ?: MutualPassData())
+                                    container.satelliteRepo.selectPass(catNum, aosTime)
+                                    navigateToRadar()
+                                }
+                            )
+                        }
+                        entry<Screen.AMSAT> { SatStatusDestination() }
+                        entry<Screen.Settings> {
+                            SettingsDestination()
+                        }
+                    }
+                )
+                // Radio tracking status banner
+                if (trackingState.isActive) {
+                    val infiniteTransition = rememberInfiniteTransition(label = "trackingPulse")
+                    val alpha by infiniteTransition.animateFloat(
+                        initialValue = 1f, targetValue = 0.4f,
+                        animationSpec = infiniteRepeatable(
+                            animation = tween(1000, easing = LinearEasing),
+                            repeatMode = RepeatMode.Reverse
+                        ), label = "pulseAlpha"
+                    )
+                    Row(
+                        verticalAlignment = Alignment.CenterVertically,
+                        modifier = Modifier
+                            .fillMaxWidth()
+                            .background(MaterialTheme.colorScheme.primaryContainer)
+                            .clickable {
+                                val pass = trackingState.currentPass
+                                if (pass != null) {
+                                    container.setMutualPassData(MutualPassData())
+                                    container.satelliteRepo.selectPass(pass.catNum, pass.aosTime)
+                                    navigateToRadar()
+                                }
+                            }
+                            .padding(horizontal = 12.dp, vertical = 6.dp)
+                    ) {
+                        Box(
+                            modifier = Modifier
+                                .size(8.dp)
+                                .clip(CircleShape)
+                                .background(Color(0xFF4CAF50).copy(alpha = alpha))
+                        )
+                        Spacer(modifier = Modifier.width(8.dp))
+                        Text(
+                            text = "Tracking: ${trackingState.currentPass?.name ?: ""}",
+                            fontSize = 13.sp,
+                            fontWeight = FontWeight.Medium,
+                            color = MaterialTheme.colorScheme.onPrimaryContainer,
+                            modifier = Modifier.weight(1f)
+                        )
+                        val txOk = if (trackingState.txConnected) "TX" else ""
+                        val rxOk = if (trackingState.rxConnected) "RX" else ""
+                        Text(
+                            text = listOf(txOk, rxOk).filter { it.isNotBlank() }.joinToString("/"),
+                            fontSize = 12.sp,
+                            color = MaterialTheme.colorScheme.onPrimaryContainer
+                        )
+                    }
+                }
            }
-            radarDestination { navController.navigateUp() }
-            mapDestination()
-            settingsDestination()
        }
    }
 }
@@ -0,0 +1,4 @@
+<?xml version="1.0" encoding="utf-8"?>
+<paths xmlns:android="http://schemas.android.com/apk/res/android">
+    <cache-path name="updates" path="." />
+</paths>
@@ -0,0 +1,4 @@
+<?xml version="1.0" encoding="utf-8"?>
+<network-security-config>
+    <base-config cleartextTrafficPermitted="true" />
+</network-security-config>
@@ -24,25 +24,25 @@ group = "com.rtbishop.look4sat.build_logic.convention"

 gradlePlugin {
    plugins {
-        register("androidAppPlugin") {
-            id = libs.plugins.convention.androidAppPlugin.get().pluginId
-            implementationClass = "com.rtbishop.look4sat.convention.AndroidAppPlugin"
+        register("applicationPlugin") {
+            id = libs.plugins.convention.applicationPlugin.get().pluginId
+            implementationClass = "com.rtbishop.look4sat.convention.ApplicationPlugin"
        }
-        register("androidLibraryPlugin") {
-            id = libs.plugins.convention.androidLibraryPlugin.get().pluginId
-            implementationClass = "com.rtbishop.look4sat.convention.AndroidLibraryPlugin"
+        register("coreDataPlugin") {
+            id = libs.plugins.convention.coreDataPlugin.get().pluginId
+            implementationClass = "com.rtbishop.look4sat.convention.CoreDataPlugin"
        }
-        register("composeFeaturePlugin") {
-            id = libs.plugins.convention.composeFeaturePlugin.get().pluginId
-            implementationClass = "com.rtbishop.look4sat.convention.ComposeFeaturePlugin"
+        register("coreDomainPlugin") {
+            id = libs.plugins.convention.coreDomainPlugin.get().pluginId
+            implementationClass = "com.rtbishop.look4sat.convention.CoreDomainPlugin"
        }
-        register("composeLibraryPlugin") {
-            id = libs.plugins.convention.composeLibraryPlugin.get().pluginId
-            implementationClass = "com.rtbishop.look4sat.convention.ComposeLibraryPlugin"
+        register("corePresentationPlugin") {
+            id = libs.plugins.convention.corePresentationPlugin.get().pluginId
+            implementationClass = "com.rtbishop.look4sat.convention.CorePresentationPlugin"
        }
-        register("kotlinLibraryPlugin") {
-            id = libs.plugins.convention.kotlinLibraryPlugin.get().pluginId
-            implementationClass = "com.rtbishop.look4sat.convention.KotlinLibraryPlugin"
+        register("featurePlugin") {
+            id = libs.plugins.convention.featurePlugin.get().pluginId
+            implementationClass = "com.rtbishop.look4sat.convention.FeaturePlugin"
        }
    }
 }
@@ -1,46 +0,0 @@
-/*
- * Look4Sat. Amateur radio satellite tracker and pass predictor.
- * Copyright (C) 2019-2026 Arty Bishop and contributors.
- *
- * This program is free software: you can redistribute it and/or modify
- * it under the terms of the GNU General Public License as published by
- * the Free Software Foundation, either version 3 of the License, or
- * (at your option) any later version.
- *
- * This program is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- * GNU General Public License for more details.
- *
- * You should have received a copy of the GNU General Public License
- * along with this program.  If not, see <https://www.gnu.org/licenses/>.
- */
-package com.rtbishop.look4sat.convention
-
-import org.gradle.api.Plugin
-import org.gradle.api.Project
-import org.gradle.kotlin.dsl.dependencies
-
-@Suppress("Unused")
-internal class AndroidAppPlugin : Plugin<Project> {
-    override fun apply(target: Project) {
-        with(target) {
-            setupAndroidApplication()
-            setupComposeFeature()
-            setupKotlinToolchain()
-            setupAndroidTestDependencies()
-            setupTestDependencies()
-            dependencies {
-                IMPLEMENTATION(project(":core:data"))
-                IMPLEMENTATION(project(":core:domain"))
-                IMPLEMENTATION(project(":core:presentation"))
-                IMPLEMENTATION(project(":feature:map"))
-                IMPLEMENTATION(project(":feature:passes"))
-                IMPLEMENTATION(project(":feature:radar"))
-                IMPLEMENTATION(project(":feature:satellites"))
-                IMPLEMENTATION(project(":feature:settings"))
-                IMPLEMENTATION(libs.androidx.core.splashscreen)
-            }
-        }
-    }
-}
@@ -0,0 +1,47 @@
+/*
+ * Look4Sat. Amateur radio satellite tracker and pass predictor.
+ * Copyright (C) 2019-2026 Arty Bishop and contributors.
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <https://www.gnu.org/licenses/>.
+ */
+package com.rtbishop.look4sat.convention
+
+import org.gradle.api.Plugin
+import org.gradle.api.Project
+import org.gradle.kotlin.dsl.dependencies
+
+@Suppress("Unused")
+internal class ApplicationPlugin : Plugin<Project> {
+    override fun apply(target: Project) = with(target) {
+        setupAndroidApp()
+        setupCompose()
+        setupKotlin()
+        dependencies {
+            implementation(project(":core:data"))
+            implementation(project(":core:domain"))
+            implementation(project(":core:presentation"))
+            implementation(project(":feature:map"))
+            implementation(project(":feature:mutual"))
+            implementation(project(":feature:passes"))
+            implementation(project(":feature:radar"))
+            implementation(project(":feature:satellites"))
+            implementation(project(":feature:settings"))
+            implementation(project(":feature:status"))
+            implementation(libs.androidx.core.splashscreen)
+            implementation(libs.compose.material3.adaptive)
+            implementation(libs.compose.navigation3)
+            androidTestImplementation(libs.bundles.androidTest)
+        }
+    }
+}
@@ -22,25 +22,22 @@ import org.gradle.api.Project
 import org.gradle.kotlin.dsl.dependencies

@Suppress("Unused")
-internal class AndroidLibraryPlugin : Plugin<Project> {
-    override fun apply(target: Project) {
-        with(target) {
-            with(pluginManager) {
-                alias(libs.plugins.google.ksp)
-            }
-            setupCommonLibrary()
-            setupKotlinToolchain()
-            setupAndroidTestDependencies()
-            setupTestDependencies()
-            dependencies {
-                IMPLEMENTATION(project(":core:domain"))
-                IMPLEMENTATION(libs.androidx.core.ktx)
-                IMPLEMENTATION(libs.androidx.room.asProvider())
-                IMPLEMENTATION(libs.androidx.room.runtime)
-                KSP(libs.androidx.room.compiler)
-                IMPLEMENTATION(libs.other.coroutines)
-                IMPLEMENTATION(libs.other.okhttp)
-            }
+internal class CoreDataPlugin : Plugin<Project> {
+    override fun apply(target: Project) = with(target) {
+        applyPlugin(libs.plugins.google.ksp)
+        setupAndroidLib()
+        setupKotlin()
+        dependencies {
+            implementation(project(":core:domain"))
+            implementation(libs.androidx.core.ktx)
+            implementation(libs.androidx.room)
+            implementation(libs.androidx.room.runtime)
+            ksp(libs.androidx.room.compiler)
+            implementation(libs.kotlin.coroutines)
+            implementation(libs.other.okhttp)
+            // android.jar's org.json is a stub ("not mocked") in unit tests;
+            // provide a real implementation so JSON parsing is testable.
+            testImplementation(libs.test.json)
        }
    }
 }
@@ -22,18 +22,14 @@ import org.gradle.api.Project
 import org.gradle.kotlin.dsl.dependencies

@Suppress("Unused")
-internal class KotlinLibraryPlugin : Plugin<Project> {
-    override fun apply(target: Project) {
-        with(target) {
-            with(pluginManager) {
-                alias(libs.plugins.kotlin.jvm)
-            }
-            setupKotlinToolchain()
-            setupTestDependencies()
-            dependencies {
-                IMPLEMENTATION(libs.other.coroutines)
-                IMPLEMENTATION(libs.other.json)
-            }
+internal class CoreDomainPlugin : Plugin<Project> {
+    override fun apply(target: Project) = with(target) {
+        applyPlugin(libs.plugins.kotlin.jvm)
+        applyPlugin(libs.plugins.kotlin.serialization)
+        setupKotlin()
+        dependencies {
+            implementation(libs.kotlin.coroutines)
+            implementation(libs.kotlin.serialization)
        }
    }
 }
@@ -22,18 +22,17 @@ import org.gradle.api.Project
 import org.gradle.kotlin.dsl.dependencies

@Suppress("Unused")
-internal class ComposeLibraryPlugin : Plugin<Project> {
-    override fun apply(target: Project) {
-        with(target) {
-            setupCommonLibrary()
-            setupComposeFeature()
-            setupKotlinToolchain()
-            setupAndroidTestDependencies()
-            setupTestDependencies()
-            dependencies {
-                IMPLEMENTATION(project(":core:domain"))
-                IMPLEMENTATION(libs.androidx.core.splashscreen)
-            }
+internal class CorePresentationPlugin : Plugin<Project> {
+    override fun apply(target: Project) = with(target) {
+        applyPlugin(libs.plugins.kotlin.serialization)
+        setupAndroidLib()
+        setupCompose()
+        setupKotlin()
+        dependencies {
+            implementation(project(":core:domain"))
+            implementation(libs.androidx.core.splashscreen)
+            implementation(libs.kotlin.serialization)
+            implementation(libs.compose.material3.adaptive)
        }
    }
 }
@@ -22,18 +22,14 @@ import org.gradle.api.Project
 import org.gradle.kotlin.dsl.dependencies

@Suppress("Unused")
-internal class ComposeFeaturePlugin : Plugin<Project> {
-    override fun apply(target: Project) {
-        with(target) {
-            setupCommonLibrary()
-            setupComposeFeature()
-            setupKotlinToolchain()
-            setupAndroidTestDependencies()
-            setupTestDependencies()
-            dependencies {
-                IMPLEMENTATION(project(":core:domain"))
-                IMPLEMENTATION(project(":core:presentation"))
-            }
+internal class FeaturePlugin : Plugin<Project> {
+    override fun apply(target: Project) = with(target) {
+        setupAndroidLib()
+        setupCompose()
+        setupKotlin()
+        dependencies {
+            implementation(project(":core:domain"))
+            implementation(project(":core:presentation"))
        }
    }
 }
@@ -21,7 +21,7 @@ import com.android.build.api.dsl.ApplicationExtension
 import com.android.build.api.dsl.CommonExtension
 import org.gradle.accessors.dm.LibrariesForLibs
 import org.gradle.api.Project
-import org.gradle.api.plugins.PluginManager
+import org.gradle.api.artifacts.dsl.DependencyHandler
 import org.gradle.api.provider.Provider
 import org.gradle.kotlin.dsl.accessors.runtime.extensionOf
 import org.gradle.kotlin.dsl.configure
@@ -29,23 +29,30 @@ import org.gradle.kotlin.dsl.dependencies
 import org.gradle.plugin.use.PluginDependency
 import org.jetbrains.kotlin.gradle.dsl.kotlinExtension

-internal const val ANDROID_TEST_IMPLEMENTATION = "androidTestImplementation"
-internal const val DEBUG_IMPLEMENTATION = "debugImplementation"
-internal const val IMPLEMENTATION = "implementation"
-internal const val KSP = "ksp"
-internal const val TEST_IMPLEMENTATION = "testImplementation"
-
 internal val Project.libs
    get(): LibrariesForLibs = extensionOf(this, "libs") as LibrariesForLibs

-internal fun PluginManager.alias(notation: Provider<PluginDependency>) {
-    apply(notation.get().pluginId)
+internal fun Project.applyPlugin(notation: Provider<PluginDependency>) {
+    pluginManager.apply(notation.get().pluginId)
 }

-internal fun Project.setupAndroidApplication() {
-    with(pluginManager) {
-        alias(libs.plugins.android.application)
-    }
+internal fun DependencyHandler.implementation(dependencyNotation: Any) =
+    add("implementation", dependencyNotation)
+
+internal fun DependencyHandler.debugImplementation(dependencyNotation: Any) =
+    add("debugImplementation", dependencyNotation)
+
+internal fun DependencyHandler.testImplementation(dependencyNotation: Any) =
+    add("testImplementation", dependencyNotation)
+
+internal fun DependencyHandler.androidTestImplementation(dependencyNotation: Any) =
+    add("androidTestImplementation", dependencyNotation)
+
+internal fun DependencyHandler.ksp(dependencyNotation: Any) =
+    add("ksp", dependencyNotation)
+
+internal fun Project.setupAndroidApp() {
+    applyPlugin(libs.plugins.android.application)
    extensions.configure<ApplicationExtension> {
        namespace = libs.versions.packageName.get()
        compileSdk = libs.versions.compileSdk.get().toInt()
@@ -55,9 +62,6 @@ internal fun Project.setupAndroidApplication() {
            versionCode = libs.versions.appVersionCode.get().toInt()
            versionName = libs.versions.appVersionName.get()
        }
-        buildFeatures {
-            compose = true
-        }
        buildTypes {
            debug {
                applicationIdSuffix = ".debug"
@@ -70,49 +74,38 @@ internal fun Project.setupAndroidApplication() {
        }
        androidResources {
            generateLocaleConfig = true
-            localeFilters.addAll(listOf("en", "es", "ru", "si", "uk", "zh"))
+            localeFilters.addAll(listOf("en", "es", "ru", "si", "tr", "uk", "zh"))
        }
        packaging { resources { excludes += listOf("META-INF/*") } }
    }
 }

-internal fun Project.setupCommonLibrary() {
-    with(pluginManager) {
-        alias(libs.plugins.android.library)
-    }
+internal fun Project.setupAndroidLib() {
+    applyPlugin(libs.plugins.android.library)
    extensions.configure<CommonExtension> {
        compileSdk = libs.versions.compileSdk.get().toInt()
        defaultConfig.minSdk = libs.versions.minSdk.get().toInt()
    }
+    dependencies {
+        androidTestImplementation(libs.bundles.androidTest)
+    }
 }

-internal fun Project.setupComposeFeature() {
-    with(pluginManager) {
-        alias(libs.plugins.compose.compiler)
-    }
+internal fun Project.setupCompose() {
+    applyPlugin(libs.plugins.compose.compiler)
    extensions.configure<CommonExtension> {
        buildFeatures.compose = true
    }
    dependencies {
-        IMPLEMENTATION(platform(libs.compose.bom))
-        IMPLEMENTATION(libs.bundles.composeAll)
-        DEBUG_IMPLEMENTATION(libs.bundles.composeDebug)
+        implementation(platform(libs.compose.bom))
+        implementation(libs.bundles.composeAll)
+        debugImplementation(libs.bundles.composeDebug)
    }
 }

-internal fun Project.setupKotlinToolchain() {
+internal fun Project.setupKotlin() {
    kotlinExtension.jvmToolchain(libs.versions.jdkVersion.get().toInt())
-}
-
-internal fun Project.setupAndroidTestDependencies() {
    dependencies {
-        ANDROID_TEST_IMPLEMENTATION(libs.bundles.androidTest)
-    }
-}
-
-internal fun Project.setupTestDependencies() {
-    dependencies {
-        TEST_IMPLEMENTATION(libs.test.coroutines)
-        TEST_IMPLEMENTATION(libs.test.junit4)
+        testImplementation(libs.bundles.unitTest)
    }
 }
@@ -4,8 +4,10 @@ plugins {
    alias(libs.plugins.compose.compiler) apply false
    alias(libs.plugins.google.ksp) apply false
    alias(libs.plugins.kotlin.jvm) apply false
+    alias(libs.plugins.kotlin.serialization) apply false
 }

 tasks.register("clean", Delete::class.java) {
+    description = "Cleans the build directory"
    delete(rootProject.layout.buildDirectory)
 }
@@ -1,5 +1,5 @@
 plugins {
-    alias(libs.plugins.convention.androidLibraryPlugin)
+    alias(libs.plugins.convention.coreDataPlugin)
 }

 android {
@@ -2,6 +2,7 @@
 <manifest xmlns:android="http://schemas.android.com/apk/res/android">

    <uses-permission android:name="android.permission.ACCESS_NETWORK_STATE" />
+    <uses-permission android:name="android.permission.ACCESS_LOCAL_NETWORK" />
    <uses-permission android:name="android.permission.ACCESS_COARSE_LOCATION" />
    <uses-permission android:name="android.permission.ACCESS_FINE_LOCATION" />
    <uses-permission
@@ -11,5 +12,6 @@
    <uses-permission android:name="android.permission.BLUETOOTH_CONNECT" />
    <uses-permission android:name="android.permission.BLUETOOTH_SCAN" />
    <uses-permission android:name="android.permission.INTERNET" />
+    <uses-permission android:name="android.permission.RECORD_AUDIO" />

 </manifest>
@@ -60,4 +60,7 @@ interface Look4SatDao {

    @Query("DELETE FROM radios")
    suspend fun deleteRadios()
+
+    @Query("DELETE FROM radios WHERE isCustom = 0")
+    suspend fun deleteManagedRadios()
 }
@@ -19,19 +19,21 @@ package com.rtbishop.look4sat.core.data.database

 import androidx.room.Database
 import androidx.room.RoomDatabase
+import androidx.room.migration.Migration
+import androidx.sqlite.db.SupportSQLiteDatabase
 import com.rtbishop.look4sat.core.data.database.entity.SatEntry
 import com.rtbishop.look4sat.core.data.database.entity.SatRadio

-@Database(entities = [SatEntry::class, SatRadio::class], version = 1, exportSchema = false)
+@Database(entities = [SatEntry::class, SatRadio::class], version = 2, exportSchema = false)
 abstract class Look4SatDb : RoomDatabase() {
    abstract fun look4SatDao(): Look4SatDao
 }

-//val MIGRATION_1_2 = object : Migration(1, 2) {
-//    override fun migrate(database: SupportSQLiteDatabase) {
-//        database.execSQL("CREATE TABLE entries_backup (name TEXT NOT NULL, epoch REAL NOT NULL, meanmo REAL NOT NULL, eccn REAL NOT NULL, incl REAL NOT NULL, raan REAL NOT NULL, argper REAL NOT NULL, meanan REAL NOT NULL, catnum INTEGER NOT NULL, bstar REAL NOT NULL, xincl REAL NOT NULL, xnodeo REAL NOT NULL, omegao REAL NOT NULL, xmo REAL NOT NULL, xno REAL NOT NULL, orbitalPeriod REAL NOT NULL, isDeepSpace INTEGER NOT NULL, comment TEXT, PRIMARY KEY(catnum))")
-//        database.execSQL("INSERT INTO entries_backup (name, epoch, meanmo, eccn, incl, raan, argper, meanan, catnum, bstar, xincl, xnodeo, omegao, xmo, xno, orbitalPeriod, isDeepSpace, comment) SELECT name, epoch, meanmo, eccn, incl, raan, argper, meanan, catnum, bstar, xincl, xnodeo, omegao, xmo, xno, 1440 / meanmo, 1440 / meanmo >= 225.0, comment FROM entries")
-//        database.execSQL("DROP TABLE entries")
-//        database.execSQL("ALTER TABLE entries_backup RENAME TO entries")
-//    }
-//}
+/** Adds the mean motion derivative, needed to tell decayed satellites apart, and marks the
+ * transceivers that were imported from a file, so that remote updates leave them alone. */
+val MIGRATION_1_2 = object : Migration(1, 2) {
+    override fun migrate(db: SupportSQLiteDatabase) {
+        db.execSQL("ALTER TABLE entries ADD COLUMN ndot REAL NOT NULL DEFAULT 0.0")
+        db.execSQL("ALTER TABLE radios ADD COLUMN isCustom INTEGER NOT NULL DEFAULT 0")
+    }
+}
@@ -30,5 +30,6 @@ data class SatEntry(
    val argper: Double,
    val meanan: Double,
    val catnum: Int,
-    val bstar: Double
+    val bstar: Double,
+    val ndot: Double = 0.0
 )
@@ -25,12 +25,14 @@ data class SatRadio(
    @PrimaryKey val uuid: String,
    val info: String,
    val isAlive: Boolean,
-    var downlinkLow: Long?,
-    var downlinkHigh: Long?,
+    val downlinkLow: Long?,
+    val downlinkHigh: Long?,
    val downlinkMode: String?,
-    var uplinkLow: Long?,
-    var uplinkHigh: Long?,
+    val uplinkLow: Long?,
+    val uplinkHigh: Long?,
    val uplinkMode: String?,
    val isInverted: Boolean,
-    val catnum: Int?
+    val catnum: Int?,
+    /** Set for manually imported transceivers, which remote updates must not replace. */
+    val isCustom: Boolean = false
 )
@@ -20,121 +20,112 @@ package com.rtbishop.look4sat.core.data.framework
 import android.bluetooth.BluetoothManager
 import android.bluetooth.BluetoothSocket
 import android.util.Log
-import com.rtbishop.look4sat.core.domain.repository.BtService
-import com.rtbishop.look4sat.core.domain.repository.IReporterRepo
-import com.rtbishop.look4sat.core.domain.repository.WithoutExtParams
+import com.rtbishop.look4sat.core.domain.repository.IReporter
 import kotlinx.coroutines.CoroutineScope
-import kotlinx.coroutines.Job
 import kotlinx.coroutines.launch
 import kotlinx.coroutines.sync.Mutex
 import kotlinx.coroutines.sync.withLock
 import java.io.OutputStream
 import java.util.UUID
-import kotlin.math.abs
-
-data class DeviceConnection(
-    var socket: BluetoothSocket? = null,
-    var outputStream: OutputStream? = null,
-    var connected: Boolean = false,
-    var connecting: Boolean = false,
-    var connectionJob: Job? = null
-)

 class BluetoothReporter(
    private val bluetoothManager: BluetoothManager,
-    private val reporterScope: CoroutineScope
-) : IReporterRepo<WithoutExtParams> {
+    private val reporterScope: CoroutineScope,
+    private val rotatorDeviceId: String,
+    private val frequencyDeviceId: String
+) : IReporter {

    private val tag = "BTReporter"
-    private val sppid: UUID = UUID.fromString("00001101-0000-1000-8000-00805f9b34fb")
-
-    private val serviceToDevice = mutableMapOf<BtService, String>()
-    private val deviceConnections = mutableMapOf<String, DeviceConnection>()
+    private val sppId: UUID = UUID.fromString("00001101-0000-1000-8000-00805f9b34fb")
    private val writeMutex = Mutex()

-    override fun isConnected(service: BtService): Boolean {
-        val deviceId = serviceToDevice[service] ?: return false
-        return deviceConnections[deviceId]?.connected == true
-    }
+    private var rotatorSocket: BluetoothSocket? = null
+    private var rotatorStream: OutputStream? = null
+    private var rotatorConnected = false
+    private var rotatorConnecting = false

-    override fun isConnecting(service: BtService): Boolean {
-        val deviceId = serviceToDevice[service] ?: return false
-        return deviceConnections[deviceId]?.connecting == true
-    }
+    private var frequencySocket: BluetoothSocket? = null
+    private var frequencyStream: OutputStream? = null
+    private var frequencyConnected = false
+    private var frequencyConnecting = false

-    override fun connect(service: BtService, deviceId: String) {
-        serviceToDevice[service] = deviceId
-        val connection = deviceConnections.getOrPut(deviceId) {
-            DeviceConnection()
+    override fun reportRotation(format: String, azimuth: Double, elevation: Double) {
+        reporterScope.launch {
+            ensureRotatorConnected()
+            if (!rotatorConnected) return@launch
+            val el = if (elevation > 0.0) elevation else 0.0
+            val command = format
+                .replace($$"$AZ", azimuth.toString())
+                .replace($$"$EL", el.toString())
+                .unescapeControlChars()
+            write(rotatorStream, command) { rotatorConnected = false }
        }
-        if (connection.connected || connection.connecting) return
-        connection.connectionJob = reporterScope.launch {
+    }
+
+    override fun reportFrequency(format: String, frequency: Long) {
+        reporterScope.launch {
+            ensureFrequencyConnected()
+            if (!frequencyConnected) return@launch
+            val command = format
+                .replace($$"$FREQ", frequency.toString())
+                .unescapeControlChars()
+            write(frequencyStream, command) { frequencyConnected = false }
+        }
+    }
+
+    private fun ensureRotatorConnected() {
+        if (rotatorConnected || rotatorConnecting || rotatorDeviceId.isBlank()) return
+        reporterScope.launch {
            try {
-                connection.connecting = true
-                val device = bluetoothManager.adapter.getRemoteDevice(deviceId)
-                val socket = device.createInsecureRfcommSocketToServiceRecord(sppid)
+                rotatorConnecting = true
+                val device = bluetoothManager.adapter.getRemoteDevice(rotatorDeviceId)
+                val socket = device.createInsecureRfcommSocketToServiceRecord(sppId)
                socket.connect()
-                connection.socket = socket
-                connection.outputStream = socket.outputStream
-                connection.connected = true
-                Log.i(tag, "$tag: Connected to $deviceId")
+                rotatorSocket = socket
+                rotatorStream = socket.outputStream
+                rotatorConnected = true
+                Log.i(tag, "Rotator connected to $rotatorDeviceId")
            } catch (e: Exception) {
-                Log.e(tag, "$tag: ${e.message}")
-                connection.connected = false
+                Log.e(tag, "Rotator connect error: ${e.message}")
+                rotatorConnected = false
            } finally {
-                connection.connecting = false
+                rotatorConnecting = false
            }
        }
    }

-    private suspend fun write(service: BtService, buffer: String) {
-        val deviceId = serviceToDevice[service] ?: return
-        val connection = deviceConnections[deviceId] ?: return
-        if (!connection.connected) return
+    private fun ensureFrequencyConnected() {
+        if (frequencyConnected || frequencyConnecting || frequencyDeviceId.isBlank()) return
+        reporterScope.launch {
+            try {
+                frequencyConnecting = true
+                val device = bluetoothManager.adapter.getRemoteDevice(frequencyDeviceId)
+                val socket = device.createInsecureRfcommSocketToServiceRecord(sppId)
+                socket.connect()
+                frequencySocket = socket
+                frequencyStream = socket.outputStream
+                frequencyConnected = true
+                Log.i(tag, "Frequency connected to $frequencyDeviceId")
+            } catch (e: Exception) {
+                Log.e(tag, "Frequency connect error: ${e.message}")
+                frequencyConnected = false
+            } finally {
+                frequencyConnecting = false
+            }
+        }
+    }
+
+    private suspend fun write(stream: OutputStream?, data: String, onError: () -> Unit) {
        try {
            writeMutex.withLock {
-                connection.outputStream?.write(buffer.toByteArray())
+                stream?.write(data.toByteArray())
            }
        } catch (e: Exception) {
-            Log.e(tag, "$tag: Write failed ${e.message}")
-            connection.connected = false
+            Log.e(tag, "Write error: ${e.message}")
+            onError()
        }
    }

-    override fun reportRotation(format: String, azimuth: Double, elevation: Double, params: WithoutExtParams) {
-        reporterScope.launch {
-            if (!isConnected(BtService.ROTATOR)) return@launch
-            val newElevation = if (elevation > 0.0) elevation else 0.0
-            val azimuthString = intToStringWithLeadingZeroes(azimuth.toInt())
-            val elevationString = intToStringWithLeadingZeroes(newElevation.toInt())
-            val buffer = format
-                .replace($$"$AZ", azimuthString)
-                .replace($$"$EL", elevationString)
-                .replace("\\r", "\r")
-                .replace("\\n", "\n")
-                .replace("\\t", "\t")
-            write(BtService.ROTATOR, buffer)
-        }
-    }
-
-    override fun reportFrequency(format: String, frequency: Long, params: WithoutExtParams) {
-        reporterScope.launch {
-            if (!isConnected(BtService.FREQUENCY)) return@launch
-            val buffer = format
-                .replace($$"$FREQ", frequency.toString())
-                .replace("\\r", "\r")
-                .replace("\\n", "\n")
-                .replace("\\t", "\t")
-            write(BtService.FREQUENCY, buffer)
-        }
-    }
-
-    private fun intToStringWithLeadingZeroes(value: Int): String {
-        return if (value > 0) {
-            if (value < 10) "00$value" else if (value < 100) "0$value" else "$value"
-        } else {
-            val absValue = abs(value)
-            if (value > -10) "-00$absValue" else if (value > -100) "-0$absValue" else "-$absValue"
-        }
-    }
+    private fun String.unescapeControlChars(): String =
+        replace("\\r", "\r").replace("\\n", "\n").replace("\\t", "\t")
 }
@@ -0,0 +1,139 @@
+/*
+ * Look4Sat. Amateur radio satellite tracker and pass predictor.
+ * Copyright (C) 2019-2026 Arty Bishop and contributors.
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <https://www.gnu.org/licenses/>.
+ */
+package com.rtbishop.look4sat.core.data.framework
+
+import java.util.Locale
+import kotlin.math.roundToLong
+
+object Ft817CatProtocol {
+
+    const val CMD_SET_FREQ: Byte = 0x01
+    const val CMD_READ_FREQ_MODE: Byte = 0x03
+    const val CMD_SET_MODE: Byte = 0x07
+    const val CMD_PTT_ON: Byte = 0x08
+    const val CMD_PTT_OFF: Byte = 0x88.toByte()
+    const val CMD_CTCSS_MODE: Byte = 0x0A
+    const val CMD_CTCSS_TONE: Byte = 0x0B
+
+    const val CTCSS_ENC_ON: Byte = 0x2A
+    const val CTCSS_OFF: Byte = 0x8A.toByte()
+
+    val MODE_TO_BYTE: Map<String, Byte> = mapOf(
+        "LSB" to 0x00,
+        "USB" to 0x01,
+        "CW" to 0x02,
+        "CW-R" to 0x03,
+        "AM" to 0x04,
+        "FM" to 0x08,
+        "DIG" to 0x0A,
+        "PKT" to 0x0C
+    )
+
+    val BYTE_TO_MODE: Map<Byte, String> = MODE_TO_BYTE.entries.associate { it.value to it.key }
+
+    /**
+     * Encode frequency in Hz to 4-byte BCD with 10 Hz resolution.
+     * Example: 145500000 Hz → [0x14, 0x55, 0x00, 0x00]
+     */
+    fun encodeFrequencyBcd(frequencyHz: Long): ByteArray {
+        val freq10Hz = frequencyHz / 10
+        val bcd = ByteArray(4)
+        val digits = String.format(Locale.US, "%08d", freq10Hz)
+        for (i in 0 until 4) {
+            val high = digits[i * 2] - '0'
+            val low = digits[i * 2 + 1] - '0'
+            bcd[i] = ((high shl 4) or low).toByte()
+        }
+        return bcd
+    }
+
+    /**
+     * Decode 4-byte BCD frequency to Hz.
+     */
+    fun decodeFrequencyBcd(bcd: ByteArray): Long {
+        var freq10Hz = 0L
+        for (i in 0 until 4) {
+            val b = bcd[i].toInt() and 0xFF
+            val high = b shr 4
+            val low = b and 0x0F
+            freq10Hz = freq10Hz * 100 + high * 10 + low
+        }
+        return freq10Hz * 10
+    }
+
+    /**
+     * Encode CTCSS tone frequency (in Hz, e.g. 67.0) to 2-byte BCD.
+     * 67.0 Hz → 670 (in 0.1 Hz) → BCD [0x06, 0x70]
+     */
+    fun encodeCtcssToneBcd(toneHz: Double): ByteArray {
+        val tone01Hz = (toneHz * 10).roundToLong()
+        val digits = String.format(Locale.US, "%04d", tone01Hz)
+        val bcd = ByteArray(2)
+        for (i in 0 until 2) {
+            val high = digits[i * 2] - '0'
+            val low = digits[i * 2 + 1] - '0'
+            bcd[i] = ((high shl 4) or low).toByte()
+        }
+        return bcd
+    }
+
+    fun buildSetFreqCommand(frequencyHz: Long): ByteArray {
+        val bcd = encodeFrequencyBcd(frequencyHz)
+        return byteArrayOf(bcd[0], bcd[1], bcd[2], bcd[3], CMD_SET_FREQ)
+    }
+
+    fun buildSetModeCommand(mode: String): ByteArray? {
+        val modeByte = MODE_TO_BYTE[mode.uppercase(Locale.US)] ?: return null
+        return byteArrayOf(modeByte, 0x00, 0x00, 0x00, CMD_SET_MODE)
+    }
+
+    fun buildReadFreqModeCommand(): ByteArray {
+        return byteArrayOf(0x00, 0x00, 0x00, 0x00, CMD_READ_FREQ_MODE)
+    }
+
+    fun buildPttOnCommand(): ByteArray {
+        return byteArrayOf(0x00, 0x00, 0x00, 0x00, CMD_PTT_ON)
+    }
+
+    fun buildPttOffCommand(): ByteArray {
+        return byteArrayOf(0x00, 0x00, 0x00, 0x00, CMD_PTT_OFF)
+    }
+
+    fun buildCtcssModeCommand(enabled: Boolean): ByteArray {
+        val sub = if (enabled) CTCSS_ENC_ON else CTCSS_OFF
+        return byteArrayOf(sub, 0x00, 0x00, 0x00, CMD_CTCSS_MODE)
+    }
+
+    fun buildSetCtcssToneCommand(toneHz: Double): ByteArray {
+        val bcd = encodeCtcssToneBcd(toneHz)
+        return byteArrayOf(bcd[0], bcd[1], 0x00, 0x00, CMD_CTCSS_TONE)
+    }
+
+    /**
+     * Parse the 5-byte response from a READ FREQ+MODE command.
+     * Returns (frequencyHz, modeString) or null if parsing fails.
+     */
+    fun parseReadResponse(response: ByteArray): Pair<Long, String>? {
+        if (response.size < 5) return null
+        val freqBcd = response.copyOfRange(0, 4)
+        val frequencyHz = decodeFrequencyBcd(freqBcd)
+        val modeByte = response[4]
+        val mode = BYTE_TO_MODE[modeByte] ?: return null
+        return Pair(frequencyHz, mode)
+    }
+}
@@ -0,0 +1,207 @@
+/*
+ * Look4Sat. Amateur radio satellite tracker and pass predictor.
+ * Copyright (C) 2019-2026 Arty Bishop and contributors.
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <https://www.gnu.org/licenses/>.
+ */
+package com.rtbishop.look4sat.core.data.framework
+
+import android.bluetooth.BluetoothManager
+import android.bluetooth.BluetoothSocket
+import android.util.Log
+import com.rtbishop.look4sat.core.domain.repository.IRadioController
+import kotlinx.coroutines.Dispatchers
+import kotlinx.coroutines.delay
+import kotlinx.coroutines.sync.Mutex
+import kotlinx.coroutines.sync.withLock
+import kotlinx.coroutines.withContext
+import java.io.InputStream
+import java.io.OutputStream
+import java.util.UUID
+import kotlin.time.Duration.Companion.milliseconds
+
+class Ft817Controller(
+    private val bluetoothManager: BluetoothManager,
+    private val deviceAddress: String
+) : IRadioController {
+
+    private val tag = "FT817"
+    private val sppId: UUID = UUID.fromString("00001101-0000-1000-8000-00805f9b34fb")
+    private val ioMutex = Mutex()
+    private val commandDelayMs = 200L
+    private val maxAckReadFailures = 3
+
+    private var socket: BluetoothSocket? = null
+    private var outputStream: OutputStream? = null
+    private var inputStream: InputStream? = null
+    private var ackReadFailureCount = 0
+
+    override var isConnected: Boolean = false
+        private set
+
+    override suspend fun connect(): Boolean = withContext(Dispatchers.IO) {
+        if (isConnected) return@withContext true
+        if (deviceAddress.isBlank()) return@withContext false
+        try {
+            val device = bluetoothManager.adapter.getRemoteDevice(deviceAddress)
+            val btSocket = device.createInsecureRfcommSocketToServiceRecord(sppId)
+            btSocket.connect()
+            socket = btSocket
+            outputStream = btSocket.outputStream
+            inputStream = btSocket.inputStream
+            ackReadFailureCount = 0
+            isConnected = true
+            Log.i(tag, "Connected to $deviceAddress")
+            true
+        } catch (e: Exception) {
+            Log.e(tag, "Connect error: ${e.message}")
+            isConnected = false
+            false
+        }
+    }
+
+    override suspend fun disconnect() {
+        withContext(Dispatchers.IO) {
+            try {
+                inputStream?.close()
+                outputStream?.close()
+                socket?.close()
+            } catch (e: Exception) {
+                Log.e(tag, "Disconnect error: ${e.message}")
+            } finally {
+                inputStream = null
+                outputStream = null
+                socket = null
+                ackReadFailureCount = 0
+                isConnected = false
+                Log.i(tag, "Disconnected from $deviceAddress")
+            }
+        }
+    }
+
+    override suspend fun setFrequency(frequencyHz: Long): Boolean = withContext(Dispatchers.IO) {
+        ioMutex.withLock {
+            sendCommandWithAck(Ft817CatProtocol.buildSetFreqCommand(frequencyHz))
+        }
+    }
+
+    override suspend fun setMode(mode: String): Boolean = withContext(Dispatchers.IO) {
+        val cmd = Ft817CatProtocol.buildSetModeCommand(mode) ?: return@withContext false
+        ioMutex.withLock { sendCommandWithAck(cmd) }
+    }
+
+    override suspend fun setCtcssMode(enabled: Boolean): Boolean = withContext(Dispatchers.IO) {
+        ioMutex.withLock {
+            sendCommandWithAck(Ft817CatProtocol.buildCtcssModeCommand(enabled))
+        }
+    }
+
+    override suspend fun setCtcssTone(toneHz: Double): Boolean = withContext(Dispatchers.IO) {
+        ioMutex.withLock {
+            sendCommandWithAck(Ft817CatProtocol.buildSetCtcssToneCommand(toneHz))
+        }
+    }
+
+    override suspend fun readFrequencyAndMode(): Pair<Long, String>? = withContext(Dispatchers.IO) {
+        ioMutex.withLock {
+            val sent = sendCommand(Ft817CatProtocol.buildReadFreqModeCommand())
+            if (!sent) return@withContext null
+            delay(commandDelayMs.milliseconds)
+            val response = readResponse() ?: return@withContext null
+            Ft817CatProtocol.parseReadResponse(response)
+        }
+    }
+
+    override suspend fun pttOn(): Boolean = withContext(Dispatchers.IO) {
+        ioMutex.withLock { sendCommandWithAck(Ft817CatProtocol.buildPttOnCommand()) }
+    }
+
+    override suspend fun pttOff(): Boolean = withContext(Dispatchers.IO) {
+        ioMutex.withLock { sendCommandWithAck(Ft817CatProtocol.buildPttOffCommand()) }
+    }
+
+    private suspend fun sendCommand(bytes: ByteArray): Boolean {
+        return withContext(Dispatchers.IO) {
+            try {
+                outputStream?.write(bytes) ?: return@withContext false
+                outputStream?.flush()
+                delay(commandDelayMs.milliseconds)
+                true
+            } catch (e: Exception) {
+                Log.e(tag, "Send error: ${e.message}")
+                isConnected = false
+                false
+            }
+        }
+    }
+
+    /** Send command and read the 1-byte ACK response (0x00 = OK). */
+    private suspend fun sendCommandWithAck(bytes: ByteArray): Boolean {
+        if (!sendCommand(bytes)) return false
+        return withContext(Dispatchers.IO) {
+            try {
+                val ack = inputStream?.read() ?: run {
+                    ackReadFailureCount = 0
+                    isConnected = false
+                    return@withContext false
+                }
+                if (ack < 0) {
+                    ackReadFailureCount = 0
+                    Log.i(tag, "ACK stream closed by remote device")
+                    isConnected = false
+                    return@withContext false
+                }
+                ackReadFailureCount = 0
+                ack == 0x00
+            } catch (e: Exception) {
+                ackReadFailureCount += 1
+                Log.w(tag, "ACK read error (${ackReadFailureCount}/$maxAckReadFailures): ${e.message}")
+                if (ackReadFailureCount >= maxAckReadFailures) {
+                    Log.e(tag, "Too many ACK read errors, marking radio disconnected")
+                    isConnected = false
+                    false
+                } else {
+                    true // Command was sent, treat transient ACK read failures as best-effort
+                }
+            }
+        }
+    }
+
+    private suspend fun readResponse(): ByteArray? {
+        return withContext(Dispatchers.IO) {
+            try {
+                val responseSize = 5
+                val buffer = ByteArray(responseSize)
+                var read = 0
+                while (read < responseSize) {
+                    val count = inputStream?.read(buffer, read, responseSize - read) ?: run {
+                        isConnected = false
+                        return@withContext null
+                    }
+                    if (count < 0) {
+                        Log.i(tag, "Response stream closed by remote device")
+                        isConnected = false
+                        return@withContext null
+                    }
+                    read += count
+                }
+                buffer
+            } catch (e: Exception) {
+                Log.e(tag, "Read error: ${e.message}")
+                isConnected = false
+                null
+            }
+        }
+    }
+}
@@ -0,0 +1,364 @@
+/*
+ * Look4Sat. Amateur radio satellite tracker and pass predictor.
+ * Copyright (C) 2019-2026 Arty Bishop and contributors.
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <https://www.gnu.org/licenses/>.
+ */
+package com.rtbishop.look4sat.core.data.framework
+
+import android.bluetooth.BluetoothManager
+import android.bluetooth.BluetoothSocket
+import android.util.Log
+import com.rtbishop.look4sat.core.domain.repository.IRadioController
+import kotlinx.coroutines.Dispatchers
+import kotlinx.coroutines.delay
+import kotlinx.coroutines.sync.Mutex
+import kotlinx.coroutines.sync.withLock
+import kotlinx.coroutines.withContext
+import java.io.InputStream
+import java.io.OutputStream
+import java.util.UUID
+
+/**
+ * Icom IC-705 CI-V controller over Bluetooth SPP.
+ *
+ * The IC-705 emits broadcast frames continuously (band scope, UTC, signal
+ * level, …).  A reply to any command we send may therefore be buried in
+ * that noise.  All response reads drain up to [ACK_TIMEOUT_MS] and scan the
+ * entire accumulated buffer for the frame we expect rather than assuming
+ * the very next byte is the response.
+ */
+class Ic705Controller(
+    private val bluetoothManager: BluetoothManager,
+    private val deviceAddress: String
+) : IRadioController {
+
+    private val tag = "IC705"
+    private val sppId: UUID = UUID.fromString("00001101-0000-1000-8000-00805f9b34fb")
+    private val ioMutex = Mutex()
+
+    /** Time budget (ms) to wait for a response amid broadcast noise. */
+    private val ACK_TIMEOUT_MS = 500L
+    /** Polling interval while draining the input buffer. */
+    private val POLL_INTERVAL_MS = 20L
+    /** Small pause after writing a command before reading the response. */
+    private val WRITE_SETTLE_MS = 50L
+
+    private var socket: BluetoothSocket? = null
+    private var outputStream: OutputStream? = null
+    private var inputStream: InputStream? = null
+
+    override var isConnected: Boolean = false
+        private set
+
+    // ── Connection ──────────────────────────────────────────────────────────
+
+    override suspend fun connect(): Boolean = withContext(Dispatchers.IO) {
+        if (isConnected) return@withContext true
+        if (deviceAddress.isBlank()) return@withContext false
+        try {
+            val device  = bluetoothManager.adapter.getRemoteDevice(deviceAddress)
+            val btSocket = device.createInsecureRfcommSocketToServiceRecord(sppId)
+            btSocket.connect()
+            socket       = btSocket
+            outputStream = btSocket.outputStream
+            inputStream  = btSocket.inputStream
+            isConnected  = true
+            // Enter VFO mode — frequency/mode commands return FA if the radio
+            // is in memory-channel mode. Safe to send regardless of current state.
+            Log.i(tag, "Connected to $deviceAddress — entering VFO mode")
+            val vfoCmd = IcomCivProtocol.buildEnterVfoModeCommand()
+            Log.d(tag, "CMD enterVfoMode → ${IcomCivProtocol.toHex(vfoCmd)}")
+            ioMutex.withLock { sendAndWaitAck(vfoCmd) }
+            true
+        } catch (e: Exception) {
+            Log.e(tag, "Connect error: ${e.message}")
+            isConnected = false
+            false
+        }
+    }
+
+    override suspend fun disconnect() {
+        withContext(Dispatchers.IO) {
+            try {
+                inputStream?.close()
+                outputStream?.close()
+                socket?.close()
+            } catch (e: Exception) {
+                Log.e(tag, "Disconnect error: ${e.message}")
+            } finally {
+                inputStream  = null
+                outputStream = null
+                socket       = null
+                isConnected  = false
+                Log.i(tag, "Disconnected from $deviceAddress")
+            }
+        }
+    }
+
+    // ── IRadioController – standard operations ──────────────────────────────
+
+    override suspend fun setFrequency(frequencyHz: Long): Boolean = withContext(Dispatchers.IO) {
+        Log.d(tag, "setFrequency: ${frequencyHz}Hz")
+        ioMutex.withLock {
+            val cmd = IcomCivProtocol.buildSetFreqCommand(frequencyHz)
+            Log.d(tag, "CMD setFreq → ${IcomCivProtocol.toHex(cmd)}")
+            sendAndWaitAck(cmd)
+        }
+    }
+
+    override suspend fun setMode(mode: String): Boolean = withContext(Dispatchers.IO) {
+        val cmd = IcomCivProtocol.buildSetModeCommand(mode) ?: run {
+            Log.w(tag, "setMode: unknown mode '$mode'")
+            return@withContext false
+        }
+        Log.d(tag, "setMode: $mode")
+        Log.d(tag, "CMD setMode → ${IcomCivProtocol.toHex(cmd)}")
+        ioMutex.withLock { sendAndWaitAck(cmd) }
+    }
+
+    override suspend fun setCtcssMode(enabled: Boolean): Boolean = withContext(Dispatchers.IO) {
+        Log.d(tag, "setCtcssMode: $enabled")
+        val cmd = IcomCivProtocol.buildCtcssModeCommand(enabled)
+        Log.d(tag, "CMD ctcssMode → ${IcomCivProtocol.toHex(cmd)}")
+        ioMutex.withLock { sendAndWaitAck(cmd) }
+    }
+
+    override suspend fun setCtcssTone(toneHz: Double): Boolean = withContext(Dispatchers.IO) {
+        Log.d(tag, "setCtcssTone: ${toneHz}Hz")
+        val cmd = IcomCivProtocol.buildSetCtcssToneCommand(toneHz)
+        Log.d(tag, "CMD ctcssTone → ${IcomCivProtocol.toHex(cmd)}")
+        ioMutex.withLock { sendAndWaitAck(cmd) }
+    }
+
+    override suspend fun readFrequencyAndMode(): Pair<Long, String>? = withContext(Dispatchers.IO) {
+        ioMutex.withLock {
+            val cmd = IcomCivProtocol.buildReadFreqCommand()
+            Log.d(tag, "CMD readFreq → ${IcomCivProtocol.toHex(cmd)}")
+            val payload = sendAndReadResponse(cmd, IcomCivProtocol.CMD_READ_FREQ) ?: return@withContext null
+            // Read-freq reply payload: [cmd byte already stripped by parseResponse] [5 freq bytes] [mode] [filter]
+            IcomCivProtocol.parseFreqModePayload(payload).also {
+                if (it != null) Log.d(tag, "readFreqMode: ${it.first}Hz, ${it.second}")
+                else Log.w(tag, "readFreqMode: parse failed, payload=${IcomCivProtocol.toHex(payload)}")
+            }
+        }
+    }
+
+    override suspend fun pttOn(): Boolean = withContext(Dispatchers.IO) {
+        Log.w(tag, "pttOn: not used for IC-705")
+        true
+    }
+
+    override suspend fun pttOff(): Boolean = withContext(Dispatchers.IO) {
+        Log.w(tag, "pttOff: not used for IC-705")
+        true
+    }
+
+    // ── IRadioController – IC-705 extended operations ───────────────────────
+
+    /** Select the band for [frequencyHz] via CMD 0x1A sub 0x00 (band stacking register). */
+    override suspend fun setBand(frequencyHz: Long): Boolean = withContext(Dispatchers.IO) {
+        val cmd = IcomCivProtocol.buildBandSelectCommand(frequencyHz) ?: run {
+            Log.w(tag, "setBand: no band code for ${frequencyHz}Hz — skipping")
+            return@withContext false
+        }
+        Log.d(tag, "CMD setBand (${frequencyHz}Hz) → ${IcomCivProtocol.toHex(cmd)}")
+        ioMutex.withLock { sendAndWaitAck(cmd) }
+    }
+
+    /** Select VFO-A (main/RX) or VFO-B (sub/TX). */
+    override suspend fun setVfo(vfoA: Boolean): Boolean = withContext(Dispatchers.IO) {
+        val cmd = if (vfoA) IcomCivProtocol.buildSelectVfoACommand()
+                  else      IcomCivProtocol.buildSelectVfoBCommand()
+        Log.d(tag, "CMD selectVFO${if (vfoA) "A" else "B"} → ${IcomCivProtocol.toHex(cmd)}")
+        ioMutex.withLock { sendAndWaitAck(cmd) }
+    }
+
+    /**
+     * Enable or disable SPLIT mode (TX on sub-VFO while listening on main VFO).
+     */
+    override suspend fun setSplitMode(enabled: Boolean): Boolean = withContext(Dispatchers.IO) {
+        val cmd = IcomCivProtocol.buildSplitModeCommand(enabled)
+        Log.d(tag, "CMD split ${if (enabled) "ON" else "OFF"} → ${IcomCivProtocol.toHex(cmd)}")
+        ioMutex.withLock { sendAndWaitAck(cmd) }
+    }
+
+    /**
+     * Set the frequency of the **currently active** VFO (CMD 0x25 sub 0x00).
+     * In split mode the radio automatically switches active VFO on PTT, so
+     * always writing to the active VFO is the correct strategy.
+     */
+    override suspend fun setWorkingFrequency(frequencyHz: Long): Boolean = withContext(Dispatchers.IO) {
+        Log.d(tag, "setWorkingFrequency (0x25/00): ${frequencyHz}Hz")
+        val cmd = IcomCivProtocol.buildSetWorkingFreqCommand(frequencyHz)
+        Log.d(tag, "CMD setWorkingFreq → ${IcomCivProtocol.toHex(cmd)}")
+        ioMutex.withLock { sendAndWaitAck(cmd) }
+    }
+
+    /**
+     * Set TX VFO frequency via CMD 0x25 sub 0x01 (unselected VFO).
+     * Sent every tracking cycle in split mode alongside [setWorkingFrequency].
+     */
+    override suspend fun setTxVfoFrequency(frequencyHz: Long): Boolean = withContext(Dispatchers.IO) {
+        Log.d(tag, "setTxVfoFrequency (0x25/01): ${frequencyHz}Hz")
+        val cmd = IcomCivProtocol.buildSetUnselectedVfoFreqCommand(frequencyHz)
+        Log.d(tag, "CMD setTxVfoFreq → ${IcomCivProtocol.toHex(cmd)}")
+        ioMutex.withLock { sendAndWaitAck(cmd) }
+    }
+
+    /**
+     * Read the frequency of the currently active VFO (CMD 0x25 sub 0x00).
+     * Used for tuning detection in split mode.
+     */
+    override suspend fun readWorkingFrequency(): Long? = withContext(Dispatchers.IO) {
+        ioMutex.withLock {
+            val cmd = IcomCivProtocol.buildReadWorkingFreqCommand()
+            Log.d(tag, "CMD readWorkingFreq → ${IcomCivProtocol.toHex(cmd)}")
+            val payload = sendAndReadResponse(cmd, IcomCivProtocol.CMD_SELECTED_VFO_FREQ) ?: return@withContext null
+            // Response payload: [sub] [5 freq bytes] — CMD byte already stripped by parseResponse
+            Log.d(tag, "readWorkingFreq: got ${payload.size} bytes: ${IcomCivProtocol.toHex(payload)}")
+            if (payload.size < 6) {
+                Log.w(tag, "readWorkingFreq: payload too short (${payload.size} bytes)")
+                return@withContext null
+            }
+            val freqBcd = payload.sliceArray(1..5)
+            val freq = IcomCivProtocol.decodeFrequencyBcd(freqBcd)
+            Log.d(tag, "readWorkingFreq: ${freq}Hz")
+            freq
+        }
+    }
+
+    /**
+     * Read the frequency of the inactive/TX VFO (CMD 0x25 sub 0x01).
+     * Used for tuning detection in split mode.
+     */
+    override suspend fun readTxVfoFrequency(): Long? = withContext(Dispatchers.IO) {
+        ioMutex.withLock {
+            val cmd = IcomCivProtocol.buildReadTxVfoFreqCommand()
+            Log.d(tag, "CMD readTxVfoFreq → ${IcomCivProtocol.toHex(cmd)}")
+            val payload = sendAndReadResponse(cmd, IcomCivProtocol.CMD_SELECTED_VFO_FREQ) ?: return@withContext null
+            // Response payload: [sub] [5 freq bytes] — CMD byte already stripped by parseResponse
+            Log.d(tag, "readTxVfoFreq: got ${payload.size} bytes: ${IcomCivProtocol.toHex(payload)}")
+            if (payload.size < 6) {
+                Log.w(tag, "readTxVfoFreq: payload too short (${payload.size} bytes)")
+                return@withContext null
+            }
+            val freqBcd = payload.sliceArray(1..5)
+            val freq = IcomCivProtocol.decodeFrequencyBcd(freqBcd)
+            Log.d(tag, "readTxVfoFreq: ${freq}Hz")
+            freq
+        }
+    }
+
+    // ── Internal I/O helpers ────────────────────────────────────────────────
+
+    /**
+     * Write [cmd] to the radio and drain the input stream for up to
+     * [ACK_TIMEOUT_MS], looking for an OK/NG acknowledgement frame.
+     */
+    private suspend fun sendAndWaitAck(cmd: ByteArray): Boolean {
+        if (!write(cmd)) return false
+        delay(WRITE_SETTLE_MS)
+        val buf = drainWithTimeout(ACK_TIMEOUT_MS)
+        val ok  = IcomCivProtocol.containsAck(buf)
+        if (!ok) Log.w(tag, "ACK not found in ${buf.size} bytes: ${IcomCivProtocol.toHex(buf)}")
+        return ok
+    }
+
+    /**
+     * Write [cmd] to the radio and drain the input stream for up to
+     * [ACK_TIMEOUT_MS], scanning for a response frame carrying [expectCmd].
+     * Returns the payload bytes of that frame, or null on timeout/error.
+     */
+    private suspend fun sendAndReadResponse(cmd: ByteArray, expectCmd: Byte): ByteArray? {
+        if (!write(cmd)) return null
+        delay(WRITE_SETTLE_MS)
+        val buf      = drainWithTimeout(ACK_TIMEOUT_MS)
+        val response = IcomCivProtocol.parseResponse(buf, expectCmd)
+        if (response == null) {
+            Log.w(tag, "No response for cmd 0x${String.format("%02X", expectCmd.toInt() and 0xFF)} " +
+                    "in ${buf.size} bytes: ${IcomCivProtocol.toHex(buf)}")
+        }
+        return response?.payload
+    }
+
+    /**
+     * Drain whatever bytes the radio has buffered within a [timeoutMs] window.
+     * Exits early as soon as a complete CI-V frame addressed to us is present
+     * in the buffer (i.e., FE FE E0 A4 … FD), so we don't waste the remaining
+     * timeout on responses that already arrived.
+     */
+    private suspend fun drainWithTimeout(timeoutMs: Long): ByteArray {
+        val result   = mutableListOf<Byte>()
+        val deadline = System.currentTimeMillis() + timeoutMs
+        val stream   = inputStream ?: return ByteArray(0)
+        while (System.currentTimeMillis() < deadline) {
+            try {
+                val available = stream.available()
+                if (available > 0) {
+                    val chunk = ByteArray(available)
+                    val read  = stream.read(chunk)
+                    if (read > 0) {
+                        result.addAll(chunk.take(read))
+                        // Exit early once we have a complete frame for us
+                        if (hasCompleteFrameForUs(result)) break
+                    }
+                } else {
+                    delay(POLL_INTERVAL_MS)
+                }
+            } catch (e: Exception) {
+                Log.e(tag, "Drain error: ${e.message}")
+                isConnected = false
+                break
+            }
+        }
+        return result.toByteArray()
+    }
+
+    /**
+     * Returns true if [buf] contains a complete CI-V frame addressed to the
+     * controller (FE FE [ADDR_CTRL] [ADDR_IC705] … FD).
+     * CI-V data bytes cannot be 0xFD, so the first 0xFD after the header is
+     * always the frame terminator.
+     */
+    private fun hasCompleteFrameForUs(buf: List<Byte>): Boolean {
+        var i = 0
+        while (i < buf.size - 4) {
+            if (buf[i]     == IcomCivProtocol.PREAMBLE    &&
+                buf[i + 1] == IcomCivProtocol.PREAMBLE    &&
+                buf[i + 2] == IcomCivProtocol.ADDR_CTRL   &&
+                buf[i + 3] == IcomCivProtocol.ADDR_IC705
+            ) {
+                for (k in i + 4 until buf.size) {
+                    if (buf[k] == IcomCivProtocol.END_OF_MSG) return true
+                }
+                return false  // header found but no FD yet
+            }
+            i++
+        }
+        return false
+    }
+
+    private fun write(bytes: ByteArray): Boolean {
+        return try {
+            outputStream?.write(bytes)
+            outputStream?.flush()
+            true
+        } catch (e: Exception) {
+            Log.e(tag, "Write error: ${e.message}")
+            isConnected = false
+            false
+        }
+    }
+}
@@ -0,0 +1,352 @@
+/*
+ * Look4Sat. Amateur radio satellite tracker and pass predictor.
+ * Copyright (C) 2019-2026 Arty Bishop and contributors.
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <https://www.gnu.org/licenses/>.
+ */
+package com.rtbishop.look4sat.core.data.framework
+
+import java.util.Locale
+
+/**
+ * Icom CI-V protocol encoder/decoder for the IC-705.
+ *
+ * Frame structure:
+ *   FE FE <DEST> <SRC> <CMD> [<SUB>] [<DATA...>] FD
+ *
+ * IC-705 default CI-V address : 0xA4
+ * Controller (us) address     : 0xE0
+ */
+object IcomCivProtocol {
+
+    // ── Framing constants ──────────────────────────────────────────────────
+    const val PREAMBLE: Byte      = 0xFE.toByte()
+    const val END_OF_MSG: Byte    = 0xFD.toByte()
+    const val ACK_OK: Byte        = 0xFB.toByte()
+    const val ACK_NG: Byte        = 0xFA.toByte()
+
+    // ── Address constants ──────────────────────────────────────────────────
+    /** Default CI-V address of the IC-705. */
+    const val ADDR_IC705: Byte    = 0xA4.toByte()
+    /** Default CI-V address of the controller (us). */
+    const val ADDR_CTRL: Byte     = 0xE0.toByte()
+
+    // ── Command bytes ──────────────────────────────────────────────────────
+    /** Read operating frequency (main VFO). */
+    const val CMD_READ_FREQ: Byte           = 0x03
+    /** Set operating frequency (main VFO). */
+    const val CMD_SET_FREQ: Byte            = 0x05
+    /** Set operating mode. */
+    const val CMD_SET_MODE: Byte            = 0x06
+    /** Select VFO / memory. */
+    const val CMD_SELECT_VFO: Byte          = 0x07
+    /**
+     * Select operating mode (VFO vs memory-channel).
+     * Sub 0x00 = VFO mode. Must be sent after connect if the radio is in
+     * memory-channel mode — frequency/mode commands return FA until it is.
+     */
+    const val CMD_SELECT_OP_MODE: Byte      = 0x08
+    /** Set repeater duplex / SPLIT. */
+    const val CMD_DUPLEX_SPLIT: Byte        = 0x0F
+    /** Band stacking register / band select (sub 0x00 = select, data = BCD band number). */
+    const val CMD_BAND_SELECT: Byte         = 0x1A
+    /** Read/write CTCSS tone frequency. */
+    const val CMD_CTCSS_TONE: Byte          = 0x1B
+    /** Read/write misc settings (used for enabling CTCSS encode). */
+    const val CMD_MISC_SETTING: Byte        = 0x16
+    /** Read/write selected-VFO frequency (cmd 0x25). */
+    const val CMD_SELECTED_VFO_FREQ: Byte   = 0x25
+
+    // ── Sub-command bytes ──────────────────────────────────────────────────
+    /** Sub for CMD_SELECT_VFO: select VFO-A (main). */
+    const val SUB_VFO_A: Byte   = 0x00
+    /** Sub for CMD_SELECT_VFO: select VFO-B (sub). */
+    const val SUB_VFO_B: Byte   = 0x01
+    /** Sub for CMD_DUPLEX_SPLIT: simplex / split OFF. */
+    const val SUB_SPLIT_OFF: Byte = 0x00
+    /** Sub for CMD_DUPLEX_SPLIT: SPLIT ON. */
+    const val SUB_SPLIT_ON: Byte  = 0x01
+    /** Sub for CMD_SELECTED_VFO_FREQ: selected (active) VFO frequency. */
+    const val SUB_SELECTED_VFO: Byte = 0x00
+    /** Sub for CMD_SELECTED_VFO_FREQ: unselected (inactive / TX in split) VFO frequency. */
+    const val SUB_UNSELECTED_VFO: Byte = 0x01
+    /** Sub for CMD_MISC_SETTING: CTCSS/DTCS tone squelch. */
+    const val SUB_CTCSS_SETTING: Byte = 0x42.toByte()
+
+    // ── Mode bytes ────────────────────────────────────────────────────────
+    /** Maps mode strings (upper-case) → IC-705 mode bytes. */
+    val MODE_TO_BYTE: Map<String, Byte> = mapOf(
+        "LSB"    to 0x00,
+        "USB"    to 0x01,
+        "AM"     to 0x02,
+        "CW"     to 0x03,
+        "RTTY"   to 0x04,
+        "FM"     to 0x05,
+        "WFM"    to 0x06,
+        "CW-R"   to 0x07,
+        "RTTY-R" to 0x08,
+        "DV"     to 0x12,
+        "AFSK"   to 0x05  // AFSK uses FM modulation
+    )
+
+    val BYTE_TO_MODE: Map<Byte, String> = MODE_TO_BYTE.entries.associate { it.value to it.key }
+
+    // ── Frequency BCD encoding ─────────────────────────────────────────────
+
+    /**
+     * Encode a frequency in Hz to the IC-705's 5-byte BCD format.
+     *
+     * The IC-705 uses 5 bytes, LSB pair first, with 1 Hz resolution.
+     * Example: 145,500,000 Hz → "0145500000" → pairs LSB→MSB:
+     *   [00, 00, 50, 45, 01]
+     */
+    fun encodeFrequencyBcd(frequencyHz: Long): ByteArray {
+        val digits = String.format(Locale.US, "%010d", frequencyHz)
+        val bcd = ByteArray(5)
+        for (i in 0 until 5) {
+            // digits are MSB first; we want pair index 0 = LSB pair
+            val pairIndex = 4 - i
+            val high = digits[pairIndex * 2] - '0'
+            val low  = digits[pairIndex * 2 + 1] - '0'
+            bcd[i] = ((high shl 4) or low).toByte()
+        }
+        return bcd
+    }
+
+    /**
+     * Decode 5-byte BCD frequency (LSB pair first) to Hz.
+     */
+    fun decodeFrequencyBcd(bcd: ByteArray): Long {
+        // Build digit string MSB→LSB by reversing the byte order
+        var freqHz = 0L
+        for (i in 4 downTo 0) {
+            val b    = bcd[i].toInt() and 0xFF
+            val high = b shr 4
+            val low  = b and 0x0F
+            freqHz   = freqHz * 100 + high * 10 + low
+        }
+        return freqHz
+    }
+
+    /**
+     * Encode a CTCSS tone (Hz, e.g. 67.0) to 2-byte BCD (0.1 Hz resolution).
+     * 67.0 → 670 (tenths of Hz) → BCD bytes [0x06, 0x70].
+     */
+    fun encodeCtcssToneBcd(toneHz: Double): ByteArray {
+        val tone01 = (toneHz * 10).toLong()
+        val digits = String.format(Locale.US, "%04d", tone01)
+        return byteArrayOf(
+            ((digits[0] - '0') shl 4 or (digits[1] - '0')).toByte(),
+            ((digits[2] - '0') shl 4 or (digits[3] - '0')).toByte()
+        )
+    }
+
+    // ── Message builders ───────────────────────────────────────────────────
+
+    /** Wrap payload bytes in a CI-V frame: FE FE DEST SRC ... FD. */
+    private fun frame(vararg payload: Byte): ByteArray {
+        return byteArrayOf(PREAMBLE, PREAMBLE, ADDR_IC705, ADDR_CTRL) +
+                payload +
+                byteArrayOf(END_OF_MSG)
+    }
+
+    /** Set operating frequency via CMD 0x05 (main VFO). */
+    fun buildSetFreqCommand(frequencyHz: Long): ByteArray {
+        return frame(CMD_SET_FREQ, *encodeFrequencyBcd(frequencyHz))
+    }
+
+    /**
+     * Set selected-VFO frequency via CMD 0x25 sub 0x00.
+     * This updates whichever VFO is currently active (RX or TX after split).
+     */
+    fun buildSetWorkingFreqCommand(frequencyHz: Long): ByteArray {
+        return frame(CMD_SELECTED_VFO_FREQ, SUB_SELECTED_VFO, *encodeFrequencyBcd(frequencyHz))
+    }
+
+    /**
+     * Set unselected-VFO frequency via CMD 0x25 sub 0x01.
+     * In split mode while PTT is pressed the IC-705 makes VFO-B active, so
+     * this command targets VFO-A (the RX VFO) — and vice-versa when in RX.
+     * Use this to update the TX VFO when PTT is on.
+     */
+    fun buildSetUnselectedVfoFreqCommand(frequencyHz: Long): ByteArray {
+        return frame(CMD_SELECTED_VFO_FREQ, SUB_UNSELECTED_VFO, *encodeFrequencyBcd(frequencyHz))
+    }
+
+    /** Read operating frequency (CMD 0x03). */
+    fun buildReadFreqCommand(): ByteArray = frame(CMD_READ_FREQ)
+
+    /** Read selected (active) VFO frequency (CMD 0x25 sub 0x00). */
+    fun buildReadWorkingFreqCommand(): ByteArray = frame(CMD_SELECTED_VFO_FREQ, SUB_SELECTED_VFO)
+
+    /** Read unselected (inactive/TX in split) VFO frequency (CMD 0x25 sub 0x01). */
+    fun buildReadTxVfoFreqCommand(): ByteArray = frame(CMD_SELECTED_VFO_FREQ, SUB_UNSELECTED_VFO)
+
+    /**
+     * Select band via CMD 0x1A sub 0x00.
+     * Band codes are BCD-numbered: 1=160m, 2=80m, …, 9=10m, 0x10=6m, 0x11=2m, 0x12=70cm, 0x13=23cm.
+     * Returns null if [frequencyHz] doesn't fall in a known amateur band.
+     */
+    fun buildBandSelectCommand(frequencyHz: Long): ByteArray? {
+        val code = bandCodeForFrequency(frequencyHz) ?: return null
+        return frame(CMD_BAND_SELECT, 0x00, code)
+    }
+
+    /**
+     * Map a frequency in Hz to the IC-705 band stacking register code.
+     * Codes are BCD (band number in decimal expressed as hex nibbles).
+     */
+    fun bandCodeForFrequency(frequencyHz: Long): Byte? = when {
+        frequencyHz in 1_800_000L     ..1_999_999L     -> 0x01 // 160 m
+        frequencyHz in 3_500_000L     ..3_999_999L     -> 0x02 // 80 m
+        frequencyHz in 7_000_000L     ..7_299_999L     -> 0x03 // 40 m
+        frequencyHz in 10_100_000L    ..10_149_999L    -> 0x04 // 30 m
+        frequencyHz in 14_000_000L    ..14_349_999L    -> 0x05 // 20 m
+        frequencyHz in 18_068_000L    ..18_167_999L    -> 0x06 // 17 m
+        frequencyHz in 21_000_000L    ..21_449_999L    -> 0x07 // 15 m
+        frequencyHz in 24_890_000L    ..24_989_999L    -> 0x08 // 12 m
+        frequencyHz in 28_000_000L    ..29_699_999L    -> 0x09 // 10 m
+        frequencyHz in 50_000_000L    ..53_999_999L    -> 0x10 // 6 m  (BCD 10)
+        frequencyHz in 144_000_000L   ..147_999_999L   -> 0x11 // 2 m  (BCD 11)
+        frequencyHz in 420_000_000L   ..449_999_999L   -> 0x12 // 70 cm (BCD 12)
+        frequencyHz in 1_240_000_000L ..1_299_999_999L -> 0x13 // 23 cm (BCD 13)
+        else -> null
+    }
+
+    /** Set operating mode (CMD 0x06). Filter byte is omitted — radio uses its default filter for the mode. */
+    fun buildSetModeCommand(mode: String): ByteArray? {
+        val modeByte = MODE_TO_BYTE[mode.uppercase(Locale.US)] ?: return null
+        return frame(CMD_SET_MODE, modeByte)
+    }
+
+    /** Select VFO-A (CMD 0x07 sub 0x00). */
+    fun buildSelectVfoACommand(): ByteArray = frame(CMD_SELECT_VFO, SUB_VFO_A)
+
+    /** Select VFO-B (CMD 0x07 sub 0x01). */
+    fun buildSelectVfoBCommand(): ByteArray = frame(CMD_SELECT_VFO, SUB_VFO_B)
+
+    /**
+     * Enter VFO operating mode (CMD 0x08 sub 0x00).
+     * Sent after connect — if the radio is in memory-channel mode frequency
+     * and mode commands return FA until this is issued.
+     */
+    fun buildEnterVfoModeCommand(): ByteArray = frame(CMD_SELECT_OP_MODE, 0x00)
+
+    /** Enable or disable SPLIT mode (CMD 0x0F). */
+    fun buildSplitModeCommand(enable: Boolean): ByteArray {
+        val sub = if (enable) SUB_SPLIT_ON else SUB_SPLIT_OFF
+        return frame(CMD_DUPLEX_SPLIT, sub)
+    }
+
+    /**
+     * Enable/disable CTCSS encode (CMD 0x16 sub 0x42).
+     * 0x01 = CTCSS encoder ON, 0x00 = OFF.
+     */
+    fun buildCtcssModeCommand(enabled: Boolean): ByteArray {
+        val value: Byte = if (enabled) 0x01 else 0x00
+        return frame(CMD_MISC_SETTING, SUB_CTCSS_SETTING, value)
+    }
+
+    /**
+     * Set CTCSS tone frequency (CMD 0x1B sub 0x00).
+     */
+    fun buildSetCtcssToneCommand(toneHz: Double): ByteArray {
+        val bcd = encodeCtcssToneBcd(toneHz)
+        return frame(CMD_CTCSS_TONE, 0x00, *bcd)
+    }
+
+    // ── Response parsing ───────────────────────────────────────────────────
+
+    /**
+     * Find and parse a complete CI-V response frame from a buffer.
+     *
+     * Returns the bytes between "FE FE E0 A4 <CMD>" and FD, or null if no
+     * complete frame was found. The search is tolerant of interleaved
+     * broadcast traffic.
+     *
+     * @param buf       bytes accumulated from the radio
+     * @param expectCmd the command byte we are looking for in the reply, or
+     *                  null to accept any command response from the radio
+     */
+    fun parseResponse(buf: ByteArray, expectCmd: Byte?): ParsedResponse? {
+        var i = 0
+        while (i < buf.size - 5) {
+            // Look for FE FE preamble
+            if (buf[i] != PREAMBLE || buf[i + 1] != PREAMBLE) { i++; continue }
+            val dest = buf[i + 2]
+            val src  = buf[i + 3]
+            val cmd  = buf[i + 4]
+            // We only care about frames addressed to us from the radio
+            if (dest != ADDR_CTRL || src != ADDR_IC705) { i++; continue }
+            // Find the terminating FD
+            val fdIdx = buf.indexOf(END_OF_MSG, startIndex = i + 5)
+            if (fdIdx < 0) break  // incomplete frame, wait for more data
+            val payload = buf.copyOfRange(i + 5, fdIdx)
+            if (expectCmd == null || cmd == expectCmd) {
+                return ParsedResponse(cmd, payload, fdIdx + 1)
+            }
+            i = fdIdx + 1
+        }
+        return null
+    }
+
+    private fun ByteArray.indexOf(b: Byte, startIndex: Int): Int {
+        for (k in startIndex until size) if (this[k] == b) return k
+        return -1
+    }
+
+    /**
+     * Check whether a buffer contains an OK acknowledgement (FB FD) from
+     * the radio. Tolerates broadcast noise before the ACK.
+     */
+    fun containsAck(buf: ByteArray): Boolean {
+        var i = 0
+        while (i < buf.size - 5) {
+            if (buf[i] != PREAMBLE || buf[i + 1] != PREAMBLE) { i++; continue }
+            val dest = buf[i + 2]
+            val src  = buf[i + 3]
+            val cmd  = buf[i + 4]
+            if (dest != ADDR_CTRL || src != ADDR_IC705) { i++; continue }
+            // Skip to FD
+            val fdIdx = buf.indexOf(END_OF_MSG, startIndex = i + 5)
+            if (fdIdx < 0) break
+            if (cmd == ACK_OK) return true
+            if (cmd == ACK_NG) return false
+            i = fdIdx + 1
+        }
+        return false
+    }
+
+    /**
+     * Parse frequency + mode from a CMD_READ_FREQ reply payload.
+     * Payload layout after stripping command byte: [5 freq bytes] [mode byte] [filter byte]
+     */
+    fun parseFreqModePayload(payload: ByteArray): Pair<Long, String>? {
+        if (payload.size < 6) return null
+        val freqHz = decodeFrequencyBcd(payload.copyOfRange(0, 5))
+        val mode   = BYTE_TO_MODE[payload[5]] ?: return null
+        return freqHz to mode
+    }
+
+    /** Hex dump of bytes, useful for debug logging. */
+    fun toHex(bytes: ByteArray): String =
+        bytes.joinToString(" ") { String.format(Locale.US, "%02X", it.toInt() and 0xFF) }
+
+    data class ParsedResponse(
+        val cmd: Byte,
+        val payload: ByteArray,
+        /** Index in the source buffer immediately after the FD terminator. */
+        val nextOffset: Int
+    )
+}
@@ -17,11 +17,10 @@
 */
 package com.rtbishop.look4sat.core.data.framework

-import com.rtbishop.look4sat.core.domain.repository.BtService
-import com.rtbishop.look4sat.core.domain.repository.ExtendedParams
-import com.rtbishop.look4sat.core.domain.repository.IReporterRepo
+import com.rtbishop.look4sat.core.domain.model.Constants
+import com.rtbishop.look4sat.core.domain.repository.IReporter
 import kotlinx.coroutines.CoroutineScope
-import kotlinx.coroutines.Job
+import kotlinx.coroutines.channels.Channel
 import kotlinx.coroutines.launch
 import kotlinx.coroutines.sync.Mutex
 import kotlinx.coroutines.sync.withLock
@@ -29,89 +28,133 @@ import java.net.InetSocketAddress
 import java.nio.ByteBuffer
 import java.nio.channels.SocketChannel

-enum class NetworkService { ROTATOR, FREQUENCY }
+class NetworkReporter(
+    private val reporterScope: CoroutineScope,
+    private val rotatorServer: String,
+    private val rotatorPort: Int,
+    private val frequencyServer: String,
+    private val frequencyPort: Int,
+    private val frequencyOffsetHz: Long = 0L
+) : IReporter {

-data class SocketConnection(
-    var socket: SocketChannel? = null,
-    var connected: Boolean = false,
-    var connecting: Boolean = false,
-    var connectionJob: Job? = null
-)
-
-class NetworkReporter(private val reporterScope: CoroutineScope) : IReporterRepo<ExtendedParams> {
-    private val serviceToAddress = mutableMapOf<NetworkService, String>()
-    private val connections = mutableMapOf<String, SocketConnection>()
    private val writeMutex = Mutex()
+    private val connectionMutex = Mutex()
+    private val frequencyCommands = Channel<String>(Channel.CONFLATED)

-    fun isConnected(service: NetworkService): Boolean {
-        val addr = serviceToAddress[service] ?: return false
-        return connections[addr]?.connected == true
-    }
+    private var rotatorSocket: SocketChannel? = null
+    private var rotatorConnected = false

-    private fun getOrCreateConnection(addr: String): SocketConnection {
-        return connections.getOrPut(addr) { SocketConnection() }
-    }
+    private var frequencySocket: SocketChannel? = null
+    private var frequencyConnected = false

-    fun connect(service: NetworkService, server: String, port: Int) {
-        val addr = "$server:$port"
-        serviceToAddress[service] = addr
-        val connection = getOrCreateConnection(addr)
-        if (connection.connected || connection.connecting) return
-        connection.connectionJob = reporterScope.launch {
-            try {
-                connection.connecting = true
-                val socket = SocketChannel.open(InetSocketAddress(server, port))
-                connection.socket = socket
-                connection.connected = true
-                println("NetworkReporter: $service connected to $addr")
-            } catch (e: Exception) {
-                println("NetworkReporter connect error: ${e.message}")
-                connection.connected = false
-            } finally {
-                connection.connecting = false
+    init {
+        // Keep only the latest frequency command to avoid stale backlog and effective lag.
+        reporterScope.launch {
+            for (command in frequencyCommands) {
+                ensureFrequencyConnected()
+                if (!frequencyConnected) continue
+                write(frequencySocket, command) { resetFrequencyConnection() }
            }
        }
    }

-    private suspend fun write(service: NetworkService, command: String) {
-        val addr = serviceToAddress[service] ?: return
-        val connection = connections[addr] ?: return
-        if (!connection.connected) return
+    override fun reportRotation(format: String, azimuth: Double, elevation: Double) {
+        reporterScope.launch {
+            ensureRotatorConnected()
+            if (!rotatorConnected) return@launch
+            val el = if (elevation > 0.0) elevation else 0.0
+            val command = format
+                .replace($$"$AZ", azimuth.toString())
+                .replace($$"$EL", el.toString())
+                .unescapeControlChars()
+            write(rotatorSocket, command) { resetRotatorConnection() }
+        }
+    }
+
+    override fun reportFrequency(format: String, frequency: Long) {
+        val clampedOffset = frequencyOffsetHz.coerceIn(
+            Constants.FREQ_OFFSET_MIN_HZ,
+            Constants.FREQ_OFFSET_MAX_HZ
+        )
+        val correctedFreq = frequency.coerceAtLeast(0L).safeAdd(clampedOffset).coerceAtLeast(0L)
+        val command = format
+            .replace($$"$FREQ", correctedFreq.toString())
+            .unescapeControlChars()
+        frequencyCommands.trySend(command)
+    }
+
+    private suspend fun ensureRotatorConnected() {
+        connectionMutex.withLock {
+            if (rotatorConnected || rotatorServer.isBlank()) return
+            try {
+                resetRotatorConnection()
+                rotatorSocket = SocketChannel.open(InetSocketAddress(rotatorServer, rotatorPort))
+                rotatorConnected = true
+                println("NetworkReporter: Rotator connected to $rotatorServer:$rotatorPort")
+            } catch (e: Exception) {
+                println("NetworkReporter rotator connect error: ${e.message}")
+                resetRotatorConnection()
+            }
+        }
+    }
+
+    private suspend fun ensureFrequencyConnected() {
+        connectionMutex.withLock {
+            if (frequencyConnected || frequencyServer.isBlank()) return
+            try {
+                resetFrequencyConnection()
+                frequencySocket = SocketChannel.open(InetSocketAddress(frequencyServer, frequencyPort))
+                frequencyConnected = true
+                println("NetworkReporter: Frequency connected to $frequencyServer:$frequencyPort")
+            } catch (e: Exception) {
+                println("NetworkReporter frequency connect error: ${e.message}")
+                resetFrequencyConnection()
+            }
+        }
+    }
+
+    private suspend fun write(socket: SocketChannel?, command: String, onError: () -> Unit) {
        try {
            writeMutex.withLock {
-                val buffer = ByteBuffer.wrap("\\$command\n".toByteArray())
-                connection.socket?.write(buffer)
+                val buffer = ByteBuffer.wrap("$command\n".toByteArray())
+                while (buffer.hasRemaining()) {
+                    socket?.write(buffer)
+                }
            }
        } catch (e: Exception) {
            println("NetworkReporter write error: ${e.message}")
-            connection.connected = false
+            onError()
        }
    }

-    override fun isConnected(service: BtService): Boolean = false
+    private fun resetRotatorConnection() {
+        rotatorConnected = false
+        closeQuietly(rotatorSocket)
+        rotatorSocket = null
+    }

-    override fun isConnecting(service: BtService): Boolean = false
+    private fun resetFrequencyConnection() {
+        frequencyConnected = false
+        closeQuietly(frequencySocket)
+        frequencySocket = null
+    }

-    override fun connect(service: BtService, deviceId: String) {}
+    private fun closeQuietly(socket: SocketChannel?) {
+        try {
+            socket?.close()
+        } catch (_: Exception) {}
+    }

-    override fun reportRotation(format: String, azimuth: Double, elevation: Double, params: ExtendedParams) {
-        reporterScope.launch {
-            connect(NetworkService.ROTATOR, params.server, params.port)
-            if (!isConnected(NetworkService.ROTATOR)) return@launch
-            val el = if (elevation > 0.0) elevation else 0.0
-            val command = format
-                .replace("\$AZ", azimuth.toString())
-                .replace("\$EL", el.toString())
-            write(NetworkService.ROTATOR, command)
+    private fun Long.safeAdd(delta: Long): Long {
+        return when {
+            delta > 0 && this > Long.MAX_VALUE - delta -> Long.MAX_VALUE
+            delta < 0 && this < Long.MIN_VALUE - delta -> Long.MIN_VALUE
+            else -> this + delta
        }
    }

-    override fun reportFrequency(format: String, frequency: Long, params: ExtendedParams) {
-        reporterScope.launch {
-            connect(NetworkService.FREQUENCY, params.server, params.port)
-            if (!isConnected(NetworkService.FREQUENCY)) return@launch
-            val command = format.replace("\$FREQ", frequency.toString())
-            write(NetworkService.FREQUENCY, command)
-        }
-    }
+    private fun String.unescapeControlChars(): String =
+        replace("""\r""", 13.toChar().toString())
+            .replace("""\n""", 10.toChar().toString())
+            .replace("""\t""", 9.toChar().toString())
 }
@@ -0,0 +1,556 @@
+/*
+ * Look4Sat. Amateur radio satellite tracker and pass predictor.
+ * Copyright (C) 2019-2026 Arty Bishop and contributors.
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <https://www.gnu.org/licenses/>.
+ */
+package com.rtbishop.look4sat.core.data.framework
+
+import android.bluetooth.BluetoothManager
+import android.util.Log
+import com.rtbishop.look4sat.core.domain.model.RadioControlSettings
+import com.rtbishop.look4sat.core.domain.model.SatRadio
+import com.rtbishop.look4sat.core.domain.predict.OrbitalPass
+import com.rtbishop.look4sat.core.domain.predict.SPEED_OF_LIGHT
+import com.rtbishop.look4sat.core.domain.repository.IRadioController
+import com.rtbishop.look4sat.core.domain.repository.IRadioTrackingService
+import com.rtbishop.look4sat.core.domain.repository.ISatelliteRepo
+import com.rtbishop.look4sat.core.domain.repository.ISettingsRepo
+import com.rtbishop.look4sat.core.domain.repository.RadioTrackingState
+import com.rtbishop.look4sat.core.domain.utility.TransponderMapper
+import kotlinx.coroutines.CoroutineScope
+import kotlinx.coroutines.Job
+import kotlinx.coroutines.currentCoroutineContext
+import kotlinx.coroutines.delay
+import kotlinx.coroutines.flow.MutableStateFlow
+import kotlinx.coroutines.flow.StateFlow
+import kotlinx.coroutines.flow.update
+import kotlinx.coroutines.isActive
+import kotlinx.coroutines.launch
+
+class RadioTrackingService(
+    private val appScope: CoroutineScope,
+    private val bluetoothManager: BluetoothManager,
+    private val satelliteRepo: ISatelliteRepo,
+    private val settingsRepo: ISettingsRepo
+) : IRadioTrackingService {
+
+    private val tag = "RadioTracking"
+    /** Delay between each step of the split-mode init sequence (ms). */
+    private val INIT_STEP_DELAY_MS = 200L
+    private val _state = MutableStateFlow(RadioTrackingState())
+    override val state: StateFlow<RadioTrackingState> = _state
+
+    private var txController: IRadioController? = null
+    private var rxController: IRadioController? = null
+    private var trackingJob: Job? = null
+
+    // ── Connection ──────────────────────────────────────────────────────────
+
+    override suspend fun connectRadios() {
+        txController?.disconnect()
+        rxController?.disconnect()
+
+        val rcSettings = settingsRepo.radioControlSettings.value
+        val txAddr     = rcSettings.txRadioAddress
+        val rxAddr     = rcSettings.rxRadioAddress
+        val isIcom     = rcSettings.radioModel == RadioControlSettings.MODEL_ICOM_IC705
+        val isSplit    = isIcom && rcSettings.splitMode
+
+        Log.i(tag, "connectRadios model=${rcSettings.radioModel} split=$isSplit TX=$txAddr RX=$rxAddr")
+
+        if (isSplit) {
+            // Single-radio split mode: only TX slot is used
+            if (txAddr.isBlank()) {
+                _state.update { it.copy(errorMessage = "No radio address configured in Settings") }
+                return
+            }
+            val tx = makeController(isIcom, txAddr)
+            txController = tx
+            rxController = null
+            _state.update { it.copy(errorMessage = null) }
+            val txOk = tx.connect()
+            _state.update {
+                it.copy(
+                    txConnected = txOk,
+                    rxConnected = false,
+                    errorMessage = if (!txOk) "Could not connect to radio ($txAddr)" else null
+                )
+            }
+            Log.i(tag, "IC-705 split mode connected: txOk=$txOk")
+        } else {
+            if (txAddr.isBlank() && rxAddr.isBlank()) {
+                _state.update { it.copy(errorMessage = "No radio addresses configured in Settings") }
+                return
+            }
+            val tx = makeController(isIcom, txAddr)
+            val rx = makeController(isIcom, rxAddr)
+            txController = tx
+            rxController = rx
+            _state.update { it.copy(errorMessage = null) }
+            val txOk = if (txAddr.isNotBlank()) tx.connect() else false
+            val rxOk = if (rxAddr.isNotBlank()) rx.connect() else false
+            _state.update {
+                it.copy(
+                    txConnected = txOk,
+                    rxConnected = rxOk,
+                    errorMessage = when {
+                        !txOk && !rxOk -> "Could not connect to TX and RX radios"
+                        !txOk          -> "Could not connect to TX radio ($txAddr)"
+                        !rxOk          -> "Could not connect to RX radio ($rxAddr)"
+                        else           -> null
+                    }
+                )
+            }
+            Log.i(tag, "Dual-radio connected: txOk=$txOk rxOk=$rxOk")
+        }
+    }
+
+    private fun makeController(isIcom: Boolean, address: String): IRadioController =
+        if (isIcom) Ic705Controller(bluetoothManager, address)
+        else        Ft817Controller(bluetoothManager, address)
+
+    override suspend fun disconnectRadios() {
+        stopTracking()
+        txController?.disconnect()
+        rxController?.disconnect()
+        txController = null
+        rxController = null
+        _state.update { it.copy(txConnected = false, rxConnected = false, isActive = false) }
+    }
+
+    // ── Tracking ────────────────────────────────────────────────────────────
+
+    override fun startTracking(pass: OrbitalPass, transponder: SatRadio, txBaseFreqHz: Long?) {
+        _state.update {
+            it.copy(
+                isActive             = true,
+                currentPass          = pass,
+                selectedTransponder  = transponder,
+                txBaseFrequencyHz    = txBaseFreqHz
+            )
+        }
+        trackingJob?.cancel()
+
+        val rcSettings = settingsRepo.radioControlSettings.value
+        val isIcom     = rcSettings.radioModel == RadioControlSettings.MODEL_ICOM_IC705
+        val isSplit    = isIcom && rcSettings.splitMode
+
+        if (isSplit) {
+            trackingJob = appScope.launch { runSplitTracking(transponder, txBaseFreqHz) }
+        } else {
+            trackingJob = appScope.launch { runDualRadioTracking(transponder, txBaseFreqHz) }
+        }
+    }
+
+    // ── Dual-radio tracking (Yaesu or two IC-705s) ──────────────────────────
+
+    private suspend fun runDualRadioTracking(transponder: SatRadio, initialTxBaseFreqHz: Long?) {
+        val tx = txController
+        val rx = rxController
+
+        // Initial setup: set band/mode/CTCSS on both radios
+        val txMode = transponder.uplinkMode
+        val rxMode = transponder.downlinkMode
+            ?: transponder.uplinkMode?.let {
+                TransponderMapper.mapUplinkModeToDownlinkMode(it, transponder.isInverted)
+            }
+
+        Log.i(tag, "DualRadio start: txMode=$txMode rxMode=$rxMode")
+
+        if (tx != null && tx.isConnected && txMode != null) {
+            Log.d(tag, "Setting TX mode: $txMode")
+            tx.setMode(txMode)
+        }
+        if (rx != null && rx.isConnected && rxMode != null) {
+            Log.d(tag, "Setting RX mode: $rxMode")
+            rx.setMode(rxMode)
+        }
+        if (txMode?.uppercase() == "FM") {
+            _state.value.ctcssTone?.let { tone ->
+                Log.d(tag, "Setting CTCSS: ${tone}Hz")
+                tx?.setCtcssTone(tone)
+                tx?.setCtcssMode(true)
+            }
+        }
+        _state.update { it.copy(txMode = txMode, rxMode = rxMode) }
+
+        var lastSetTxFreq = 0.0
+        var lastSetRxFreq = 0.0
+        var tuningRadio   = ""
+        var lastReadFreq  = 0L
+        var stableCount   = 0
+
+        while (currentCoroutineContext().isActive) {
+            val currentState = _state.value
+            if (!currentState.isActive) break
+
+            val satPass = currentState.currentPass ?: break
+            val xpdr    = currentState.selectedTransponder ?: break
+            var txBaseFreq = currentState.txBaseFrequencyHz
+            val stationPos = settingsRepo.stationPosition.value
+            val pos = satelliteRepo.getPosition(satPass.orbitalObject, stationPos, System.currentTimeMillis())
+            val txNow = txController
+            val rxNow = rxController
+            val v = pos.distanceRate * 1000.0
+
+            if (tuningRadio.isNotEmpty()) {
+                val radio = if (tuningRadio == "tx") txNow else rxNow
+                if (radio != null && radio.isConnected) {
+                    val read = radio.readFrequencyAndMode()
+                    if (read != null) {
+                        val (freq, _) = read
+                        if (kotlin.math.abs(freq - lastReadFreq) <= 20) stableCount++
+                        else { stableCount = 0; lastReadFreq = freq }
+                        if (stableCount >= 2) {
+                            if (tuningRadio == "tx" && txBaseFreq != null) {
+                                val newBase = (freq.toDouble() * SPEED_OF_LIGHT / (SPEED_OF_LIGHT + v)).toLong()
+                                if (newBase > 0) {
+                                    txBaseFreq = newBase
+                                    _state.update { it.copy(txBaseFrequencyHz = newBase) }
+                                    Log.i(tag, "TX tuning done → base=$newBase")
+                                }
+                            } else if (tuningRadio == "rx") {
+                                val rxNominal = (freq.toDouble() * SPEED_OF_LIGHT / (SPEED_OF_LIGHT - v)).toLong()
+                                val newTxBase = TransponderMapper.mapDownlinkToUplink(rxNominal, xpdr)
+                                if (newTxBase != null && newTxBase > 0) {
+                                    txBaseFreq = newTxBase
+                                    _state.update { it.copy(txBaseFrequencyHz = newTxBase) }
+                                    Log.i(tag, "RX tuning done → txBase=$newTxBase")
+                                }
+                            }
+                            tuningRadio   = ""
+                            stableCount   = 0
+                            lastSetTxFreq = 0.0
+                            lastSetRxFreq = 0.0
+                        }
+                    }
+                }
+            } else {
+                // Detect manual dial changes
+                if (txBaseFreq != null && txNow != null && txNow.isConnected && lastSetTxFreq > 0.0) {
+                    val read = txNow.readFrequencyAndMode()
+                    if (read != null && kotlin.math.abs(read.first - lastSetTxFreq) >= 20.0) {
+                        tuningRadio  = "tx"
+                        lastReadFreq = read.first
+                        stableCount  = 0
+                        Log.i(tag, "TX tuning detected (read=${read.first}, lastSet=$lastSetTxFreq)")
+                    }
+                }
+                if (tuningRadio.isEmpty() && rxNow != null && rxNow.isConnected && lastSetRxFreq > 0.0) {
+                    val read = rxNow.readFrequencyAndMode()
+                    if (read != null && kotlin.math.abs(read.first - lastSetRxFreq) >= 20.0) {
+                        tuningRadio  = "rx"
+                        lastReadFreq = read.first
+                        stableCount  = 0
+                        Log.i(tag, "RX tuning detected (read=${read.first}, lastSet=$lastSetRxFreq)")
+                    }
+                }
+            }
+
+            val txRadioFreq = txBaseFreq?.let { pos.getUplinkFreq(it) }
+            val rxBaseFreq  = if (txBaseFreq != null) {
+                TransponderMapper.mapUplinkToDownlink(txBaseFreq, xpdr)
+            } else xpdr.downlinkLow
+            val rxRadioFreq = rxBaseFreq?.let { pos.getDownlinkFreq(it) }
+
+            if (tuningRadio.isEmpty()) {
+                if (txNow != null && txNow.isConnected && txRadioFreq != null) {
+                    txNow.setFrequency(txRadioFreq)
+                    lastSetTxFreq = txRadioFreq.toDouble()
+                }
+                if (rxNow != null && rxNow.isConnected && rxRadioFreq != null) {
+                    rxNow.setFrequency(rxRadioFreq)
+                    lastSetRxFreq = rxRadioFreq.toDouble()
+                }
+            }
+
+            _state.update {
+                it.copy(
+                    txConnected  = txNow?.isConnected ?: false,
+                    rxConnected  = rxNow?.isConnected ?: false,
+                    txFrequencyHz = txRadioFreq,
+                    rxFrequencyHz = rxRadioFreq,
+                    azimuth      = Math.toDegrees(pos.azimuth),
+                    elevation    = Math.toDegrees(pos.elevation),
+                    distance     = pos.distance
+                )
+            }
+            delay(1000)
+        }
+    }
+
+    // ── IC-705 split-radio tracking ─────────────────────────────────────────
+
+    private suspend fun runSplitTracking(transponder: SatRadio, initialTxBaseFreqHz: Long?) {
+        val radio = txController ?: return
+        if (!radio.isConnected) return
+
+        val txMode = transponder.uplinkMode
+        val rxMode = transponder.downlinkMode
+            ?: transponder.uplinkMode?.let {
+                TransponderMapper.mapUplinkModeToDownlinkMode(it, transponder.isInverted)
+            }
+
+        // Compute nominal base frequencies
+        val txCenter = when {
+            transponder.uplinkLow != null && transponder.uplinkHigh != null ->
+                (transponder.uplinkLow!! + transponder.uplinkHigh!!) / 2
+            transponder.uplinkLow != null -> transponder.uplinkLow!!
+            else -> null
+        }
+        val rxNominal = if (txCenter != null) {
+            TransponderMapper.mapUplinkToDownlink(txCenter, transponder)
+        } else transponder.downlinkLow
+
+        val txBase = initialTxBaseFreqHz ?: txCenter
+        Log.i(tag, "IC-705 split setup: txBase=${txBase}Hz rxNominal=${rxNominal}Hz txMode=$txMode rxMode=$rxMode")
+
+        // ── Initial setup sequence ──────────────────────────────────────────
+        // Sequence per IC-705: explicitly select VFO, then band → freq → mode.
+        // ACK from each command gates the next — no fixed delays needed.
+
+        // VFO-A = RX (downlink)
+        Log.d(tag, "Split init: selecting VFO-A for RX (downlink)")
+        radio.setVfo(vfoA = true)
+        if (rxNominal != null) {
+            Log.d(tag, "Split init: VFO-A band for ${rxNominal}Hz")
+            radio.setBand(rxNominal)
+            Log.d(tag, "Split init: VFO-A freq=${rxNominal}Hz")
+            radio.setFrequency(rxNominal)
+        }
+        if (rxMode != null) {
+            Log.d(tag, "Split init: VFO-A mode=$rxMode")
+            radio.setMode(rxMode)
+        }
+
+        // VFO-B = TX (uplink)
+        Log.d(tag, "Split init: selecting VFO-B for TX (uplink)")
+        radio.setVfo(vfoA = false)
+        if (txBase != null) {
+            Log.d(tag, "Split init: VFO-B band for ${txBase}Hz")
+            radio.setBand(txBase)
+            Log.d(tag, "Split init: VFO-B freq=${txBase}Hz")
+            radio.setFrequency(txBase)
+        }
+        if (txMode != null) {
+            Log.d(tag, "Split init: VFO-B mode=$txMode")
+            radio.setMode(txMode)
+        }
+        if (txMode?.uppercase() == "FM") {
+            val tone = _state.value.ctcssTone
+            if (tone != null) {
+                Log.d(tag, "Split init: CTCSS=${tone}Hz")
+                radio.setCtcssTone(tone)
+                radio.setCtcssMode(true)
+            } else {
+                radio.setCtcssMode(false)
+            }
+        }
+
+        // Enable SPLIT on VFO-A (return display to RX VFO first)
+        Log.d(tag, "Split init: returning to VFO-A, then enabling SPLIT mode")
+        radio.setVfo(vfoA = true)
+        radio.setSplitMode(enabled = true)
+
+        _state.update { it.copy(txMode = txMode, rxMode = rxMode, txBaseFrequencyHz = txBase) }
+        Log.i(tag, "IC-705 split init done — entering tracking loop")
+
+        // ── Tracking loop with tuning detection ─────────────────────────────
+        var lastSetTxFreq = 0.0
+        var lastSetRxFreq = 0.0
+        var tuningRadio   = ""  // "tx" or "rx" when manual tuning detected
+        var lastReadFreq  = 0L
+        var stableCount   = 0
+
+        while (currentCoroutineContext().isActive) {
+            val currentState = _state.value
+            if (!currentState.isActive) break
+
+            val satPass = currentState.currentPass ?: break
+            val xpdr    = currentState.selectedTransponder ?: break
+            var txBaseFreq = currentState.txBaseFrequencyHz
+            val stationPos = settingsRepo.stationPosition.value
+            val pos = satelliteRepo.getPosition(satPass.orbitalObject, stationPos, System.currentTimeMillis())
+            val v = pos.distanceRate * 1000.0
+
+            if (tuningRadio.isNotEmpty()) {
+                // User is tuning — wait for frequency to stabilize
+                val readFreq = if (tuningRadio == "tx") radio.readTxVfoFrequency() else radio.readWorkingFrequency()
+                if (readFreq != null) {
+                    if (kotlin.math.abs(readFreq - lastReadFreq) <= 20) stableCount++
+                    else { stableCount = 0; lastReadFreq = readFreq }
+
+                    if (stableCount >= 2) {
+                        // Frequency stable — reverse-calculate base frequency
+                        if (tuningRadio == "tx" && txBaseFreq != null) {
+                            val newBase = (readFreq.toDouble() * SPEED_OF_LIGHT / (SPEED_OF_LIGHT + v)).toLong()
+                            if (newBase > 0) {
+                                txBaseFreq = newBase
+                                _state.update { it.copy(txBaseFrequencyHz = newBase) }
+                                Log.i(tag, "Split TX tuning done → base=$newBase")
+                            }
+                        } else if (tuningRadio == "rx") {
+                            val rxNominal = (readFreq.toDouble() * SPEED_OF_LIGHT / (SPEED_OF_LIGHT - v)).toLong()
+                            val newTxBase = TransponderMapper.mapDownlinkToUplink(rxNominal, xpdr)
+                            if (newTxBase != null && newTxBase > 0) {
+                                txBaseFreq = newTxBase
+                                _state.update { it.copy(txBaseFrequencyHz = newTxBase) }
+                                Log.i(tag, "Split RX tuning done → txBase=$newTxBase")
+                            }
+                        }
+                        tuningRadio   = ""
+                        stableCount   = 0
+                        lastSetTxFreq = 0.0
+                        lastSetRxFreq = 0.0
+                    }
+                }
+            } else {
+                // Detect manual dial changes
+                if (txBaseFreq != null && lastSetTxFreq > 0.0) {
+                    val readTx = radio.readTxVfoFrequency()
+                    if (readTx != null && kotlin.math.abs(readTx - lastSetTxFreq) >= 20.0) {
+                        tuningRadio  = "tx"
+                        lastReadFreq = readTx
+                        stableCount  = 0
+                        Log.i(tag, "Split TX tuning detected (read=${readTx}, lastSet=$lastSetTxFreq)")
+                    }
+                }
+                if (tuningRadio.isEmpty() && lastSetRxFreq > 0.0) {
+                    val readRx = radio.readWorkingFrequency()
+                    if (readRx != null && kotlin.math.abs(readRx - lastSetRxFreq) >= 20.0) {
+                        tuningRadio  = "rx"
+                        lastReadFreq = readRx
+                        stableCount  = 0
+                        Log.i(tag, "Split RX tuning detected (read=${readRx}, lastSet=$lastSetRxFreq)")
+                    }
+                }
+            }
+
+            // Determine Doppler-corrected frequencies
+            val txRadioFreq = txBaseFreq?.let { pos.getUplinkFreq(it) }
+            val rxBaseCalc  = if (txBaseFreq != null) {
+                TransponderMapper.mapUplinkToDownlink(txBaseFreq, xpdr)
+            } else xpdr.downlinkLow
+            val rxRadioFreq = rxBaseCalc?.let { pos.getDownlinkFreq(it) }
+
+            if (radio.isConnected && tuningRadio.isEmpty()) {
+                // Update both VFOs every cycle — no PTT polling needed.
+                // 0x25/00 = active (RX) VFO, 0x25/01 = inactive (TX) VFO.
+                if (rxRadioFreq != null) {
+                    Log.d(tag, "Split loop RX (0x25/00): ${rxRadioFreq}Hz")
+                    radio.setWorkingFrequency(rxRadioFreq)
+                    lastSetRxFreq = rxRadioFreq.toDouble()
+                }
+                if (txRadioFreq != null) {
+                    Log.d(tag, "Split loop TX (0x25/01): ${txRadioFreq}Hz")
+                    radio.setTxVfoFrequency(txRadioFreq)
+                    lastSetTxFreq = txRadioFreq.toDouble()
+                }
+            }
+
+            _state.update {
+                it.copy(
+                    txConnected   = radio.isConnected,
+                    rxConnected   = false,  // single radio
+                    txFrequencyHz = txRadioFreq,
+                    rxFrequencyHz = rxRadioFreq,
+                    azimuth       = Math.toDegrees(pos.azimuth),
+                    elevation     = Math.toDegrees(pos.elevation),
+                    distance      = pos.distance
+                )
+            }
+            delay(1000)
+        }
+    }
+
+    // ── Other IRadioTrackingService methods ─────────────────────────────────
+
+    override fun stopTracking() {
+        trackingJob?.cancel()
+        trackingJob = null
+        _state.update { it.copy(isActive = false) }
+    }
+
+    override fun setTransponder(transponder: SatRadio) {
+        appScope.launch {
+            val tx = txController
+            val rx = rxController
+            transponder.uplinkMode?.let { tx?.setMode(it) }
+            val rxMode = transponder.downlinkMode
+                ?: transponder.uplinkMode?.let {
+                    TransponderMapper.mapUplinkModeToDownlinkMode(it, transponder.isInverted)
+                }
+            rxMode?.let { rx?.setMode(it) }
+            if (transponder.uplinkMode?.uppercase() == "FM") {
+                _state.value.ctcssTone?.let { tone ->
+                    tx?.setCtcssTone(tone)
+                    tx?.setCtcssMode(true)
+                }
+            }
+        }
+        val txCenter = when {
+            transponder.uplinkLow != null && transponder.uplinkHigh != null ->
+                (transponder.uplinkLow!! + transponder.uplinkHigh!!) / 2
+            transponder.uplinkLow != null -> transponder.uplinkLow!!
+            else -> null
+        }
+        val rxNominal = if (txCenter != null) {
+            TransponderMapper.mapUplinkToDownlink(txCenter, transponder)
+        } else transponder.downlinkLow
+        _state.update {
+            it.copy(
+                selectedTransponder = transponder,
+                txBaseFrequencyHz   = txCenter,
+                txFrequencyHz       = txCenter,
+                rxFrequencyHz       = rxNominal,
+                txMode              = transponder.uplinkMode,
+                rxMode              = transponder.downlinkMode
+                    ?: transponder.uplinkMode?.let { m ->
+                        TransponderMapper.mapUplinkModeToDownlinkMode(m, transponder.isInverted)
+                    }
+            )
+        }
+    }
+
+    override fun setTxBaseFrequency(frequencyHz: Long) {
+        _state.update { it.copy(txBaseFrequencyHz = frequencyHz) }
+    }
+
+    override fun adjustTxBaseFrequency(deltaHz: Long) {
+        val current = _state.value.txBaseFrequencyHz ?: return
+        _state.update { it.copy(txBaseFrequencyHz = current + deltaHz) }
+    }
+
+    override fun setCtcssTone(toneHz: Double?) {
+        _state.update { it.copy(ctcssTone = toneHz) }
+        appScope.launch {
+            val tx = txController
+            if (toneHz != null) {
+                tx?.setCtcssTone(toneHz)
+                tx?.setCtcssMode(true)
+            } else {
+                tx?.setCtcssMode(false)
+            }
+        }
+    }
+
+    override fun setMode(txMode: String, rxMode: String) {
+        appScope.launch {
+            txController?.setMode(txMode)
+            rxController?.setMode(rxMode)
+        }
+        _state.update { it.copy(txMode = txMode, rxMode = rxMode) }
+    }
+}
@@ -1,72 +1,162 @@
+/*
+ * Look4Sat. Amateur radio satellite tracker and pass predictor.
+ * Copyright (C) 2019-2026 Arty Bishop and contributors.
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <https://www.gnu.org/licenses/>.
+ */
 package com.rtbishop.look4sat.core.data.injection

 import android.bluetooth.BluetoothManager
 import android.content.Context
-import android.hardware.Sensor
 import android.hardware.SensorManager
+import android.hardware.display.DisplayManager
 import android.location.LocationManager
-import android.view.WindowManager
 import androidx.room.Room
 import com.rtbishop.look4sat.core.data.database.Look4SatDb
+import com.rtbishop.look4sat.core.data.database.MIGRATION_1_2
 import com.rtbishop.look4sat.core.data.framework.BluetoothReporter
+import com.rtbishop.look4sat.core.data.framework.Ft817Controller
+import com.rtbishop.look4sat.core.data.framework.Ic705Controller
 import com.rtbishop.look4sat.core.data.framework.NetworkReporter
+import com.rtbishop.look4sat.core.data.framework.RadioTrackingService
+import com.rtbishop.look4sat.core.data.repository.AmSatRepository
 import com.rtbishop.look4sat.core.data.repository.DatabaseRepo
 import com.rtbishop.look4sat.core.data.repository.SatelliteRepo
 import com.rtbishop.look4sat.core.data.repository.SelectionRepo
 import com.rtbishop.look4sat.core.data.repository.SensorsRepo
 import com.rtbishop.look4sat.core.data.repository.SettingsRepo
+import com.rtbishop.look4sat.core.data.repository.UpdateRepository
+import com.rtbishop.look4sat.core.data.repository.LoTWRepository
+import com.rtbishop.look4sat.core.data.repository.WavelogRepository
 import com.rtbishop.look4sat.core.data.source.LocalSource
 import com.rtbishop.look4sat.core.data.source.RemoteSource
 import com.rtbishop.look4sat.core.data.usecase.AddToCalendar
+import com.rtbishop.look4sat.core.data.usecase.AudioCapture
+import com.rtbishop.look4sat.core.data.usecase.SaveImage
 import com.rtbishop.look4sat.core.data.usecase.ShowToast
-import com.rtbishop.look4sat.core.domain.repository.ExtendedParams
+import com.rtbishop.look4sat.core.domain.model.RadioControlSettings
 import com.rtbishop.look4sat.core.domain.repository.IDatabaseRepo
 import com.rtbishop.look4sat.core.domain.repository.IMainContainer
-import com.rtbishop.look4sat.core.domain.repository.IReporterRepo
+import com.rtbishop.look4sat.core.domain.repository.IRadioController
+import com.rtbishop.look4sat.core.domain.repository.IRadioTrackingService
+import com.rtbishop.look4sat.core.domain.repository.IReporter
+import com.rtbishop.look4sat.core.domain.repository.ILoTWRepository
 import com.rtbishop.look4sat.core.domain.repository.ISatelliteRepo
 import com.rtbishop.look4sat.core.domain.repository.ISelectionRepo
 import com.rtbishop.look4sat.core.domain.repository.ISensorsRepo
 import com.rtbishop.look4sat.core.domain.repository.ISettingsRepo
-import com.rtbishop.look4sat.core.domain.repository.WithoutExtParams
+import com.rtbishop.look4sat.core.domain.repository.IWavelogRepository
+import com.rtbishop.look4sat.core.domain.repository.MutualPassData
 import com.rtbishop.look4sat.core.domain.source.ILocalSource
 import com.rtbishop.look4sat.core.domain.source.IRemoteSource
 import com.rtbishop.look4sat.core.domain.usecase.IAddToCalendar
+import com.rtbishop.look4sat.core.domain.usecase.IAudioCapture
+import com.rtbishop.look4sat.core.domain.usecase.ISaveImage
 import com.rtbishop.look4sat.core.domain.usecase.IShowToast
 import com.rtbishop.look4sat.core.domain.utility.DataParser
 import kotlinx.coroutines.CoroutineExceptionHandler
 import kotlinx.coroutines.CoroutineScope
 import kotlinx.coroutines.Dispatchers
 import kotlinx.coroutines.SupervisorJob
+import kotlinx.coroutines.flow.MutableStateFlow
+import kotlinx.coroutines.flow.StateFlow
+import kotlinx.coroutines.flow.asStateFlow
 import okhttp3.OkHttpClient

 class MainContainer(private val context: Context) : IMainContainer {

    private val localSource = provideLocalSource()
+    private val remoteSource = provideRemoteSource()
    private val mainHandler = CoroutineExceptionHandler { _, error -> println("MainHandler: $error") }
    override val appScope = CoroutineScope(SupervisorJob() + Dispatchers.Default + mainHandler)
    override val settingsRepo = provideSettingsRepo()
    override val selectionRepo = provideSelectionRepo()
    override val satelliteRepo = provideSatelliteRepo()
    override val databaseRepo = provideDatabaseRepo()
+    override val amSatRepo by lazy { AmSatRepository(remoteSource, appScope) }
+    override val updateRepo by lazy { UpdateRepository(remoteSource) }
+    override val wavelogRepo: IWavelogRepository by lazy { WavelogRepository() }
+    override val lotwRepo: ILoTWRepository by lazy { LoTWRepository() }
+    override val radioTrackingService: IRadioTrackingService by lazy {
+        val manager = context.getSystemService(Context.BLUETOOTH_SERVICE) as BluetoothManager
+        RadioTrackingService(appScope, manager, satelliteRepo, settingsRepo)
+    }
+
+    private val _mutualPassData = MutableStateFlow(MutualPassData())
+    override val mutualPassData: StateFlow<MutualPassData> = _mutualPassData.asStateFlow()
+
+    override fun setMutualPassData(data: MutualPassData) {
+        _mutualPassData.value = data
+    }

    override fun provideAddToCalendar(): IAddToCalendar = AddToCalendar(context)

    override fun provideShowToast(): IShowToast = ShowToast(context)

-    override fun provideBluetoothReporter(): IReporterRepo<WithoutExtParams> {
+    override fun provideAudioCapture(): IAudioCapture = AudioCapture()
+
+    override fun provideSaveImage(): ISaveImage = SaveImage(context)
+
+    override fun provideBluetoothReporter(): IReporter {
        val manager = context.getSystemService(Context.BLUETOOTH_SERVICE) as BluetoothManager
-        return BluetoothReporter(manager, CoroutineScope(Dispatchers.IO))
+        val rc = settingsRepo.rcSettings.value
+        return BluetoothReporter(
+            manager,
+            CoroutineScope(Dispatchers.IO),
+            rc.bluetoothRotatorAddress,
+            rc.bluetoothFrequencyAddress
+        )
    }

-    override fun provideNetworkReporter(): IReporterRepo<ExtendedParams> {
-        return NetworkReporter(CoroutineScope(Dispatchers.IO))
+    override fun provideNetworkReporter(): IReporter {
+        val rc = settingsRepo.rcSettings.value
+        return NetworkReporter(
+            CoroutineScope(Dispatchers.IO),
+            rc.rotatorAddress,
+            rc.rotatorPort.toIntOrNull() ?: 0,
+            rc.frequencyAddress,
+            rc.frequencyPort.toIntOrNull() ?: 0,
+            rc.frequencyOffsetHz
+        )
+    }
+
+    override fun provideTxRadioController(): IRadioController {
+        val manager  = context.getSystemService(Context.BLUETOOTH_SERVICE) as BluetoothManager
+        val settings = settingsRepo.radioControlSettings.value
+        val address  = settings.txRadioAddress
+        return if (settings.radioModel == RadioControlSettings.MODEL_ICOM_IC705) {
+            Ic705Controller(manager, address)
+        } else {
+            Ft817Controller(manager, address)
+        }
+    }
+
+    override fun provideRxRadioController(): IRadioController {
+        val manager  = context.getSystemService(Context.BLUETOOTH_SERVICE) as BluetoothManager
+        val settings = settingsRepo.radioControlSettings.value
+        val address  = settings.rxRadioAddress
+        return if (settings.radioModel == RadioControlSettings.MODEL_ICOM_IC705) {
+            Ic705Controller(manager, address)
+        } else {
+            Ft817Controller(manager, address)
+        }
    }

    override fun provideSensorsRepo(): ISensorsRepo {
        val manager = context.getSystemService(Context.SENSOR_SERVICE) as SensorManager
-        val sensor = manager.getDefaultSensor(Sensor.TYPE_ROTATION_VECTOR)
-        val window = context.getSystemService(Context.WINDOW_SERVICE) as WindowManager
-        return SensorsRepo(manager,sensor,window)
+        val displayManager = context.getSystemService(DisplayManager::class.java)
+        return SensorsRepo(manager, displayManager)
    }

    private fun provideDatabaseRepo(): IDatabaseRepo {
@@ -78,7 +168,10 @@ class MainContainer(private val context: Context) : IMainContainer {

    private fun provideLocalSource(): ILocalSource {
        val builder = Room.databaseBuilder(context, Look4SatDb::class.java, "Look4SatDBv400")
-        val database = builder.fallbackToDestructiveMigration(false).build()
+        val database = builder
+            .addMigrations(MIGRATION_1_2)
+            .fallbackToDestructiveMigration(false)
+            .build()
        return LocalSource(database.look4SatDao())
    }

@@ -0,0 +1,288 @@
+package com.rtbishop.look4sat.core.data.repository
+
+import com.rtbishop.look4sat.core.domain.model.AmSatReportSubmission
+import com.rtbishop.look4sat.core.domain.model.AmSatReportSubmitResult
+import com.rtbishop.look4sat.core.domain.model.SatDay
+import com.rtbishop.look4sat.core.domain.model.SatReport
+import com.rtbishop.look4sat.core.domain.model.SatSlot
+import com.rtbishop.look4sat.core.domain.model.SatStatus
+import com.rtbishop.look4sat.core.domain.model.SatStatusPage
+import com.rtbishop.look4sat.core.domain.repository.IAmSatRepository
+import com.rtbishop.look4sat.core.domain.source.IRemoteSource
+import kotlinx.coroutines.CoroutineScope
+import kotlinx.coroutines.Deferred
+import kotlinx.coroutines.Dispatchers
+import kotlinx.coroutines.SupervisorJob
+import kotlinx.coroutines.async
+import kotlinx.coroutines.sync.Mutex
+import kotlinx.coroutines.sync.withLock
+import kotlinx.coroutines.withContext
+import org.json.JSONObject
+import java.text.SimpleDateFormat
+import java.util.Calendar
+import java.util.Date
+import java.util.Locale
+import java.util.TimeZone
+
+/** One report from the AMSAT API (data layer model). */
+private data class ApiReport(
+    val id: String,
+    val name: String,
+    val callsign: String,
+    val report: String,
+    val gridSquare: String,
+    val reportedTimeUtcSec: Long
+)
+
+/** AMSAT status repository using RemoteSource (Clean Architecture: data layer handles HTTP). */
+class AmSatRepository(
+    private val remoteSource: IRemoteSource,
+    private val scope: CoroutineScope = CoroutineScope(SupervisorJob() + Dispatchers.IO)
+) : IAmSatRepository {
+
+    private val statusCacheMutex = Mutex()
+
+    @Volatile
+    private var statusCache: SatStatusPage? = null
+
+    @Volatile
+    private var statusFetchInFlight: Deferred<SatStatusPage?>? = null
+
+    @Volatile
+    private var cacheGeneration = 0
+
+    private val isoUtcFormat = SimpleDateFormat("yyyy-MM-dd'T'HH:mm:ss'Z'", Locale.US).apply {
+        timeZone = TimeZone.getTimeZone("UTC")
+    }
+
+    override fun getCachedStatus(): SatStatusPage? = statusCache
+
+    override suspend fun fetchStatus(forceRefresh: Boolean): SatStatusPage? {
+        if (!forceRefresh) statusCache?.let { return it }
+
+        var cachedPage: SatStatusPage? = null
+        val inFlightFetch = statusCacheMutex.withLock {
+            if (!forceRefresh) {
+                val cached = statusCache
+                if (cached != null) {
+                    cachedPage = cached
+                    return@withLock null
+                }
+            }
+
+            statusFetchInFlight ?: scope.async(Dispatchers.IO) {
+                fetchStatusFromRemote(cacheGeneration)
+            }.also { statusFetchInFlight = it }
+        }
+
+        cachedPage?.let { return it }
+        val fetch = inFlightFetch ?: return null
+        return try {
+            fetch.await()
+        } finally {
+            statusCacheMutex.withLock {
+                if (statusFetchInFlight === fetch && fetch.isCompleted) statusFetchInFlight = null
+            }
+        }
+    }
+
+    private suspend fun fetchStatusFromRemote(generation: Int): SatStatusPage? {
+        val nowSec = System.currentTimeMillis() / 1000
+        val catalogJson = remoteSource.getAmSatCatalog() ?: return null
+        // 72h = 3 days; API hard cap is limit=500 regardless of what we send.
+        // 500 records across ~100 catalog satellites ≈ ~1-5 reports/satellite/day — enough for 3 days.
+        // Upgrade path: paginate or request AMSAT to raise the cap if catalog grows beyond ~200 sats.
+        val reportsJson = remoteSource.getAmSatReports(hours = 72, limit = 500) ?: return null
+
+        val names = parseCatalog(catalogJson)
+        val reports = parseReports(reportsJson)
+
+        if (names.isEmpty() && reports.isEmpty()) return null
+
+        val statuses = buildStatuses(names, reports, nowSec)
+        val reportMap = reports.associate { it.id to toSatReport(it) }
+        return SatStatusPage(System.currentTimeMillis(), statuses, reportMap).also { page ->
+            if (generation == cacheGeneration) statusCache = page
+        }
+    }
+
+    override suspend fun prefetchStatus() {
+        fetchStatus(forceRefresh = false)
+    }
+
+    override fun clearStatusCache() {
+        cacheGeneration += 1
+        statusCache = null
+        statusFetchInFlight = null
+    }
+
+    override suspend fun submitReport(submission: AmSatReportSubmission): AmSatReportSubmitResult = withContext(Dispatchers.IO) {
+        val payload = JSONObject().apply {
+            put("name", submission.name)
+            put("report", submission.report)
+            put("callsign", submission.callsign)
+            put("reported_at", isoUtcFormat.format(Date(submission.reportedAtUtcMillis)))
+            if (submission.gridSquare.isNotBlank()) put("grid_square", submission.gridSquare)
+        }
+        val response = remoteSource.submitAmSatReport(payload.toString())
+            ?: return@withContext AmSatReportSubmitResult(success = false, message = "Network request failed")
+        val (code, body) = response
+        val errorMessage = parseSubmitError(body)
+        return@withContext if (code in 200..299 && errorMessage.isBlank()) {
+            AmSatReportSubmitResult(success = true, reportId = parseSubmitReportId(body))
+        } else {
+            AmSatReportSubmitResult(
+                success = false,
+                message = errorMessage.ifBlank { "HTTP $code" }
+            )
+        }
+    }
+
+    private fun parseSubmitError(json: String): String {
+        return try {
+            JSONObject(json).optJSONObject("error")?.optString("message").orEmpty()
+        } catch (_: Exception) {
+            ""
+        }
+    }
+
+    private fun parseSubmitReportId(json: String): String? {
+        return try {
+            val obj = JSONObject(json)
+            obj.optJSONObject("data")?.optString("id")?.takeIf { it.isNotBlank() }
+                ?: obj.optString("id").takeIf { it.isNotBlank() }
+        } catch (_: Exception) {
+            null
+        }
+    }
+
+    /** Parse catalog JSON to list of satellite names */
+    private fun parseCatalog(json: String): List<String> {
+        return try {
+            val arr = JSONObject(json).getJSONArray("data")
+            (0 until arr.length()).map { arr.getJSONObject(it).getString("name") }
+        } catch (_: Exception) {
+            emptyList()
+        }
+    }
+
+    /** Parse reports JSON to list of ApiReport domain objects */
+    private fun parseReports(json: String): List<ApiReport> {
+        return try {
+            val arr = JSONObject(json).getJSONArray("data")
+            (0 until arr.length()).mapNotNull { i ->
+                val o = arr.getJSONObject(i)
+                val iso = o.optString("reported_time", "")
+                if (iso.isEmpty()) null else ApiReport(
+                    id = o.optString("id", ""),
+                    name = o.optString("name", ""),
+                    callsign = o.optString("callsign", ""),
+                    report = o.optString("report", ""),
+                    gridSquare = o.optString("grid_square", ""),
+                    reportedTimeUtcSec = parseIsoUtcSec(iso)
+                )
+            }
+        } catch (_: Exception) {
+            emptyList()
+        }
+    }
+
+    /** Parse ISO 8601 UTC timestamp to epoch seconds (e.g., "2026-08-05T07:30:00Z") */
+    private fun parseIsoUtcSec(iso: String): Long {
+        return try {
+            (isoUtcFormat.parse(iso)?.time ?: 0L) / 1000
+        } catch (_: Exception) {
+            0L
+        }
+    }
+
+    /** Build one SatStatus (3 days x 12 slots) per catalog satellite, slotting reports by age. */
+    private fun buildStatuses(names: List<String>, reports: List<ApiReport>, nowSec: Long): List<SatStatus> {
+        val byName = reports.groupBy { it.name }
+        val utc = Calendar.getInstance(TimeZone.getTimeZone("UTC"))
+        val labels = (0 until 3).map { d ->
+            utc.timeInMillis = (nowSec - d * 86400L) * 1000
+            formatDayLabel(utc)
+        }
+        return names.map { name ->
+            val slots = (0 until 36).map { slotIdx ->
+                val slotStart = nowSec - (slotIdx + 1) * 7200L
+                val slotEnd = nowSec - slotIdx * 7200L
+                val inSlot = byName[name].orEmpty().filter { it.reportedTimeUtcSec in slotStart until slotEnd }
+                if (inSlot.isEmpty()) {
+                    SatSlot(statusColor = NO_REPORT_GRAY, count = 0)
+                } else {
+                    val newest = inSlot.maxByOrNull { it.reportedTimeUtcSec }!!
+                    SatSlot(
+                        statusColor = statusColorOf(newest.report),
+                        count = inSlot.size,
+                        reportIds = inSlot.map { it.id }
+                    )
+                }
+            }
+            val days = (0 until 3).map { d ->
+                // 当天最近连续相同状态报告数:从最新一条往回数,遇状态不同即停。
+                // 空时段(无报告)不打断;按状态文本严格比较,不跨天。
+                val dayStart = nowSec - (d + 1) * 86400L
+                val dayEnd = nowSec - d * 86400L
+                val dayReports = byName[name].orEmpty()
+                    .filter { it.reportedTimeUtcSec in dayStart until dayEnd }
+                    .sortedByDescending { it.reportedTimeUtcSec }
+                val streakCount = if (dayReports.isEmpty()) 0 else {
+                    val newestStatus = dayReports.first().report
+                    dayReports.takeWhile { it.report == newestStatus }.size
+                }
+                SatDay(
+                    dateLabel = labels[d],
+                    slots = slots.subList(d * 12, (d + 1) * 12),
+                    streakCount = streakCount
+                )
+            }
+            SatStatus(name = name, days = days)
+        }
+    }
+
+    private fun formatDayLabel(calendar: Calendar): String {
+        return if (Locale.getDefault().language == Locale.CHINESE.language) {
+            "${calendar.get(Calendar.MONTH) + 1}月${calendar.get(Calendar.DAY_OF_MONTH)}日"
+        } else {
+            val monthAbbr = arrayOf("Jan", "Feb", "Mar", "Apr", "May", "Jun", "Jul", "Aug", "Sep", "Oct", "Nov", "Dec")
+            "${monthAbbr[calendar.get(Calendar.MONTH)]} ${calendar.get(Calendar.DAY_OF_MONTH)}"
+        }
+    }
+
+    private fun toSatReport(r: ApiReport): SatReport {
+        val cal = Calendar.getInstance(TimeZone.getTimeZone("UTC"))
+        cal.timeInMillis = r.reportedTimeUtcSec * 1000
+        val hh = cal.get(Calendar.HOUR_OF_DAY).toString().padStart(2, '0')
+        val mm = cal.get(Calendar.MINUTE).toString().padStart(2, '0')
+        val y = cal.get(Calendar.YEAR)
+        val mo = (cal.get(Calendar.MONTH) + 1).toString().padStart(2, '0')
+        val d = cal.get(Calendar.DAY_OF_MONTH).toString().padStart(2, '0')
+        return SatReport(
+            id = r.id,
+            statusText = r.report,
+            call = r.callsign,
+            grid = r.gridSquare,
+            dateUtc = "$y-$mo-$d",
+            timeUtc = "$hh:$mm UTC"
+        )
+    }
+
+    /** Map status text to color value (for UI rendering). */
+    private fun statusColorOf(report: String): Long = when (report.lowercase()) {
+        "heard", "crew active" -> ACTIVE_BLUE
+        "telemetry only" -> TLM_ORANGE
+        "not heard" -> NOT_HEARD_PINK
+        else -> CONFLICT_DEEP_ORANGE
+    }
+
+    companion object {
+        // AMSAT official status colors (from amsat.org/status)
+        private const val ACTIVE_BLUE = 0xFF648FFF
+        private const val TLM_ORANGE = 0xFFFFB000
+        private const val NOT_HEARD_PINK = 0xFFDC267F
+        private const val CONFLICT_DEEP_ORANGE = 0xFFFE6100
+        private const val NO_REPORT_GRAY = 0xFFC0C0C0
+    }
+}
@@ -18,7 +18,6 @@
 package com.rtbishop.look4sat.core.data.repository

 import com.rtbishop.look4sat.core.domain.model.DatabaseState
-import com.rtbishop.look4sat.core.domain.model.SatRadio
 import com.rtbishop.look4sat.core.domain.predict.OrbitalData
 import com.rtbishop.look4sat.core.domain.repository.IDatabaseRepo
 import com.rtbishop.look4sat.core.domain.repository.ISettingsRepo
@@ -28,7 +27,9 @@ import com.rtbishop.look4sat.core.domain.source.Sources
 import com.rtbishop.look4sat.core.domain.utility.DataParser
 import kotlinx.coroutines.CoroutineDispatcher
 import kotlinx.coroutines.async
+import kotlinx.coroutines.awaitAll
 import kotlinx.coroutines.withContext
+import java.io.InputStream
 import java.util.zip.ZipInputStream

 class DatabaseRepo(
@@ -39,80 +40,81 @@ class DatabaseRepo(
    private val settingsRepo: ISettingsRepo
 ) : IDatabaseRepo {

-    override suspend fun updateTLEFromFile(uri: String) = withContext(dispatcher) {
-        val importedSatellites = remoteSource.getFileStream(uri)?.let { dataParser.parseTLEStream(it) }
-        importedSatellites?.let { localSource.insertEntries(it) }
-        setUpdateSuccessful(System.currentTimeMillis())
-    }
+    private val customSourceType = "Other"

-    override suspend fun updateTransceiversFromFile(uri: String) = withContext(dispatcher) {
-        val radios = remoteSource.getFileStream(uri)?.let { dataParser.parseJSONStream(it) }
-        radios?.let {
-            if(it.isNotEmpty()) {
-                localSource.deleteRadios()
-                localSource.insertRadios(it)
-            }
+    override suspend fun updateTLEFromFile(uri: String): Int = withContext(dispatcher) {
+        var importedCount = 0
+        remoteSource.getFileStream(uri)?.let { stream ->
+            val entries = parseSatelliteStream(uri, unwrapIfZipped(uri, stream))
+            localSource.insertEntries(entries)
+            settingsRepo.setSatelliteTypeIds(customSourceType, entries.map { it.catnum })
+            importedCount = entries.size
        }
        setUpdateSuccessful(System.currentTimeMillis())
+        importedCount
+    }
+
+    override suspend fun updateTransceiversFromFile(uri: String): Int = withContext(dispatcher) {
+        var importedCount = 0
+        remoteSource.getFileStream(uri)?.let { stream ->
+            val transceivers = dataParser.parseJSONStream(unwrapIfZipped(uri, stream))
+            localSource.insertRadios(transceivers, isCustom = true)
+            importedCount = transceivers.size
+        }
+        setUpdateSuccessful(System.currentTimeMillis())
+        importedCount
    }

    override suspend fun updateFromRemote() = withContext(dispatcher) {
-        val importedEntries = mutableListOf<OrbitalData>()
-        val importedRadios = mutableListOf<SatRadio>()
-        val tleUrls = Sources.satelliteDataUrls.toMutableMap().apply {
-            if (settingsRepo.dataSourcesSettings.value.useCustomTLE) {
-                this["Other"] = settingsRepo.dataSourcesSettings.value.tleUrl
-            }
+        val settings = settingsRepo.dataSourcesSettings.value
+        // Keep the raw URL as the status key (matches what the settings UI
+        // displays) while requesting with the normalized URL.
+        val tleUrls = settings.satelliteUrls
+            .filterIndexed { i, url -> url.isNotBlank() && settings.isSatelliteEnabled(i) }
+            .map { it to normalizeUrl(it) }
+            .distinctBy { it.second }
+        val radioUrls = settings.transceiversUrls
+            .filterIndexed { i, url -> url.isNotBlank() && settings.isTransceiverEnabled(i) }
+            .map { it to normalizeUrl(it) }
+            .distinctBy { it.second }
+        val builtinTypesByUrl = Sources.satelliteDataUrls
+            .filterValues { it.isNotBlank() }
+            .mapValues { normalizeUrl(it.value) }
+            .entries
+            .associate { (type, url) -> url to type }
+        val importedTypeIds = mutableMapOf<String, MutableList<Int>>()
+        // launch all network requests concurrently, keeping the raw url as key for status reporting
+        val tleJobs = tleUrls.map { (raw, norm) -> async { raw to remoteSource.getNetworkStream(norm) } }
+        val radioJobs = radioUrls.map { (raw, norm) -> async { raw to remoteSource.getNetworkStream(norm) } }
+        val tleResults = tleJobs.awaitAll()
+        val radioResults = radioJobs.awaitAll()
+        // report the HTTP status code of every source (200, 404, ...)
+        settingsRepo.updateDataSourcesStatus(
+            (tleResults + radioResults).associate { (url, result) -> url to result.code }
+        )
+        // parse fetched data concurrently and associate known built-in URLs with existing type filters.
+        val importedEntries = tleResults.flatMap { (rawUrl, result) ->
+            val normUrl = normalizeUrl(rawUrl)
+            val entries = result.stream?.let { parseSatelliteStream(normUrl, unwrapIfZipped(normUrl, it)) }.orEmpty()
+            val type = builtinTypesByUrl[normUrl] ?: customSourceType
+            importedTypeIds.getOrPut(type) { mutableListOf() }.addAll(entries.map { it.catnum })
+            entries
+        }.distinctBy { it.catnum }
+        importedTypeIds.forEach { (type, ids) -> settingsRepo.setSatelliteTypeIds(type, ids.distinct()) }
+        val importedRadios = radioResults.flatMap { (rawUrl, result) ->
+            val normUrl = normalizeUrl(rawUrl)
+            result.stream?.let { dataParser.parseJSONStream(unwrapIfZipped(normUrl, it)) }.orEmpty()
+        }.filter { it.uuid.isNotBlank() }.distinctBy { it.uuid }
+        // insert parsed data into the database.
+        // Transceivers are a full snapshot: sources publish active entries only, so a retired
+        // transceiver simply disappears from the feed and has to be dropped locally as well.
+        // Manually imported ones (isCustom) are kept: no source can refresh them, so nothing
+        // would bring them back if they were replaced here.
+        if (importedRadios.isNotEmpty()) {
+            localSource.deleteManagedRadios()
+            localSource.insertRadios(importedRadios)
        }
-        val jobsMap = tleUrls
-            .filter { (_, url) -> url.isNotEmpty() }
-            .mapValues { (_, url) -> async { remoteSource.getNetworkStream(url) } }
-        val radioUrls = buildList {
-            add(Sources.RADIO_DATA_URL)
-            if (settingsRepo.dataSourcesSettings.value.useCustomTransceivers) {
-                add(settingsRepo.dataSourcesSettings.value.transceiversUrl)
-            }
-        }
-        val jobRadios = radioUrls.associateWith { url -> async { remoteSource.getNetworkStream(url) } }
-        // parse
-        jobsMap.mapValues { job -> job.value.await() }.forEach { entry ->
-            entry.value?.let { stream ->
-                when (val type = entry.key) {
-                    "Amsat", "R4UAB", "Other" -> {
-                        // parse tle stream
-                        val satellites = dataParser.parseTLEStream(stream)
-                        val catnums = satellites.map { it.catnum }
-                        settingsRepo.setSatelliteTypeIds(type, catnums)
-                        importedEntries.addAll(satellites)
-                    }
-
-                    "McCants", "Classified" -> {
-                        // unzip and parse tle stream
-                        val unzipped = ZipInputStream(stream).apply { nextEntry }
-                        val satellites = dataParser.parseTLEStream(unzipped)
-                        val catnums = satellites.map { it.catnum }
-                        settingsRepo.setSatelliteTypeIds(type, catnums)
-                        importedEntries.addAll(satellites)
-                    }
-
-                    else -> {
-                        // parse csv stream
-                        val satellites = dataParser.parseCSVStream(stream)
-                        val catnums = satellites.map { it.catnum }
-                        settingsRepo.setSatelliteTypeIds(type, catnums)
-                        importedEntries.addAll(satellites)
-                    }
-                }
-            }
-        }
-        jobRadios.values.forEach { job ->
-            job.await()?.let {
-                importedRadios.addAll(dataParser.parseJSONStream(it))
-            }
-        }
-        // insert
-        localSource.insertEntries(importedEntries)
-        localSource.insertRadios(importedRadios)
+        if (importedEntries.isNotEmpty()) localSource.insertEntries(importedEntries)
        setUpdateSuccessful(System.currentTimeMillis())
    }

@@ -122,9 +124,42 @@ class DatabaseRepo(
        setUpdateSuccessful(0L)
    }

-    private suspend fun setUpdateSuccessful(timestamp: Long) = withContext(dispatcher) {
-        val numberOfRadios = localSource.getRadiosTotal()
-        val numberOfSatellites = localSource.getEntriesTotal()
-        settingsRepo.updateDatabaseState(DatabaseState(numberOfRadios, numberOfSatellites, timestamp))
+    private fun normalizeUrl(url: String): String =
+        if (url.startsWith("http", ignoreCase = true)) url else "https://$url"
+
+    private suspend fun parseSatelliteStream(url: String, stream: InputStream): List<OrbitalData> {
+        val bufferedStream = stream.buffered()
+        return when {
+            hasCsvHint(url) || looksLikeCsv(bufferedStream) -> dataParser.parseCSVStream(bufferedStream)
+            else -> dataParser.parseTLEStream(bufferedStream)
+        }
    }
+
+    private fun hasCsvHint(url: String): Boolean {
+        return url.contains("FORMAT=csv", ignoreCase = true) ||
+            url.endsWith(".csv", ignoreCase = true) ||
+            url.endsWith(".csv.zip", ignoreCase = true)
+    }
+
+    private fun looksLikeCsv(stream: InputStream): Boolean {
+        if (!stream.markSupported()) return false
+        stream.mark(4096)
+        val preview = ByteArray(4096)
+        val length = stream.read(preview)
+        stream.reset()
+        if (length <= 0) return false
+        val line = preview.decodeToString(0, length).lineSequence().firstOrNull()?.trim().orEmpty()
+        return line.contains("OBJECT_NAME", ignoreCase = true) ||
+            line.contains("NORAD_CAT_ID", ignoreCase = true) ||
+            line.count { it == ',' } >= 4
+    }
+
+    private suspend fun setUpdateSuccessful(timestamp: Long) {
+        settingsRepo.updateDatabaseState(
+            DatabaseState(localSource.getRadiosTotal(), localSource.getEntriesTotal(), timestamp)
+        )
+    }
+
+    private fun unwrapIfZipped(url: String, stream: InputStream): InputStream =
+        if (url.endsWith(".zip", ignoreCase = true)) ZipInputStream(stream).apply { nextEntry } else stream
 }
@@ -0,0 +1,460 @@
+/*
+ * Look4Sat. Amateur radio satellite tracker and pass predictor.
+ * Copyright (C) 2019-2026 Arty Bishop and contributors.
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <https://www.gnu.org/licenses/>.
+ */
+package com.rtbishop.look4sat.core.data.repository
+
+import com.rtbishop.look4sat.core.domain.repository.ILoTWRepository
+import com.rtbishop.look4sat.core.domain.repository.LoTWPhase
+import com.rtbishop.look4sat.core.domain.repository.LoTWProgress
+import com.rtbishop.look4sat.core.domain.repository.LoTWResult
+import kotlinx.coroutines.Dispatchers
+import kotlinx.coroutines.ensureActive
+import kotlinx.coroutines.withContext
+import kotlin.coroutines.coroutineContext
+import java.net.HttpURLConnection
+import java.net.SocketTimeoutException
+import java.net.URL
+import java.net.URLEncoder
+import java.io.IOException
+import javax.net.ssl.SSLException
+
+/**
+ * Fetches confirmed gridsquares directly from ARRL LoTW via the official report endpoint:
+ *   GET https://lotw.arrl.org/lotwuser/lotwreport.adi?login=<call>&password=<pwd>
+ *       &qso_query=1&qso_qsl=yes&qso_qsldetail=yes&qso_mydetail=yes&qso_qslsince=<date>
+ *
+ * Only QSL_RCVD=Y records are returned by LoTW for qso_qsl=yes, so every grid in the
+ * report is a *confirmed* grid (green on the map). GRIDSQUARE may be a 4- or 6-char
+ * value; VUCC_GRIDS ("EN52en,EN53fa") also yields 4-char fields. All values are
+ * truncated/expanded to the 4-char form used by the map overlay.
+ *
+ * ARRL rate-limits the report endpoint: one download in progress per user id, and
+ * frequent full-report pulls get refused. Failures are reported with an explicit
+ * cause (see LoTWResult) so the UI can tell the user what to do next.
+ */
+class LoTWRepository : ILoTWRepository {
+
+    override suspend fun fetchConfirmedGrids(callsign: String, password: String): LoTWResult =
+        withContext(Dispatchers.IO) {
+            fetchReportBody(callsign, password, since = "", onProgress = {}).fold(
+                onSuccess = { body ->
+                    parseBoth(body)?.let { (grids, _, roamed) ->
+                        LoTWResult.Success(grids, emptyMap(), roamed)
+                    } ?: LoTWResult.RateLimited
+                },
+                onFailure = { toResult(it) }
+            )
+        }
+
+    override suspend fun fetchConfirmedGridQsos(
+        callsign: String,
+        password: String,
+        since: String,
+        onProgress: (LoTWProgress) -> Unit
+    ): LoTWResult = withContext(Dispatchers.IO) {
+        fetchReportBody(callsign, password, since, onProgress).fold(
+            onSuccess = { body ->
+                parseBoth(body)?.let { (grids, qsos, roamed) ->
+                    LoTWResult.Success(grids, qsos, roamed)
+                } ?: LoTWResult.RateLimited
+            },
+            onFailure = { toResult(it) }
+        )
+    }
+
+    internal fun toResult(e: Throwable): LoTWResult = when (e) {
+        is CredentialsException -> LoTWResult.BadCredentials
+        is RateLimitException -> LoTWResult.RateLimited
+        is TimeoutException -> LoTWResult.Timeout
+        else -> LoTWResult.NetworkError(e.message ?: e.javaClass.simpleName)
+    }
+
+    /** Single report fetch feeding the grid set, the per-QSO detail and the roamed set. */
+    private fun parseBoth(
+        body: String
+    ): Triple<Set<String>, Map<String, List<com.rtbishop.look4sat.core.domain.model.GridQso>>, Set<String>>? {
+        val grids = parseConfirmedGrids(body) ?: return null
+        val qsos = parseConfirmedGridQsos(body) ?: return null
+        val roamed = parseRoamedGrids(body) ?: return null
+        return Triple(grids, qsos, roamed)
+    }
+
+    private suspend fun fetchReportBody(
+        callsign: String,
+        password: String,
+        since: String,
+        onProgress: (LoTWProgress) -> Unit
+    ): Result<String> {
+        val call = callsign.trim().uppercase()
+        val pwd = password.trim()
+        if (call.isBlank() || pwd.isBlank()) return Result.failure(IOException("empty credentials"))
+        // Empty since -> full report. qso_qslsince with an early date forces a
+        // FULL confirmed-QSL report; without it LoTW applies a "system supplied
+        // default" since-date and only returns confirmations newer than the
+        // account's last query — subsequent syncs would be incremental/empty.
+        val effectiveSince = since.ifBlank { "2000-01-01" }
+        val query = buildString {
+            append("login=").append(URLEncoder.encode(call, "UTF-8"))
+            append("&password=").append(URLEncoder.encode(pwd, "UTF-8"))
+            append("&qso_query=1&qso_qsl=yes&qso_qsldetail=yes&qso_mydetail=yes")
+            append("&qso_qslsince=").append(URLEncoder.encode(effectiveSince, "UTF-8"))
+        }
+        return try {
+            val connection = URL("$BASE_URL?$query").openConnection() as HttpURLConnection
+            // ARRL can be slow to accept connections from mobile networks
+            // (long TLS handshakes across the Pacific, occasional server-side
+            // queueing — a busy server took 36.5 s to accept a connection in
+            // testing, so 30 s connect would have killed it).
+            //
+            // NOTE: readTimeout is NOT a total-download cap. It is the longest
+            // wait for the NEXT chunk of data (a stall timeout). A full report
+            // for a huge account (tens of thousands of QSLs ≈ tens of MB at
+            // ARRL's ~10 KB/s stream rate) legitimately takes 30+ minutes;
+            // as long as chunks keep arriving it must never be cut off.
+            // 600 s tolerates long server-side pauses while it generates the
+            // report; a truly dead link (no data at all) still fails within it.
+            connection.connectTimeout = 60_000
+            connection.readTimeout = 600_000
+            connection.requestMethod = "GET"
+            connection.setRequestProperty("Accept-Encoding", "gzip")
+            connection.instanceFollowRedirects = true
+            onProgress(LoTWProgress(LoTWPhase.Connecting))
+            val code = connection.responseCode
+            if (code !in 200..299) {
+                connection.disconnect()
+                // Observed in the wild (CQRLOG #2422): LoTW answers a throttled
+                // report pull with HTTP 503 "Page request limit".
+                return if (code == 503 || code == 429) Result.failure(RateLimitException())
+                else Result.failure(IOException("HTTP $code"))
+            }
+            val stream = connection.inputStream
+            val isGzip = "gzip".equals(connection.contentEncoding, ignoreCase = true)
+            val body = readBodyWithProgress(stream, isGzip, onProgress)
+            connection.disconnect()
+            when {
+                // Login failure: HTTP 200 + HTML login page with the error text.
+                body.contains("incorrect", ignoreCase = true) &&
+                    body.contains("assword", ignoreCase = true) -> Result.failure(CredentialsException())
+                // Any other non-ADIF body: rate-limit refusal / server error page.
+                !body.contains("<eoh>", ignoreCase = true) -> Result.failure(RateLimitException())
+                else -> Result.success(body)
+            }
+        } catch (e: java.util.concurrent.CancellationException) {
+            // Cancellation must propagate — it is not a network failure.
+            throw e
+        } catch (e: SocketTimeoutException) {
+            Result.failure(TimeoutException(e.message ?: "timed out"))
+        } catch (e: SSLException) {
+            Result.failure(IOException("TLS: ${e.message ?: "handshake failed"}"))
+        } catch (e: Exception) {
+            println("LoTWRepository fetch failure: $e")
+            Result.failure(IOException(e.message ?: e.javaClass.simpleName))
+        }
+    }
+
+    /**
+     * Streams the report body into a string while reporting download progress.
+     * Once the header's record count (<APP_LoTW_NUMREC>) is seen, the total
+     * body size is estimated as NUMREC * AVG_RECORD_BYTES so the UI can show a
+     * meaningful progress bar and remaining-time estimate.
+     */
+    private suspend fun readBodyWithProgress(
+        stream: java.io.InputStream,
+        isGzip: Boolean,
+        onProgress: (LoTWProgress) -> Unit
+    ): String {
+        val input = if (isGzip) java.util.zip.GZIPInputStream(stream) else stream
+        val reader = java.io.InputStreamReader(input, Charsets.UTF_8)
+        val sb = StringBuilder()
+        val buf = CharArray(8192)
+        var bytesRead = 0L
+        var expected = 0L
+        var qsoCount = 0L
+        var speed = 0L
+        var headerSeen = false
+        var lastSampleMs = System.currentTimeMillis()
+        var lastSampleBytes = 0L
+        var lastEmitMs = 0L
+        while (true) {
+            // Cooperative cancellation: lets the user abort a full sync that
+            // was started by mistake. Throws CancellationException once the
+            // job is cancelled; the blocking read below is fast while chunks
+            // keep arriving, so the abort lands on the next chunk boundary.
+            coroutineContext.ensureActive()
+            val n = reader.read(buf)
+            if (n <= 0) break
+            sb.append(buf, 0, n)
+            bytesRead += n
+            // The record count sits in the report header, long before the data.
+            if (!headerSeen) {
+                NUMREC_REGEX.find(sb)?.let { m ->
+                    qsoCount = m.groupValues[1].toLongOrNull() ?: 0L
+                    expected = qsoCount * AVG_RECORD_BYTES
+                    headerSeen = true
+                }
+            }
+            // Sample speed every 500ms, EMA-smoothed.
+            val now = System.currentTimeMillis()
+            if (now - lastSampleMs >= 500) {
+                val elapsedS = (now - lastSampleMs) / 1000.0
+                if (elapsedS > 0) {
+                    val inst = ((bytesRead - lastSampleBytes) / elapsedS).toLong()
+                    speed = if (speed == 0L) inst else (speed * 7 + inst * 3) / 10
+                    lastSampleMs = now
+                    lastSampleBytes = bytesRead
+                }
+            }
+            // Throttle callbacks to ~4/s so StateFlow updates stay cheap.
+            if (now - lastEmitMs >= 250) {
+                onProgress(LoTWProgress(LoTWPhase.Downloading, bytesRead, expected, speed, qsoCount))
+                lastEmitMs = now
+            }
+        }
+        onProgress(LoTWProgress(LoTWPhase.Downloading, bytesRead, expected, speed, qsoCount))
+        return sb.toString()
+    }
+
+    internal class CredentialsException : Exception("bad callsign/password")
+    internal class RateLimitException : Exception("report refused (rate limit / server error)")
+    internal class TimeoutException(message: String) : Exception(message)
+
+    internal fun parseConfirmedGridQsos(
+        body: String
+    ): Map<String, List<com.rtbishop.look4sat.core.domain.model.GridQso>>? {
+        if (!body.contains("<eoh>", ignoreCase = true)) return null
+        // One ADIF record = fields up to <EOR>. We buffer the fields we care
+        // about, then emit a GridQso on <EOR> when the record is a satellite
+        // QSO (PROP_MODE=SAT) carrying a grid.
+        val result = mutableMapOf<String, MutableList<com.rtbishop.look4sat.core.domain.model.GridQso>>()
+        var propMode: String? = null
+        var call = ""
+        var qsoDate = ""
+        var timeOn = ""
+        var satName = ""
+        var mode = ""
+        var bandUp = ""
+        var bandDown = ""
+        var dxcc: Int? = null
+        var country: String? = null
+        var cqz: Int? = null
+        var state: String? = null
+        var myGrid: String? = null
+        val gridsInRecord = mutableListOf<String>()
+
+        fun emitRecord() {
+            if (propMode != "SAT" || gridsInRecord.isEmpty()) return
+            val epochMs = adifTimestampToEpoch(qsoDate, timeOn)
+            val qso = com.rtbishop.look4sat.core.domain.model.GridQso(
+                call = call, epochMs = epochMs, satName = satName,
+                mode = mode, bandUp = bandUp, bandDown = bandDown,
+                dxcc = dxcc, country = country, cqz = cqz, state = state,
+                myGrid = myGrid
+            )
+            for (grid in gridsInRecord) {
+                result.getOrPut(grid) { mutableListOf() }.add(qso)
+            }
+        }
+
+        fun resetRecord() {
+            propMode = null; call = ""; qsoDate = ""; timeOn = ""
+            satName = ""; mode = ""; bandUp = ""; bandDown = ""
+            dxcc = null; country = null; cqz = null; state = null
+            myGrid = null
+            gridsInRecord.clear()
+        }
+
+        for (raw in body.lineSequence()) {
+            val line = raw.trim()
+            when {
+                line.equals("<EOR>", ignoreCase = true) -> {
+                    emitRecord()
+                    resetRecord()
+                }
+                line.startsWith("<PROP_MODE:") ->
+                    propMode = adifValue(line).uppercase()
+                line.startsWith("<CALL:") ->
+                    call = adifValue(line).uppercase()
+                line.startsWith("<QSO_DATE:") ->
+                    qsoDate = adifValue(line)
+                line.startsWith("<TIME_ON:") ->
+                    timeOn = adifValue(line)
+                line.startsWith("<SAT_NAME:") ->
+                    satName = adifValue(line)
+                line.startsWith("<MODE:") ->
+                    mode = adifValue(line)
+                line.startsWith("<BAND_RX:") ->
+                    bandUp = adifValue(line).uppercase()
+                line.startsWith("<BAND:") && !line.startsWith("<BAND_RX:") ->
+                    bandDown = adifValue(line).uppercase()
+                line.startsWith("<DXCC:") ->
+                    dxcc = adifValue(line).toIntOrNull()
+                line.startsWith("<COUNTRY:") ->
+                    country = adifValue(line).ifBlank { null }
+                line.startsWith("<CQZ:") ->
+                    cqz = adifValue(line).toIntOrNull()
+                line.startsWith("<STATE:") ->
+                    state = adifValue(line).trim().ifBlank { null }?.let { normalizeState(it) }
+                line.startsWith("<MY_GRIDSQUARE:") -> {
+                    // Own-station grid (must not be confused with GRIDSQUARE —
+                    // the opposite station's grid). Recorded per QSO so awards
+                    // can be counted per operated grid.
+                    val value = adifValue(line)
+                    if (value.length >= 4) myGrid = value.take(4).uppercase()
+                }
+                line.startsWith("<GRIDSQUARE:") || line.startsWith("<VUCC_GRIDS:") -> {
+                    // VUCC_GRIDS holds a comma-separated list of grids
+                    // ("EN52en,EN53fa"), up to four for contacts spanning
+                    // several squares; split and keep every 4-char field.
+                    adifValue(line).split(',').forEach { grid ->
+                        val field = grid.trim().uppercase()
+                        if (field.length >= 4) gridsInRecord.add(field.take(4))
+                    }
+                }
+            }
+        }
+        return result
+    }
+
+    /** ADIF field value: "<GRIDSQUARE:4>OL62" -> "OL62". */
+    private fun adifValue(line: String): String =
+        line.substringAfter('>').substringBefore("E<").trim()
+
+    /**
+     * LoTW returns STATE as "CODE // NAME" (e.g. "HB // Hubei" for China,
+     * "34 // Tottori-ken" for Japan, "CA // California" for the US). The award
+     * statistics match on the short CODE only (China 2-letter province pinyin,
+     * Japan 2-digit prefecture, US 2-letter state), so strip the " // NAME"
+     * suffix here once, storing the clean code for every downstream consumer
+     * (persistence, AwardCalculator).
+     */
+    private fun normalizeState(raw: String): String = raw.substringBefore(" // ").trim()
+
+    /** "20260820" + "1130" (or "113000") -> UTC epoch ms; 0 when unparseable. */
+    private fun adifTimestampToEpoch(date: String, time: String): Long = try {
+        val d = date.trim()
+        val t = time.trim().padEnd(6, '0').take(6)
+        val fmt = java.time.format.DateTimeFormatterBuilder()
+            .appendPattern("yyyyMMddHHmmss")
+            .toFormatter()
+            .withZone(java.time.ZoneOffset.UTC)
+        java.time.Instant.from(fmt.parse(d + t)).toEpochMilli()
+    } catch (_: Exception) {
+        0L
+    }
+
+    internal fun parseConfirmedGrids(body: String): Set<String>? {
+        // LoTW answers with ADIF text; on bad credentials it returns a short error
+        // page without an <eoh> header terminator. Real reports always carry <eoh>
+        // (LoTW writes it lowercase). Match case-insensitively to be safe.
+        if (!body.contains("<eoh>", ignoreCase = true)) return null
+        val grids = mutableSetOf<String>()
+        // ADIF fields of one QSO record span multiple lines and are terminated by
+        // <EOR>. Satellite QSOs carry <PROP_MODE:3>SAT (plus <SAT_NAME>); ground
+        // QSOs omit it. Grid fields (GRIDSQUARE / VUCC_GRIDS) must only be
+        // collected for records whose PROP_MODE is SAT, otherwise the map mixes
+        // in terrestrial contacts.
+        //
+        // Buffered per-record pattern (same as parseConfirmedGridQsos): field order
+        // is NOT reliable — ADIF producers (incl. LoTW) emit fields alphabetically,
+        // so <GRIDSQUARE> (G) arrives BEFORE <PROP_MODE> (P) within a record. A
+        // sequential gate ("only add while propMode == SAT") silently drops every
+        // grid on real reports. Buffer the record and decide at <EOR> instead.
+        var propMode: String? = null
+        var pendingGrids = mutableListOf<String>()
+        for (raw in body.lineSequence()) {
+            val line = raw.trim()
+            when {
+                line.equals("<EOR>", ignoreCase = true) -> {
+                    if (propMode == "SAT") grids.addAll(pendingGrids)
+                    propMode = null
+                    pendingGrids = mutableListOf()
+                }
+                line.startsWith("<PROP_MODE:") -> {
+                    propMode = adifValue(line).uppercase()
+                }
+                line.startsWith("<GRIDSQUARE:") || line.startsWith("<VUCC_GRIDS:") -> {
+                    // VUCC_GRIDS holds a comma-separated PAIR of grids
+                    // ("EN52en,EN53fa") for contacts spanning two squares —
+                    // split on ',' and take the 4-char field of each, or the
+                    // second grid is silently dropped.
+                    val value = adifValue(line)
+                    value.split(',').forEach { grid ->
+                        val field = grid.trim().uppercase()
+                        if (field.length >= 4) pendingGrids.add(field.take(4))
+                    }
+                }
+            }
+        }
+        return grids
+    }
+
+    /**
+     * Distinct 4-char gridsquares the account itself operated from, taken from
+     * ADIF <MY_GRIDSQUARE> of satellite QSO records only. This is the
+     * "roamed / activated" set shown as blue stripes on the map — the grids
+     * where the operator's own station was located during confirmed QSOs (a
+     * rover may log several distinct grids; the home grid is included too).
+     * Returns null when the body is not an ADIF report (mirrors the other parsers).
+     */
+    internal fun parseRoamedGrids(body: String): Set<String>? {
+        if (!body.contains("<eoh>", ignoreCase = true)) return null
+        val grids = mutableSetOf<String>()
+        // Buffered per-record pattern (same as parseConfirmedGridQsos): field
+        // order is NOT reliable — ADIF producers (incl. LoTW) emit fields
+        // alphabetically, so <MY_GRIDSQUARE> (M) arrives BEFORE <PROP_MODE> (P)
+        // within a record. A sequential gate ("only add while propMode == SAT")
+        // would silently drop every own grid on real reports; buffer the record
+        // and decide at <EOR> instead.
+        var propMode: String? = null
+        var myGrid: String? = null
+        for (raw in body.lineSequence()) {
+            val line = raw.trim()
+            when {
+                line.equals("<EOR>", ignoreCase = true) -> {
+                    if (propMode == "SAT" && myGrid != null) grids.add(myGrid)
+                    propMode = null
+                    myGrid = null
+                }
+                line.startsWith("<PROP_MODE:") -> {
+                    propMode = adifValue(line).uppercase()
+                }
+                line.startsWith("<MY_GRIDSQUARE:") -> {
+                    // MY_GRIDSQUARE must not be mistaken for GRIDSQUARE (the
+                    // opposite station's grid) — only own-station grids count.
+                    val value = adifValue(line)
+                    if (value.length >= 4) myGrid = value.take(4)
+                }
+            }
+        }
+        return grids
+    }
+
+    private companion object {
+        const val BASE_URL = "https://lotw.arrl.org/lotwuser/lotwreport.adi"
+
+        /** Record count in the report header: `<APP_LoTW_NUMREC:4>2367`. */
+        val NUMREC_REGEX = Regex("<APP_LoTW_NUMREC:\\d+>(\\d+)")
+        /**
+         * Measured 2026-09-16 (BH6RJD, 2367 QSLs): 1.7 MB body streamed at
+         * ~9.5 KB/s ≈ 180 s, i.e. ≈ 720 bytes per ADIF record. Use a
+         * CONSERVATIVE (larger) estimate so the progress bar never hits 100%
+         * before the download truly ends — an under-estimate made the bar sit
+         * at 100% while data was still flowing, read as "finished but stuck".
+         */
+        const val AVG_RECORD_BYTES = 900L
+    }
+}
@@ -28,10 +28,18 @@ import com.rtbishop.look4sat.core.domain.source.ILocalSource
 import com.rtbishop.look4sat.core.domain.utility.round
 import com.rtbishop.look4sat.core.domain.utility.toDegrees
 import kotlinx.coroutines.CoroutineDispatcher
+import kotlinx.coroutines.async
+import kotlinx.coroutines.awaitAll
+import kotlinx.coroutines.coroutineScope
+import kotlinx.coroutines.delay
 import kotlinx.coroutines.flow.MutableStateFlow
 import kotlinx.coroutines.flow.StateFlow
+import kotlinx.coroutines.flow.combine
+import kotlinx.coroutines.flow.distinctUntilChanged
+import kotlinx.coroutines.flow.map
 import kotlinx.coroutines.flow.update
 import kotlinx.coroutines.withContext
+import java.util.TimeZone

 class SatelliteRepo(
    private val dispatcher: CoroutineDispatcher,
@@ -42,18 +50,44 @@ class SatelliteRepo(
    private val _passes = MutableStateFlow<List<OrbitalPass>>(emptyList())
    override val passes: StateFlow<List<OrbitalPass>> = _passes

+    private val _isCalculating = MutableStateFlow(false)
+    override val isCalculating: StateFlow<Boolean> = _isCalculating
+
    private val _satellites = MutableStateFlow<List<OrbitalObject>>(emptyList())
    override val satellites: StateFlow<List<OrbitalObject>> = _satellites

+    private val _selectedPass = MutableStateFlow(0 to 0L)
+    override val selectedPass: StateFlow<Pair<Int, Long>> = _selectedPass
+
+    override fun selectPass(catNum: Int, aosTime: Long) {
+        _selectedPass.value = catNum to aosTime
+    }
+
    override suspend fun getRadiosWithId(id: Int) = localStorage.getRadiosWithId(id)

    override suspend fun initRepository() = withContext(dispatcher) {
-        settingsRepo.selectedIds.collect { selectedIds ->
-            _satellites.update { localStorage.getEntriesWithIds(selectedIds) }
-            val (hoursAhead, minElevation, modes) = settingsRepo.passesSettings.value
-            val timeNow = 1000 * ((System.currentTimeMillis() + 500) / 1000)
-            calculatePasses(timeNow, hoursAhead, minElevation, modes)
-        }
+        combine(
+            settingsRepo.selectedIds,
+            settingsRepo.stationPosition,
+            // Recalculate passes when the UTC display toggle changes, so an existing
+            // AOS time window is reapplied in the newly selected timezone.
+            settingsRepo.otherSettings.map { it.stateOfUtc }.distinctUntilChanged()
+        ) { selectedIds, _, _ -> selectedIds }
+            .collect { selectedIds ->
+                _satellites.update { localStorage.getEntriesWithIds(selectedIds) }
+                val settings = settingsRepo.passesSettings.value
+                val now = System.currentTimeMillis()
+                // 历史过境: 回看窗口 hoursBefore 小时, 过境列表从更早时间开始计算.
+                calculatePasses(
+                    time = now - settings.hoursBefore * 60L * 60L * 1000L,
+                    hoursAhead = settings.hoursBefore + settings.hoursAhead,
+                    minElevation = settings.minElevation,
+                    aosStartMinute = settings.aosStartMinute,
+                    aosEndMinute = settings.aosEndMinute,
+                    invertAosTimeWindow = settings.invertAosTimeWindow,
+                    modes = settings.selectedModes
+                )
+            }
    }

    override suspend fun getPosition(sat: OrbitalObject, pos: GeoPos, time: Long): OrbitalPos {
@@ -62,7 +96,8 @@ class SatelliteRepo(

    override suspend fun getTrack(sat: OrbitalObject, pos: GeoPos, start: Long, end: Long): List<OrbitalPos> {
        return withContext(dispatcher) {
-            val positions = mutableListOf<OrbitalPos>()
+            val estimatedSize = ((end - start) / 15000).toInt() + 1
+            val positions = ArrayList<OrbitalPos>(estimatedSize)
            var currentTime = start
            while (currentTime < end) {
                positions.add(sat.getPosition(pos, currentTime))
@@ -80,65 +115,109 @@ class SatelliteRepo(
    ): List<SatRadio> {
        return withContext(dispatcher) {
            val satPos = sat.getPosition(pos, time)
-            val copiedList = radios.map { it.copy() }
-            copiedList.forEach { transmitter ->
-                transmitter.downlinkLow?.let { transmitter.downlinkLow = satPos.getDownlinkFreq(it) }
-                transmitter.downlinkHigh?.let { transmitter.downlinkHigh = satPos.getDownlinkFreq(it) }
-                transmitter.uplinkLow?.let { transmitter.uplinkLow = satPos.getUplinkFreq(it) }
-                transmitter.uplinkHigh?.let { transmitter.uplinkHigh = satPos.getUplinkFreq(it) }
+            radios.map { transmitter ->
+                transmitter.copy(
+                    downlinkLow = transmitter.downlinkLow?.let { satPos.getDownlinkFreq(it) },
+                    downlinkHigh = transmitter.downlinkHigh?.let { satPos.getDownlinkFreq(it) },
+                    uplinkLow = transmitter.uplinkLow?.let { satPos.getUplinkFreq(it) },
+                    uplinkHigh = transmitter.uplinkHigh?.let { satPos.getUplinkFreq(it) }
+                )
            }
-            copiedList.map { it.copy() }
        }
    }

-    override suspend fun processPasses(passList: List<OrbitalPass>, time: Long): List<OrbitalPass> {
-        return withContext(dispatcher) {
-            passList.forEach { pass ->
-                if (!pass.isDeepSpace) {
-                    val timeStart = pass.aosTime
-                    if (time > timeStart) {
-                        val deltaNow = time.minus(timeStart).toFloat()
-                        val deltaTotal = pass.losTime.minus(timeStart).toFloat()
-                        pass.progress = (deltaNow / deltaTotal).round(2)
+    override suspend fun calculatePasses(
+        time: Long,
+        hoursAhead: Int,
+        minElevation: Double,
+        aosStartMinute: Int,
+        aosEndMinute: Int,
+        invertAosTimeWindow: Boolean,
+        modes: List<String>
+    ) {
+        _isCalculating.value = true
+        // Normalize to the start of the current minute so that coarse 60-second stepping
+        // in getLeoPass always begins from the same phase, producing stable AOS/LOS times
+        val normalizedTime = time / 60_000L * 60_000L
+        val currentSatellites = _satellites.value
+        withContext(dispatcher) {
+            val idsWithModes = localStorage.getIdsWithModes(modes)
+            val stationPos = settingsRepo.stationPosition.value
+            val filteredSatellites = if (idsWithModes.isEmpty()) {
+                currentSatellites
+            } else {
+                currentSatellites.filter { it.data.catnum in idsWithModes }
+            }
+            // Compute passes for each satellite in parallel
+            val passLists = coroutineScope {
+                filteredSatellites.map { satellite ->
+                    async { satellite.getPasses(stationPos, normalizedTime, hoursAhead) }
+                }.awaitAll()
+            }
+            // Flatten and filter in a single pass
+            val timeFuture = normalizedTime + (hoursAhead * 60L * 60L * 1000L)
+            val newPasses = ArrayList<OrbitalPass>()
+            for (list in passLists) {
+                for (pass in list) {
+                    if (
+                        pass.losTime > time
+                        && pass.aosTime < timeFuture
+                        && pass.maxElevation > minElevation
+                        && (pass.isDeepSpace || isAosInRange(pass.aosTime, aosStartMinute, aosEndMinute, invertAosTimeWindow))
+                    ) {
+                        newPasses.add(pass)
                    }
                }
            }
-            passList.filter { pass -> pass.progress < 1.0 }.map { it.copy() }
+            newPasses.sortBy { it.aosTime }
+            delay(1000) // Simulate loading time for better UX
+            _passes.update { newPasses }
        }
+        _isCalculating.value = false
    }

-    override suspend fun calculatePasses(time: Long, hoursAhead: Int, minElevation: Double, modes: List<String>) {
-        if (_satellites.value.isNotEmpty()) {
-            withContext(dispatcher) {
-                val newPasses = mutableListOf<OrbitalPass>()
-                val idsWithModes = localStorage.getIdsWithModes(modes)
-                _satellites.value.forEach { satellite ->
-                    if (idsWithModes.isEmpty() || satellite.data.catnum in idsWithModes) {
-                        newPasses.addAll(satellite.getPasses(settingsRepo.stationPosition.value, time, hoursAhead))
-                    }
-                }
-                _passes.update { newPasses.filter(time, hoursAhead, minElevation) }
-            }
+    private fun isAosInRange(
+        aosTime: Long,
+        aosStartMinute: Int,
+        aosEndMinute: Int,
+        invertAosTimeWindow: Boolean
+    ): Boolean {
+        // Follow the UTC display toggle: with UTC enabled the window is interpreted
+        // in UTC, otherwise in the device's local timezone. Otherwise the pass list
+        // shows UTC times while the filter silently uses local time — the two
+        // disagree by the timezone offset (e.g. 8h for China).
+        val tz = if (settingsRepo.otherSettings.value.stateOfUtc) {
+            TimeZone.getTimeZone("UTC")
        } else {
-            _passes.update { emptyList() }
+            TimeZone.getDefault()
        }
+        val offsetMillis = tz.getOffset(aosTime).toLong()
+        val localMillis = Math.floorMod(aosTime + offsetMillis, 24L * 60L * 60L * 1000L)
+        val aosMinute = (localMillis / 60_000L).toInt()
+        val inRange = if (aosStartMinute <= aosEndMinute) {
+            aosMinute in aosStartMinute..aosEndMinute
+        } else {
+            aosMinute >= aosStartMinute || aosMinute <= aosEndMinute
+        }
+        return if (invertAosTimeWindow) !inRange else inRange
    }

    private fun OrbitalObject.getPasses(pos: GeoPos, time: Long, hours: Int): List<OrbitalPass> {
        val passes = mutableListOf<OrbitalPass>()
        val endDate = time + hours * 60L * 60L * 1000L
        val quarterOrbitMin = (this.data.orbitalPeriod / 4.0).toInt()
+        val decayed = this.data.hasDecayed(time)
        var startDate = time
        var shouldRewind = true
        var lastAosDate: Long
        var count = 0
        if (this.willBeSeen(pos)) {
            if (this.data.isDeepSpace) {
-                passes.add(getGeoPass(this, pos, time))
+                passes.add(getGeoPass(this, pos, time, decayed))
            } else {
                do {
                    if (count > 0) shouldRewind = false
-                    val pass = getLeoPass(this, pos, startDate, shouldRewind)
+                    val pass = getLeoPass(this, pos, startDate, shouldRewind, decayed)
                    lastAosDate = pass.aosTime
                    passes.add(pass)
                    startDate = pass.losTime + (quarterOrbitMin * 3) * 60L * 1000L
@@ -149,94 +228,80 @@ class SatelliteRepo(
        return passes
    }

-    private fun List<OrbitalPass>.filter(time: Long, hoursAhead: Int, minElev: Double): List<OrbitalPass> {
-        val timeFuture = time + (hoursAhead * 60L * 60L * 1000L)
-        return this.filter { it.losTime > time }.filter { it.aosTime < timeFuture }
-            .filter { it.maxElevation > minElev }.sortedBy { it.aosTime }
-    }
-
-    private fun getGeoPass(sat: OrbitalObject, pos: GeoPos, time: Long): OrbitalPass {
+    private fun getGeoPass(sat: OrbitalObject, pos: GeoPos, time: Long, decayed: Boolean): OrbitalPass {
        val satPos = sat.getPosition(pos, time)
        val aos = time - 24 * 60L * 60L * 1000L
        val los = time + 24 * 60L * 60L * 1000L // val tca = (aos + los) / 2
        val az = satPos.azimuth.toDegrees().round(1)
        val elev = satPos.elevation.toDegrees().round(1)
        val alt = satPos.altitude
-        return OrbitalPass(aos, az, los, az, alt.toInt(), elev, sat)
+        return OrbitalPass(aos, az, los, az, alt.toInt(), elev, sat, hasDecayed = decayed)
    }

-    private fun getLeoPass(sat: OrbitalObject, pos: GeoPos, time: Long, rewind: Boolean): OrbitalPass {
+    private fun getLeoPass(sat: OrbitalObject, pos: GeoPos, time: Long, rewind: Boolean, decayed: Boolean): OrbitalPass {
        val quarterOrbitMin = (sat.data.orbitalPeriod / 4.0).toInt()
        var calendarTimeMillis = time
        var elevation: Double
        var maxElevation = 0.0
-        var alt = 0.0 // var tcaAz = 0.0
        // rewind 1/4 of an orbit
-        if (rewind) calendarTimeMillis += -quarterOrbitMin * 60L * 1000L
+        if (rewind) calendarTimeMillis -= quarterOrbitMin * 60L * 1000L

-        var satPos = sat.getPosition(pos, calendarTimeMillis)
-        if (satPos.elevation > 0.0) {
+        // Use lightweight elevation check for coarse searching
+        if (sat.getElevation(pos, calendarTimeMillis) > 0.0) {
            // move forward in 30 second intervals until the sat goes below the horizon
            do {
                calendarTimeMillis += 30 * 1000L
-                satPos = sat.getPosition(pos, calendarTimeMillis)
-            } while (satPos.elevation > 0.0)
+            } while (sat.getElevation(pos, calendarTimeMillis) > 0.0)
            // move forward 3/4 of an orbit
            calendarTimeMillis += quarterOrbitMin * 3 * 60L * 1000L
        }

-        // find the next time sat comes above the horizon
+        // find the next time sat comes above the horizon (coarse: 60s steps)
        do {
            calendarTimeMillis += 60L * 1000L
-            satPos = sat.getPosition(pos, calendarTimeMillis)
-            elevation = satPos.elevation
-            if (elevation > maxElevation) {
-                maxElevation = elevation
-                alt = satPos.altitude // tcaAz = satPos.azimuth.toDegrees()
-            }
-        } while (satPos.elevation < 0.0)
+            elevation = sat.getElevation(pos, calendarTimeMillis)
+            if (elevation > maxElevation) maxElevation = elevation
+        } while (elevation < 0.0)

-        // refine to 1 second
-        calendarTimeMillis += -60L * 1000L
+        // refine AOS to ~500ms precision
+        calendarTimeMillis -= 60L * 1000L
        do {
-            calendarTimeMillis += 1L * 500L
-            satPos = sat.getPosition(pos, calendarTimeMillis)
-            elevation = satPos.elevation
-            if (elevation > maxElevation) {
-                maxElevation = elevation
-                alt = satPos.altitude // tcaAz = satPos.azimuth.toDegrees()
-            }
-        } while (satPos.elevation < 0.0)
+            calendarTimeMillis += 500L
+            elevation = sat.getElevation(pos, calendarTimeMillis)
+            if (elevation > maxElevation) maxElevation = elevation
+        } while (elevation < 0.0)

-        val aos = 1000 * ((satPos.time + 500) / 1000)
-        val aosAz = satPos.azimuth.toDegrees().round(1)
+        // Get full position for AOS data (azimuth, altitude)
+        val aosPos = sat.getFullPosition(pos, calendarTimeMillis)
+        val aos = 1000 * ((aosPos.time + 500) / 1000)
+        val aosAz = aosPos.azimuth.toDegrees().round(1)

-        // find when sat goes below
+        // find when sat goes below (coarse: 30s steps)
        do {
            calendarTimeMillis += 30L * 1000L
-            satPos = sat.getPosition(pos, calendarTimeMillis)
-            elevation = satPos.elevation
-            if (elevation > maxElevation) {
-                maxElevation = elevation
-                alt = satPos.altitude // tcaAz = satPos.azimuth.toDegrees()
-            }
-        } while (satPos.elevation > 0.0)
+            elevation = sat.getElevation(pos, calendarTimeMillis)
+            if (elevation > maxElevation) maxElevation = elevation
+        } while (elevation > 0.0)

-        // refine to 1 second
-        calendarTimeMillis += -30L * 1000L
+        // refine LOS to ~500ms precision
+        calendarTimeMillis -= 30L * 1000L
        do {
-            calendarTimeMillis += 1L * 500L
-            satPos = sat.getPosition(pos, calendarTimeMillis)
-            elevation = satPos.elevation
-            if (elevation > maxElevation) {
-                maxElevation = elevation
-                alt = satPos.altitude // tcaAz = satPos.azimuth.toDegrees()
-            }
-        } while (satPos.elevation > 0.0)
+            calendarTimeMillis += 500L
+            elevation = sat.getElevation(pos, calendarTimeMillis)
+            if (elevation > maxElevation) maxElevation = elevation
+        } while (elevation > 0.0)
+
+        // Get full position for LOS data (azimuth, altitude)
+        val losPos = sat.getFullPosition(pos, calendarTimeMillis)
+        val los = 1000 * ((losPos.time + 500) / 1000)
+        val losAz = losPos.azimuth.toDegrees().round(1)
+
+        // Get altitude at approximate TCA (max elevation)
+        val tcaTime = (aos + los) / 2
+        val tcaPos = sat.getFullPosition(pos, tcaTime)
+        val alt = tcaPos.altitude

-        val los = 1000 * ((satPos.time + 500) / 1000) // val tca = (aos + los) / 2
-        val losAz = satPos.azimuth.toDegrees().round(1)
        val elev = maxElevation.toDegrees().round(1)
-        return OrbitalPass(aos, aosAz, los, losAz, alt.toInt(), elev, sat)
+        return OrbitalPass(aos, aosAz, los, losAz, alt.toInt(), elev, sat, hasDecayed = decayed)
    }
 }
@@ -40,11 +40,23 @@ class SelectionRepo(
    private val currentItems = MutableStateFlow<List<SatItem>>(emptyList())
    private val currentTypes = MutableStateFlow(settingsRepo.selectedTypes.value)
    private val currentQuery = MutableStateFlow("")
+
+    // Resolve type IDs once when types change, then filter items reactively.
+    // The HashSet gives O(1) catnum lookups instead of O(n) with a List.
    private val itemsWithTypes = currentTypes.flatMapLatest { types: List<String> ->
-        currentItems.map { items -> items.filterByTypes(types) }
+        val catnumSet: Set<Int>? = if (types.isEmpty()) {
+            null // null = no filtering
+        } else {
+            val ids = settingsRepo.getSatelliteTypesIds(types)
+            if (ids.isEmpty()) null else ids.toHashSet()
+        }
+        currentItems.map { items ->
+            if (catnumSet == null) items else items.filter { it.catnum in catnumSet }
+        }
    }
+
    private val itemsWithQuery = currentQuery.flatMapLatest { query ->
-        itemsWithTypes.map { items -> items.filterByQuery(query) }
+        itemsWithTypes.map { items -> filterByQuery(items, query) }
    }

    override fun getCurrentTypes() = currentTypes.value
@@ -54,7 +66,7 @@ class SelectionRepo(
    }

    override suspend fun getEntriesFlow() = withContext(dispatcher) {
-        val selectedIds = settingsRepo.selectedIds.value
+        val selectedIds = settingsRepo.selectedIds.value.toHashSet()
        currentItems.value = localSource.getEntriesList().map { item ->
            item.copy(isSelected = item.catnum in selectedIds)
        }
@@ -66,17 +78,19 @@ class SelectionRepo(
        settingsRepo.setSelectedTypes(types)
    }

-    override suspend fun setQuery(query: String) = withContext(dispatcher) {
+    override suspend fun setQuery(query: String) {
        currentQuery.value = query
    }

    override suspend fun setSelection(selectAll: Boolean) = withContext(dispatcher) {
-        setSelection(itemsWithQuery.first().map { item -> item.catnum }, selectAll)
+        val visibleIds = itemsWithQuery.first().mapTo(HashSet()) { it.catnum }
+        setSelection(visibleIds, selectAll)
    }

    override suspend fun setSelection(ids: List<Int>, isTicked: Boolean) = withContext(dispatcher) {
+        val idSet = ids.toHashSet()
        currentItems.value = currentItems.value.map { item ->
-            if (item.catnum in ids) item.copy(isSelected = isTicked) else item
+            if (item.catnum in idSet) item.copy(isSelected = isTicked) else item
        }
    }

@@ -85,19 +99,41 @@ class SelectionRepo(
        settingsRepo.setSelectedIds(currentSelection)
    }

-    private suspend fun List<SatItem>.filterByTypes(types: List<String>) = withContext(dispatcher) {
-        if (types.isEmpty()) return@withContext this@filterByTypes
-        val catnums = settingsRepo.getSatelliteTypesIds(types)
-        if (catnums.isEmpty()) return@withContext this@filterByTypes
-        return@withContext this@filterByTypes.filter { item -> item.catnum in catnums }
-    }
-
-    private suspend fun List<SatItem>.filterByQuery(query: String) = withContext(dispatcher) {
-        if (query.isBlank()) return@withContext this@filterByQuery
-        return@withContext try {
-            this@filterByQuery.filter { it.catnum == query.toInt() }
-        } catch (_: Exception) {
-            this@filterByQuery.filter { item -> item.name.lowercase().contains(query.lowercase()) }
+    /**
+     * Bulk selection using a pre-built Set for O(1) lookups.
+     */
+    private suspend fun setSelection(idSet: Set<Int>, isTicked: Boolean) = withContext(dispatcher) {
+        currentItems.value = currentItems.value.map { item ->
+            if (item.catnum in idSet) item.copy(isSelected = isTicked) else item
        }
    }
+
+    /**
+     * Filters items by query. Uses toIntOrNull() instead of exception-based flow,
+     * and lowercases the query once up front instead of per-item.
+     *
+     * Fuzzy search: the query is split into space-separated tokens and every
+     * token must appear in the satellite name after both sides are normalized
+     * (lowercased, non-alphanumeric separators such as dashes, spaces, brackets
+     * and dots stripped). This makes "ao7" match "AO-7 (AMSAT-OSCAR 7)" and
+     * "iss zarya" match "ISS (ZARYA)" — exact continuous-substring matching
+     * previously failed whenever the name contained a separator the query lacked.
+     */
+    private fun filterByQuery(items: List<SatItem>, query: String): List<SatItem> {
+        if (query.isBlank()) return items
+        val catnum = query.toIntOrNull()
+        if (catnum != null) return items.filter { it.catnum == catnum }
+        val tokens = query.split(' ')
+            .map { normalizeForSearch(it) }
+            .filter { it.isNotEmpty() }
+        if (tokens.isEmpty()) return items
+        return items.filter { item ->
+            val normalizedName = normalizeForSearch(item.name)
+            tokens.all { normalizedName.contains(it) }
+        }
+    }
+
+    /** Lowercases and strips all non-alphanumeric chars for fuzzy matching. */
+    private fun normalizeForSearch(text: String): String =
+        text.lowercase().filter { it.isLetterOrDigit() }
 }
@@ -22,91 +22,144 @@ import android.hardware.Sensor
 import android.hardware.SensorEvent
 import android.hardware.SensorEventListener
 import android.hardware.SensorManager
+import android.hardware.display.DisplayManager
+import android.view.Display
 import android.view.Surface
-import android.view.WindowManager
 import com.rtbishop.look4sat.core.domain.predict.GeoPos
 import com.rtbishop.look4sat.core.domain.predict.RAD2DEG
+import com.rtbishop.look4sat.core.domain.repository.CompassAccuracy
 import com.rtbishop.look4sat.core.domain.repository.ISensorsRepo
 import kotlinx.coroutines.flow.MutableStateFlow
 import kotlinx.coroutines.flow.StateFlow
 import kotlin.math.round

+private const val SMOOTHING_FACTOR = 0.15f
+private const val SENSOR_RATE_US = 16_000
+
 class SensorsRepo(
    private val sensorManager: SensorManager,
-    private val sensor: Sensor?,
-    private val windowManager: WindowManager
-) :
-    SensorEventListener, ISensorsRepo {
+    private val displayManager: DisplayManager?
+) : ISensorsRepo, SensorEventListener {

-    private val _orientation = MutableStateFlow(Pair(0f, 0f))
+    private val _sensorData = MutableStateFlow(Pair(0f, 0f))
+    private val rotationSensor: Sensor? = sensorManager.getDefaultSensor(Sensor.TYPE_ROTATION_VECTOR)
+    private val magneticSensor: Sensor? = sensorManager.getDefaultSensor(Sensor.TYPE_MAGNETIC_FIELD)
+    private val _compassAccuracy = MutableStateFlow(
+        if (rotationSensor == null || magneticSensor == null) CompassAccuracy.UNAVAILABLE
+        else CompassAccuracy.UNRELIABLE
+    )
    private val rotationMatrix = FloatArray(9)
+    private val tempMatrix = FloatArray(9)
    private val orientationValues = FloatArray(3)
-    private var sensorAccuracy = SensorManager.SENSOR_STATUS_UNRELIABLE
+    private var smoothAzimuth = 0f
+    private var smoothPitch = 0f
+    private var hasInitialReading = false

-    override val orientation: StateFlow<Pair<Float, Float>> = _orientation
+    override val sensorData: StateFlow<Pair<Float, Float>> = _sensorData
+    override val compassAccuracy: StateFlow<CompassAccuracy> = _compassAccuracy

    override fun getMagDeclination(geoPos: GeoPos, time: Long): Float {
-        val latitude = geoPos.latitude.toFloat()
-        val longitude = geoPos.longitude.toFloat()
-        return GeomagneticField(latitude, longitude, geoPos.altitude.toFloat(), time).declination
+        return GeomagneticField(
+            geoPos.latitude.toFloat(),
+            geoPos.longitude.toFloat(),
+            geoPos.altitude.toFloat(),
+            time
+        ).declination
    }

    override fun enableSensor() {
-        sensor?.let { sensorManager.registerListener(this, it, 8000) }
+        hasInitialReading = false
+        if (rotationSensor == null || magneticSensor == null) {
+            _compassAccuracy.value = CompassAccuracy.UNAVAILABLE
+            return
+        }
+        _compassAccuracy.value = CompassAccuracy.UNRELIABLE
+        val rotationRegistered = sensorManager.registerListener(this, rotationSensor, SENSOR_RATE_US)
+        val magneticRegistered = sensorManager.registerListener(this, magneticSensor, SENSOR_RATE_US)
+        if (!rotationRegistered || !magneticRegistered) {
+            sensorManager.unregisterListener(this)
+            _compassAccuracy.value = CompassAccuracy.UNAVAILABLE
+        }
    }

    override fun disableSensor() = sensorManager.unregisterListener(this)

    override fun onAccuracyChanged(sensor: Sensor, accuracy: Int) {
-        sensorAccuracy = accuracy
+        if (sensor.type == Sensor.TYPE_MAGNETIC_FIELD) {
+            updateAccuracy(accuracy)
+        }
    }

-    override fun onSensorChanged(event: SensorEvent) = when {
-        sensorAccuracy == SensorManager.SENSOR_STATUS_UNRELIABLE -> {}
-        event.sensor == sensor -> updateOrientation(event.values)
-        else -> {}
+    override fun onSensorChanged(event: SensorEvent) {
+        when (event.sensor.type) {
+            Sensor.TYPE_ROTATION_VECTOR -> handleSensorEvent(event)
+            Sensor.TYPE_MAGNETIC_FIELD -> updateAccuracy(event.accuracy)
+        }
+    }
+
+    private fun updateAccuracy(accuracy: Int) {
+        _compassAccuracy.value = when (accuracy) {
+            SensorManager.SENSOR_STATUS_ACCURACY_HIGH -> CompassAccuracy.HIGH
+            SensorManager.SENSOR_STATUS_ACCURACY_MEDIUM -> CompassAccuracy.MEDIUM
+            SensorManager.SENSOR_STATUS_ACCURACY_LOW -> CompassAccuracy.LOW
+            else -> CompassAccuracy.UNRELIABLE
+        }
    }

    private fun getDisplayRotation(): Int {
-        return try {
-            @Suppress("DEPRECATION")
-            windowManager.defaultDisplay.rotation
-        } catch (e: Exception) {
-            Surface.ROTATION_0
-        }
+        return displayManager?.getDisplay(Display.DEFAULT_DISPLAY)?.rotation ?: Surface.ROTATION_0
    }

-    private fun transformRotationMatrix(rotationMatrix: FloatArray, rotation: Int) {
-        val tempMatrix = FloatArray(9)
-        when (rotation) {
-            Surface.ROTATION_0 -> {
-                SensorManager.remapCoordinateSystem(rotationMatrix, SensorManager.AXIS_X, SensorManager.AXIS_Y, tempMatrix)
-                System.arraycopy(tempMatrix, 0, rotationMatrix, 0, 9)
-            }
-            Surface.ROTATION_90 -> {
-                SensorManager.remapCoordinateSystem(rotationMatrix, SensorManager.AXIS_Y, SensorManager.AXIS_MINUS_X, tempMatrix)
-                SensorManager.remapCoordinateSystem(tempMatrix, SensorManager.AXIS_MINUS_X, SensorManager.AXIS_Y, rotationMatrix)
-            }
-            Surface.ROTATION_180 -> {
-                SensorManager.remapCoordinateSystem(rotationMatrix, SensorManager.AXIS_MINUS_X, SensorManager.AXIS_MINUS_Y, tempMatrix)
-                System.arraycopy(tempMatrix, 0, rotationMatrix, 0, 9)
-            }
-            Surface.ROTATION_270 -> {
-                SensorManager.remapCoordinateSystem(rotationMatrix, SensorManager.AXIS_MINUS_Y, SensorManager.AXIS_X, tempMatrix)
-                SensorManager.remapCoordinateSystem(tempMatrix, SensorManager.AXIS_MINUS_X, SensorManager.AXIS_Y, rotationMatrix)
-            }
+    private fun remapForRotation(rotation: Int) {
+        val remapped = when (rotation) {
+            Surface.ROTATION_90 -> SensorManager.remapCoordinateSystem(
+                rotationMatrix, SensorManager.AXIS_Y, SensorManager.AXIS_MINUS_X, tempMatrix
+            )
+
+            Surface.ROTATION_180 -> SensorManager.remapCoordinateSystem(
+                rotationMatrix, SensorManager.AXIS_MINUS_X, SensorManager.AXIS_MINUS_Y, tempMatrix
+            )
+
+            Surface.ROTATION_270 -> SensorManager.remapCoordinateSystem(
+                rotationMatrix, SensorManager.AXIS_MINUS_Y, SensorManager.AXIS_X, tempMatrix
+            )
+
+            else -> false
        }
+        if (remapped) System.arraycopy(tempMatrix, 0, rotationMatrix, 0, 9)
    }

-    private fun updateOrientation(rotationVector: FloatArray) {
-        SensorManager.getRotationMatrixFromVector(rotationMatrix, rotationVector)
-        transformRotationMatrix(rotationMatrix, getDisplayRotation())
+    private fun handleSensorEvent(event: SensorEvent) {
+        SensorManager.getRotationMatrixFromVector(rotationMatrix, event.values)
+        remapForRotation(getDisplayRotation())
        SensorManager.getOrientation(rotationMatrix, orientationValues)
-        val azimuth = (orientationValues[0] * RAD2DEG).toFloat()
-        val pitch = (orientationValues[1] * RAD2DEG).toFloat() // roll [2]
-        val magneticAzimuth = (azimuth + 360f) % 360f
-        val roundedAzimuth = round(magneticAzimuth * 10) / 10
-        val roundedPitch = round(pitch * 10) / 10
-        _orientation.value = Pair(roundedAzimuth, roundedPitch)
+        val azimuth = normalizeAzimuth((orientationValues[0] * RAD2DEG).toFloat())
+        val pitch = (orientationValues[1] * RAD2DEG).toFloat()
+        if (!hasInitialReading) {
+            smoothAzimuth = azimuth
+            smoothPitch = pitch
+            hasInitialReading = true
+        } else {
+            smoothAzimuth = lowPassAngle(smoothAzimuth, azimuth)
+            smoothPitch = lowPass(smoothPitch, pitch)
+        }
+        _sensorData.value = Pair(round(smoothAzimuth * 10) / 10, round(smoothPitch * 10) / 10)
    }
+
+    private fun lowPass(previous: Float, current: Float): Float {
+        return previous + SMOOTHING_FACTOR * (current - previous)
+    }
+
+    /**
+     * Low-pass filter that accounts for the 0°/360° wraparound.
+     * Always takes the shortest angular path between the two values.
+     */
+    private fun lowPassAngle(previous: Float, current: Float): Float {
+        var delta = current - previous
+        while (delta > 180f) delta -= 360f
+        while (delta <= -180f) delta += 360f
+        return normalizeAzimuth(previous + SMOOTHING_FACTOR * delta)
+    }
+
+    private fun normalizeAzimuth(value: Float): Float = (value + 360f) % 360f
 }
@@ -28,6 +28,8 @@ import com.rtbishop.look4sat.core.domain.model.DatabaseState
 import com.rtbishop.look4sat.core.domain.model.OtherSettings
 import com.rtbishop.look4sat.core.domain.model.PassesSettings
 import com.rtbishop.look4sat.core.domain.model.RCSettings
+import com.rtbishop.look4sat.core.domain.model.RadioControlSettings
+import com.rtbishop.look4sat.core.domain.model.WavelogSettings
 import com.rtbishop.look4sat.core.domain.predict.GeoPos
 import com.rtbishop.look4sat.core.domain.repository.ISettingsRepo
 import com.rtbishop.look4sat.core.domain.utility.positionToQth
@@ -36,6 +38,10 @@ import com.rtbishop.look4sat.core.domain.utility.round
 import kotlinx.coroutines.flow.MutableStateFlow
 import kotlinx.coroutines.flow.StateFlow
 import kotlinx.coroutines.flow.update
+import org.json.JSONObject
+import java.util.Locale
+import com.rtbishop.look4sat.core.domain.model.Constants
+import com.rtbishop.look4sat.core.domain.source.Sources

 class SettingsRepo(
    private val locationManager: LocationManager,
@@ -50,8 +56,13 @@ class SettingsRepo(
    private val keyBluetoothFrequencyState = "bluetoothFrequencyState"
    private val keyBluetoothFrequencyAddress = "bluetoothFrequencyAddress"
    private val keyBluetoothFrequencyFormat = "bluetoothFrequencyFormat"
+    private val keyFilterShowDeepSpace = "filterShowDeepSpace"
    private val keyFilterHoursAhead = "filterHoursAhead"
+    private val keyFilterHoursBefore = "filterHoursBefore"
    private val keyFilterMinElevation = "filterMinElevation"
+    private val keyFilterAosStartMinute = "filterAosStartMinute"
+    private val keyFilterAosEndMinute = "filterAosEndMinute"
+    private val keyFilterAosInvert = "filterAosInvert"
    private val keyNumberOfRadios = "numberOfRadios"
    private val keyNumberOfSatellites = "numberOfSatellites"
    private val keyRotatorAddress = "rotatorAddress"
@@ -62,14 +73,20 @@ class SettingsRepo(
    private val keyFrequencyAddress = "frequencyAddress"
    private val keyFrequencyPort = "frequencyPort"
    private val keyFrequencyFormat = "frequencyFormat"
+    private val keyFrequencyOffsetHz = "frequencyOffsetHz"
    private val keySelectedIds = "selectedIds"
    private val keySelectedTypes = "selectedTypes"
    private val keySelectedModes = "selectedModes"
    private val keyStateOfAutoUpdate = "stateOfAutoUpdate"
+    private val keyStateOfAutoLotwSync = "stateOfAutoLotwSync"
    private val keyStateOfSensors = "stateOfSensors"
+    private val keyCompassOffsetDegrees = "compassOffsetDegrees"
    private val keyStateOfSweep = "stateOfSweep"
    private val keyStateOfUtc = "stateOfUtc"
    private val keyStateOfLightTheme = "stateOfLightTheme"
+    private val keyStateOfNightMode = "stateOfNightMode"
+    private val keyStateOfMapGrid = "stateOfMapGrid"
+    private val keyStateOfMapFirstCall = "stateOfMapFirstCall"
    private val keyStationAltitude = "stationAltitude"
    private val keyStationLatitude = "stationLatitude"
    private val keyStationLongitude = "stationLongitude"
@@ -78,11 +95,22 @@ class SettingsRepo(
    private val keyUpdateTimestamp = "updateTimestamp"
    private val keyShouldSeeWarning = "shouldSeeWarning"
    private val keyShouldSeeWhatsNew = "shouldSeeWhatsNew_v$appVersionName"
+    private val keySstvMode = "sstvMode"
+    private val keyLowElevation = "lowElevation"
+    private val keyHighElevation = "highElevation"
    private val keyUseCustomTle = "useCustomTle"
    private val keyUseCustomTransceivers = "useCustomTransceivers"
    private val keyTleUrl = "tleUrl"
    private val keyTransceiversUrl = "transceiversUrl"
+    private val keySatelliteUrls = "satelliteUrls"
+    private val keyTransceiversUrls = "transceiversUrls"
+    private val keySatelliteEnabled = "satelliteEnabled"
+    private val keyTransceiversEnabled = "transceiversEnabled"
+    private val keySatnogsTleSourceMigration = "satnogsTleSourceMigration"
    private val separatorComma = ","
+    private val separatorUrl = "\n"
+    private val legacyCelestrakSatnogsUrl =
+        "https://celestrak.org/NORAD/elements/gp.php?GROUP=satnogs&FORMAT=csv"

    //region # Satellites selection settings
    private val _satelliteSelection = MutableStateFlow(getSelectedIds())
@@ -109,29 +137,218 @@ class SettingsRepo(
    }

    private fun getSelectedTypes(): List<String> {
-        val typesString = preferences.getString(keySelectedTypes, null)
-        if (typesString.isNullOrEmpty()) return listOf("Amateur")
+        val typesString = preferences.getString(keySelectedTypes, "Amateur")
+        if (typesString.isNullOrEmpty()) return emptyList()
        return typesString.split(separatorComma)
    }
    //endregion

-    //region # Passes filter settings
+    //region # Wavelog worked-grids settings
+    private val keyWavelogUrl = "wavelogUrl"
+    private val keyWavelogToken = "wavelogToken"
+    private val keyWorkedGrids = "workedGrids"
+
+    private val _wavelogSettings = MutableStateFlow(getWavelogSettings())
+    override val wavelogSettings: StateFlow<WavelogSettings> = _wavelogSettings
+
+    override fun updateWavelogSettings(settings: WavelogSettings) {
+        preferences.edit {
+            putString(keyWavelogUrl, settings.url.trim())
+            putString(keyWavelogToken, settings.token.trim())
+        }
+        _wavelogSettings.value = settings.copy(url = settings.url.trim(), token = settings.token.trim())
+    }
+
+    private fun getWavelogSettings(): WavelogSettings = WavelogSettings(
+        url = preferences.getString(keyWavelogUrl, null).orEmpty(),
+        token = preferences.getString(keyWavelogToken, null).orEmpty()
+    )
+
+    override fun getWorkedGrids(): Set<String> {
+        val json = preferences.getString(keyWorkedGrids, null).orEmpty()
+        if (json.isBlank()) return emptySet()
+        return try {
+            val array = org.json.JSONArray(json)
+            (0 until array.length()).mapNotNull { i ->
+                array.optString(i).takeIf { it.isNotBlank() }
+            }.toSet()
+        } catch (_: Exception) {
+            emptySet()
+        }
+    }
+
+    override fun setWorkedGrids(grids: Set<String>) {
+        val array = org.json.JSONArray()
+        grids.sorted().forEach { array.put(it) }
+        preferences.edit { putString(keyWorkedGrids, array.toString()) }
+    }
+
+    // Confirmed satellite QSOs per worked gridsquare, persisted as a single JSON
+    // object: {"OL62":[{"c":call,"t":epochMs,"s":sat,"m":mode,"bu":up,"bd":down}]}.
+    private val keyWorkedGridQsos = "workedGridQsos"
+
+    override fun getWorkedGridQsos(): Map<String, List<com.rtbishop.look4sat.core.domain.model.GridQso>> {
+        val json = preferences.getString(keyWorkedGridQsos, null).orEmpty()
+        if (json.isBlank()) return emptyMap()
+        return try {
+            val root = org.json.JSONObject(json)
+            val result = mutableMapOf<String, List<com.rtbishop.look4sat.core.domain.model.GridQso>>()
+            for (grid in root.keys()) {
+                val array = root.optJSONArray(grid) ?: continue
+                val list = (0 until array.length()).mapNotNull { i ->
+                    val o = array.optJSONObject(i) ?: return@mapNotNull null
+                    com.rtbishop.look4sat.core.domain.model.GridQso(
+                        call = o.optString("c"),
+                        epochMs = o.optLong("t"),
+                        satName = o.optString("s"),
+                        mode = o.optString("m"),
+                        bandUp = o.optString("bu"),
+                        bandDown = o.optString("bd"),
+                        // New award fields: absent in pre-award data -> null.
+                        dxcc = o.optInt("dx", 0).takeIf { it > 0 },
+                        country = o.optString("cty").ifBlank { null },
+                        cqz = o.optInt("cq", 0).takeIf { it > 0 },
+                        state = o.optString("st").ifBlank { null },
+                        // Own-grid field: absent in pre-myGrid data -> null.
+                        myGrid = o.optString("mg").ifBlank { null }
+                    )
+                }
+                if (list.isNotEmpty()) result[grid] = list
+            }
+            result
+        } catch (_: Exception) {
+            emptyMap()
+        }
+    }
+
+    override fun setWorkedGridQsos(qsos: Map<String, List<com.rtbishop.look4sat.core.domain.model.GridQso>>) {
+        val root = org.json.JSONObject()
+        for ((grid, list) in qsos) {
+            val array = org.json.JSONArray()
+            for (q in list) {
+                array.put(
+                    org.json.JSONObject()
+                        .put("c", q.call)
+                        .put("t", q.epochMs)
+                        .put("s", q.satName)
+                        .put("m", q.mode)
+                        .put("bu", q.bandUp)
+                        .put("bd", q.bandDown)
+                        .put("dx", q.dxcc ?: 0)
+                        .put("cty", q.country ?: "")
+                        .put("cq", q.cqz ?: 0)
+                        .put("st", q.state ?: "")
+                        .put("mg", q.myGrid ?: "")
+                )
+            }
+            root.put(grid, array)
+        }
+        preferences.edit { putString(keyWorkedGridQsos, root.toString()) }
+    }
+
+    // Distinct 4-char gridsquares the account operated from (LoTW <MY_GRIDSQUARE>,
+    // satellite QSOs only). Stored as a JSONArray like workedGrids.
+    private val keyRoamedGrids = "roamedGrids"
+
+    override fun getRoamedGrids(): Set<String> {
+        val json = preferences.getString(keyRoamedGrids, null).orEmpty()
+        if (json.isBlank()) return emptySet()
+        return try {
+            val array = org.json.JSONArray(json)
+            (0 until array.length()).mapNotNull { i ->
+                array.optString(i).takeIf { it.isNotBlank() }
+            }.toSet()
+        } catch (_: Exception) {
+            emptySet()
+        }
+    }
+
+    override fun setRoamedGrids(grids: Set<String>) {
+        val array = org.json.JSONArray()
+        grids.sorted().forEach { array.put(it) }
+        preferences.edit { putString(keyRoamedGrids, array.toString()) }
+    }
+
+    // LoTW credentials (stored locally on the device only)
+    private val keyLoTWCall = "lotwCallsign"
+    private val keyLoTWPass = "lotwPassword"
+
+    override val lotwSettings: kotlinx.coroutines.flow.StateFlow<com.rtbishop.look4sat.core.domain.model.LoTWSettings>
+        get() = _lotwSettings
+    private val _lotwSettings = MutableStateFlow(getLoTWSettings())
+
+    override fun updateLoTWSettings(settings: com.rtbishop.look4sat.core.domain.model.LoTWSettings) {
+        preferences.edit {
+            putString(keyLoTWCall, settings.callsign.trim().uppercase())
+            putString(keyLoTWPass, settings.password)
+        }
+        _lotwSettings.value = settings.copy(
+            callsign = settings.callsign.trim().uppercase(),
+            password = settings.password
+        )
+    }
+
+    private fun getLoTWSettings(): com.rtbishop.look4sat.core.domain.model.LoTWSettings =
+        com.rtbishop.look4sat.core.domain.model.LoTWSettings(
+            callsign = preferences.getString(keyLoTWCall, null).orEmpty(),
+            password = preferences.getString(keyLoTWPass, null).orEmpty()
+        )
+
+    // Last successful sync bookkeeping: date ("yyyyMMdd") and callsign. Used to
+    // decide incremental (same callsign) vs full (first time / callsign change)
+    // report requests and to merge increments into the stored grid data.
+    private val keyLastLotwSyncDate = "lotwLastSyncDate"
+    private val keyLastLotwSyncCallsign = "lotwLastSyncCallsign"
+
+    override fun getLastLotwSyncDate(): String =
+        preferences.getString(keyLastLotwSyncDate, null).orEmpty()
+
+    override fun setLastLotwSyncDate(date: String) =
+        preferences.edit { putString(keyLastLotwSyncDate, date) }
+
+    override fun getLastLotwSyncCallsign(): String =
+        preferences.getString(keyLastLotwSyncCallsign, null).orEmpty()
+
+    override fun setLastLotwSyncCallsign(callsign: String) =
+        preferences.edit { putString(keyLastLotwSyncCallsign, callsign.trim().uppercase()) }
+    //endregion
+
+    //region # Transceivers settings
    private val _passesSettings = MutableStateFlow(getPassesSettings())
    override val passesSettings: StateFlow<PassesSettings> = _passesSettings

    override fun setPassesSettings(settings: PassesSettings) = preferences.edit {
+        putBoolean(keyFilterShowDeepSpace, settings.showDeepSpace)
        putInt(keyFilterHoursAhead, settings.hoursAhead)
+        putInt(keyFilterHoursBefore, settings.hoursBefore)
        putLong(keyFilterMinElevation, settings.minElevation.toRawBits())
+        putInt(keyFilterAosStartMinute, settings.aosStartMinute)
+        putInt(keyFilterAosEndMinute, settings.aosEndMinute)
+        putBoolean(keyFilterAosInvert, settings.invertAosTimeWindow)
        putString(keySelectedModes, settings.selectedModes.joinToString(separatorComma))
        _passesSettings.value = settings
    }

    private fun getPassesSettings(): PassesSettings {
+        val showDeepSpace = preferences.getBoolean(keyFilterShowDeepSpace, true)
        val hoursAhead = preferences.getInt(keyFilterHoursAhead, 24)
+        val hoursBefore = preferences.getInt(keyFilterHoursBefore, 0).coerceIn(0, 240)
        val minElevation = Double.fromBits(preferences.getLong(keyFilterMinElevation, 16.0.toRawBits()))
+        val aosStartMinute = preferences.getInt(keyFilterAosStartMinute, 0).coerceIn(0, 23 * 60 + 59)
+        val aosEndMinute = preferences.getInt(keyFilterAosEndMinute, 23 * 60 + 59).coerceIn(0, 23 * 60 + 59)
+        val invertAosTimeWindow = preferences.getBoolean(keyFilterAosInvert, false)
        val selectedModesString = preferences.getString(keySelectedModes, null)
        val selectedModes = selectedModesString?.split(separatorComma)?.sorted() ?: emptyList()
-        return PassesSettings(hoursAhead, minElevation, selectedModes)
+        return PassesSettings(
+            showDeepSpace,
+            hoursAhead,
+            minElevation,
+            aosStartMinute,
+            aosEndMinute,
+            invertAosTimeWindow,
+            selectedModes,
+            hoursBefore
+        )
    }
    //endregion

@@ -246,82 +463,56 @@ class SettingsRepo(
    //endregion

    //region # RC settings
+    init {
+        migrateRCFormats()
+    }
+
+    // TODO: Remove after a few releases (added in v4.2.0)
+    private val keyRCFormatsMigrated = "rcFormatsMigrated"
+
+    private fun migrateRCFormats() {
+        if (preferences.getBoolean(keyRCFormatsMigrated, false)) return
+        val formatKeys = listOf(
+            keyRotatorFormat, keyFrequencyFormat, keyBluetoothRotatorFormat, keyBluetoothFrequencyFormat
+        )
+        preferences.edit {
+            for (key in formatKeys) {
+                val value = preferences.getString(key, null) ?: continue
+                if (value.contains("_") && !value.startsWith("\\")) {
+                    putString(key, "\\$value")
+                }
+            }
+            putBoolean(keyRCFormatsMigrated, true)
+        }
+    }
+
    private val _rcSettings = MutableStateFlow(getRCSettings())
    override val rcSettings: StateFlow<RCSettings> = _rcSettings

-    override fun setBluetoothRotatorAddress(value: String) {
-        preferences.edit { putString(keyBluetoothRotatorAddress, value) }
-        _rcSettings.update { it.copy(bluetoothRotatorAddress = value) }
-    }
-
-    override fun setBluetoothRotatorFormat(value: String) {
-        preferences.edit { putString(keyBluetoothRotatorFormat, value) }
-        _rcSettings.update { it.copy(bluetoothRotatorFormat = value) }
-    }
-
-    override fun setBluetoothRotatorName(value: String) {
-        preferences.edit { putString(keyBluetoothRotatorName, value) }
-        _rcSettings.update { it.copy(bluetoothRotatorName = value) }
-    }
-
-    override fun setBluetoothRotatorState(value: Boolean) {
-        preferences.edit { putBoolean(keyBluetoothRotatorState, value) }
-        _rcSettings.update { it.copy(bluetoothRotatorState = value) }
-    }
-
-    override fun setBluetoothFrequencyState(value: Boolean) {
-        preferences.edit { putBoolean(keyBluetoothFrequencyState, value) }
-        _rcSettings.update { it.copy(bluetoothFrequencyState = value) }
-    }
-
-    override fun setBluetoothFrequencyAddress(value: String) {
-        preferences.edit { putString(keyBluetoothFrequencyAddress, value) }
-        _rcSettings.update { it.copy(bluetoothFrequencyAddress = value) }
-    }
-
-    override fun setBluetoothFrequencyFormat(value: String) {
-        preferences.edit { putString(keyBluetoothFrequencyFormat, value) }
-        _rcSettings.update { it.copy(bluetoothFrequencyFormat = value) }
-    }
-
-    override fun setRotatorAddress(value: String) {
-        preferences.edit { putString(keyRotatorAddress, value) }
-        _rcSettings.update { it.copy(rotatorAddress = value) }
-    }
-
-    override fun setRotatorPort(value: String) {
-        preferences.edit { putString(keyRotatorPort, value) }
-        _rcSettings.update { it.copy(rotatorPort = value) }
-    }
-
-    override fun setRotatorState(value: Boolean) {
-        preferences.edit { putBoolean(keyRotatorState, value) }
-        _rcSettings.update { it.copy(rotatorState = value) }
-    }
-
-    override fun setRotatorFormat(value: String) {
-        preferences.edit { putString(keyRotatorFormat, value) }
-        _rcSettings.update { it.copy(rotatorFormat = value) }
-    }
-
-    override fun setFrequencyState(value: Boolean) {
-        preferences.edit { putBoolean(keyFrequencyState, value) }
-        _rcSettings.update { it.copy(frequencyState = value) }
-    }
-
-    override fun setFrequencyAddress(value: String) {
-        preferences.edit { putString(keyFrequencyAddress, value) }
-        _rcSettings.update { it.copy(frequencyAddress = value) }
-    }
-
-    override fun setFrequencyPort(value: String) {
-        preferences.edit { putString(keyFrequencyPort, value) }
-        _rcSettings.update { it.copy(frequencyPort = value) }
-    }
-
-    override fun setFrequencyFormat(value: String) {
-        preferences.edit { putString(keyFrequencyFormat, value) }
-        _rcSettings.update { it.copy(frequencyFormat = value) }
+    override fun updateRCSettings(settings: RCSettings) {
+        val clampedFreqOffsetHz = settings.frequencyOffsetHz.coerceIn(
+            Constants.FREQ_OFFSET_MIN_HZ,
+            Constants.FREQ_OFFSET_MAX_HZ
+        )
+        preferences.edit {
+            putBoolean(keyRotatorState, settings.rotatorState)
+            putString(keyRotatorAddress, settings.rotatorAddress)
+            putString(keyRotatorPort, settings.rotatorPort)
+            putString(keyRotatorFormat, settings.rotatorFormat)
+            putBoolean(keyFrequencyState, settings.frequencyState)
+            putString(keyFrequencyAddress, settings.frequencyAddress)
+            putString(keyFrequencyPort, settings.frequencyPort)
+            putString(keyFrequencyFormat, settings.frequencyFormat)
+            putLong(keyFrequencyOffsetHz, clampedFreqOffsetHz)
+            putBoolean(keyBluetoothRotatorState, settings.bluetoothRotatorState)
+            putString(keyBluetoothRotatorFormat, settings.bluetoothRotatorFormat)
+            putString(keyBluetoothRotatorName, settings.bluetoothRotatorName)
+            putString(keyBluetoothRotatorAddress, settings.bluetoothRotatorAddress)
+            putBoolean(keyBluetoothFrequencyState, settings.bluetoothFrequencyState)
+            putString(keyBluetoothFrequencyFormat, settings.bluetoothFrequencyFormat)
+            putString(keyBluetoothFrequencyAddress, settings.bluetoothFrequencyAddress)
+        }
+        _rcSettings.value = settings.copy(frequencyOffsetHz = clampedFreqOffsetHz)
    }

    private fun getRCSettings(): RCSettings = RCSettings(
@@ -332,14 +523,16 @@ class SettingsRepo(
        frequencyState = preferences.getBoolean(keyFrequencyState, false),
        frequencyAddress = preferences.getString(keyFrequencyAddress, null) ?: "127.0.0.1",
        frequencyPort = preferences.getString(keyFrequencyPort, null) ?: "4532",
-        frequencyFormat = preferences.getString(keyFrequencyFormat, null) ?: $$"set_freq $FREQ",
+        frequencyFormat = preferences.getString(keyFrequencyFormat, null) ?: $$"F $FREQ",
+        frequencyOffsetHz = preferences.getLong(keyFrequencyOffsetHz, 0L)
+            .coerceIn(Constants.FREQ_OFFSET_MIN_HZ, Constants.FREQ_OFFSET_MAX_HZ),
        bluetoothRotatorState = preferences.getBoolean(keyBluetoothRotatorState, false),
-        bluetoothRotatorFormat = preferences.getString(keyBluetoothRotatorFormat, null) ?: $$"W$AZ $EL",
+        bluetoothRotatorFormat = preferences.getString(keyBluetoothRotatorFormat, null) ?: $$"P $AZ $EL",
        bluetoothRotatorName = preferences.getString(keyBluetoothRotatorName, null) ?: "Default",
        bluetoothRotatorAddress = preferences.getString(keyBluetoothRotatorAddress, null) ?: "00:0C:BF:13:80:5D",
        bluetoothFrequencyState = preferences.getBoolean(keyBluetoothFrequencyState, false),
        bluetoothFrequencyAddress = preferences.getString(keyBluetoothFrequencyAddress, null) ?: "00:0C:BF:13:80:5D",
-        bluetoothFrequencyFormat = preferences.getString(keyBluetoothFrequencyFormat, null) ?: $$"FA$FREQ"
+        bluetoothFrequencyFormat = preferences.getString(keyBluetoothFrequencyFormat, null) ?: $$"F $FREQ"
    )
    //endregion

@@ -347,49 +540,46 @@ class SettingsRepo(
    private val _otherSettings = MutableStateFlow(getOtherSettings())
    override val otherSettings: StateFlow<OtherSettings> = _otherSettings

-    override fun setStateOfAutoUpdate(value: Boolean) {
-        preferences.edit { putBoolean(keyStateOfAutoUpdate, value) }
-        _otherSettings.update { it.copy(stateOfAutoUpdate = value) }
-    }
-
-    override fun setStateOfSensors(value: Boolean) {
-        preferences.edit { putBoolean(keyStateOfSensors, value) }
-        _otherSettings.update { it.copy(stateOfSensors = value) }
-    }
-
-    override fun setStateOfSweep(value: Boolean) {
-        preferences.edit { putBoolean(keyStateOfSweep, value) }
-        _otherSettings.update { it.copy(stateOfSweep = value) }
-    }
-
-    override fun setStateOfUtc(value: Boolean) {
-        preferences.edit { putBoolean(keyStateOfUtc, value) }
-        _otherSettings.update { it.copy(stateOfUtc = value) }
-    }
-
-    override fun setStateOfLightTheme(value: Boolean){
-        preferences.edit { putBoolean(keyStateOfLightTheme, value) }
-        _otherSettings.update { it.copy(stateOfLightTheme = value) }
-    }
-
-    override fun setWarningDismissed() {
-        preferences.edit { putBoolean(keyShouldSeeWarning, false) }
-        _otherSettings.update { it.copy(shouldSeeWarning = false) }
-    }
-
-    override fun setWhatsNewDismissed() {
-        preferences.edit { putBoolean(keyShouldSeeWhatsNew, false) }
-        _otherSettings.update { it.copy(shouldSeeWhatsNew = false) }
+    override fun updateOtherSettings(transform: (OtherSettings) -> OtherSettings) {
+        _otherSettings.update { current ->
+            val new = transform(current)
+            preferences.edit {
+                putBoolean(keyStateOfAutoUpdate, new.stateOfAutoUpdate)
+                putBoolean(keyStateOfAutoLotwSync, new.stateOfAutoLotwSync)
+                putBoolean(keyStateOfSensors, new.stateOfSensors)
+                putFloat(keyCompassOffsetDegrees, new.compassOffsetDegrees.coerceIn(-180f, 180f))
+                putBoolean(keyStateOfSweep, new.stateOfSweep)
+                putBoolean(keyStateOfUtc, new.stateOfUtc)
+                putBoolean(keyStateOfLightTheme, new.stateOfLightTheme)
+                putBoolean(keyStateOfNightMode, new.stateOfNightMode)
+                putBoolean(keyStateOfMapGrid, new.stateOfMapGrid)
+                putBoolean(keyStateOfMapFirstCall, new.stateOfMapFirstCall)
+                putBoolean(keyShouldSeeWarning, new.shouldSeeWarning)
+                putBoolean(keyShouldSeeWhatsNew, new.shouldSeeWhatsNew)
+                putString(keySstvMode, new.sstvMode)
+                putLong(keyLowElevation, new.lowElevation.toRawBits())
+                putLong(keyHighElevation, new.highElevation.toRawBits())
+            }
+            new
+        }
    }

    private fun getOtherSettings(): OtherSettings = OtherSettings(
        stateOfAutoUpdate = preferences.getBoolean(keyStateOfAutoUpdate, true),
+        stateOfAutoLotwSync = preferences.getBoolean(keyStateOfAutoLotwSync, true),
        stateOfSensors = preferences.getBoolean(keyStateOfSensors, true),
+        compassOffsetDegrees = preferences.getFloat(keyCompassOffsetDegrees, 0f).coerceIn(-180f, 180f),
        stateOfSweep = preferences.getBoolean(keyStateOfSweep, true),
        stateOfUtc = preferences.getBoolean(keyStateOfUtc, false),
        stateOfLightTheme = preferences.getBoolean(keyStateOfLightTheme, false),
+        stateOfNightMode = preferences.getBoolean(keyStateOfNightMode, false),
+        stateOfMapGrid = preferences.getBoolean(keyStateOfMapGrid, false),
+        stateOfMapFirstCall = preferences.getBoolean(keyStateOfMapFirstCall, false),
        shouldSeeWarning = preferences.getBoolean(keyShouldSeeWarning, true),
-        shouldSeeWhatsNew = preferences.getBoolean(keyShouldSeeWhatsNew, true)
+        shouldSeeWhatsNew = preferences.getBoolean(keyShouldSeeWhatsNew, true),
+        sstvMode = preferences.getString(keySstvMode, null) ?: "Auto",
+        lowElevation = Double.fromBits(preferences.getLong(keyLowElevation, 15.0.toRawBits())),
+        highElevation = Double.fromBits(preferences.getLong(keyHighElevation, 45.0.toRawBits()))
    )
    //endregion

@@ -397,31 +587,198 @@ class SettingsRepo(
    private val _dataSourcesSettings = MutableStateFlow(getDataSourcesSettings())
    override val dataSourcesSettings: StateFlow<DataSourcesSettings> = _dataSourcesSettings

-    override fun setUseCustomTle(value: Boolean) {
-        preferences.edit { putBoolean(keyUseCustomTle, value) }
-        _dataSourcesSettings.update { it.copy(useCustomTLE = value) }
-    }
-
-    override fun setUseCustomTransceivers(value: Boolean) {
-        preferences.edit { putBoolean(keyUseCustomTransceivers, value) }
-        _dataSourcesSettings.update { it.copy(useCustomTransceivers = value) }
-    }
-
-    override fun setTleUrl(value: String) {
-        preferences.edit { putString(keyTleUrl, value) }
-        _dataSourcesSettings.update { it.copy(tleUrl = value) }
-    }
-
-    override fun setTransceiversUrl(value: String) {
-        preferences.edit { putString(keyTransceiversUrl, value) }
-        _dataSourcesSettings.update { it.copy(transceiversUrl = value) }
+    override fun updateDataSourcesSettings(settings: DataSourcesSettings) {
+        // Normalize the enabled lists so they are positionally aligned with the URL lists.
+        // Missing entries default to enabled (true), keeping the persisted "one flag per URL"
+        // invariant intact even when a default empty list is used to construct the model.
+        val normalized = settings.copy(
+            satelliteEnabled = alignFlags(settings.satelliteUrls, settings.satelliteEnabled),
+            transceiversEnabled = alignFlags(settings.transceiversUrls, settings.transceiversEnabled)
+        )
+        preferences.edit {
+            putString(keySatelliteUrls, normalized.satelliteUrls.joinToString(separatorUrl))
+            putString(keyTransceiversUrls, normalized.transceiversUrls.joinToString(separatorUrl))
+            putString(keySatelliteEnabled, normalized.satelliteEnabled.joinToString(separatorComma))
+            putString(keyTransceiversEnabled, normalized.transceiversEnabled.joinToString(separatorComma))
+            putBoolean(keySatnogsTleSourceMigration, true)
+        }
+        _dataSourcesSettings.value = normalized
    }

    private fun getDataSourcesSettings(): DataSourcesSettings = DataSourcesSettings(
-        useCustomTLE = preferences.getBoolean(keyUseCustomTle, false),
-        useCustomTransceivers = preferences.getBoolean(keyUseCustomTransceivers, false),
-        tleUrl = preferences.getString(keyTleUrl, "https://example.com/tle.txt") ?: "",
-        transceiversUrl = preferences.getString(keyTransceiversUrl, "https://example.com/radio.json") ?: ""
+        satelliteUrls = getDataSourceUrls(
+            key = keySatelliteUrls,
+            defaultUrls = Sources.satelliteDataUrls.values.filter { it.isNotBlank() },
+            legacyEnabledKey = keyUseCustomTle,
+            legacyUrlKey = keyTleUrl
+        ).migrateSatnogsTleSource(),
+        transceiversUrls = getDataSourceUrls(
+            key = keyTransceiversUrls,
+            defaultUrls = Sources.transceiversDataUrls.values.filter { it.isNotBlank() },
+            legacyEnabledKey = keyUseCustomTransceivers,
+            legacyUrlKey = keyTransceiversUrl
+        ),
+        satelliteEnabled = readEnabledFlags(keySatelliteEnabled),
+        transceiversEnabled = readEnabledFlags(keyTransceiversEnabled)
+    )
+
+    /** Read the persisted per-source enabled flags (empty when never stored). */
+    private fun readEnabledFlags(key: String): List<Boolean> {
+        return preferences.getString(key, null)
+            ?.split(separatorComma)
+            ?.mapNotNull { it.trim() }
+            ?.filter { it == "true" || it == "false" }
+            ?.map { it == "true" }
+            ?: emptyList()
+    }
+
+    /** Keep the flags positionally aligned with the URL list, defaulting to enabled. */
+    private fun alignFlags(urls: List<String>, flags: List<Boolean>): List<Boolean> {
+        if (flags.size >= urls.size) return flags.take(urls.size)
+        return flags + List(urls.size - flags.size) { true }
+    }
+
+    private fun getDataSourceUrls(
+        key: String,
+        defaultUrls: List<String>,
+        legacyEnabledKey: String,
+        legacyUrlKey: String
+    ): List<String> {
+        val stored = preferences.getString(key, null)
+            ?.split(separatorUrl)
+            ?.map { it.trim() }
+            ?.filter { it.isNotBlank() }
+        if (stored != null) return stored
+        val legacyCustomUrl = preferences.getString(legacyUrlKey, null)?.trim().orEmpty()
+        return if (preferences.getBoolean(legacyEnabledKey, false) && legacyCustomUrl.isNotBlank()) {
+            (defaultUrls + legacyCustomUrl).distinct()
+        } else {
+            defaultUrls
+        }
+    }
+
+    private fun List<String>.migrateSatnogsTleSource(): List<String> {
+        if (preferences.getBoolean(keySatnogsTleSourceMigration, false)) return this
+        val satnogsTleUrl = Sources.satelliteDataUrls["SatNOGS"].orEmpty()
+        if (satnogsTleUrl.isBlank() || containsSourceUrl(satnogsTleUrl)) return this
+        val celestrakSatnogsIndex = indexOfFirst { isSameSourceUrl(it, legacyCelestrakSatnogsUrl) }
+        if (celestrakSatnogsIndex < 0) return this
+
+        val migrated = toMutableList().apply { add(celestrakSatnogsIndex + 1, satnogsTleUrl) }
+        preferences.edit {
+            putString(keySatelliteUrls, migrated.joinToString(separatorUrl))
+            putBoolean(keySatnogsTleSourceMigration, true)
+        }
+        return migrated
+    }
+
+    private fun List<String>.containsSourceUrl(url: String): Boolean = any { isSameSourceUrl(it, url) }
+
+    private fun isSameSourceUrl(first: String, second: String): Boolean =
+        normalizeSourceUrl(first).equals(normalizeSourceUrl(second), ignoreCase = true)
+
+    private fun normalizeSourceUrl(url: String): String {
+        val trimmed = url.trim()
+        return if (trimmed.startsWith("http", ignoreCase = true)) trimmed else "https://$trimmed"
+    }
+    //endregion
+
+    //region # Data sources status
+    private val _dataSourcesStatus = MutableStateFlow<Map<String, Int>>(emptyMap())
+    override val dataSourcesStatus: StateFlow<Map<String, Int>> = _dataSourcesStatus
+
+    override fun updateDataSourcesStatus(status: Map<String, Int>) {
+        _dataSourcesStatus.value = status
+    }
+    //endregion
+
+    //region # Radio control settings
+    private val keyRadioControlEnabled = "radioControlEnabled"
+    private val keyRadioModel = "radioModel"
+    private val keyTxRadioAddress = "txRadioAddress"
+    private val keyRxRadioAddress = "rxRadioAddress"
+    private val keyTxRadioName = "txRadioName"
+    private val keyRxRadioName = "rxRadioName"
+    private val keyRadioBaudRate = "radioBaudRate"
+    private val keyRadioSplitMode = "radioSplitMode"
+
+    private val _radioControlSettings = MutableStateFlow(getRadioControlSettings())
+    override val radioControlSettings: StateFlow<RadioControlSettings> = _radioControlSettings
+
+    override fun updateRadioControlSettings(settings: RadioControlSettings) {
+        preferences.edit {
+            putBoolean(keyRadioControlEnabled, settings.enabled)
+            putString(keyRadioModel, settings.radioModel)
+            putString(keyTxRadioAddress, settings.txRadioAddress)
+            putString(keyRxRadioAddress, settings.rxRadioAddress)
+            putString(keyTxRadioName, settings.txRadioName)
+            putString(keyRxRadioName, settings.rxRadioName)
+            putInt(keyRadioBaudRate, settings.baudRate)
+            putBoolean(keyRadioSplitMode, settings.splitMode)
+        }
+        _radioControlSettings.value = settings
+    }
+
+    private fun getRadioControlSettings(): RadioControlSettings = RadioControlSettings(
+        enabled = preferences.getBoolean(keyRadioControlEnabled, false),
+        radioModel = preferences.getString(keyRadioModel, null) ?: RadioControlSettings.MODEL_YAESU_FT817,
+        txRadioAddress = preferences.getString(keyTxRadioAddress, null) ?: "",
+        rxRadioAddress = preferences.getString(keyRxRadioAddress, null) ?: "",
+        txRadioName = preferences.getString(keyTxRadioName, null) ?: "TX Radio",
+        rxRadioName = preferences.getString(keyRxRadioName, null) ?: "RX Radio",
+        baudRate = preferences.getInt(keyRadioBaudRate, 4800),
+        splitMode = preferences.getBoolean(keyRadioSplitMode, false)
    )
    //endregion
+
+    //region # Per-satellite calculator offset settings
+    private val keySatelliteOffsets = "satelliteOffsets"
+    private val keyLegacySatelliteOffsetPrefix = "offset_khz_"
+
+    override fun getSatelliteOffset(catnum: Int): String {
+        val json = preferences.getString(keySatelliteOffsets, "{}") ?: "{}"
+        val stored = try {
+            JSONObject(json).optString(catnum.toString(), "")
+        } catch (_: Exception) {
+            ""
+        }
+        if (stored.isNotEmpty()) return stored
+
+        // Lazy migration from the fork's old UI-layer implementation, which stored
+        // one SharedPreferences entry per satellite directly from TransceiversPage.
+        val legacyKey = "$keyLegacySatelliteOffsetPrefix$catnum"
+        val legacy = preferences.getString(legacyKey, "").orEmpty()
+        if (legacy.isNotEmpty()) {
+            setSatelliteOffset(catnum, legacy)
+        }
+        return legacy
+    }
+
+    override fun setSatelliteOffset(catnum: Int, offset: String) {
+        val json = preferences.getString(keySatelliteOffsets, "{}") ?: "{}"
+        val updated = try {
+            val obj = JSONObject(json)
+            if (offset.isEmpty()) obj.remove(catnum.toString()) else obj.put(catnum.toString(), offset)
+            obj.toString()
+        } catch (_: Exception) {
+            if (offset.isEmpty()) "{}" else """{"$catnum": "$offset"}"""
+        }
+        preferences.edit {
+            putString(keySatelliteOffsets, updated)
+            remove("$keyLegacySatelliteOffsetPrefix$catnum")
+        }
+    }
+    //endregion
+
+    //region # AMSAT status report settings
+    private val keyAmSatCallsign = "amSatCallsign"
+
+    override fun getAmSatCallsign(): String {
+        return preferences.getString(keyAmSatCallsign, "").orEmpty()
+    }
+
+    override fun setAmSatCallsign(callsign: String) {
+        preferences.edit { putString(keyAmSatCallsign, callsign.trim().uppercase(Locale.US)) }
+    }
+    //endregion
 }
@@ -0,0 +1,106 @@
+package com.rtbishop.look4sat.core.data.repository
+
+import com.rtbishop.look4sat.core.domain.model.LatestRelease
+import com.rtbishop.look4sat.core.domain.repository.IUpdateRepository
+import com.rtbishop.look4sat.core.domain.source.IRemoteSource
+import kotlinx.coroutines.Dispatchers
+import kotlinx.coroutines.withContext
+import java.io.File
+
+class UpdateRepository(
+    private val remoteSource: IRemoteSource
+) : IUpdateRepository {
+
+    override suspend fun getLatestRelease(): LatestRelease? = withContext(Dispatchers.IO) {
+        // Use the GitHub releases web page instead of the REST API endpoint:
+        // the API endpoint is rate-limited to 60 requests/hour per IP, which is
+        // quickly exhausted on shared egress IPs (e.g. VPN proxies), causing 403
+        // failures. The web endpoint redirects to the latest tag with no such limit.
+        // When GitHub is unreachable (common on mainland-China networks without a
+        // proxy), fall back to community GitHub accelerator mirrors that proxy the
+        // same page; each mirror resolves the identical tag and asset URLs.
+        for (baseUrl in LATEST_RELEASE_URLS) {
+            val result = remoteSource.getNetworkStream(baseUrl)
+            val stream = result.stream ?: continue
+            val parsed = try {
+                parseRelease(stream.bufferedReader().use { it.readText() }, baseUrl)
+            } catch (e: Exception) {
+                println("UpdateRepository parse failure: $e")
+                null
+            }
+            if (parsed != null) return@withContext parsed
+        }
+        null
+    }
+
+    override suspend fun downloadApk(url: String, dest: File): Boolean = withContext(Dispatchers.IO) {
+        if (url.isBlank()) return@withContext false
+        val result = remoteSource.getNetworkStream(url)
+        val stream = result.stream ?: return@withContext false
+        try {
+            dest.outputStream().use { out -> stream.use { it.copyTo(out) } }
+            true
+        } catch (e: Exception) {
+            println("UpdateRepository download failure: $e")
+            false
+        }
+    }
+
+    private fun parseRelease(html: String, sourceUrl: String): LatestRelease? {
+        // The redirect target is the latest release's tag page. Extract the tag
+        // from the og:url meta tag ("…/releases/tag/v4.4.6-ba7opf.8") — stable and
+        // unambiguous. The <title> also holds the release name, but that is free
+        // text and cannot be used to build the asset URL.
+        val ogUrl = Regex("<meta\\s+property=\"og:url\"\\s+content=\"([^\"]*)\"").find(html)
+            ?.groupValues?.get(1) ?: return null
+        val tag = Regex("/releases/tag/(v[0-9][0-9A-Za-z.\\-]*)$").find(ogUrl)
+            ?.groupValues?.get(1) ?: return null
+        val title = Regex("<title>(.*?)</title>", RegexOption.DOT_MATCHES_ALL)
+            .find(html)?.groupValues?.get(1)?.trim()
+            ?.substringBefore("·")?.removePrefix("Release")?.trim() ?: tag
+        // Release notes live in the page's markdown-body section (first occurrence
+        // is the release description). Strip HTML tags for plain-text display.
+        val raw = Regex("<div[^>]*class=\"[^\"]*markdown-body[^\"]*\"[^>]*>(.*?)</div>", RegexOption.DOT_MATCHES_ALL)
+            .find(html)?.groupValues?.get(1) ?: ""
+        val body = raw.replace(Regex("<[^>]+>"), "")
+            .replace("&lt;", "<").replace("&gt;", ">").replace("&amp;", "&")
+            .replace("&quot;", "\"").replace("&#39;", "'")
+            .trim()
+        // The release APK asset naming: Look4Sat-<tag without leading v>.apk
+        // (since v4.4.6-ba7opf.9.9 the releases are uploaded with the bare
+        // versioned filename, no "-release" suffix). When the page was fetched
+        // through an accelerator mirror (https://<mirror>/https://github.com/...),
+        // download through the same mirror — raw github.com is unreachable on the
+        // networks that needed the mirror in the first place.
+        val mirrorPrefix = sourceUrl.substringBefore("https://github.com")
+        val apkName = "Look4Sat-${tag.removePrefix("v")}.apk"
+        val apkUrl = if (mirrorPrefix.isEmpty()) {
+            "$DOWNLOAD_BASE_URL/$tag/$apkName"
+        } else {
+            "${mirrorPrefix}https://github.com/atsunatsu/Look4Sat/releases/download/$tag/$apkName"
+        }
+        return LatestRelease(
+            versionTag = tag,
+            title = title,
+            body = body,
+            apkUrl = apkUrl
+        )
+    }
+
+    private companion object {
+        // Web pages are used instead of api.github.com to avoid the 60 req/hour
+        // anonymous rate limit (see getLatestRelease above). The GitHub URL is
+        // tried first; if it is unreachable (no proxy on mainland networks) the
+        // accelerator mirrors are tried in order. Download URLs always point at
+        // the mirrors too — raw github.com release downloads are equally blocked
+        // without a proxy, so a mirror-resolved tag must be downloaded via the
+        // same mirror.
+        val LATEST_RELEASE_URLS = listOf(
+            "https://github.com/atsunatsu/Look4Sat/releases/latest",
+            "https://ghfast.top/https://github.com/atsunatsu/Look4Sat/releases/latest",
+            "https://gh.llkk.cc/https://github.com/atsunatsu/Look4Sat/releases/latest",
+            "https://github.moeyy.xyz/https://github.com/atsunatsu/Look4Sat/releases/latest"
+        )
+        const val DOWNLOAD_BASE_URL = "https://github.com/atsunatsu/Look4Sat/releases/download"
+    }
+}
@@ -0,0 +1,97 @@
+/*
+ * Look4Sat. Amateur radio satellite tracker and pass predictor.
+ * Copyright (C) 2019-2026 Arty Bishop and contributors.
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <https://www.gnu.org/licenses/>.
+ */
+package com.rtbishop.look4sat.core.data.repository
+
+import com.rtbishop.look4sat.core.domain.repository.IWavelogRepository
+import kotlinx.coroutines.Dispatchers
+import kotlinx.coroutines.withContext
+import org.json.JSONArray
+import org.json.JSONObject
+
+/**
+ * Fetches the list of worked gridsquares from a self-hosted Wavelog instance.
+ *
+ * Uses the Wavelog v1 API endpoint (verified against Wavelog 3.0.2):
+ *   POST {base}/index.php/api/logbook_get_worked_grids
+ *   Body: {"key": "<api key>", "logbook_id": "<logbook id>"}
+ *   Response 201: JSON array of 4-char gridsquares, e.g. ["JN47","JO30"]
+ *   (see Wavelog Api.php logbook_get_worked_grids / Api_model::get_grids_worked_in_logbook)
+ *
+ * The token field carries "<api_key>:<logbook_id>" so one credential line
+ * configures both values (the dialog explains this to the user).
+ */
+class WavelogRepository : IWavelogRepository {
+
+    override suspend fun fetchWorkedGrids(url: String, token: String): Set<String>? = withContext(Dispatchers.IO) {
+        val parts = token.trim().split(":")
+        val apiKey = parts.getOrNull(0)?.trim().orEmpty()
+        val logbookId = parts.getOrNull(1)?.trim().orEmpty()
+        if (url.isBlank() || apiKey.isBlank() || logbookId.isBlank()) return@withContext null
+        val base = url.trim().trimEnd('/')
+        val requestUrl = "$base/index.php/api/logbook_get_worked_grids"
+        try {
+            val connection = java.net.URL(requestUrl).openConnection() as java.net.HttpURLConnection
+            connection.connectTimeout = 10_000
+            connection.readTimeout = 15_000
+            connection.requestMethod = "POST"
+            connection.doOutput = true
+            connection.setRequestProperty("Content-Type", "application/json")
+            val body = JSONObject().apply {
+                put("key", apiKey)
+                put("logbook_id", logbookId)
+            }.toString().toByteArray()
+            connection.outputStream.use { it.write(body) }
+            val code = connection.responseCode
+            if (code !in 200..299) {
+                connection.disconnect()
+                return@withContext null
+            }
+            val response = connection.inputStream.bufferedReader().use { it.readText() }
+            connection.disconnect()
+            parseWorkedGrids(response)
+        } catch (e: Exception) {
+            println("WavelogRepository fetch failure: $e")
+            null
+        }
+    }
+
+    internal fun parseWorkedGrids(body: String): Set<String>? {
+        return try {
+            val array = when {
+                body.trimStart().startsWith("[") -> JSONArray(body)
+                else -> {
+                    // Tolerate {"grids": [...]} wrappers too
+                    JSONObject(body).optJSONArray("grids") ?: return null
+                }
+            }
+            val result = mutableSetOf<String>()
+            for (i in 0 until array.length()) {
+                val grid = array.optString(i, "").trim().uppercase()
+                // Keep only well-formed 4-character Maidenhead squares (e.g. OL62)
+                if (grid.length == 4 && grid[0] in 'A'..'R' && grid[1] in 'A'..'R'
+                    && grid[2] in '0'..'9' && grid[3] in '0'..'9'
+                ) {
+                    result.add(grid)
+                }
+            }
+            result
+        } catch (_: Exception) {
+            null
+        }
+    }
+}
@@ -51,12 +51,12 @@ class LocalSource(private val look4SatDao: Look4SatDao) : ILocalSource {

    private fun FrameworkEntry.toDomain() = OrbitalData(
        this.name, this.epoch, this.meanmo, this.eccn, this.incl,
-        this.raan, this.argper, this.meanan, this.catnum, this.bstar
+        this.raan, this.argper, this.meanan, this.catnum, this.bstar, this.ndot
    )

    private fun OrbitalData.toEntity() = FrameworkEntry(
        this.name, this.epoch, this.meanmo, this.eccn, this.incl,
-        this.raan, this.argper, this.meanan, this.catnum, this.bstar
+        this.raan, this.argper, this.meanan, this.catnum, this.bstar, this.ndot
    )

    private fun List<OrbitalData>.toEntity() = this.map { item -> item.toEntity() }
@@ -73,21 +73,22 @@ class LocalSource(private val look4SatDao: Look4SatDao) : ILocalSource {
        return look4SatDao.getRadiosWithId(id).toDomainRadios()
    }

-    override suspend fun insertRadios(radios: List<SatRadio>) {
-        look4SatDao.deleteRadios()
-        look4SatDao.insertRadios(radios.toFrameworkRadios())
+    override suspend fun insertRadios(radios: List<SatRadio>, isCustom: Boolean) {
+        look4SatDao.insertRadios(radios.map { it.copy(isCustom = isCustom) }.toFrameworkRadios())
    }

+    override suspend fun deleteManagedRadios() = look4SatDao.deleteManagedRadios()
+
    override suspend fun deleteRadios() = look4SatDao.deleteRadios()

    private fun DomainRadio.toFramework() = FrameworkRadio(
        this.uuid, this.info, this.isAlive, this.downlinkLow, this.downlinkHigh, this.downlinkMode,
-        this.uplinkLow, this.uplinkHigh, this.uplinkMode, this.isInverted, this.catnum
+        this.uplinkLow, this.uplinkHigh, this.uplinkMode, this.isInverted, this.catnum, this.isCustom
    )

    private fun FrameworkRadio.toDomain() = DomainRadio(
        this.uuid, this.info, this.isAlive, this.downlinkLow, this.downlinkHigh, this.downlinkMode,
-        this.uplinkLow, this.uplinkHigh, this.uplinkMode, this.isInverted, this.catnum
+        this.uplinkLow, this.uplinkHigh, this.uplinkMode, this.isInverted, this.catnum, this.isCustom
    )

    private fun List<DomainRadio>.toFrameworkRadios() = this.map { radio -> radio.toFramework() }
@@ -20,10 +20,13 @@ package com.rtbishop.look4sat.core.data.source
 import android.content.ContentResolver
 import androidx.core.net.toUri
 import com.rtbishop.look4sat.core.domain.source.IRemoteSource
+import com.rtbishop.look4sat.core.domain.source.NetworkResult
 import kotlinx.coroutines.CoroutineDispatcher
 import kotlinx.coroutines.withContext
+import okhttp3.MediaType.Companion.toMediaType
 import okhttp3.OkHttpClient
 import okhttp3.Request
+import okhttp3.RequestBody.Companion.toRequestBody
 import java.io.InputStream

 class RemoteSource(
@@ -42,12 +45,74 @@ class RemoteSource(
        }
    }

-    override suspend fun getNetworkStream(url: String): InputStream? = withContext(dispatcher) {
+    override suspend fun getNetworkStream(url: String): NetworkResult = withContext(dispatcher) {
        try {
            val networkRequest = Request.Builder().url(url).build()
-            httpClient.newCall(networkRequest).execute().body.byteStream()
+            val response = httpClient.newCall(networkRequest).execute()
+            if (!response.isSuccessful) {
+                val code = response.code
+                response.close()
+                return@withContext NetworkResult(code, null)
+            }
+            // Return the body stream directly as the caller is responsible for closing it.
+            // Closing the stream returns the connection to OkHttp's pool.
+            val body = response.body
+            if (body == null) {
+                response.close()
+                return@withContext NetworkResult(response.code, null)
+            }
+            NetworkResult(response.code, body.byteStream().buffered())
        } catch (exception: Exception) {
            println("RemoteSource network stream exception: $exception")
+            NetworkResult(NetworkResult.CONNECTION_ERROR, null)
+        }
+    }
+
+    override suspend fun getAmSatCatalog(): String? = withContext(dispatcher) {
+        try {
+            val request = Request.Builder()
+                .url("https://www.amsat.org/status/api/v1/catalog.php")
+                .header("User-Agent", "Look4Sat")
+                .build()
+            httpClient.newCall(request).execute().use { response ->
+                if (!response.isSuccessful) return@use null
+                response.body.string()
+            }
+        } catch (exception: Exception) {
+            println("RemoteSource getAmSatCatalog exception: $exception")
+            null
+        }
+    }
+
+    override suspend fun getAmSatReports(hours: Int, limit: Int): String? = withContext(dispatcher) {
+        try {
+            val request = Request.Builder()
+                .url("https://www.amsat.org/status/api/v1/reports.php?hours=$hours&limit=$limit")
+                .header("User-Agent", "Look4Sat")
+                .build()
+            httpClient.newCall(request).execute().use { response ->
+                if (!response.isSuccessful) return@use null
+                response.body.string()
+            }
+        } catch (exception: Exception) {
+            println("RemoteSource getAmSatReports exception: $exception")
+            null
+        }
+    }
+
+    override suspend fun submitAmSatReport(payloadJson: String): Pair<Int, String>? = withContext(dispatcher) {
+        try {
+            val body = payloadJson.toRequestBody("application/json; charset=utf-8".toMediaType())
+            val request = Request.Builder()
+                .url("https://www.amsat.org/status/api/v1/reports.php")
+                .header("User-Agent", "Look4Sat")
+                .post(body)
+                .build()
+            httpClient.newCall(request).execute().use { response ->
+                response.code to response.body.string()
+            }
+        } catch (exception: Exception) {
+            println("RemoteSource submitAmSatReport exception: $exception")
            null
        }
    }
@@ -0,0 +1,63 @@
+/*
+ * Look4Sat. Amateur radio satellite tracker and pass predictor.
+ * Copyright (C) 2019-2026 Arty Bishop and contributors.
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <https://www.gnu.org/licenses/>.
+ */
+package com.rtbishop.look4sat.core.data.usecase
+
+import android.media.AudioFormat
+import android.media.AudioRecord
+import android.media.MediaRecorder
+import androidx.annotation.RequiresPermission
+import com.rtbishop.look4sat.core.domain.usecase.IAudioCapture
+import kotlinx.coroutines.Dispatchers
+import kotlinx.coroutines.currentCoroutineContext
+import kotlinx.coroutines.flow.Flow
+import kotlinx.coroutines.flow.flow
+import kotlinx.coroutines.flow.flowOn
+import kotlinx.coroutines.isActive
+
+class AudioCapture : IAudioCapture {
+
+    override val sampleRate: Int = 44100
+
+    private val channelConfig = AudioFormat.CHANNEL_IN_MONO
+    private val audioFormat = AudioFormat.ENCODING_PCM_FLOAT
+    private val bufferSize = AudioRecord.getMinBufferSize(sampleRate, channelConfig, audioFormat)
+        .coerceAtLeast(sampleRate) // at least 1 second buffer
+
+    @RequiresPermission(android.Manifest.permission.RECORD_AUDIO)
+    override fun audioFlow(): Flow<FloatArray> = flow {
+        val recorder = AudioRecord(
+            MediaRecorder.AudioSource.MIC,
+            sampleRate,
+            channelConfig,
+            audioFormat,
+            bufferSize * 4 // bytes for float
+        )
+        try {
+            recorder.startRecording()
+            val chunkSize = sampleRate / 10 // ~100ms chunks
+            val buffer = FloatArray(chunkSize)
+            while (currentCoroutineContext().isActive) {
+                val read = recorder.read(buffer, 0, chunkSize, AudioRecord.READ_BLOCKING)
+                if (read > 0) emit(if (read == chunkSize) buffer.copyOf() else buffer.copyOfRange(0, read))
+            }
+        } finally {
+            recorder.stop()
+            recorder.release()
+        }
+    }.flowOn(Dispatchers.IO)
+}
@@ -0,0 +1,84 @@
+/*
+ * Look4Sat. Amateur radio satellite tracker and pass predictor.
+ * Copyright (C) 2019-2026 Arty Bishop and contributors.
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <https://www.gnu.org/licenses/>.
+ */
+package com.rtbishop.look4sat.core.data.usecase
+
+import android.content.ContentValues
+import android.content.Context
+import android.graphics.Bitmap
+import android.os.Build
+import android.os.Environment
+import android.provider.MediaStore
+import com.rtbishop.look4sat.core.domain.usecase.ISaveImage
+import kotlinx.coroutines.Dispatchers
+import kotlinx.coroutines.withContext
+import java.io.File
+import java.io.FileOutputStream
+import java.text.SimpleDateFormat
+import java.util.Date
+import java.util.Locale
+
+//Saves images to the device gallery using MediaStore (API 29+) or direct file write (API < 29)
+class SaveImage(private val context: Context) : ISaveImage {
+
+    override suspend fun invoke(pixels: IntArray, width: Int, height: Int, modeName: String): Boolean {
+        return withContext(Dispatchers.IO) {
+            try {
+                val bitmap = Bitmap.createBitmap(pixels, width, height, Bitmap.Config.ARGB_8888)
+                val timestamp = SimpleDateFormat("yyyyMMdd_HHmmss", Locale.US).format(Date())
+                val filename = "SSTV_${modeName}_$timestamp.png"
+                if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.Q) {
+                    saveWithMediaStore(bitmap, filename)
+                } else {
+                    saveToExternalStorage(bitmap, filename)
+                }
+                bitmap.recycle()
+                true
+            } catch (_: Exception) {
+                false
+            }
+        }
+    }
+
+    private fun saveWithMediaStore(bitmap: Bitmap, filename: String) {
+        val values = ContentValues().apply {
+            put(MediaStore.Images.Media.DISPLAY_NAME, filename)
+            put(MediaStore.Images.Media.MIME_TYPE, "image/png")
+            put(MediaStore.Images.Media.RELATIVE_PATH, "${Environment.DIRECTORY_PICTURES}/Look4Sat")
+            put(MediaStore.Images.Media.IS_PENDING, 1)
+        }
+        val resolver = context.contentResolver
+        val uri = resolver.insert(MediaStore.Images.Media.EXTERNAL_CONTENT_URI, values)
+            ?: throw IllegalStateException("Failed to create MediaStore entry")
+        resolver.openOutputStream(uri)?.use { stream ->
+            bitmap.compress(Bitmap.CompressFormat.PNG, 100, stream)
+        }
+        values.clear()
+        values.put(MediaStore.Images.Media.IS_PENDING, 0)
+        resolver.update(uri, values, null, null)
+    }
+
+    private fun saveToExternalStorage(bitmap: Bitmap, filename: String) {
+        val picturesDir = Environment.getExternalStoragePublicDirectory(Environment.DIRECTORY_PICTURES)
+        val dir = File(picturesDir, "Look4Sat")
+        if (!dir.exists()) dir.mkdirs()
+        val file = File(dir, filename)
+        FileOutputStream(file).use { stream ->
+            bitmap.compress(Bitmap.CompressFormat.PNG, 100, stream)
+        }
+    }
+}
@@ -0,0 +1,150 @@
+package com.rtbishop.look4sat.core.data.framework
+
+import org.junit.Assert.assertArrayEquals
+import org.junit.Assert.assertEquals
+import org.junit.Assert.assertNotNull
+import org.junit.Assert.assertNull
+import org.junit.Test
+
+class Ft817CatProtocolTest {
+
+    @Test
+    fun encodeFrequencyBcd_145500000() {
+        val bcd = Ft817CatProtocol.encodeFrequencyBcd(145500000L)
+        assertArrayEquals(byteArrayOf(0x14, 0x55, 0x00, 0x00), bcd)
+    }
+
+    @Test
+    fun encodeFrequencyBcd_435100000() {
+        val bcd = Ft817CatProtocol.encodeFrequencyBcd(435100000L)
+        assertArrayEquals(byteArrayOf(0x43, 0x51, 0x00, 0x00), bcd)
+    }
+
+    @Test
+    fun encodeFrequencyBcd_7074000() {
+        val bcd = Ft817CatProtocol.encodeFrequencyBcd(7074000L)
+        assertArrayEquals(byteArrayOf(0x00, 0x70, 0x74, 0x00), bcd)
+    }
+
+    @Test
+    fun decodeFrequencyBcd_roundTrips() {
+        val testFreqs = listOf(145500000L, 435100000L, 7074000L, 14200000L, 28500000L)
+        for (freq in testFreqs) {
+            val rounded = (freq / 10) * 10
+            val bcd = Ft817CatProtocol.encodeFrequencyBcd(freq)
+            assertEquals(rounded, Ft817CatProtocol.decodeFrequencyBcd(bcd))
+        }
+    }
+
+    @Test
+    fun buildSetFreqCommand_correctFormat() {
+        val cmd = Ft817CatProtocol.buildSetFreqCommand(145500000L)
+        assertEquals(5, cmd.size)
+        assertEquals(0x01.toByte(), cmd[4])
+        assertArrayEquals(byteArrayOf(0x14, 0x55, 0x00, 0x00, 0x01), cmd)
+    }
+
+    @Test
+    fun buildSetModeCommand_usb() {
+        val cmd = Ft817CatProtocol.buildSetModeCommand("USB")
+        assertNotNull(cmd)
+        assertArrayEquals(byteArrayOf(0x01, 0x00, 0x00, 0x00, 0x07), cmd)
+    }
+
+    @Test
+    fun buildSetModeCommand_fm() {
+        val cmd = Ft817CatProtocol.buildSetModeCommand("FM")
+        assertNotNull(cmd)
+        assertArrayEquals(byteArrayOf(0x08, 0x00, 0x00, 0x00, 0x07), cmd)
+    }
+
+    @Test
+    fun buildSetModeCommand_unknownReturnsNull() {
+        assertNull(Ft817CatProtocol.buildSetModeCommand("INVALID"))
+    }
+
+    @Test
+    fun encodeCtcssTone_67_0() {
+        val bcd = Ft817CatProtocol.encodeCtcssToneBcd(67.0)
+        assertArrayEquals(byteArrayOf(0x06, 0x70), bcd)
+    }
+
+    @Test
+    fun encodeCtcssTone_74_4() {
+        val bcd = Ft817CatProtocol.encodeCtcssToneBcd(74.4)
+        assertArrayEquals(byteArrayOf(0x07, 0x44), bcd)
+    }
+
+    @Test
+    fun encodeCtcssTone_141_3() {
+        val bcd = Ft817CatProtocol.encodeCtcssToneBcd(141.3)
+        assertArrayEquals(byteArrayOf(0x14, 0x13), bcd)
+    }
+
+    @Test
+    fun buildSetCtcssToneCommand_correctFormat() {
+        val cmd = Ft817CatProtocol.buildSetCtcssToneCommand(67.0)
+        assertEquals(5, cmd.size)
+        assertEquals(0x0B.toByte(), cmd[4])
+        assertArrayEquals(byteArrayOf(0x06, 0x70, 0x00, 0x00, 0x0B), cmd)
+    }
+
+    @Test
+    fun buildCtcssModeCommand_enable() {
+        val cmd = Ft817CatProtocol.buildCtcssModeCommand(true)
+        assertArrayEquals(byteArrayOf(0x2A, 0x00, 0x00, 0x00, 0x0A), cmd)
+    }
+
+    @Test
+    fun buildCtcssModeCommand_disable() {
+        val cmd = Ft817CatProtocol.buildCtcssModeCommand(false)
+        assertEquals(0x8A.toByte(), cmd[0])
+        assertEquals(0x0A.toByte(), cmd[4])
+    }
+
+    @Test
+    fun parseReadResponse_validResponse() {
+        val response = byteArrayOf(0x14, 0x55, 0x00, 0x00, 0x01)
+        val result = Ft817CatProtocol.parseReadResponse(response)
+        assertNotNull(result)
+        result ?: return
+        assertEquals(145500000L, result.first)
+        assertEquals("USB", result.second)
+    }
+
+    @Test
+    fun parseReadResponse_fmMode() {
+        val response = byteArrayOf(0x14, 0x60, 0x00, 0x00, 0x08)
+        val result = Ft817CatProtocol.parseReadResponse(response)
+        assertNotNull(result)
+        result ?: return
+        assertEquals(146000000L, result.first)
+        assertEquals("FM", result.second)
+    }
+
+    @Test
+    fun parseReadResponse_tooShort() {
+        assertNull(Ft817CatProtocol.parseReadResponse(byteArrayOf(0x14, 0x55, 0x00)))
+    }
+
+    @Test
+    fun parseReadResponse_unknownMode() {
+        val response = byteArrayOf(0x14, 0x55, 0x00, 0x00, 0x0F)
+        assertNull(Ft817CatProtocol.parseReadResponse(response))
+    }
+
+    @Test
+    fun buildPttCommands() {
+        val on = Ft817CatProtocol.buildPttOnCommand()
+        assertArrayEquals(byteArrayOf(0x00, 0x00, 0x00, 0x00, 0x08), on)
+
+        val off = Ft817CatProtocol.buildPttOffCommand()
+        assertEquals(0x88.toByte(), off[4])
+    }
+
+    @Test
+    fun buildReadCommand() {
+        val cmd = Ft817CatProtocol.buildReadFreqModeCommand()
+        assertArrayEquals(byteArrayOf(0x00, 0x00, 0x00, 0x00, 0x03), cmd)
+    }
+}
@@ -0,0 +1,171 @@
+package com.rtbishop.look4sat.core.data.repository
+
+import com.rtbishop.look4sat.core.domain.model.SatStatus
+import com.rtbishop.look4sat.core.domain.model.SatStatusPage
+import com.rtbishop.look4sat.core.domain.source.IRemoteSource
+import com.rtbishop.look4sat.core.domain.source.NetworkResult
+import kotlinx.coroutines.async
+import kotlinx.coroutines.delay
+import kotlinx.coroutines.test.runTest
+import org.junit.Assert.assertEquals
+import org.junit.Assert.assertNull
+import org.junit.Assert.assertSame
+import org.junit.Test
+import java.io.InputStream
+import java.text.SimpleDateFormat
+import java.util.Date
+import java.util.Locale
+import java.util.TimeZone
+
+class AmSatRepositoryTest {
+
+    @Test
+    fun fetchStatusReturnsSeededCacheUntilCacheIsCleared() = runTest {
+        val remoteSource = FakeAmSatRemoteSource()
+        val repository = AmSatRepository(remoteSource)
+        val cachedPage = SatStatusPage(
+            fetchedAtUtcMs = 123L,
+            statuses = listOf(SatStatus(name = "AO-7", days = emptyList())),
+            reports = emptyMap()
+        )
+        repository.seedStatusCache(cachedPage)
+
+        val firstPage = repository.fetchStatus()
+        val secondPage = repository.fetchStatus()
+
+        assertSame(cachedPage, firstPage)
+        assertSame(cachedPage, secondPage)
+        assertSame(cachedPage, repository.getCachedStatus())
+        assertEquals(0, remoteSource.catalogRequests)
+        assertEquals(0, remoteSource.reportRequests)
+
+        repository.clearStatusCache()
+        assertNull(repository.getCachedStatus())
+        repository.fetchStatus()
+
+        assertEquals(1, remoteSource.catalogRequests)
+        assertEquals(1, remoteSource.reportRequests)
+    }
+
+    @Test
+    fun forceRefreshBypassesCachedPage() = runTest {
+        val remoteSource = FakeAmSatRemoteSource()
+        val repository = AmSatRepository(remoteSource)
+        repository.seedStatusCache(
+            SatStatusPage(
+                fetchedAtUtcMs = 123L,
+                statuses = listOf(SatStatus(name = "AO-7", days = emptyList())),
+                reports = emptyMap()
+            )
+        )
+
+        repository.fetchStatus(forceRefresh = true)
+
+        assertEquals(1, remoteSource.catalogRequests)
+        assertEquals(1, remoteSource.reportRequests)
+    }
+
+    @Test
+    fun fetchStatusSharesStartupPrefetchRequest() = runTest {
+        val remoteSource = FakeAmSatRemoteSource(responseDelayMillis = 50)
+        val repository = AmSatRepository(remoteSource)
+
+        val prefetch = async { repository.prefetchStatus() }
+        val pageFetch = async { repository.fetchStatus() }
+        prefetch.await()
+        val page = pageFetch.await()
+
+        assertSame(page, repository.getCachedStatus())
+        assertEquals(1, remoteSource.catalogRequests)
+        assertEquals(1, remoteSource.reportRequests)
+    }
+
+    @Test
+    fun buildStatusesStreakCountsConsecutiveSameStatusReportsPerDay() = runTest {
+        val nowSec = System.currentTimeMillis() / 1000
+        val remoteSource = FakeAmSatRemoteSource(
+            reportsJson = amSatReportsJson(
+                // 当天(day 0)最新槽(slot 0)混合状态:最新 Heard、次新 Heard、再旧 Not Heard → 连续=2
+                report("r1", "AO-7", "Heard", nowSec - 3600),
+                report("r2", "AO-7", "Heard", nowSec - 5400),
+                report("r3", "AO-7", "Not Heard", nowSec - 7000),
+                // 空时段(无报告)不打断:slot 8 的 Heard 更旧,不应计入(被 r3 打断)
+                report("r4", "AO-7", "Heard", nowSec - 63000),
+                // 前一天(day 1):最新 Heard,更旧的 Not Heard → 连续=1,且不跨天合并
+                report("r5", "AO-7", "Heard", nowSec - 90000),
+                report("r6", "AO-7", "Not Heard", nowSec - 100000)
+                // day 2 无报告 → 0
+            )
+        )
+        val repository = AmSatRepository(remoteSource)
+
+        val page = repository.fetchStatus()
+        val status = page?.statuses?.single()
+        assertEquals("AO-7", status?.name)
+        assertEquals(3, status?.days?.size)
+
+        assertEquals(2, status?.days?.get(0)?.streakCount)
+        assertEquals(1, status?.days?.get(1)?.streakCount)
+        assertEquals(0, status?.days?.get(2)?.streakCount)
+    }
+
+    @Test
+    fun buildStatusesStreakCountsAllReportsWhenStatusNeverChanges() = runTest {
+        val nowSec = System.currentTimeMillis() / 1000
+        val remoteSource = FakeAmSatRemoteSource(
+            reportsJson = amSatReportsJson(
+                report("r1", "AO-7", "Heard", nowSec - 1800),
+                report("r2", "AO-7", "Heard", nowSec - 3600),
+                report("r3", "AO-7", "Heard", nowSec - 5400),
+                report("r4", "AO-7", "Heard", nowSec - 30000)
+            )
+        )
+        val repository = AmSatRepository(remoteSource)
+
+        val page = repository.fetchStatus()
+        assertEquals(4, page?.statuses?.single()?.days?.get(0)?.streakCount)
+    }
+}
+
+private fun AmSatRepository.seedStatusCache(page: SatStatusPage) {
+    val cacheField = AmSatRepository::class.java.getDeclaredField("statusCache")
+    cacheField.isAccessible = true
+    cacheField.set(this, page)
+}
+
+private class FakeAmSatRemoteSource(
+    private val responseDelayMillis: Long = 0L,
+    private val reportsJson: String = """{"data":[]}"""
+) : IRemoteSource {
+    var catalogRequests = 0
+    var reportRequests = 0
+
+    override suspend fun getFileStream(uri: String): InputStream? = null
+
+    override suspend fun getNetworkStream(url: String): NetworkResult = NetworkResult(404, null)
+
+    override suspend fun getAmSatCatalog(): String? {
+        if (responseDelayMillis > 0L) delay(responseDelayMillis)
+        catalogRequests += 1
+        return """{"data":[{"name":"AO-7"}]}"""
+    }
+
+    override suspend fun getAmSatReports(hours: Int, limit: Int): String? {
+        if (responseDelayMillis > 0L) delay(responseDelayMillis)
+        reportRequests += 1
+        return reportsJson
+    }
+
+    override suspend fun submitAmSatReport(payloadJson: String): Pair<Int, String>? = null
+}
+
+private fun amSatReportsJson(vararg reports: String): String =
+    """{"data":[${reports.joinToString(",")}]}"""
+
+private fun report(id: String, name: String, status: String, epochSec: Long): String =
+    """{"id":"$id","name":"$name","callsign":"BA7OPF","report":"$status","grid_square":"OL62","reported_time":"${isoUtc(epochSec)}"}"""
+
+private fun isoUtc(epochSec: Long): String =
+    SimpleDateFormat("yyyy-MM-dd'T'HH:mm:ss'Z'", Locale.US).apply {
+        timeZone = TimeZone.getTimeZone("UTC")
+    }.format(Date(epochSec * 1000))
@@ -0,0 +1,322 @@
+/*
+ * Look4Sat. Amateur radio satellite tracker and pass predictor.
+ * Copyright (C) 2019-2026 Arty Bishop and contributors.
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <https://www.gnu.org/licenses/>.
+ */
+package com.rtbishop.look4sat.core.data.repository
+
+import com.rtbishop.look4sat.core.domain.model.DataSourcesSettings
+import com.rtbishop.look4sat.core.domain.model.DatabaseState
+import com.rtbishop.look4sat.core.domain.model.GridQso
+import com.rtbishop.look4sat.core.domain.model.OtherSettings
+import com.rtbishop.look4sat.core.domain.model.PassesSettings
+import com.rtbishop.look4sat.core.domain.model.RCSettings
+import com.rtbishop.look4sat.core.domain.model.RadioControlSettings
+import com.rtbishop.look4sat.core.domain.model.SatItem
+import com.rtbishop.look4sat.core.domain.model.SatRadio
+import com.rtbishop.look4sat.core.domain.predict.GeoPos
+import com.rtbishop.look4sat.core.domain.predict.OrbitalData
+import com.rtbishop.look4sat.core.domain.predict.OrbitalObject
+import com.rtbishop.look4sat.core.domain.repository.ISettingsRepo
+import com.rtbishop.look4sat.core.domain.source.ILocalSource
+import com.rtbishop.look4sat.core.domain.source.IRemoteSource
+import com.rtbishop.look4sat.core.domain.source.NetworkResult
+import com.rtbishop.look4sat.core.domain.source.Sources
+import com.rtbishop.look4sat.core.domain.utility.DataParser
+import kotlinx.coroutines.ExperimentalCoroutinesApi
+import kotlinx.coroutines.flow.MutableStateFlow
+import kotlinx.coroutines.flow.StateFlow
+import kotlinx.coroutines.test.StandardTestDispatcher
+import kotlinx.coroutines.test.runTest
+import org.junit.Assert.assertEquals
+import org.junit.Assert.assertTrue
+import org.junit.Test
+import java.io.InputStream
+
+@OptIn(ExperimentalCoroutinesApi::class)
+class DatabaseRepoTest {
+
+    private val dispatcher = StandardTestDispatcher()
+    private val dataParser = DataParser(dispatcher)
+
+    @Test
+    fun `manual satellite import parses csv stream from content uri`() = runTest(dispatcher) {
+        val uri = "content://look4sat/import/satellites"
+        val localSource = FakeLocalSource()
+        val remoteSource = FakeRemoteSource().apply {
+            fileStreams[uri] = { validCsvStream() }
+        }
+        val settingsRepo = FakeSettingsRepo()
+        val repository = DatabaseRepo(dispatcher, dataParser, localSource, remoteSource, settingsRepo)
+
+        repository.updateTLEFromFile(uri)
+
+        assertEquals(1, localSource.insertedEntries.size)
+        assertEquals(25544, localSource.insertedEntries.first().catnum)
+        assertEquals(listOf(25544), settingsRepo.satelliteTypeIdsByType["Other"])
+        assertTrue(settingsRepo.databaseState.value.numberOfSatellites > 0)
+    }
+
+    @Test
+    fun `manual satellite import keeps tle support`() = runTest(dispatcher) {
+        val uri = "content://look4sat/import/legacy"
+        val localSource = FakeLocalSource()
+        val remoteSource = FakeRemoteSource().apply {
+            fileStreams[uri] = { validTleStream() }
+        }
+        val settingsRepo = FakeSettingsRepo()
+        val repository = DatabaseRepo(dispatcher, dataParser, localSource, remoteSource, settingsRepo)
+
+        repository.updateTLEFromFile(uri)
+
+        assertEquals(1, localSource.insertedEntries.size)
+        assertEquals(25544, localSource.insertedEntries.first().catnum)
+    }
+
+    @Test
+    fun `custom data source imports omm csv from web`() = runTest(dispatcher) {
+        val customCsvUrl = "https://example.com/custom-omm.csv"
+        val localSource = FakeLocalSource()
+        val remoteSource = FakeRemoteSource().apply {
+            networkStreams[customCsvUrl] = { validCsvStream() }
+        }
+        val settingsRepo = FakeSettingsRepo(
+            dataSources = DataSourcesSettings(
+                satelliteUrls = listOf(customCsvUrl),
+                transceiversUrls = emptyList()
+            )
+        )
+        val repository = DatabaseRepo(dispatcher, dataParser, localSource, remoteSource, settingsRepo)
+
+        repository.updateFromRemote()
+
+        assertTrue(localSource.insertedEntries.any { it.catnum == 25544 })
+        assertEquals(listOf(25544), settingsRepo.satelliteTypeIdsByType["Other"])
+    }
+
+    @Test
+    fun `remote update imports satellites from real SatNOGS TLE source`() = runTest(dispatcher) {
+        val satnogsUrl = Sources.satelliteDataUrls.getValue("SatNOGS")
+        val localSource = FakeLocalSource()
+        val remoteSource = FakeRemoteSource().apply {
+            networkStreams[satnogsUrl] = { jamxTleStream() }
+        }
+        val settingsRepo = FakeSettingsRepo(
+            dataSources = DataSourcesSettings(
+                satelliteUrls = listOf(satnogsUrl),
+                transceiversUrls = emptyList()
+            )
+        )
+        val repository = DatabaseRepo(dispatcher, dataParser, localSource, remoteSource, settingsRepo)
+
+        repository.updateFromRemote()
+
+        assertTrue(localSource.insertedEntries.any { it.name == "JAMX-0825b" && it.catnum == 98248 })
+        assertEquals(listOf(98248), settingsRepo.satelliteTypeIdsByType["SatNOGS"])
+    }
+
+    private fun validCsvStream(): InputStream = """
+        OBJECT_NAME,OBJECT_ID,EPOCH,MEAN_MOTION,ECCENTRICITY,INCLINATION,RA_OF_ASC_NODE,ARG_OF_PERICENTER,MEAN_ANOMALY,EPHEMERIS_TYPE,CLASSIFICATION_TYPE,NORAD_CAT_ID,ELEMENT_SET_NO,REV_AT_EPOCH,BSTAR,MEAN_MOTION_DOT,MEAN_MOTION_DDOT
+        ISS (ZARYA),1998-067A,2021-11-16T12:28:09.322176,15.48582035,.0004694,51.6447,309.4881,203.6966,299.8876,0,U,25544,999,31220,.31985E-4,.1288E-4,0
+    """.trimIndent().byteInputStream()
+
+    private fun validTleStream(): InputStream = """
+        ISS (ZARYA)
+        1 25544U 98067A   21320.51955234  .00001288  00000+0  31985-4 0  9990
+        2 25544  51.6447 309.4881 0004694 203.6966 299.8876 15.48582035312205
+    """.trimIndent().byteInputStream()
+
+    private fun jamxTleStream(): InputStream = """
+        JAMX-0825b
+        1 98248U          26237.16675926  .00015724  00000-0  97477-3 0 00013
+        2 98248 097.5373 310.9694 0011309 278.1232 340.7230 15.09766181000012
+    """.trimIndent().byteInputStream()
+}
+
+private class FakeRemoteSource : IRemoteSource {
+    val fileStreams: MutableMap<String, () -> InputStream> = mutableMapOf()
+    val networkStreams: MutableMap<String, () -> InputStream> = mutableMapOf()
+
+    override suspend fun getFileStream(uri: String): InputStream? = fileStreams[uri]?.invoke()
+
+    override suspend fun getNetworkStream(url: String): NetworkResult =
+        networkStreams[url]?.let { NetworkResult(200, it()) } ?: NetworkResult(404, null)
+
+    override suspend fun getAmSatCatalog(): String? = null
+
+    override suspend fun getAmSatReports(hours: Int, limit: Int): String? = null
+
+    override suspend fun submitAmSatReport(payloadJson: String): Pair<Int, String>? = null
+}
+
+private class FakeLocalSource : ILocalSource {
+    val insertedEntries = mutableListOf<OrbitalData>()
+    private val insertedRadios = mutableListOf<SatRadio>()
+
+    override suspend fun getEntriesTotal(): Int = insertedEntries.size
+
+    override suspend fun getEntriesList(): List<SatItem> = emptyList()
+
+    override suspend fun getEntriesWithIds(ids: List<Int>): List<OrbitalObject> = emptyList()
+
+    override suspend fun insertEntries(entries: List<OrbitalData>) {
+        insertedEntries += entries
+    }
+
+    override suspend fun deleteEntries() {
+        insertedEntries.clear()
+    }
+
+    override suspend fun getIdsWithModes(modes: List<String>): List<Int> = emptyList()
+
+    override suspend fun getRadiosTotal(): Int = insertedRadios.size
+
+    override suspend fun getRadiosWithId(id: Int): List<SatRadio> = emptyList()
+
+    override suspend fun insertRadios(radios: List<SatRadio>, isCustom: Boolean) {
+        insertedRadios += radios.map { it.copy(isCustom = isCustom) }
+    }
+
+    override suspend fun deleteManagedRadios() {
+        insertedRadios.removeAll { !it.isCustom }
+    }
+
+    override suspend fun deleteRadios() {
+        insertedRadios.clear()
+    }
+}
+
+private class FakeSettingsRepo(dataSources: DataSourcesSettings = defaultDataSourcesSettings()) : ISettingsRepo {
+
+    override val appVersionName: String = "test"
+
+    override val selectedIds: StateFlow<List<Int>> = MutableStateFlow(emptyList())
+
+    override val selectedTypes: StateFlow<List<String>> = MutableStateFlow(emptyList())
+
+    override val passesSettings: StateFlow<PassesSettings> = MutableStateFlow(
+        PassesSettings(hoursAhead = 24, minElevation = 0.0, selectedModes = emptyList())
+    )
+
+    override val stationPosition: StateFlow<GeoPos> = MutableStateFlow(GeoPos(0.0, 0.0))
+
+    override val databaseState: MutableStateFlow<DatabaseState> = MutableStateFlow(DatabaseState(0, 0, 0L))
+
+    override val rcSettings: StateFlow<RCSettings> = MutableStateFlow(
+        RCSettings(false, "", "", "", false, "", "", "", 0L, false, "", "", "", false, "", "")
+    )
+
+    override val otherSettings: StateFlow<OtherSettings> = MutableStateFlow(
+        OtherSettings(
+            false, false, false, false, false, false, false,
+            shouldSeeWarning = false, shouldSeeWhatsNew = false
+        )
+    )
+
+    override val dataSourcesSettings: MutableStateFlow<DataSourcesSettings> = MutableStateFlow(dataSources)
+
+    override val radioControlSettings: StateFlow<RadioControlSettings> = MutableStateFlow(
+        RadioControlSettings(false, RadioControlSettings.MODEL_YAESU_FT817, "", "", "", "", 9600)
+    )
+
+    val satelliteTypeIdsByType = mutableMapOf<String, List<Int>>()
+
+    override fun setSelectedIds(ids: List<Int>) = Unit
+
+    override fun setSelectedTypes(types: List<String>) = Unit
+
+    override fun setPassesSettings(settings: PassesSettings) = Unit
+
+    override fun setStationPosition(latitude: Double, longitude: Double, altitude: Double): Boolean = true
+
+    override fun setStationPosition(): Boolean = true
+
+    override fun setStationPosition(locator: String): Boolean = true
+
+    override fun getSatelliteTypesIds(types: List<String>): List<Int> = emptyList()
+
+    override fun setSatelliteTypeIds(type: String, ids: List<Int>) {
+        satelliteTypeIdsByType[type] = ids
+    }
+
+    override fun updateDatabaseState(state: DatabaseState) {
+        databaseState.value = state
+    }
+
+    override fun updateRCSettings(settings: RCSettings) = Unit
+
+    override fun updateOtherSettings(transform: (OtherSettings) -> OtherSettings) = Unit
+
+    override fun updateDataSourcesSettings(settings: DataSourcesSettings) {
+        dataSourcesSettings.value = settings
+    }
+
+    override val dataSourcesStatus: StateFlow<Map<String, Int>> = MutableStateFlow(emptyMap())
+
+    override fun updateDataSourcesStatus(status: Map<String, Int>) {
+        (dataSourcesStatus as? MutableStateFlow)?.value = status
+    }
+
+    override fun updateRadioControlSettings(settings: RadioControlSettings) = Unit
+
+    override fun getSatelliteOffset(catnum: Int): String = ""
+
+    override fun setSatelliteOffset(catnum: Int, offset: String) = Unit
+
+    override fun getAmSatCallsign(): String = ""
+
+    override fun setAmSatCallsign(callsign: String) = Unit
+
+    override val wavelogSettings: StateFlow<com.rtbishop.look4sat.core.domain.model.WavelogSettings> =
+        MutableStateFlow(com.rtbishop.look4sat.core.domain.model.WavelogSettings())
+
+    override fun updateWavelogSettings(settings: com.rtbishop.look4sat.core.domain.model.WavelogSettings) = Unit
+
+    override fun getWorkedGrids(): Set<String> = emptySet()
+
+    private val workedGrids = MutableStateFlow(emptySet<String>())
+
+    override fun setWorkedGrids(grids: Set<String>) {
+        workedGrids.value = grids
+    }
+
+    override val lotwSettings: StateFlow<com.rtbishop.look4sat.core.domain.model.LoTWSettings> =
+        MutableStateFlow(com.rtbishop.look4sat.core.domain.model.LoTWSettings())
+
+    override fun updateLoTWSettings(settings: com.rtbishop.look4sat.core.domain.model.LoTWSettings) = Unit
+    override fun getLastLotwSyncDate(): String = ""
+    override fun setLastLotwSyncDate(date: String) = Unit
+    override fun getLastLotwSyncCallsign(): String = ""
+    override fun setLastLotwSyncCallsign(callsign: String) = Unit
+
+    override fun getWorkedGridQsos(): Map<String, List<com.rtbishop.look4sat.core.domain.model.GridQso>> = emptyMap()
+
+    override fun setWorkedGridQsos(qsos: Map<String, List<com.rtbishop.look4sat.core.domain.model.GridQso>>) = Unit
+
+    override fun getRoamedGrids(): Set<String> = emptySet()
+
+    private val roamedGrids = MutableStateFlow(emptySet<String>())
+
+    override fun setRoamedGrids(grids: Set<String>) {
+        roamedGrids.value = grids
+    }
+}
+
+private fun defaultDataSourcesSettings(): DataSourcesSettings {
+    return DataSourcesSettings(
+        satelliteUrls = emptyList(),
+        transceiversUrls = emptyList()
+    )
+}
@@ -0,0 +1,312 @@
+package com.rtbishop.look4sat.core.data.repository
+
+import com.rtbishop.look4sat.core.domain.repository.LoTWResult
+import org.junit.Assert.assertEquals
+import org.junit.Assert.assertNull
+import org.junit.Assert.assertTrue
+import org.junit.Test
+
+class LoTWRepositoryTest {
+
+    private val repo = LoTWRepository()
+
+    private fun report(vararg records: String): String =
+        buildString {
+            append("<ADIF_VERS:5>3.1.4\n")
+            append("<PROGRAMID:8>look4sat\n")
+            append("<eoh>\n")
+            records.forEach { append(it).append("\n") }
+        }
+
+    @Test
+    fun parseRejectsBodyWithoutEoh() {
+        assertNull(repo.parseConfirmedGrids("<HTML>Username/password incorrect</HTML>"))
+    }
+
+    @Test
+    fun parseCollectsOnlySatelliteGrids() {
+        // Satellite QSO: PROP_MODE SAT, confirmed, opponent grid.
+        val satQso = "<CALL:6>BA7OPF\n" +
+            "<QSO_DATE:8>20260820\n" +
+            "<PROP_MODE:3>SAT\n" +
+            "<SAT_NAME:5>FO-29\n" +
+            "<GRIDSQUARE:4>NL47\n" +
+            "<EOR>\n"
+        // Ground QSO: same grid but no PROP_MODE -> must be excluded.
+        val groundQso = "<CALL:6>BA7OPF\n" +
+            "<QSO_DATE:8>20260821\n" +
+            "<GRIDSQUARE:4>NL47\n" +
+            "<EOR>\n"
+        val result = repo.parseConfirmedGrids(report(satQso, groundQso))
+        assertEquals(setOf("NL47"), result)
+    }
+
+    @Test
+    fun parseSupportsVuccGridPairsAndSixCharGrids() {
+        val satQso = "<PROP_MODE:3>SAT\n" +
+            "<SAT_NAME:5>SO-50\n" +
+            "<GRIDSQUARE:6>OM60IL\n" +
+            "<VUCC_GRIDS:11>EN52en,EN53fa\n" +
+            "<EOR>\n"
+        val result = repo.parseConfirmedGrids(report(satQso))
+        assertEquals(setOf("OM60", "EN52", "EN53"), result)
+    }
+
+    @Test
+    fun parsePropModeDoesNotLeakAcrossRecords() {
+        // PROP_MODE SAT record first, then a ground QSO with a grid — the second
+        // record must not inherit the satellite flag after its own <EOR>.
+        val satQso = "<PROP_MODE:3>SAT\n<GRIDSQUARE:4>OL62\n<EOR>\n"
+        val groundQso = "<GRIDSQUARE:4>PM00\n<EOR>\n"
+        val result = repo.parseConfirmedGrids(report(satQso, groundQso))
+        assertEquals(setOf("OL62"), result)
+    }
+
+    @Test
+    fun parseHandlesAlphabeticalFieldOrder() {
+        // Real lotwreport.adi emits fields in ALPHABETICAL order: GRIDSQUARE (G)
+        // and VUCC_GRIDS come BEFORE PROP_MODE (P) inside each record. The old
+        // sequential gate (add only while propMode == SAT) dropped every grid on
+        // real reports — the buffered parser must collect them regardless of
+        // field order and filter at <EOR>.
+        val satQso = "<CALL:6>BA7OPF\n" +
+            "<GRIDSQUARE:4>NL47\n" +
+            "<MODE:3>FM\n" +
+            "<PROP_MODE:3>SAT\n" +
+            "<SAT_NAME:5>FO-29\n" +
+            "<VUCC_GRIDS:11>EN52en,EN53fa\n" +
+            "<EOR>\n"
+        val groundQso = "<CALL:6>BA7OPF\n" +
+            "<GRIDSQUARE:4>PM95\n" +
+            "<QSO_DATE:8>20260821\n" +
+            "<EOR>\n"
+        val result = repo.parseConfirmedGrids(report(satQso, groundQso))
+        assertEquals(setOf("NL47", "EN52", "EN53"), result)
+    }
+
+    @Test
+    fun parseReturnsEmptySetForReportWithoutGrids() {
+        val satQso = "<PROP_MODE:3>SAT\n<SAT_NAME:5>AO-07\n<EOR>\n"
+        assertEquals(emptySet<String>(), repo.parseConfirmedGrids(report(satQso)))
+    }
+
+    // region parseConfirmedGridQsos
+
+    private val satQsoFull = "<CALL:5>A50QO\n" +
+        "<QSO_DATE:8>20260820\n" +
+        "<TIME_ON:6>113045\n" +
+        "<PROP_MODE:3>SAT\n" +
+        "<SAT_NAME:5>FO-29\n" +
+        "<MODE:2>CW\n" +
+        "<BAND:3>70CM\n" +
+        "<BAND_RX:3>2M\n" +
+        "<GRIDSQUARE:4>NL47\n" +
+        "<EOR>\n"
+
+    @Test
+    fun parseQsosExtractsSatelliteDetail() {
+        val result = repo.parseConfirmedGridQsos(report(satQsoFull))!!
+        val qsos = result["NL47"]!!
+        assertEquals(1, qsos.size)
+        val qso = qsos[0]
+        assertEquals("A50QO", qso.call)
+        assertEquals("FO-29", qso.satName)
+        assertEquals("CW", qso.mode)
+        assertEquals("2M", qso.bandUp)
+        assertEquals("70CM", qso.bandDown)
+        assertEquals("V/U", qso.bandLabel)
+        assertEquals(2026, java.time.Instant.ofEpochMilli(qso.epochMs).atZone(java.time.ZoneOffset.UTC).year)
+    }
+
+    @Test
+    fun parseQsosExcludesGroundQsos() {
+        val groundQso = "<CALL:6>BA7OPF\n<QSO_DATE:8>20260821\n<GRIDSQUARE:4>NL47\n<EOR>\n"
+        val result = repo.parseConfirmedGridQsos(report(satQsoFull, groundQso))!!
+        assertEquals(1, result["NL47"]!!.size)
+    }
+
+    @Test
+    fun parseQsosVuccPairFeedsBothGrids() {
+        val qso = "<PROP_MODE:3>SAT\n<SAT_NAME:5>SO-50\n" +
+            "<QSO_DATE:8>20260819\n<TIME_ON:4>1231\n" +
+            "<VUCC_GRIDS:11>EN52en,EN53fa\n<EOR>\n"
+        val result = repo.parseConfirmedGridQsos(report(qso))!!
+        assertEquals(setOf("EN52", "EN53"), result.keys)
+        assertEquals(result["EN52"]!!.first(), result["EN53"]!!.first())
+    }
+
+    @Test
+    fun parseQsosVuccQuadrupleFeedsAllFourGrids() {
+        // VUCC allows up to four grids in one contact.
+        val qso = "<PROP_MODE:3>SAT\n<SAT_NAME:5>SO-50\n" +
+            "<QSO_DATE:8>20260819\n<TIME_ON:4>1231\n" +
+            "<VUCC_GRIDS:23>EN52en,EN53fa,EN42gj,EN43kh\n<EOR>\n"
+        val result = repo.parseConfirmedGridQsos(report(qso))!!
+        assertEquals(setOf("EN52", "EN53", "EN42", "EN43"), result.keys)
+        result.values.forEach { assertEquals(1, it.size) }
+    }
+
+    @Test
+    fun parseQsosRejectsBodyWithoutEoh() {
+        assertNull(repo.parseConfirmedGridQsos("<HTML>Username/password incorrect</HTML>"))
+    }
+
+    @Test
+    fun parseQsosCapturesOwnGridPerQso() {
+        // MY_GRIDSQUARE arrives BEFORE PROP_MODE (ADIF fields are emitted
+        // alphabetically); the per-record buffer must still attach it to the QSO.
+        val qso1 = "<CALL:5>A50QO\n<QSO_DATE:8>20260820\n<MY_GRIDSQUARE:4>OL62\n" +
+            "<PROP_MODE:3>SAT\n<SAT_NAME:5>FO-29\n<MODE:2>CW\n" +
+            "<BAND:3>70CM\n<BAND_RX:3>2M\n<GRIDSQUARE:4>NL47\n<EOR>\n"
+        val qso2 = "<CALL:6>BG7ZFK\n<QSO_DATE:8>20260819\n<MY_GRIDSQUARE:4>OL72\n" +
+            "<PROP_MODE:3>SAT\n<SAT_NAME:5>SO-50\n<MODE:3>FM\n" +
+            "<BAND:3>70CM\n<BAND_RX:3>2M\n<GRIDSQUARE:4>OK48\n<EOR>\n"
+        val result = repo.parseConfirmedGridQsos(report(qso1, qso2))!!
+        assertEquals("OL62", result["NL47"]!!.first().myGrid)
+        assertEquals("OL72", result["OK48"]!!.first().myGrid)
+        // Ground QSO (no PROP_MODE=SAT) must not leak its MY_GRIDSQUARE.
+        val ground = "<CALL:6>BA7OPF\n<QSO_DATE:8>20260821\n<MY_GRIDSQUARE:4>OL62\n<GRIDSQUARE:4>NL47\n<EOR>\n"
+        assertTrue(repo.parseConfirmedGridQsos(report(qso1, ground))!!.values.all { it.all { q -> q.myGrid == "OL62" } })
+    }
+
+    // endregion
+
+    // region parseRoamedGrids (MY_GRIDSQUARE = grids the account operated from)
+
+    @Test
+    fun parseRoamedGridsCollectsOwnStationGrids() {
+        // Satellite QSOs carry MY_GRIDSQUARE = the grid the account itself
+        // operated from (the "roamed/activated" set shown as blue stripes).
+        val qso1 = "<CALL:6>BA7OPF\n<QSO_DATE:8>20260820\n<PROP_MODE:3>SAT\n<SAT_NAME:5>IO-86\n" +
+            "<MY_GRIDSQUARE:4>OL62\n<GRIDSQUARE:4>PM95\n<EOR>\n"
+        val qso2 = "<CALL:6>BA7OPF\n<QSO_DATE:8>20260901\n<PROP_MODE:3>SAT\n<SAT_NAME:5>IO-86\n" +
+            "<MY_GRIDSQUARE:4>OL72\n<GRIDSQUARE:4>NL47\n<EOR>\n"
+        assertEquals(setOf("OL62", "OL72"), repo.parseRoamedGrids(report(qso1, qso2)))
+    }
+
+    @Test
+    fun parseRoamedGridsIgnoresGroundQsos() {
+        val ground = "<CALL:6>BA7OPF\n<QSO_DATE:8>20260821\n<MY_GRIDSQUARE:4>OL72\n<EOR>\n"
+        assertEquals(emptySet<String>(), repo.parseRoamedGrids(report(ground)))
+    }
+
+    @Test
+    fun parseRoamedGridsDoesNotConfuseGridsquareWithMyGridsquare() {
+        // GRIDSQUARE (opposite station's grid) must never leak into the roamed set.
+        val qso = "<PROP_MODE:3>SAT\n<SAT_NAME:5>SO-50\n<MY_GRIDSQUARE:4>OL62\n" +
+            "<GRIDSQUARE:6>OM60IL\n<EOR>\n"
+        assertEquals(setOf("OL62"), repo.parseRoamedGrids(report(qso)))
+    }
+
+    @Test
+    fun parseRoamedGridsTruncatesSixCharToFour() {
+        val qso = "<PROP_MODE:3>SAT\n<SAT_NAME:5>IO-86\n<MY_GRIDSQUARE:6>OL62AA\n<EOR>\n"
+        assertEquals(setOf("OL62"), repo.parseRoamedGrids(report(qso)))
+    }
+
+    @Test
+    fun parseRoamedGridsHandlesAlphabeticalFieldOrder() {
+        // Real lotwreport.adi emits fields alphabetically, so <MY_GRIDSQUARE>
+        // (M) arrives BEFORE <PROP_MODE> (P). The old sequential gate (add only
+        // while propMode == SAT) silently returned an EMPTY set on real reports —
+        // this is the exact bug that made the blue roamed stripes never appear.
+        val qso = "<CALL:6>BA7OPF\n" +
+            "<GRIDSQUARE:4>PM95\n" +
+            "<MY_GRIDSQUARE:6>OL72XX\n" +
+            "<PROP_MODE:3>SAT\n" +
+            "<SAT_NAME:5>IO-86\n" +
+            "<EOR>\n"
+        assertEquals(setOf("OL72"), repo.parseRoamedGrids(report(qso)))
+    }
+
+    @Test
+    fun parseRoamedGridsRejectsBodyWithoutEoh() {
+        assertNull(repo.parseRoamedGrids("<HTML>Username/password incorrect</HTML>"))
+    }
+
+    // endregion
+
+    // region failure classification (fetchReportBody -> LoTWResult mapping)
+
+    @Test
+    fun failureClassificationMapsEachException() {
+        // LoTWRepository.toResult() must keep each failure cause distinct so
+        // the UI can show a specific message per cause.
+        assertEquals(
+            LoTWResult.BadCredentials,
+            repo.toResult(LoTWRepository.CredentialsException())
+        )
+        assertEquals(
+            LoTWResult.RateLimited,
+            repo.toResult(LoTWRepository.RateLimitException())
+        )
+        assertEquals(
+            LoTWResult.Timeout,
+            repo.toResult(LoTWRepository.TimeoutException("read timed out"))
+        )
+        val net = repo.toResult(java.io.IOException("HTTP 500"))
+        assertEquals(LoTWResult.NetworkError("HTTP 500"), net)
+    }
+
+
+    @Test
+    fun parseQsosExtractsAwardFields() {
+        // Award statistics rely on the DXCC/CQZ/STATE fields coming straight
+        // from LoTW's qso_qsldetail report (STATE depends on DXCC). LoTW
+        // writes STATE as "CODE // NAME" (verified with a real report 2026-09);
+        // the parser must strip the name suffix and keep the bare code.
+        val qso = "<CALL:5>BG7XYZ\n" +
+            "<QSO_DATE:8>20260820\n<TIME_ON:4>1130\n" +
+            "<PROP_MODE:3>SAT\n<SAT_NAME:5>FO-29\n<MODE:2>CW\n" +
+            "<DXCC:3>318\n<COUNTRY:5>CHINA\n<CQZ:2>24\n<STATE:13>GD // Guangdong\n" +
+            "<GRIDSQUARE:4>OL62\n<EOR>\n"
+        val result = repo.parseConfirmedGridQsos(report(qso))!!
+        val parsed = result["OL62"]!!.first()
+        assertEquals(318, parsed.dxcc)
+        assertEquals("CHINA", parsed.country)
+        assertEquals(24, parsed.cqz)
+        assertEquals("GD", parsed.state)
+    }
+
+    @Test
+    fun parseQsosStripsStateNameSuffixForAllEntities() {
+        // Japan prefecture: "34 // Tottori-ken" -> "34" (WAJA matching needs
+        // the 2-digit code). US states also arrive as "CODE // Name".
+        val jp = "<CALL:5>JH0ABC\n<QSO_DATE:8>20260820\n<TIME_ON:4>1130\n" +
+            "<PROP_MODE:3>SAT\n<SAT_NAME:5>RS-44\n<DXCC:3>339\n<COUNTRY:7>JAPAN\n" +
+            "<STATE:18>34 // Tottori-ken\n<GRIDSQUARE:4>PM95\n<EOR>\n"
+        val us = "<CALL:5>K1ABC\n<QSO_DATE:8>20260820\n<TIME_ON:4>1130\n" +
+            "<PROP_MODE:3>SAT\n<SAT_NAME:5>AO-07\n<DXCC:3>291\n<COUNTRY:12>UNITED STATES\n" +
+            "<STATE:22>CA // California\n<GRIDSQUARE:4>EM40\n<EOR>\n"
+        val result = repo.parseConfirmedGridQsos(report(jp, us))!!
+        assertEquals("34", result["PM95"]!!.first().state)
+        assertEquals("CA", result["EM40"]!!.first().state)
+    }
+
+    @Test
+    fun parseQsosLeavesAwardFieldsNullWhenAbsent() {
+        val qso = "<CALL:5>JH0ABC\n<QSO_DATE:8>20260820\n<TIME_ON:4>1130\n" +
+            "<PROP_MODE:3>SAT\n<SAT_NAME:5>RS-44\n<GRIDSQUARE:4>PM95\n<EOR>\n"
+        val result = repo.parseConfirmedGridQsos(report(qso))!!
+        val parsed = result["PM95"]!!.first()
+        assertNull(parsed.dxcc)
+        assertNull(parsed.country)
+        assertNull(parsed.cqz)
+        assertNull(parsed.state)
+    }
+
+    @Test
+    fun parseQsosAwardFieldsDoNotLeakAcrossRecords() {
+        val withFields = "<CALL:5>BG7AAA\n<QSO_DATE:8>20260820\n<TIME_ON:4>1130\n" +
+            "<PROP_MODE:3>SAT\n<SAT_NAME:5>FO-29\n<DXCC:3>318\n<CQZ:2>24\n<STATE:2>GD\n" +
+            "<GRIDSQUARE:4>OL62\n<EOR>\n"
+        val withoutFields = "<CALL:5>JH0BBB\n<QSO_DATE:8>20260821\n<TIME_ON:4>1130\n" +
+            "<PROP_MODE:3>SAT\n<SAT_NAME:5>RS-44\n<GRIDSQUARE:4>PM95\n<EOR>\n"
+        val result = repo.parseConfirmedGridQsos(report(withFields, withoutFields))!!
+        assertNull(result["PM95"]!!.first().dxcc)
+        assertNull(result["PM95"]!!.first().cqz)
+        assertNull(result["PM95"]!!.first().state)
+    }
+
+    // endregion
+}
@@ -0,0 +1,197 @@
+/*
+ * Look4Sat. Amateur radio satellite tracker and pass predictor.
+ * Copyright (C) 2019-2026 Arty Bishop and contributors.
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ */
+package com.rtbishop.look4sat.core.data.repository
+
+import com.rtbishop.look4sat.core.domain.model.DataSourcesSettings
+import com.rtbishop.look4sat.core.domain.model.DatabaseState
+import com.rtbishop.look4sat.core.domain.model.OtherSettings
+import com.rtbishop.look4sat.core.domain.model.PassesSettings
+import com.rtbishop.look4sat.core.domain.model.RCSettings
+import com.rtbishop.look4sat.core.domain.model.RadioControlSettings
+import com.rtbishop.look4sat.core.domain.model.SatItem
+import com.rtbishop.look4sat.core.domain.model.SatRadio
+import com.rtbishop.look4sat.core.domain.predict.GeoPos
+import com.rtbishop.look4sat.core.domain.predict.OrbitalData
+import com.rtbishop.look4sat.core.domain.predict.OrbitalObject
+import com.rtbishop.look4sat.core.domain.repository.ISelectionRepo
+import com.rtbishop.look4sat.core.domain.repository.ISettingsRepo
+import com.rtbishop.look4sat.core.domain.source.ILocalSource
+import kotlinx.coroutines.Dispatchers
+import kotlinx.coroutines.ExperimentalCoroutinesApi
+import kotlinx.coroutines.flow.MutableStateFlow
+import kotlinx.coroutines.flow.StateFlow
+import kotlinx.coroutines.flow.first
+import kotlinx.coroutines.test.runTest
+import org.junit.Assert.assertEquals
+import org.junit.Assert.assertTrue
+import org.junit.Test
+
+@OptIn(ExperimentalCoroutinesApi::class)
+class SelectionRepoSearchTest {
+
+    private val sampleItems = listOf(
+        SatItem(catnum = 25544, name = "ISS (ZARYA)"),
+        SatItem(catnum = 7530, name = "AO-7 (AMSAT-OSCAR 7)"),
+        SatItem(catnum = 39444, name = "AO-73 (FUNcube-1)"),
+        SatItem(catnum = 43803, name = "JO-97 (BIRDS-3)"),
+        SatItem(catnum = 99999, name = "FO-29"),
+    )
+
+    @Test
+    fun `query without separators matches name with dashes spaces brackets`() = runTest {
+        val repo = createRepo(sampleItems)
+        repo.setQuery("ao7")
+        val results = repo.getEntriesFlow().first()
+        // "ao7" is a substring of the normalized "AO-73 (FUNcube-1)" too, so a
+        // fuzzy search legitimately returns both AO-7 (first) and AO-73. The
+        // key guarantee is that AO-7 — which was unreachable before because of
+        // the dashes/brackets — is now found.
+        assertTrue(results.map { it.catnum }.contains(7530))
+        assertEquals(7530, results.first().catnum)
+    }
+
+    @Test
+    fun `query without separators matches name with only dashes`() = runTest {
+        val repo = createRepo(sampleItems)
+        repo.setQuery("fo29")
+        val results = repo.getEntriesFlow().first()
+        assertEquals(listOf(99999), results.map { it.catnum })
+    }
+
+    @Test
+    fun `space-separated tokens all must match in any order`() = runTest {
+        val repo = createRepo(sampleItems)
+        repo.setQuery("zarya iss")
+        val results = repo.getEntriesFlow().first()
+        assertEquals(listOf(25544), results.map { it.catnum })
+    }
+
+    @Test
+    fun `exact name query still matches`() = runTest {
+        val repo = createRepo(sampleItems)
+        repo.setQuery("AO-7 (AMSAT-OSCAR 7)")
+        val results = repo.getEntriesFlow().first()
+        assertEquals(listOf(7530), results.map { it.catnum })
+    }
+
+    @Test
+    fun `partial token query matches substring`() = runTest {
+        val repo = createRepo(sampleItems)
+        repo.setQuery("funcube")
+        val results = repo.getEntriesFlow().first()
+        assertEquals(listOf(39444), results.map { it.catnum })
+    }
+
+    @Test
+    fun `numeric query matches catnum exactly`() = runTest {
+        val repo = createRepo(sampleItems)
+        repo.setQuery("25544")
+        val results = repo.getEntriesFlow().first()
+        assertEquals(listOf(25544), results.map { it.catnum })
+    }
+
+    @Test
+    fun `no query returns all items`() = runTest {
+        val repo = createRepo(sampleItems)
+        repo.setQuery("")
+        val results = repo.getEntriesFlow().first()
+        assertEquals(sampleItems.size, results.size)
+    }
+
+    @Test
+    fun `unmatched query returns nothing`() = runTest {
+        val repo = createRepo(sampleItems)
+        repo.setQuery("zzzznomatch")
+        assertTrue(repo.getEntriesFlow().first().isEmpty())
+    }
+
+    private fun createRepo(items: List<SatItem>): ISelectionRepo {
+        return SelectionRepo(
+            dispatcher = Dispatchers.Unconfined,
+            localSource = FakeLocalSourceForSearch(items),
+            settingsRepo = FakeSettingsRepoForSearch()
+        )
+    }
+}
+
+private class FakeLocalSourceForSearch(private val items: List<SatItem>) : ILocalSource {
+    override suspend fun getEntriesTotal(): Int = items.size
+    override suspend fun getEntriesList(): List<SatItem> = items
+    override suspend fun getEntriesWithIds(ids: List<Int>): List<OrbitalObject> = emptyList()
+    override suspend fun insertEntries(entries: List<OrbitalData>) = Unit
+    override suspend fun deleteEntries() = Unit
+    override suspend fun getIdsWithModes(modes: List<String>): List<Int> = emptyList()
+    override suspend fun getRadiosTotal(): Int = 0
+    override suspend fun getRadiosWithId(id: Int): List<SatRadio> = emptyList()
+    override suspend fun insertRadios(radios: List<SatRadio>, isCustom: Boolean) = Unit
+    override suspend fun deleteManagedRadios() = Unit
+    override suspend fun deleteRadios() = Unit
+}
+
+private class FakeSettingsRepoForSearch : ISettingsRepo {
+    override val appVersionName: String = "test"
+    override val selectedIds: StateFlow<List<Int>> = MutableStateFlow(emptyList())
+    override val selectedTypes: StateFlow<List<String>> = MutableStateFlow(emptyList())
+    override val passesSettings: StateFlow<PassesSettings> = MutableStateFlow(
+        PassesSettings(hoursAhead = 24, minElevation = 0.0, selectedModes = emptyList())
+    )
+    override val stationPosition: StateFlow<GeoPos> = MutableStateFlow(GeoPos(0.0, 0.0))
+    override val databaseState: MutableStateFlow<DatabaseState> = MutableStateFlow(DatabaseState(0, 0, 0L))
+    override val rcSettings: StateFlow<RCSettings> = MutableStateFlow(
+        RCSettings(false, "", "", "", false, "", "", "", 0L, false, "", "", "", false, "", "")
+    )
+    override val otherSettings: StateFlow<OtherSettings> = MutableStateFlow(
+        OtherSettings(
+            false, false, false, false, false, false, false,
+            shouldSeeWarning = false, shouldSeeWhatsNew = false
+        )
+    )
+    override val dataSourcesSettings: MutableStateFlow<DataSourcesSettings> =
+        MutableStateFlow(DataSourcesSettings(satelliteUrls = emptyList(), transceiversUrls = emptyList()))
+    override val dataSourcesStatus: StateFlow<Map<String, Int>> = MutableStateFlow(emptyMap())
+    override val radioControlSettings: StateFlow<RadioControlSettings> = MutableStateFlow(
+        RadioControlSettings(false, RadioControlSettings.MODEL_YAESU_FT817, "", "", "", "", 9600)
+    )
+    override val wavelogSettings: StateFlow<com.rtbishop.look4sat.core.domain.model.WavelogSettings> =
+        MutableStateFlow(com.rtbishop.look4sat.core.domain.model.WavelogSettings())
+    override val lotwSettings: StateFlow<com.rtbishop.look4sat.core.domain.model.LoTWSettings> =
+        MutableStateFlow(com.rtbishop.look4sat.core.domain.model.LoTWSettings())
+
+    override fun setSelectedIds(ids: List<Int>) = Unit
+    override fun setSelectedTypes(types: List<String>) = Unit
+    override fun setPassesSettings(settings: PassesSettings) = Unit
+    override fun setStationPosition(latitude: Double, longitude: Double, altitude: Double): Boolean = true
+    override fun setStationPosition(): Boolean = true
+    override fun setStationPosition(locator: String): Boolean = true
+    override fun getSatelliteTypesIds(types: List<String>): List<Int> = emptyList()
+    override fun setSatelliteTypeIds(type: String, ids: List<Int>) = Unit
+    override fun updateDatabaseState(state: DatabaseState) = Unit
+    override fun updateRCSettings(settings: RCSettings) = Unit
+    override fun updateOtherSettings(transform: (OtherSettings) -> OtherSettings) = Unit
+    override fun updateDataSourcesSettings(settings: DataSourcesSettings) = Unit
+    override fun updateDataSourcesStatus(status: Map<String, Int>) = Unit
+    override fun updateRadioControlSettings(settings: RadioControlSettings) = Unit
+    override fun getSatelliteOffset(catnum: Int): String = ""
+    override fun setSatelliteOffset(catnum: Int, offset: String) = Unit
+    override fun getAmSatCallsign(): String = ""
+    override fun setAmSatCallsign(callsign: String) = Unit
+    override fun updateWavelogSettings(settings: com.rtbishop.look4sat.core.domain.model.WavelogSettings) = Unit
+    override fun getWorkedGrids(): Set<String> = emptySet()
+    override fun setWorkedGrids(grids: Set<String>) = Unit
+    override fun getWorkedGridQsos(): Map<String, List<com.rtbishop.look4sat.core.domain.model.GridQso>> = emptyMap()
+    override fun setWorkedGridQsos(qsos: Map<String, List<com.rtbishop.look4sat.core.domain.model.GridQso>>) = Unit
+    override fun getRoamedGrids(): Set<String> = emptySet()
+    override fun setRoamedGrids(grids: Set<String>) = Unit
+    override fun updateLoTWSettings(settings: com.rtbishop.look4sat.core.domain.model.LoTWSettings) = Unit
+    override fun getLastLotwSyncDate(): String = ""
+    override fun setLastLotwSyncDate(date: String) = Unit
+    override fun getLastLotwSyncCallsign(): String = ""
+    override fun setLastLotwSyncCallsign(callsign: String) = Unit
+}
@@ -1,3 +1,3 @@
 plugins {
-    alias(libs.plugins.convention.kotlinLibraryPlugin)
+    alias(libs.plugins.convention.coreDomainPlugin)
 }
@@ -0,0 +1,154 @@
+/*
+ * Look4Sat. Amateur radio satellite tracker and pass predictor.
+ * Copyright (C) 2019-2026 Arty Bishop and contributors.
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <https://www.gnu.org/licenses/>.
+ */
+package com.rtbishop.look4sat.core.domain.cw
+
+/**
+ * Bayesian Morse timing decoder.
+ * Replaces hard thresholds with probability-based decision making.
+ *
+ * Inspired by VE3NEA's CW Skimmer approach:
+ * "Instead of making a hard decision at every input sample whether the signal
+ * is present or not, compute the probability that the signal is present."
+ *
+ * Uses Gaussian probability density centered on expected durations:
+ *   P(dit | duration) = exp(-(duration - dotMs)^2 / (2 * variance^2))
+ *   P(dash | duration) = exp(-(duration - 3*dotMs)^2 / (2 * variance^2))
+ */
+internal class CwBayesianDecoder {
+
+    // Morse timing parameters
+    private var dotDurationMs = 60f // initial 20 WPM
+    private var speedWpm = 20f
+
+    // Current symbol being accumulated
+    private var currentSymbol = StringBuilder()
+    private var textBuffer = StringBuilder()
+
+    // Recent dit lengths for speed estimation
+    private val recentDits = mutableListOf<Float>()
+
+    // Output
+    private var _decodedText = ""
+    val decodedText: String get() = _decodedText
+
+    /** Gaussian probability. */
+    private fun gaussianProb(durationMs: Float, expectedMs: Float, varianceMs: Float): Float {
+        if (varianceMs <= 0f) return 0f
+        val diff = durationMs - expectedMs
+        return kotlin.math.exp(-(diff * diff) / (2 * varianceMs * varianceMs))
+    }
+
+    /** Process a tone duration. Returns the symbol type with highest probability. */
+    fun processTone(durationMs: Float): ToneResult {
+        val ditProb = gaussianProb(durationMs, dotDurationMs, dotDurationMs * 0.4f)
+        val dashProb = gaussianProb(durationMs, dotDurationMs * 3f, dotDurationMs * 0.6f)
+
+        return if (ditProb > dashProb && ditProb > 0.05f) {
+            currentSymbol.append('0')
+            recentDits.add(durationMs)
+            updateSpeed()
+            ToneResult('0', ditProb)
+        } else if (dashProb > 0.05f) {
+            currentSymbol.append('1')
+            ToneResult('1', dashProb)
+        } else {
+            ToneResult(null, 0f)
+        }
+    }
+
+    /** Process a gap duration. Returns decoded character or null. */
+    fun processGap(durationMs: Float): Char? {
+        if (currentSymbol.isEmpty()) {
+            val wordProb = gaussianProb(durationMs, dotDurationMs * 7f, dotDurationMs * 1.2f)
+            if (wordProb > 0.2f) {
+                textBuffer.append(' ')
+                _decodedText = textBuffer.toString()
+                return ' '
+            }
+            return null
+        }
+
+        val interCharProb = gaussianProb(durationMs, dotDurationMs * 3f, dotDurationMs * 0.6f)
+        val wordProb = gaussianProb(durationMs, dotDurationMs * 7f, dotDurationMs * 1.2f)
+
+        if (wordProb > interCharProb && wordProb > 0.2f) {
+            val char = flushSymbol()
+            textBuffer.append(' ')
+            _decodedText = textBuffer.toString()
+            return char
+        }
+        if (interCharProb > 0.15f) {
+            val char = flushSymbol()
+            _decodedText = textBuffer.toString()
+            return char
+        }
+        return null
+    }
+
+    private fun flushSymbol(): Char? {
+        if (currentSymbol.isEmpty()) return null
+        val morse = currentSymbol.toString()
+        currentSymbol.clear()
+        val char = morseToChar(morse)
+        if (char != null) textBuffer.append(char)
+        return char
+    }
+
+    private fun updateSpeed() {
+        if (recentDits.size < 3) return
+        val sorted = recentDits.sorted()
+        val median = sorted[sorted.size / 2]
+        if (median > 0f) {
+            dotDurationMs = dotDurationMs * 0.7f + median * 0.3f
+            val wpm = 60.0f / (50.0f * dotDurationMs / 1000.0f)
+            if (wpm in 5f..55f) speedWpm = wpm
+        }
+    }
+
+    fun getSpeed(): Float = speedWpm
+
+    fun reset() {
+        dotDurationMs = 60f
+        speedWpm = 20f
+        recentDits.clear()
+        currentSymbol.clear()
+        textBuffer.clear()
+        _decodedText = ""
+    }
+
+    companion object {
+        private val MORSE_TABLE = mapOf(
+            "01" to 'A', "1000" to 'B', "1010" to 'C', "100" to 'D', "0" to 'E',
+            "0010" to 'F', "110" to 'G', "0000" to 'H', "00" to 'I', "0111" to 'J',
+            "101" to 'K', "0100" to 'L', "11" to 'M', "10" to 'N', "111" to 'O',
+            "0110" to 'P', "1101" to 'Q', "010" to 'R', "000" to 'S', "1" to 'T',
+            "001" to 'U', "0001" to 'V', "011" to 'W', "1001" to 'X', "1011" to 'Y',
+            "1100" to 'Z', "01111" to '1', "00111" to '2', "00011" to '3',
+            "00001" to '4', "00000" to '5', "10000" to '6', "11000" to '7',
+            "11100" to '8', "11110" to '9', "11111" to '0',
+            "010101" to '.', "110011" to ',', "001100" to '?', "011110" to '\'',
+            "101011" to '!', "10010" to '/', "10110" to '(', "101101" to ')',
+            "01000" to '&', "111000" to ':', "101010" to ';', "10001" to '=',
+            "01010" to '+', "100001" to '-', "001101" to '_', "010010" to '"',
+            "0001001" to '$', "011010" to '@'
+        )
+        fun morseToChar(morse: String): Char? = MORSE_TABLE[morse]
+    }
+}
+
+data class ToneResult(val symbol: Char?, val probability: Float)
@@ -0,0 +1,114 @@
+/*
+ * Look4Sat. Amateur radio satellite tracker and pass predictor.
+ * Copyright (C) 2019-2026 Arty Bishop and contributors.
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <https://www.gnu.org/licenses/>.
+ */
+package com.rtbishop.look4sat.core.domain.cw
+
+/**
+ * Multi-channel CW signal tracker.
+ * Monitors the spectrogram for active frequency bins and extracts
+ * energy envelopes for each detected signal.
+ *
+ * Inspired by CW Skimmer's multi-channel approach:
+ * tracks all active signals in the passband simultaneously,
+ * selects the best one for decoded output.
+ */
+internal class CwChannelTracker(
+    private val spectrogram: CwSpectrogram,
+    private val maxChannels: Int = 3
+) {
+    data class Channel(
+        val bin: Int,
+        val frequency: Float,
+        var active: Boolean = false,
+        var energy: Float = 0f,
+        val history: MutableList<Float> = mutableListOf(),
+        var confidence: Float = 0f
+    )
+
+    private val channels = Array(maxChannels) { Channel(0, 0f) }
+
+    /** Scan the current spectrogram column and update channel tracking. */
+    fun update(): List<Channel> {
+        val col = spectrogram.getCurrentColumn()
+        val peaks = findPeaks(col, threshold = 0.3f, minDistance = 2)
+
+        // Update existing channels
+        for (ch in channels) {
+            if (ch.active) {
+                if (peaks.contains(ch.bin)) {
+                    ch.energy = col[ch.bin]
+                    ch.history.add(ch.energy)
+                    if (ch.history.size > 40) ch.history.removeAt(0)
+                    ch.confidence = computeConfidence(ch.history)
+                } else {
+                    // Signal lost — decay confidence
+                    ch.history.add(0f)
+                    if (ch.history.size > 40) ch.history.removeAt(0)
+                    ch.confidence *= 0.9f
+                    if (ch.confidence < 0.1f) ch.active = false
+                }
+            }
+        }
+
+        // Assign new peaks to inactive channels
+        var peakIdx = 0
+        for (ch in channels) {
+            if (!ch.active && peakIdx < peaks.size) {
+                val bin = peaks[peakIdx]
+                val freq = spectrogram.binToFreq(bin)
+                // Re-initialize channel
+                channels[peakIdx] = Channel(bin, freq, true, col[bin], mutableListOf(), 0.5f)
+                peakIdx++
+            }
+        }
+
+        return channels.filter { it.active }
+    }
+
+    /** Find peak bins in the spectrum. */
+    private fun findPeaks(spectrum: FloatArray, threshold: Float, minDistance: Int): List<Int> {
+        val peaks = mutableListOf<Int>()
+        for (i in 1 until spectrum.size - 1) {
+            if (spectrum[i] > spectrum[i - 1] && spectrum[i] > spectrum[i + 1] && spectrum[i] > threshold) {
+                if (peaks.isEmpty() || i - peaks.last() >= minDistance) {
+                    peaks.add(i)
+                }
+            }
+        }
+        return peaks.sortedByDescending { spectrum[it] }
+    }
+
+    /** Compute confidence from energy history. Lower variance = higher confidence. */
+    private fun computeConfidence(history: List<Float>): Float {
+        if (history.size < 10) return 0.3f
+        val recent = history.takeLast(10)
+        val mean = recent.average().toFloat()
+        val variance = recent.map { (it - mean) * (it - mean) }.average().toFloat()
+        return if (mean > 0f) (mean / (mean + variance + 0.1f)).coerceIn(0f, 1f) else 0f
+    }
+
+    /** Get the channel with highest confidence. */
+    fun getBestChannel(): Channel? {
+        return channels.filter { it.active }.maxByOrNull { it.confidence }
+    }
+
+    fun reset() {
+        for (i in channels.indices) {
+            channels[i] = Channel(0, 0f)
+        }
+    }
+}
@@ -0,0 +1,165 @@
+/*
+ * Look4Sat. Amateur radio satellite tracker and pass predictor.
+ * Copyright (C) 2019-2026 Arty Bishop and contributors.
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <https://www.gnu.org/licenses/>.
+ */
+package com.rtbishop.look4sat.core.domain.cw
+
+import kotlinx.coroutines.flow.MutableStateFlow
+import kotlinx.coroutines.flow.StateFlow
+
+/**
+ * CW (Morse code) decoder v3 — Spectrogram-based multi-channel Bayesian decoder.
+ *
+ * Architecture inspired by Morse Expert / CW Skimmer (VE3NEA):
+ *   1. FFT spectrogram creates a frequency×time matrix
+ *   2. Multi-channel peak detector finds all active signals
+ *   3. Per-channel energy envelope extraction
+ *   4. Bayesian probability for symbol timing (Gaussian likelihood)
+ *   5. Best channel selected for output
+ *
+ * Timing analysis is performed per spectrogram column (hop).
+ * Each column represents hopSize/sampleRate seconds of audio.
+ */
+class CwDecoder(
+    val sampleRate: Int = 8000,
+    cwToneFreq: Float = -1f // ignored in v3 (auto-detect via spectrogram)
+) {
+    companion object {
+        private const val FFT_SIZE = 256
+        private const val HOP_SIZE = 64
+    }
+
+    private val spectrogram = CwSpectrogram(
+        fftSize = FFT_SIZE,
+        hopSize = HOP_SIZE,
+        sampleRate = sampleRate,
+        minBin = 6,
+        maxBin = 38,
+        historyCols = 40
+    )
+    private val channelTracker = CwChannelTracker(spectrogram, maxChannels = 3)
+    private val bayesianDecoder = CwBayesianDecoder()
+
+    // Timing state per channel
+    private data class ChannelTiming(
+        var isSignal: Boolean = false,
+        var toneTicks: Int = 0,
+        var gapTicks: Int = 0
+    )
+    private val timingStates = Array(3) { ChannelTiming() }
+
+    // Time per spectrogram column in milliseconds
+    private val tickMs = 1000f * HOP_SIZE / sampleRate
+
+    // Output flows
+    private val _decodedTextFlow = MutableStateFlow("")
+    val decodedTextFlow: StateFlow<String> = _decodedTextFlow
+
+    private val _signalStrength = MutableStateFlow(0f)
+    val signalStrength: StateFlow<Float> = _signalStrength
+
+    private val _estimatedPitch = MutableStateFlow<Float?>(null)
+    val estimatedPitch: StateFlow<Float?> = _estimatedPitch
+
+    private val _estimatedSpeed = MutableStateFlow<Float?>(null)
+    val estimatedSpeed: StateFlow<Float?> = _estimatedSpeed
+
+    private var frameCount = 0
+
+    init {
+        if (cwToneFreq > 0f) {
+            _estimatedPitch.value = cwToneFreq
+        }
+    }
+
+    fun processBuffer(buffer: FloatArray) {
+        // 1. Feed samples to spectrogram
+        spectrogram.addSamples(buffer)
+
+        // 2. Get number of new columns generated
+        val newCols = spectrogram.getNewColumns()
+        if (newCols == 0) return
+
+        // 3. Update channel tracker (uses latest column for peak detection)
+        val activeChannels = channelTracker.update()
+
+        // 4. Process each new column for timing analysis
+        //    Columns are indexed 0..historyCols-1, where historyCols-1 is the newest
+        val baseIdx = (spectrogram.historyCols - newCols).coerceAtLeast(0)
+        for (colOffset in 0 until newCols) {
+            val col = spectrogram.getColumn(baseIdx + colOffset)
+
+            for ((idx, channel) in activeChannels.withIndex()) {
+                if (idx >= timingStates.size) break
+                val state = timingStates[idx]
+                val energy = if (channel.bin in col.indices) col[channel.bin] else 0f
+
+                // Adaptive threshold
+                val threshold = 0.3f + (energy - 0.3f) * 0.3f
+
+                if (energy > threshold) {
+                    if (!state.isSignal) {
+                        if (state.gapTicks > 0) {
+                            val gapMs = state.gapTicks * tickMs
+                            bayesianDecoder.processGap(gapMs)
+                        }
+                        state.gapTicks = 0
+                        state.isSignal = true
+                    }
+                    state.toneTicks++
+                } else {
+                    if (state.isSignal) {
+                        if (state.toneTicks > 0) {
+                            val toneMs = state.toneTicks * tickMs
+                            bayesianDecoder.processTone(toneMs)
+                        }
+                        state.toneTicks = 0
+                        state.isSignal = false
+                    }
+                    state.gapTicks++
+                }
+            }
+        }
+
+        // 5. Update outputs
+        frameCount++
+        if (frameCount % 5 == 0) {
+            val bestChannel = channelTracker.getBestChannel()
+            if (bestChannel != null) {
+                _estimatedPitch.value = bestChannel.frequency
+                _signalStrength.value = bestChannel.confidence
+                _estimatedSpeed.value = bayesianDecoder.getSpeed()
+            }
+            _decodedTextFlow.value = bayesianDecoder.decodedText
+        }
+    }
+
+    fun resetDecoder() {
+        spectrogram.reset()
+        channelTracker.reset()
+        bayesianDecoder.reset()
+        for (state in timingStates) {
+            state.isSignal = false
+            state.toneTicks = 0
+            state.gapTicks = 0
+        }
+        frameCount = 0
+        _decodedTextFlow.value = ""
+        _signalStrength.value = 0f
+        _estimatedPitch.value = null
+        _estimatedSpeed.value = null
+    }
+}
@@ -0,0 +1,102 @@
+/*
+ * Look4Sat. Amateur radio satellite tracker and pass predictor.
+ * Copyright (C) 2019-2026 Arty Bishop and contributors.
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <https://www.gnu.org/licenses/>.
+ */
+package com.rtbishop.look4sat.core.domain.cw
+
+import kotlin.math.PI
+import kotlin.math.cos
+import kotlin.math.sin
+import kotlin.math.sqrt
+
+/**
+ * DSP utilities for CW (Morse code) decoding.
+ * Pure Kotlin, no NDK required.
+ */
+internal object CwDsp {
+
+    /**
+     * Design a simple bandpass FIR filter coefficients using windowed sinc method.
+     * @param lowCutoff  lower cutoff frequency (Hz) as fraction of sampleRate
+     * @param highCutoff upper cutoff frequency (Hz) as fraction of sampleRate
+     * @param taps       filter length (must be odd)
+     */
+    fun bandpassFir(lowCutoff: Double, highCutoff: Double, taps: Int): FloatArray {
+        val n = if (taps % 2 == 0) taps + 1 else taps
+        val half = n / 2
+        val coeffs = FloatArray(n)
+        for (i in 0 until n) {
+            val idx = i - half
+            if (idx == 0) {
+                coeffs[i] = (2.0 * (highCutoff - lowCutoff)).toFloat()
+            } else {
+                val x = PI * idx
+                coeffs[i] = ((sin(2 * highCutoff * x) - sin(2 * lowCutoff * x)) / x).toFloat()
+            }
+            // Hamming window
+            coeffs[i] = (coeffs[i] * (0.54 - 0.46 * cos(2 * PI * i / (n - 1)))).toFloat()
+        }
+        // Normalize
+        val sum = coeffs.sum()
+        if (sum != 0f) for (i in 0 until n) coeffs[i] /= sum
+        return coeffs
+    }
+
+    /** Apply FIR filter to a buffer. */
+    fun applyFir(buffer: FloatArray, coeffs: FloatArray): FloatArray {
+        val out = FloatArray(buffer.size)
+        for (i in buffer.indices) {
+            var sum = 0f
+            for (j in coeffs.indices) {
+                val idx = i - j
+                if (idx >= 0) sum += buffer[idx] * coeffs[j]
+            }
+            out[i] = sum
+        }
+        return out
+    }
+
+    /** Simple envelope detector: abs + low-pass smoothing. */
+    fun envelope(signal: FloatArray, alpha: Float = 0.1f): FloatArray {
+        val env = FloatArray(signal.size)
+        var s = 0f
+        for (i in signal.indices) {
+            s = alpha * kotlin.math.abs(signal[i]) + (1 - alpha) * s
+            env[i] = s
+        }
+        return env
+    }
+
+    /** Estimate noise floor from envelope for adaptive thresholding. */
+    fun noiseFloor(env: FloatArray, fraction: Float = 0.3f): Float {
+        val sorted = env.sortedArray()
+        val median = sorted[sorted.size / 2]
+        return median + (sorted[sorted.size * 9 / 10] - median) * fraction
+    }
+
+    /** Simple Goertzel to detect a specific tone frequency. */
+    fun goertzel(buffer: FloatArray, targetFreq: Float, sampleRate: Int): Float {
+        val omega = 2.0 * PI * targetFreq / sampleRate
+        val coeff = 2.0 * cos(omega)
+        var s0 = 0.0; var s1 = 0.0; var s2 = 0.0
+        for (sample in buffer) {
+            s0 = sample.toDouble() + coeff * s1 - s2
+            s2 = s1; s1 = s0
+        }
+        val power = s2 * s2 + s1 * s1 - coeff * s1 * s2
+        return sqrt(kotlin.math.abs(power)).toFloat()
+    }
+}
@@ -0,0 +1,87 @@
+/*
+ * Look4Sat. Amateur radio satellite tracker and pass predictor.
+ * Copyright (C) 2019-2026 Arty Bishop and contributors.
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <https://www.gnu.org/licenses/>.
+ */
+package com.rtbishop.look4sat.core.domain.cw
+
+import kotlin.math.cos
+import kotlin.math.sqrt
+
+/**
+ * Radix-2 FFT for real-valued input.
+ * Produces magnitude spectrum for the first N/2+1 bins.
+ * Used by CwSpectrogram for time-frequency analysis.
+ */
+internal class CwFFT(private val n: Int) {
+    init {
+        require(n > 0 && n and (n - 1) == 0) { "FFT size must be power of 2, got $n" }
+    }
+
+    private val cosTable = FloatArray(n / 2)
+    private val sinTable = FloatArray(n / 2)
+
+    init {
+        for (i in 0 until n / 2) {
+            val angle = -2.0 * kotlin.math.PI * i / n
+            cosTable[i] = cos(angle).toFloat()
+            sinTable[i] = kotlin.math.sin(angle).toFloat()
+        }
+    }
+
+    /** Compute magnitude spectrum for real input. Returns array of size n/2+1. */
+    fun magnitudeSpectrum(input: FloatArray): FloatArray {
+        require(input.size == n) { "Input size must be $n, got ${input.size}" }
+
+        val real = input.copyOf()
+        val imag = FloatArray(n)
+
+        // Bit-reversal permutation
+        var j = 0
+        for (i in 1 until n) {
+            var bit = n shr 1
+            while (j and bit != 0) { j = j xor bit; bit = bit shr 1 }
+            j = j xor bit
+            if (i < j) {
+                var tmp = real[i]; real[i] = real[j]; real[j] = tmp
+            }
+        }
+
+        // Radix-2 Cooley-Tukey FFT
+        var len = 2
+        while (len <= n) {
+            val half = len / 2
+            val step = n / len
+            for (i in 0 until n step len) {
+                for (k in 0 until half) {
+                    val tReal = real[i + k + half] * cosTable[k * step] - imag[i + k + half] * sinTable[k * step]
+                    val tImag = real[i + k + half] * sinTable[k * step] + imag[i + k + half] * cosTable[k * step]
+                    real[i + k + half] = real[i + k] - tReal
+                    imag[i + k + half] = imag[i + k] - tImag
+                    real[i + k] += tReal
+                    imag[i + k] += tImag
+                }
+            }
+            len = len shl 1
+        }
+
+        // Magnitude spectrum (first N/2+1 bins)
+        val mag = FloatArray(n / 2 + 1)
+        for (i in 0..n / 2) {
+            mag[i] = sqrt(real[i] * real[i] + imag[i] * imag[i]) / n
+        }
+        return mag
+    }
+}
@@ -0,0 +1,48 @@
+/*
+ * Look4Sat. Amateur radio satellite tracker and pass predictor.
+ * Copyright (C) 2019-2026 Arty Bishop and contributors.
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <https://www.gnu.org/licenses/>.
+ */
+package com.rtbishop.look4sat.core.domain.cw
+
+/**
+ * First-order IIR filters.
+ * Ported from ggmorse/src/filter.h
+ */
+internal class CwFilter {
+    private var z1 = 0f
+
+    companion object {
+        private const val PI_F = 3.141592653589793f
+    }
+
+    fun highPass(sample: Float, cutoffHz: Float, sampleRate: Float): Float {
+        val rc = 1.0f / (2f * PI_F * cutoffHz)
+        val dt = 1.0f / sampleRate
+        val alpha = dt / (rc + dt)
+        z1 = alpha * (z1 + sample - z1)
+        return sample - z1
+    }
+
+    fun lowPass(sample: Float, cutoffHz: Float, sampleRate: Float): Float {
+        val rc = 1.0f / (2f * PI_F * cutoffHz)
+        val dt = 1.0f / sampleRate
+        val alpha = dt / (rc + dt)
+        z1 += alpha * (sample - z1)
+        return z1
+    }
+
+    fun reset() { z1 = 0f }
+}
@@ -0,0 +1,54 @@
+/*
+ * Look4Sat. Amateur radio satellite tracker and pass predictor.
+ * Copyright (C) 2019-2026 Arty Bishop and contributors.
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <https://www.gnu.org/licenses/>.
+ */
+package com.rtbishop.look4sat.core.domain.cw
+
+import kotlin.math.cos
+import kotlin.math.sqrt
+
+/**
+ * Running Goertzel filter for CW tone detection.
+ * Tracks a specific frequency over time with a sliding window.
+ * Ported from ggmorse/src/goertzel.h
+ */
+internal class CwGoertzel {
+    private var s1 = 0.0
+    private var s2 = 0.0
+    private var coeff = 0.0
+
+    fun init(sampleRate: Float, targetFreq: Float) {
+        val omega = 2.0 * kotlin.math.PI * targetFreq / sampleRate
+        coeff = 2.0 * cos(omega)
+        s1 = 0.0
+        s2 = 0.0
+    }
+
+    fun process(sample: Float) {
+        val s0 = sample.toDouble() + coeff * s1 - s2
+        s2 = s1
+        s1 = s0
+    }
+
+    fun getPower(): Float {
+        return sqrt(s2 * s2 + s1 * s1 - coeff * s1 * s2).toFloat()
+    }
+
+    fun reset() {
+        s1 = 0.0
+        s2 = 0.0
+    }
+}
@@ -0,0 +1,53 @@
+/*
+ * Look4Sat. Amateur radio satellite tracker and pass predictor.
+ * Copyright (C) 2019-2026 Arty Bishop and contributors.
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <https://www.gnu.org/licenses/>.
+ */
+package com.rtbishop.look4sat.core.domain.cw
+
+/**
+ * Simple linear resampler.
+ * Downsamples from input sample rate to output sample rate.
+ * Ported from ggmorse/src/resampler.h
+ */
+internal class CwResampler(private val inputRate: Float, private val outputRate: Float) {
+    private val ratio = inputRate / outputRate
+    private var lastSample = 0f
+
+    fun process(input: FloatArray): FloatArray {
+        if (ratio <= 0f || input.isEmpty()) return input
+        val outputLen = (input.size / ratio).toInt() + 1
+        val output = FloatArray(outputLen)
+        var idx = 0f
+        for (i in output.indices) {
+            val intIdx = idx.toInt()
+            val frac = idx - intIdx
+            if (intIdx + 1 < input.size) {
+                output[i] = input[intIdx] * (1 - frac) + input[intIdx + 1] * frac
+            } else if (intIdx < input.size) {
+                output[i] = input[intIdx] * (1 - frac) + lastSample * frac
+            } else {
+                output[i] = lastSample
+            }
+            idx += ratio
+        }
+        lastSample = input.lastOrNull() ?: lastSample
+        return output
+    }
+
+    fun reset() {
+        lastSample = 0f
+    }
+}
@@ -0,0 +1,61 @@
+/*
+ * Look4Sat. Amateur radio satellite tracker and pass predictor.
+ * Copyright (C) 2019-2026 Arty Bishop and contributors.
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <https://www.gnu.org/licenses/>.
+ */
+package com.rtbishop.look4sat.core.domain.cw
+
+import kotlin.math.cos
+import kotlin.math.sin
+import kotlin.math.sqrt
+
+/**
+ * Lightweight pitch detector using DFT at specific frequency bins.
+ * Only scans [200, 1200] Hz in configurable steps — much faster than full FFT.
+ * Ported from ggmorse/src/stfft.h (simplified for CW use case).
+ */
+internal class CwPitchDetector(
+    private val sampleRate: Float,
+    private val minFreq: Float = 200f,
+    private val maxFreq: Float = 1200f,
+    private val stepHz: Float = 10f
+) {
+    /**
+     * Find the dominant pitch frequency in the buffer.
+     * Returns null if no significant pitch found.
+     */
+    fun findPitch(buffer: FloatArray): Float? {
+        if (buffer.isEmpty()) return null
+        var bestFreq = 0f
+        var bestPower = 0f
+        var freq = minFreq
+        while (freq <= maxFreq) {
+            var real = 0.0
+            var imag = 0.0
+            val omega = 2.0 * kotlin.math.PI * freq / sampleRate
+            for (i in buffer.indices) {
+                real += buffer[i] * cos(omega * i)
+                imag += buffer[i] * -sin(omega * i)
+            }
+            val power = (real * real + imag * imag).toFloat()
+            if (power > bestPower) {
+                bestPower = power
+                bestFreq = freq
+            }
+            freq += stepHz
+        }
+        return if (bestPower > 0.001f) bestFreq else null
+    }
+}
@@ -0,0 +1,170 @@
+/*
+ * Look4Sat. Amateur radio satellite tracker and pass predictor.
+ * Copyright (C) 2019-2026 Arty Bishop and contributors.
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <https://www.gnu.org/licenses/>.
+ */
+package com.rtbishop.look4sat.core.domain.cw
+
+/**
+ * Sliding-window spectrogram for CW decoding.
+ * Maintains a time-frequency matrix updated with each audio frame.
+ *
+ * FFT size: 256, hop size: 64, sample rate: 4000 (or native)
+ * Frequency bins: 6..38 (187-1187 Hz, covers typical CW range)
+ * History: 40 columns (320 ms window)
+ * Time resolution: 64/4000 = 16 ms, Frequency resolution: 4000/256 = 15.625 Hz
+ */
+internal class CwSpectrogram(
+    private val fftSize: Int = 256,
+    private val hopSize: Int = 64,
+    private val sampleRate: Int = 4000,
+    private val minBin: Int = 6,
+    private val maxBin: Int = 38,
+    val historyCols: Int = 40
+) {
+    private val fft = CwFFT(fftSize)
+    val numBins: Int get() = maxBin - minBin + 1
+
+    // Hanning window
+    private val hanning = FloatArray(fftSize) {
+        (0.5 - 0.5 * kotlin.math.cos(2.0 * kotlin.math.PI * it / (fftSize - 1))).toFloat()
+    }
+
+    // Spectrogram data: [timeCol][freqBin]
+    private val spectrogram = Array(historyCols) { FloatArray(numBins) }
+    private var currentCol = 0
+    private var samplesBuffered = 0
+    private val buffer = FloatArray(fftSize)
+
+    // Per-bin running energy for normalization
+    private val binEnergy = FloatArray(numBins) { 1f }
+    private val alpha = 0.95f
+
+    // Counter for new columns generated since last check
+    private var newColumnCount = 0
+
+    /** Add audio samples, compute FFTs for each complete hop. */
+    fun addSamples(samples: FloatArray) {
+        var offset = 0
+        while (offset < samples.size) {
+            val needed = fftSize - samplesBuffered
+            val copyLen = minOf(needed, samples.size - offset)
+            System.arraycopy(samples, offset, buffer, samplesBuffered, copyLen)
+            samplesBuffered += copyLen
+            offset += copyLen
+
+            if (samplesBuffered >= fftSize) {
+                processFrame()
+                newColumnCount++
+                // Shift buffer: keep last (fftSize - hopSize) samples
+                System.arraycopy(buffer, hopSize, buffer, 0, fftSize - hopSize)
+                samplesBuffered = fftSize - hopSize
+            }
+        }
+    }
+
+    /** Get number of new columns generated since the last call to this method. */
+    fun getNewColumns(): Int {
+        val count = newColumnCount
+        newColumnCount = 0
+        return count
+    }
+
+    private fun processFrame() {
+        // Apply Hanning window
+        val windowed = FloatArray(fftSize) { buffer[it] * hanning[it] }
+
+        // Compute FFT magnitude spectrum
+        val mag = fft.magnitudeSpectrum(windowed)
+
+        // Update spectrogram column
+        val col = spectrogram[currentCol]
+        for (b in 0 until numBins) {
+            val binIdx = minBin + b
+            val rawMag = mag[binIdx]
+            // Running energy normalization
+            binEnergy[b] = alpha * binEnergy[b] + (1 - alpha) * rawMag
+            col[b] = if (binEnergy[b] > 1e-6f) rawMag / binEnergy[b] else 0f
+        }
+
+        currentCol = (currentCol + 1) % historyCols
+    }
+
+    /** Get the current spectrogram as a 2D array in chronological order. */
+    fun getSpectrogram(): Array<FloatArray> {
+        val result = Array(historyCols) { i ->
+            val srcIdx = (currentCol + i) % historyCols
+            spectrogram[srcIdx].copyOf()
+        }
+        return result
+    }
+
+    /** Get the most recent column (current energy across all frequencies). */
+    fun getCurrentColumn(): FloatArray {
+        val prevCol = (currentCol - 1 + historyCols) % historyCols
+        return spectrogram[prevCol].copyOf()
+    }
+
+    /** Get a column by index from the history (0 = oldest, historyCols-1 = newest). */
+    fun getColumn(index: Int): FloatArray {
+        val clamped = index.coerceIn(0, historyCols - 1)
+        val srcIdx = (currentCol - historyCols + clamped + historyCols) % historyCols
+        return spectrogram[srcIdx].copyOf()
+    }
+
+    /** Find the frequency bin with peak energy. Returns -1 if no significant signal. */
+    fun findPeakBin(): Int {
+        val col = getCurrentColumn()
+        var maxBin = -1
+        var maxVal = 0f
+        for (i in col.indices) {
+            if (col[i] > maxVal) {
+                maxVal = col[i]
+                maxBin = i
+            }
+        }
+        return if (maxVal > 0.3f) maxBin else -1
+    }
+
+    /** Get energy at a specific bin over the last N columns in chronological order. */
+    fun getBinEnergy(bin: Int, numCols: Int): FloatArray {
+        val clamped = minOf(numCols, historyCols)
+        val result = FloatArray(clamped)
+        for (i in 0 until clamped) {
+            val colIdx = (currentCol - clamped + i + historyCols) % historyCols
+            result[i] = spectrogram[colIdx][bin]
+        }
+        return result
+    }
+
+    /** Get the bin index for a frequency in Hz. */
+    fun freqToBin(freqHz: Float): Int {
+        val bin = (freqHz * fftSize / sampleRate).toInt()
+        return (bin - minBin).coerceIn(0, numBins - 1)
+    }
+
+    /** Get the center frequency for a bin. */
+    fun binToFreq(bin: Int): Float {
+        return (minBin + bin).toFloat() * sampleRate / fftSize
+    }
+
+    fun reset() {
+        for (col in spectrogram) col.fill(0f)
+        currentCol = 0
+        samplesBuffered = 0
+        buffer.fill(0f)
+        binEnergy.fill(1f)
+    }
+}
@@ -0,0 +1,17 @@
+package com.rtbishop.look4sat.core.domain.model
+
+/** One public AMSAT satellite status report submission. */
+data class AmSatReportSubmission(
+    val name: String,
+    val report: String,
+    val callsign: String,
+    val gridSquare: String,
+    val reportedAtUtcMillis: Long
+)
+
+/** Result of submitting an AMSAT satellite status report. */
+data class AmSatReportSubmitResult(
+    val success: Boolean,
+    val message: String = "",
+    val reportId: String? = null
+)
@@ -0,0 +1,194 @@
+/*
+ * Look4Sat. Amateur radio satellite tracker and pass predictor.
+ * Copyright (C) 2019-2026 Arty Bishop and contributors.
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <https://www.gnu.org/licenses/>.
+ */
+package com.rtbishop.look4sat.core.domain.model
+
+/**
+ * Award progress computed from the confirmed-QSO store.
+ *
+ * @param type      which award
+ * @param workedKeys matching keys for the boundary assets: each is compared
+ *                   against the region "code" field of the award's GeoJSON
+ *                   (e.g. WAPC -> "GD", WAJA -> "34", WAZ -> "24",
+ *                   WAS -> "CA", DXCC -> "318", VUCC -> "OL62").
+ * @param count     distinct worked units (grids / entities / provinces / ...)
+ * @param target    units required for the award
+ */
+data class AwardProgress(
+    val type: AwardType,
+    val workedKeys: Set<String>,
+    val count: Int,
+    val target: Int
+)
+
+enum class AwardType { DXCC, VUCC, WAPC, WAJA, WAZ, WAS }
+
+object AwardTargets {
+    const val DXCC = 100
+    const val VUCC = 100
+    const val WAPC = 34
+    const val WAJA = 47
+    const val WAZ = 40
+    const val WAS = 50
+}
+
+/**
+ * Derives six-award progress from the confirmed QSO store.
+ *
+ * Award rules (ADIF / award-program semantics):
+ *  - VUCC: distinct 4-char gridsquares.
+ *  - DXCC: distinct ARRL DXCC entities (from the QSO's dxcc field; falls back
+ *    to a callsign-prefix guess when LoTW omitted it).
+ *  - WAPC: distinct Chinese provinces (31 mainland STATE codes) plus the
+ *    Hong Kong / Macao / Taiwan entities (counted as their own provinces).
+ *  - WAJA: distinct Japanese prefectures (STATE code "01".."47").
+ *  - WAZ: distinct CQ zones.
+ *  - WAS: distinct US states (STATE abbreviations).
+ *
+ * The ADIF STATE field's meaning depends on the DXCC entity
+ * ("STATE depends on DXCC"), so every QSO is first classified by entity.
+ */
+object AwardCalculator {
+
+    fun calculate(qsosByGrid: Map<String, List<GridQso>>): List<AwardProgress> {
+        val all = qsosByGrid.values.flatten()
+        return listOf(
+            AwardProgress(
+                AwardType.VUCC,
+                workedKeys = qsosByGrid.keys,
+                count = qsosByGrid.size,
+                target = AwardTargets.VUCC
+            ),
+            calculateDxcc(all),
+            calculateWapc(all),
+            calculateWaja(all),
+            calculateWaz(all),
+            calculateWas(all)
+        )
+    }
+
+    private fun calculateDxcc(all: List<GridQso>): AwardProgress {
+        val keys = mutableSetOf<String>()
+        for (q in all) {
+            val code = q.dxcc ?: prefixEntityCode(q.call)
+            if (code != null) keys.add(code.toString())
+        }
+        return AwardProgress(AwardType.DXCC, keys, keys.size, AwardTargets.DXCC)
+    }
+
+    private fun calculateWapc(all: List<GridQso>): AwardProgress {
+        val keys = mutableSetOf<String>()
+        for (q in all) {
+            when (entityOf(q)) {
+                Entity.CHINA -> q.state?.trim()?.uppercase()?.takeIf { it in CN_STATES }?.let { keys.add(it) }
+                Entity.HONG_KONG -> keys.add(HK_CODE)
+                Entity.MACAO -> keys.add(MO_CODE)
+                Entity.TAIWAN -> keys.add(TW_CODE)
+                else -> {}
+            }
+        }
+        return AwardProgress(AwardType.WAPC, keys, keys.size, AwardTargets.WAPC)
+    }
+
+    private fun calculateWaja(all: List<GridQso>): AwardProgress {
+        val keys = mutableSetOf<String>()
+        for (q in all) {
+            if (entityOf(q) != Entity.JAPAN) continue
+            q.state?.trim()?.takeIf { it.length == 2 && it.all(Char::isDigit) }?.let { keys.add(it) }
+        }
+        return AwardProgress(AwardType.WAJA, keys, keys.size, AwardTargets.WAJA)
+    }
+
+    private fun calculateWaz(all: List<GridQso>): AwardProgress {
+        val keys = mutableSetOf<String>()
+        for (q in all) {
+            q.cqz?.takeIf { it in 1..40 }?.let { keys.add(it.toString()) }
+        }
+        return AwardProgress(AwardType.WAZ, keys, keys.size, AwardTargets.WAZ)
+    }
+
+    private fun calculateWas(all: List<GridQso>): AwardProgress {
+        val keys = mutableSetOf<String>()
+        for (q in all) {
+            if (entityOf(q) != Entity.USA) continue
+            q.state?.trim()?.uppercase()?.takeIf { it in US_STATES }?.let { keys.add(it) }
+        }
+        return AwardProgress(AwardType.WAS, keys, keys.size, AwardTargets.WAS)
+    }
+
+    private enum class Entity { CHINA, HONG_KONG, MACAO, TAIWAN, JAPAN, USA, OTHER }
+
+    private fun entityOf(q: GridQso): Entity = when (q.dxcc) {
+        318 -> Entity.CHINA
+        321 -> Entity.HONG_KONG
+        152 -> Entity.MACAO
+        386 -> Entity.TAIWAN
+        339 -> Entity.JAPAN
+        291 -> Entity.USA
+        else -> prefixEntity(q.call)
+    }
+
+    /** Coarse entity from callsign prefix, used when LoTW omitted the DXCC field. */
+    private fun prefixEntity(call: String): Entity {
+        val c = call.uppercase().substringBefore('/')
+        return when {
+            CN_PREFIXES.any { c.startsWith(it) } -> Entity.CHINA
+            c.startsWith("VR") -> Entity.HONG_KONG
+            c.startsWith("XX9") -> Entity.MACAO
+            TW_PREFIXES.any { c.startsWith(it) } -> Entity.TAIWAN
+            JP_PREFIXES.any { c.startsWith(it) } -> Entity.JAPAN
+            US_PREFIXES.any { c.startsWith(it) } -> Entity.USA
+            else -> Entity.OTHER
+        }
+    }
+
+    /** ARRL DXCC entity code guessed from callsign prefix (very coarse). */
+    private fun prefixEntityCode(call: String): Int? {
+        return when (prefixEntity(call)) {
+            Entity.CHINA -> 318
+            Entity.HONG_KONG -> 321
+            Entity.MACAO -> 152
+            Entity.TAIWAN -> 386
+            Entity.JAPAN -> 339
+            Entity.USA -> 291
+            else -> null
+        }
+    }
+
+    private val CN_PREFIXES = listOf("BA", "BD", "BG", "BH", "BI", "BY", "BJ", "BK", "BL", "BQ", "BR", "BS")
+    private val TW_PREFIXES = listOf("BM", "BV", "BU", "BW", "BX", "BN", "BO", "BT", "BZ")
+    private val JP_PREFIXES =
+        listOf("7J", "7K", "7L", "7M", "7N") + ('A'..'Z').map { "J$it" }
+    private val US_PREFIXES =
+        listOf("AA", "AB", "AC", "AD", "AE", "AF", "AG", "AH", "AI", "AJ", "AK", "AL", "K", "N", "W")
+
+    private val CN_STATES = setOf(
+        "AH", "BJ", "CQ", "FJ", "GD", "GS", "GX", "GZ", "HA", "HB", "HE", "HI", "HL", "HN", "JL",
+        "JS", "JX", "LN", "NM", "NX", "QH", "SC", "SD", "SH", "SN", "SX", "TJ", "XJ", "XZ", "YN", "ZJ"
+    )
+
+    private val US_STATES = setOf(
+        "AL", "AK", "AZ", "AR", "CA", "CO", "CT", "DE", "FL", "GA", "HI", "ID", "IL", "IN", "IA",
+        "KS", "KY", "LA", "ME", "MD", "MA", "MI", "MN", "MS", "MO", "MT", "NE", "NV", "NH", "NJ",
+        "NM", "NY", "NC", "ND", "OH", "OK", "OR", "PA", "RI", "SC", "SD", "TN", "TX", "UT", "VT",
+        "VA", "WA", "WV", "WI", "WY"
+    )
+
+    private const val HK_CODE = "HK"
+    private const val MO_CODE = "MO"
+    private const val TW_CODE = "TW"
+}
@@ -0,0 +1,23 @@
+/*
+ * Look4Sat. Amateur radio satellite tracker and pass predictor.
+ * Copyright (C) 2019-2026 Arty Bishop and contributors.
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <https://www.gnu.org/licenses/>.
+ */
+package com.rtbishop.look4sat.core.domain.model
+
+object Constants {
+    const val FREQ_OFFSET_MIN_HZ = -50_000L
+    const val FREQ_OFFSET_MAX_HZ = 50_000L
+}
@@ -0,0 +1,78 @@
+/*
+ * Look4Sat. Amateur radio satellite tracker and pass predictor.
+ * Copyright (C) 2019-2026 Arty Bishop and contributors.
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <https://www.gnu.org/licenses/>.
+ */
+package com.rtbishop.look4sat.core.domain.model
+
+/**
+ * One confirmed satellite QSO as reported by LoTW, kept per worked gridsquare
+ * so the map can show, for any worked grid, which callsigns were worked there
+ * and when.
+ *
+ * @param call      opposite station callsign (as logged by the opposite op)
+ * @param epochMs   QSO date+time in UTC milliseconds
+ * @param satName   satellite name (e.g. "FO-29")
+ * @param mode      ADIF mode (FM / CW / SSB ...)
+ * @param bandUp    uplink band as reported by LoTW (BAND_RX: "70CM", "2M", "10M"...)
+ * @param bandDown  downlink band (BAND: "2M", "70CM"...) — may be empty when
+ *                  LoTW did not include it
+ * @param dxcc      ARRL DXCC entity code of the opposite station (from ADIF
+ *                  <DXCC>), or null when LoTW omitted it
+ * @param country   DXCC entity name (ADIF <COUNTRY>), or null
+ * @param cqz       CQ zone of the opposite station (ADIF <CQZ>), or null
+ * @param state     Primary administrative subdivision of the opposite station
+ *                  (ADIF <STATE>). Interpretation depends on the DXCC entity:
+ *                  China -> province code ("GD"), Japan -> prefecture number
+ *                  ("34"), USA -> state abbreviation ("CA"). Null when absent.
+ */
+data class GridQso(
+    val call: String,
+    val epochMs: Long,
+    val satName: String,
+    val mode: String,
+    val bandUp: String,
+    val bandDown: String,
+    val dxcc: Int? = null,
+    val country: String? = null,
+    val cqz: Int? = null,
+    val state: String? = null,
+    /** 4-char grid the station itself operated from (ADIF MY_GRIDSQUARE). */
+    val myGrid: String? = null
+) {
+    /** Short uplink/downlink band label ("U/V", "V/A"), or "" when unknown. */
+    val bandLabel: String
+        get() {
+            val up = bandAbbrev(bandUp)
+            val down = bandAbbrev(bandDown)
+            return when {
+                up.isNotEmpty() && down.isNotEmpty() -> "$up/$down"
+                up.isNotEmpty() -> up
+                else -> ""
+            }
+        }
+
+    private fun bandAbbrev(band: String): String = when (band.trim().uppercase()) {
+        "70CM" -> "U"
+        "2M" -> "V"
+        "10M" -> "A"
+        "6M" -> "V"
+        "1.2G" -> "L"
+        "2.4G" -> "S"
+        "23CM" -> "L"
+        "13CM" -> "S"
+        else -> band.trim().uppercase()
+    }
+}
@@ -0,0 +1,9 @@
+package com.rtbishop.look4sat.core.domain.model
+
+/** Latest release info fetched from the fork's GitHub releases API. */
+data class LatestRelease(
+    val versionTag: String, // e.g. "v4.4.6-ba7opf.6"
+    val title: String,      // release name, may be empty
+    val body: String,       // release notes / update description
+    val apkUrl: String?     // first .apk asset download URL, null if absent
+)
@@ -17,16 +17,22 @@
 */
 package com.rtbishop.look4sat.core.domain.model

+import kotlinx.serialization.SerialName
+import kotlinx.serialization.Serializable
+
+@Serializable
 data class SatRadio(
-    val uuid: String,
-    val info: String,
-    val isAlive: Boolean,
-    var downlinkLow: Long?,
-    var downlinkHigh: Long?,
-    val downlinkMode: String?,
-    var uplinkLow: Long?,
-    var uplinkHigh: Long?,
-    val uplinkMode: String?,
-    val isInverted: Boolean,
-    val catnum: Int?
+    @SerialName("uuid") val uuid: String,
+    @SerialName("description") val info: String,
+    @SerialName("alive") val isAlive: Boolean,
+    @SerialName("downlink_low") val downlinkLow: Long?,
+    @SerialName("downlink_high") val downlinkHigh: Long?,
+    @SerialName("mode") val downlinkMode: String?,
+    @SerialName("uplink_low") val uplinkLow: Long?,
+    @SerialName("uplink_high") val uplinkHigh: Long?,
+    @SerialName("uplink_mode") val uplinkMode: String?,
+    @SerialName("invert") val isInverted: Boolean,
+    @SerialName("norad_cat_id") val catnum: Int?,
+    /** Set for manually imported transceivers, which remote updates must not replace. */
+    val isCustom: Boolean = false
 )
@@ -0,0 +1,38 @@
+package com.rtbishop.look4sat.core.domain.model
+
+/** One satellite status report (AMSAT site tooltip data) */
+data class SatReport(
+    val id: String,          // 报告 ID(a885153)
+    val statusText: String,  // Heard / Telemetry Only / Not Heard ...
+    val call: String,        // 呼号
+    val grid: String,        // 网格坐标(可为空)
+    val dateUtc: String,     // 2026-08-04
+    val timeUtc: String      // 2:46-:59 UTC
+)
+
+/** State of one 2-hour slot */
+data class SatSlot(
+    val statusColor: Long,   // ARGB 状态色(-1 = 无报告)
+    val count: Int,          // 报告数量(0 = 无)
+    val reportIds: List<String> = emptyList() // 该槽报告 ID 列表
+)
+
+/** One satellite day (12 two-hour slots) */
+data class SatDay(
+    val dateLabel: String,   // "Aug 4"
+    val slots: List<SatSlot>, // 12 槽(00-02 ... 22-24)
+    val streakCount: Int = 0 // 当天最近连续相同状态报告数(0 = 当天无报告)
+)
+
+/** One satellite, 3 days of state */
+data class SatStatus(
+    val name: String,        // "AO-123_[FM]"
+    val days: List<SatDay>   // 3 days (newest first)
+)
+
+/** Overall page parse result */
+data class SatStatusPage(
+    val fetchedAtUtcMs: Long,
+    val statuses: List<SatStatus>,
+    val reports: Map<String, SatReport> // id → 报告
+)
@@ -24,9 +24,15 @@ data class DatabaseState(
 )

 data class PassesSettings(
+    val showDeepSpace: Boolean = true,
    val hoursAhead: Int,
    val minElevation: Double,
-    val selectedModes: List<String>
+    val aosStartMinute: Int = 0,
+    val aosEndMinute: Int = 23 * 60 + 59,
+    val invertAosTimeWindow: Boolean = false,
+    val selectedModes: List<String>,
+    /** 历史过境回看窗口(小时): 过境列表从 now-hoursBefore 开始计算. */
+    val hoursBefore: Int = 0
 )

 data class RCSettings(
@@ -38,6 +44,7 @@ data class RCSettings(
    val frequencyAddress: String,
    val frequencyPort: String,
    val frequencyFormat: String,
+    val frequencyOffsetHz: Long = 0L,
    val bluetoothRotatorState: Boolean,
    val bluetoothRotatorFormat: String,
    val bluetoothRotatorName: String,
@@ -53,13 +60,69 @@ data class OtherSettings(
    val stateOfSweep: Boolean,
    val stateOfUtc: Boolean,
    val stateOfLightTheme: Boolean,
+    val stateOfNightMode: Boolean = false,
+    val stateOfMapGrid: Boolean = false,
+    /** Grid mode: label worked (green) cells with the FIRST callsign worked
+     *  in that grid instead of the Maidenhead code; non-worked cells get no
+     *  label at all. */
+    val stateOfMapFirstCall: Boolean = false,
    val shouldSeeWarning: Boolean,
-    val shouldSeeWhatsNew: Boolean
+    val shouldSeeWhatsNew: Boolean,
+    val sstvMode: String = "Auto",
+    val lowElevation: Double = 15.0,
+    val highElevation: Double = 45.0,
+    /** Independent auto-sync toggle for LoTW confirmed grids (separate from the
+     *  ephemeris auto-update; only effective after at least one manual sync). */
+    val stateOfAutoLotwSync: Boolean = true,
+    /** 指南针手动航向偏置(度, -180..180): 雷达方位 = 传感器方位 + 磁偏角 + 该偏置. */
+    val compassOffsetDegrees: Float = 0f
 )

 data class DataSourcesSettings(
-    val useCustomTLE: Boolean,
-    val useCustomTransceivers: Boolean,
-    val tleUrl: String,
-    val transceiversUrl: String
-)
+    val satelliteUrls: List<String>,
+    val transceiversUrls: List<String>,
+    val satelliteEnabled: List<Boolean> = emptyList(),
+    val transceiversEnabled: List<Boolean> = emptyList()
+) {
+    fun isSatelliteEnabled(index: Int): Boolean = satelliteEnabled.getOrElse(index) { true }
+    fun isTransceiverEnabled(index: Int): Boolean = transceiversEnabled.getOrElse(index) { true }
+}
+
+data class WavelogSettings(
+    val url: String = "",
+    val token: String = ""
+) {
+    val isConfigured: Boolean get() = url.isNotBlank() && token.isNotBlank()
+}
+
+data class LoTWSettings(
+    val callsign: String = "",
+    val password: String = ""
+) {
+    val isConfigured: Boolean get() = callsign.isNotBlank() && password.isNotBlank()
+}
+
+data class RadioControlSettings(
+    val enabled: Boolean,
+    val radioModel: String,
+    val txRadioAddress: String,
+    val rxRadioAddress: String,
+    val txRadioName: String,
+    val rxRadioName: String,
+    val baudRate: Int,
+    /** IC-705 only: use single-radio split-VFO mode instead of two radios. */
+    val splitMode: Boolean = false
+) {
+    companion object {
+        const val MODEL_YAESU_FT817   = "Yaesu FT-817/818"
+        const val MODEL_YAESU_FT857   = "Yaesu FT-857/897"
+        const val MODEL_ICOM_IC705    = "Icom IC-705"
+
+        val SUPPORTED_RADIOS = listOf(MODEL_YAESU_FT817, MODEL_YAESU_FT857, MODEL_ICOM_IC705)
+
+        /** Baud rates available for Yaesu radios. */
+        val BAUD_RATES_YAESU = listOf(4800, 9600, 38400)
+        /** Baud rates available for Icom IC-705 (higher speeds supported via CI-V USB/BT). */
+        val BAUD_RATES_ICOM  = listOf(4800, 9600, 19200, 38400, 57600, 115200)
+    }
+}
@@ -0,0 +1,671 @@
+/*
+ * Look4Sat. Amateur radio satellite tracker and pass predictor.
+ * Copyright (C) 2019-2026 Arty Bishop and contributors.
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <https://www.gnu.org/licenses/>.
+ */
+package com.rtbishop.look4sat.core.domain.predict
+
+import com.rtbishop.look4sat.core.domain.utility.toDegrees
+import com.rtbishop.look4sat.core.domain.utility.toRadians
+import kotlin.math.PI
+import kotlin.math.abs
+import kotlin.math.acos
+import kotlin.math.asin
+import kotlin.math.atan
+import kotlin.math.atan2
+import kotlin.math.cos
+import kotlin.math.floor
+import kotlin.math.log10
+import kotlin.math.pow
+import kotlin.math.sin
+import kotlin.math.sqrt
+import kotlin.math.tan
+
+/**
+ * Standalone celestial computations extracted from PREDICT v2.2.5.
+ * Provides Sun position, Moon position, satellite visibility classification,
+ * orbital metadata, RA/Dec conversion, and rise/set finding for Sun and Moon.
+ *
+ * All angles are in degrees unless noted. Time is Unix epoch milliseconds.
+ *
+ * Shared math utilities (thetaGJD, modulus, mod2PI, deltaET, millisToDaynum,
+ * solarPositionECI, eciToGeodetic) live in OrbitalMath.kt in the same package.
+ */
+object CelestialComputer {
+
+    // ── Result types ──
+
+    /** Sun position as seen from a ground observer. */
+    data class SunPosition(
+        val azimuth: Double,         // degrees, 0=N, 90=E
+        val elevation: Double,       // degrees, >0 above horizon
+        val distance: Double,        // normalized: 1.0 + ((range - AU) / AU)
+        val rangeRate: Double,       // km/s
+        val latitude: Double,        // sub-solar point latitude, degrees
+        val longitude: Double,       // sub-solar point longitude, degrees
+        val rightAscension: Double,  // degrees
+        val declination: Double      // degrees
+    )
+
+    /** Moon position as seen from a ground observer. */
+    data class MoonPosition(
+        val azimuth: Double,         // degrees, 0=N, 90=E
+        val elevation: Double,       // degrees
+        val rightAscension: Double,  // degrees
+        val declination: Double,     // degrees
+        val gha: Double,             // Greenwich Hour Angle, degrees
+        val angularDiameter: Double, // apparent diameter relative to Earth's diameter
+        val radialVelocity: Double   // m/s, Doppler radial velocity for EME
+    )
+
+    /**
+     * 3-state satellite visibility classification.
+     * - [VISIBLE]: satellite is sunlit, observer is in darkness (sun below -12°) — optically visible
+     * - [DAYLIGHT]: satellite is sunlit, observer is in daylight
+     * - [ECLIPSED]: satellite is in Earth's shadow
+     */
+    enum class SatVisibility { VISIBLE, DAYLIGHT, ECLIPSED }
+
+    /** Orbital metadata not typically included in pass data. */
+    data class OrbitalMetadata(
+        val footprintDiameter: Double, // km, ground coverage circle diameter
+        val orbitNumber: Long,         // current orbit/revolution number
+        val betaAngle: Double,         // degrees, angle between orbital plane and Sun
+        val orbitalPhase: Double       // 0-256 phase within current orbit
+    )
+
+    // ── Sun position ──
+
+    /**
+     * Compute the Sun's full position as seen from [observer] at [timeMillis].
+     * Includes az/el, RA/Dec, sub-solar lat/lon, range, and range rate.
+     * Based on FindSun() from PREDICT v2.2.5.
+     */
+    fun getSunPosition(observer: GeoPos, timeMillis: Long): SunPosition {
+        val daynum = millisToDaynum(timeMillis)
+        val julUtc = daynum + 2444238.5
+        val sunVec = solarPositionECI(julUtc)
+        val zeroVel = doubleArrayOf(0.0, 0.0, 0.0)
+        val obsGeo = observerGeodetic(observer)
+
+        // Az, El, Range, RangeRate
+        val obsSet = computeObsAngles(julUtc, sunVec, zeroVel, obsGeo)
+
+        // Lat/Lon of sub-solar point
+        val latLon = eciToGeodetic(julUtc, sunVec)
+
+        // RA/Dec
+        val raDec = calculateRADec(julUtc, sunVec, zeroVel, obsGeo)
+
+        return SunPosition(
+            azimuth = obsSet[0].toDegrees(),
+            elevation = obsSet[1].toDegrees(),
+            distance = 1.0 + ((obsSet[2] - ASTRONOMICAL_UNIT) / ASTRONOMICAL_UNIT),
+            rangeRate = 1000.0 * obsSet[3],
+            latitude = latLon[0].toDegrees(),
+            longitude = latLon[1].toDegrees().let { if (it > 180.0) it - 360.0 else it },
+            rightAscension = raDec[0].toDegrees(),
+            declination = raDec[1].toDegrees()
+        )
+    }
+
+    // ── Moon position ──
+
+    /**
+     * Compute the Moon's position as seen from [observer] at [timeMillis].
+     * Full Meeus lunar ephemeris from PREDICT v2.2.5 with expanded terms
+     * and radial velocity approximation for EME Doppler.
+     */
+    fun getMoonPosition(observer: GeoPos, timeMillis: Long): MoonPosition {
+        val daynum = millisToDaynum(timeMillis)
+        val jd = daynum + 2444238.5
+        var t = (jd - 2415020.0) / 36525.0
+        val t2 = t * t
+        val t3 = t2 * t
+
+        var l1 = 270.434164 + 481267.8831 * t - 0.001133 * t2 + 0.0000019 * t3
+        var mSun = 358.475833 + 35999.0498 * t - 0.00015 * t2 - 0.0000033 * t3
+        var m1 = 296.104608 + 477198.8491 * t + 0.009192 * t2 + 0.0000144 * t3
+        var d = 350.737486 + 445267.1142 * t - 0.001436 * t2 + 0.0000019 * t3
+        var ff = 11.250889 + 483202.0251 * t - 0.003211 * t2 - 0.0000003 * t3
+        val om = (259.183275 - 1934.142 * t + 0.002078 * t2 + 0.0000022 * t3) * DEG2RAD
+
+        val correction512 = sin((51.2 + 20.2 * t) * DEG2RAD)
+        val ss = 0.003964 * sin((346.56 + 132.87 * t - 0.0091731 * t2) * DEG2RAD)
+        l1 += 0.000233 * correction512 + ss + 0.001964 * sin(om)
+        mSun -= 0.001778 * correction512
+        m1 += 0.000817 * correction512 + ss + 0.002541 * sin(om)
+        d += 0.002011 * correction512 + ss + 0.001964 * sin(om)
+        ff += ss - 0.024691 * sin(om) - 0.004328 * sin(om + (275.05 - 2.3 * t) * DEG2RAD)
+
+        val ex = 1.0 - 0.002495 * t - 0.00000752 * t2
+        l1 = primeAngle(l1); mSun = primeAngle(mSun); m1 = primeAngle(m1)
+        d = primeAngle(d); ff = primeAngle(ff)
+
+        val mR = mSun * DEG2RAD
+        val m1R = m1 * DEG2RAD
+        val dR = d * DEG2RAD
+        val ffR = ff * DEG2RAD
+
+        // Ecliptic longitude — expanded v225 terms
+        var l = l1 + 6.28875 * sin(m1R) + 1.274018 * sin(2 * dR - m1R) + 0.658309 * sin(2 * dR)
+        l += 0.213616 * sin(2 * m1R) - ex * 0.185596 * sin(mR) - 0.114336 * sin(2 * ffR)
+        l += 0.058793 * sin(2 * dR - 2 * m1R) + ex * 0.057212 * sin(2 * dR - mR - m1R) + 0.05332 * sin(2 * dR + m1R)
+        l += ex * 0.045874 * sin(2 * dR - mR) + ex * 0.041024 * sin(m1R - mR) - 0.034718 * sin(dR)
+        l -= ex * 0.030465 * sin(mR + m1R) + 0.015326 * sin(2 * dR - 2 * ffR) - 0.012528 * sin(2 * ffR + m1R)
+        l -= 0.01098 * sin(2 * ffR - m1R) + 0.010674 * sin(4 * dR - m1R) + 0.010034 * sin(3 * m1R)
+        l += 0.008548 * sin(4 * dR - 2 * m1R) - ex * 0.00791 * sin(mR - m1R + 2 * dR)
+        l -= ex * 0.006783 * sin(2 * dR + mR)
+        l += 0.005162 * sin(m1R - dR) + ex * 0.005 * sin(mR + dR) + ex * 0.004049 * sin(m1R - mR + 2 * dR)
+        l += 0.003996 * sin(2 * m1R + 2 * dR) + 0.003862 * sin(4 * dR) + 0.003665 * sin(2 * dR - 3 * m1R)
+        l += ex * 0.002695 * sin(2 * m1R - mR) + 0.002602 * sin(m1R - 2 * ffR - 2 * dR)
+        l += ex * 0.002396 * sin(2 * dR - mR - 2 * m1R)
+        l -= 0.002349 * sin(m1R + dR) + ex * ex * 0.002249 * sin(2 * dR - 2 * mR)
+        l -= ex * 0.002125 * sin(2 * m1R + mR)
+        l -= ex * ex * 0.002079 * sin(2 * mR) + ex * ex * 0.002059 * sin(2 * dR - m1R - 2 * mR)
+        l -= 0.001773 * sin(m1R + 2 * dR - 2 * ffR)
+        l += ex * 0.00122 * sin(4 * dR - mR - m1R) - 0.00111 * sin(2 * m1R + 2 * ffR) + 0.000892 * sin(m1R - 3 * dR)
+        l -= ex * 0.000811 * sin(mR + m1R + 2 * dR) + ex * 0.000761 * sin(4 * dR - mR - 2 * m1R)
+        l += ex * ex * 0.000717 * sin(m1R - 2 * mR)
+        l += ex * ex * 0.000704 * sin(m1R - 2 * mR - 2 * dR) + ex * 0.000693 * sin(mR - 2 * m1R + 2 * dR)
+        l += ex * 0.000598 * sin(2 * dR - mR - 2 * ffR) + 0.00055 * sin(m1R + 4 * dR)
+        l += 0.000538 * sin(4 * m1R) + ex * 0.000521 * sin(4 * dR - mR) + 0.000486 * sin(2 * m1R - dR)
+        l -= 0.001595 * sin(2 * ffR + 2 * dR)
+
+        // Ecliptic latitude — expanded v225 terms
+        var b =
+            5.128189 * sin(ffR) + 0.280606 * sin(m1R + ffR) + 0.277693 * sin(m1R - ffR) + 0.173238 * sin(2 * dR - ffR)
+        b += 0.055413 * sin(2 * dR + ffR - m1R) + 0.046272 * sin(2 * dR - ffR - m1R) + 0.032573 * sin(2 * dR + ffR)
+        b += 0.017198 * sin(2 * m1R + ffR) + 9.266999e-03 * sin(2 * dR + m1R - ffR) + 0.008823 * sin(2 * m1R - ffR)
+        b += ex * 0.008247 * sin(2 * dR - mR - ffR) + 0.004323 * sin(2 * dR - ffR - 2 * m1R)
+        b += 0.0042 * sin(2 * dR + ffR + m1R)
+        b += ex * 0.003372 * sin(ffR - mR - 2 * dR) + ex * 0.002472 * sin(2 * dR + ffR - mR - m1R)
+        b += ex * 0.002222 * sin(2 * dR + ffR - mR)
+        b += 0.002072 * sin(2 * dR - ffR - mR - m1R) + ex * 0.001877 * sin(ffR - mR + m1R)
+        b += 0.001828 * sin(4 * dR - ffR - m1R)
+        b -= ex * 0.001803 * sin(ffR + mR) - 0.00175 * sin(3 * ffR)
+        b += ex * 0.00157 * sin(m1R - mR - ffR) - 0.001487 * sin(ffR + dR)
+        b -= ex * 0.001481 * sin(ffR + mR + m1R) + ex * 0.001417 * sin(ffR - mR - m1R)
+        b += ex * 0.00135 * sin(ffR - mR) + 0.00133 * sin(ffR - dR)
+        b += 0.001106 * sin(ffR + 3 * m1R) + 0.00102 * sin(4 * dR - ffR) + 0.000833 * sin(ffR + 4 * dR - m1R)
+        b += 0.000781 * sin(m1R - 3 * ffR) + 0.00067 * sin(ffR + 4 * dR - 2 * m1R)
+        b += 0.000606 * sin(2 * dR - 3 * ffR)
+        b += 0.000597 * sin(2 * dR + 2 * m1R - ffR) + ex * 0.000492 * sin(2 * dR + m1R - mR - ffR)
+        b += 0.00045 * sin(2 * m1R - ffR - 2 * dR)
+        b += 0.000439 * sin(3 * m1R - ffR) + 0.000423 * sin(ffR + 2 * dR + 2 * m1R)
+        b += 0.000422 * sin(2 * dR - ffR - 3 * m1R)
+        b -= ex * 0.000367 * sin(mR + ffR + 2 * dR - m1R) - ex * 0.000353 * sin(mR + ffR + 2 * dR)
+        b += 0.000331 * sin(ffR + 4 * dR)
+        b += ex * 0.000317 * sin(2 * dR + ffR - mR + m1R) + ex * ex * 0.000306 * sin(2 * dR - 2 * mR - ffR)
+        b -= 0.000283 * sin(m1R + 3 * ffR)
+
+        val w1 = 0.0004664 * cos(om)
+        val w2 = 0.0000754 * cos(om + (275.05 - 2.3 * t) * DEG2RAD)
+        val bt = b * (1.0 - w1 - w2)
+
+        // Parallax — expanded v225 terms
+        var p =
+            0.950724 + 0.051818 * cos(m1R) + 0.009531 * cos(2 * dR - m1R) + 0.007843 * cos(2 * dR) + 0.002824 * cos(2 * m1R)
+        p += 0.000857 * cos(2 * dR + m1R) + ex * 0.000533 * cos(2 * dR - mR) + ex * 0.000401 * cos(2 * dR - mR - m1R)
+        p += 0.000173 * cos(3 * m1R) + 0.000167 * cos(4 * dR - m1R) - ex * 0.000111 * cos(mR)
+        p += 0.000103 * cos(4 * dR - 2 * m1R) - 0.000084 * cos(2 * m1R - 2 * dR) - ex * 0.000083 * cos(2 * dR + mR)
+        p += 0.000079 * cos(2 * dR + 2 * m1R)
+        p += 0.000072 * cos(4 * dR) + ex * 0.000064 * cos(2 * dR - mR + m1R) - ex * 0.000063 * cos(2 * dR + mR - m1R)
+        p += ex * 0.000041 * cos(mR + dR) + ex * 0.000035 * cos(2 * m1R - mR) - 0.000033 * cos(3 * m1R - 2 * dR)
+        p -= 0.00003 * cos(m1R + dR) - 0.000029 * cos(2 * ffR - 2 * dR) - ex * 0.000029 * cos(2 * m1R + mR)
+        p += ex * ex * 0.000026 * cos(2 * dR - 2 * mR) - 0.000023 * cos(2 * ffR - 2 * dR + m1R)
+        p += ex * 0.000019 * cos(4 * dR - mR - m1R)
+
+        val bRad = bt * DEG2RAD
+        val lm = l * DEG2RAD
+        val moonDx = 3.0 / (PI * p)
+
+        // Ecliptic → equatorial
+        val z = (jd - 2415020.5) / 365.2422
+        val ob = (23.452294 - (0.46845 * z + 5.9e-07 * z * z) / 3600.0).toRadians()
+        val dec = asin(sin(bRad) * cos(ob) + cos(bRad) * sin(ob) * sin(lm))
+        var ra = acos(cos(bRad) * cos(lm) / cos(dec)); if (lm > PI) ra = TWO_PI - ra
+
+        val n = observer.latitude * DEG2RAD
+        t = (jd - 2451545.0) / 36525.0
+        var teg = 280.46061837 + 360.98564736629 * (jd - 2451545.0) + (0.000387933 * t - t * t / 38710000.0) * t
+        while (teg > 360.0) teg -= 360.0
+        // LST = GMST + east longitude (positive east convention)
+        val th = mod2PI((teg + observer.longitude) * DEG2RAD)
+        val h = th - ra
+        val azVal = atan2(sin(h), cos(h) * sin(n) - tan(dec) * cos(n)) + PI
+        val el = asin(sin(n) * sin(dec) + cos(n) * cos(dec) * cos(h))
+
+        // Moon radial velocity approximation (from "Amateur Radio Software", GM4ANB, RSGB 1985)
+        val mm = fixAngle(1.319238 + daynum * 0.228027135)
+        val radT2 = 0.10976
+        val radT1 = mm + radT2 * sin(mm)
+        var dv = 0.01255 * moonDx * moonDx * sin(radT1) * (1.0 + radT2 * cos(mm))
+        dv *= 4449.0
+        val earthR = 6378.0
+        val moonDist = 384401.0
+        val radT3 = earthR * moonDist * (cos(dec) * cos(n) * sin(h)) /
+            sqrt(moonDist * moonDist - moonDist * earthR * sin(el))
+        val moonDv = dv + radT3 * 0.0753125
+
+        val moonRa = ra / DEG2RAD
+        var moonGha = teg - moonRa
+        if (moonGha < 0.0) moonGha += 360.0
+
+        return MoonPosition(
+            azimuth = azVal / DEG2RAD,
+            elevation = el / DEG2RAD,
+            rightAscension = moonRa,
+            declination = dec / DEG2RAD,
+            gha = moonGha,
+            angularDiameter = moonDx,
+            radialVelocity = moonDv
+        )
+    }
+
+    // ── Satellite visibility ──
+
+    /**
+     * Classify satellite visibility given its eclipse state and the Sun's elevation
+     * at the observer's location.
+     *
+     * @param isEclipsed whether the satellite is in Earth's shadow
+     * @param sunElevationDeg Sun elevation at observer in degrees
+     * @param satElevationDeg satellite elevation at observer in degrees (must be >= 0)
+     */
+    fun classifyVisibility(
+        isEclipsed: Boolean,
+        sunElevationDeg: Double,
+        satElevationDeg: Double
+    ): SatVisibility {
+        if (isEclipsed) return SatVisibility.ECLIPSED
+        return if (sunElevationDeg <= -12.0 && satElevationDeg >= 0.0) SatVisibility.VISIBLE
+        else SatVisibility.DAYLIGHT
+    }
+
+    // ── Orbital metadata ──
+
+    /**
+     * Compute orbital metadata for a satellite at its current position.
+     *
+     * @param altitudeKm satellite altitude in km
+     * @param meanMotion revolutions per day from TLE
+     * @param bstar drag term from TLE
+     * @param meanAnomaly mean anomaly at epoch (radians)
+     * @param revNumAtEpoch revolution number at TLE epoch
+     * @param ageDays days since TLE epoch (julUTC - julEpoch)
+     * @param phase orbital phase in radians (from SGP4/SDP4 output)
+     * @param satPosECI satellite ECI position [x, y, z]
+     * @param satVelECI satellite ECI velocity [vx, vy, vz]
+     * @param sunPosECI sun ECI position [x, y, z]
+     */
+    fun computeOrbitalMetadata(
+        altitudeKm: Double,
+        meanMotion: Double,
+        bstar: Double,
+        meanAnomaly: Double,
+        revNumAtEpoch: Int,
+        ageDays: Double,
+        phase: Double,
+        satPosECI: DoubleArray,
+        satVelECI: DoubleArray,
+        sunPosECI: DoubleArray
+    ): OrbitalMetadata {
+        // Footprint diameter (km)
+        val footprint = 12756.33 * acos(EARTH_RADIUS / (EARTH_RADIUS + altitudeKm))
+
+        // Orbit number
+        val xmnpda = 1.44E3
+        val orbitNum = floor(
+            (meanMotion * xmnpda / TWO_PI + ageDays * bstar) * ageDays + meanAnomaly / TWO_PI
+        ).toLong() + revNumAtEpoch
+
+        // Beta angle: angle between orbital plane and Sun direction
+        // Orbital plane normal = cross(pos, vel)
+        val nx = satPosECI[1] * satVelECI[2] - satPosECI[2] * satVelECI[1]
+        val ny = satPosECI[2] * satVelECI[0] - satPosECI[0] * satVelECI[2]
+        val nz = satPosECI[0] * satVelECI[1] - satPosECI[1] * satVelECI[0]
+        val nMag = sqrt(nx * nx + ny * ny + nz * nz)
+        val sMag = sqrt(sunPosECI[0] * sunPosECI[0] + sunPosECI[1] * sunPosECI[1] + sunPosECI[2] * sunPosECI[2])
+        val dotNS = nx * sunPosECI[0] + ny * sunPosECI[1] + nz * sunPosECI[2]
+        val betaAngle = if (nMag > 0 && sMag > 0) {
+            (PI / 2.0 - acos(dotNS / (nMag * sMag))).toDegrees()
+        } else 0.0
+
+        // Phase (0-256 scale, matching PREDICT convention)
+        val orbitalPhase = 256.0 * (phase / TWO_PI)
+
+        return OrbitalMetadata(footprint, orbitNum, betaAngle, orbitalPhase)
+    }
+
+    // ── Satellite status checks ──
+
+    /** Check if a satellite is geostationary (mean motion ≈ 1.0027 rev/day). */
+    fun isGeostationary(meanMotion: Double): Boolean = abs(meanMotion - 1.0027) < 0.0002
+
+    /**
+     * Check if a satellite has likely decayed based on drag and time since epoch.
+     *
+     * @param meanMotion revolutions per day
+     * @param drag first derivative of mean motion / 2 (from TLE line 1)
+     * @param epochDaynum TLE epoch as daynum (days since 31Dec79)
+     * @param currentDaynum current time as daynum
+     */
+    fun hasDecayed(meanMotion: Double, drag: Double, epochDaynum: Double, currentDaynum: Double): Boolean {
+        return epochDaynum + ((16.666666 - meanMotion) / (10.0 * abs(drag))) < currentDaynum
+    }
+
+    // ── Rise/Set finding ──
+
+    /** Rise and set times for a celestial body. */
+    data class RiseSetTimes(
+        val riseTimeMillis: Long,  // 0 if not found
+        val setTimeMillis: Long    // 0 if not found
+    )
+
+    /**
+     * Find the next sunrise and sunset times from [startMillis] for [observer].
+     * Uses elevation threshold of -0.8333° to match the standard civil definition:
+     * upper limb on geometric horizon with standard atmospheric refraction (~0.57°)
+     * and solar semidiameter (~0.27°) corrections applied, matching USNO/timeanddate.com.
+     */
+    fun findSunRiseSet(observer: GeoPos, startMillis: Long): RiseSetTimes {
+        // Standard civil threshold: center elevation when upper limb meets geometric horizon
+        // -0.8333° = standard refraction (~0.5667°) + solar semidiameter (~0.2667°)
+        val threshold = 0.8333
+        var daynum = millisToDaynum(startMillis)
+        var sunPos = getSunPosition(observer, daynumToMillis(daynum))
+
+        // Phase 1: if sun is above threshold, fast-forward to well past sunset into night
+        if (sunPos.elevation > -threshold) {
+            var guard = 0
+            while (sunPos.elevation > -threshold && guard++ < 500) {
+                daynum += 0.008  // fixed ~11.5 min steps past the setting sun
+                sunPos = getSunPosition(observer, daynumToMillis(daynum))
+            }
+            // Now advance until sun is clearly below minimum (deep night)
+            guard = 0
+            while (sunPos.elevation > -12.0 && guard++ < 500) {
+                daynum += 0.02
+                sunPos = getSunPosition(observer, daynumToMillis(daynum))
+            }
+        }
+
+        // Phase 2: advance until sun starts rising toward threshold (elevation increasing)
+        var guard = 0
+        while (sunPos.elevation < -threshold && guard++ < 500) {
+            daynum += 0.008
+            sunPos = getSunPosition(observer, daynumToMillis(daynum))
+        }
+
+        // Phase 3: converge symmetrically on elevation = -threshold (sunrise)
+        var sunrise = 0.0
+        guard = 0
+        while (sunrise == 0.0 && guard++ < 200) {
+            val delta = sunPos.elevation + threshold
+            if (abs(delta) < 0.01) {
+                sunrise = daynum
+            } else {
+                daynum -= 0.004 * delta
+                sunPos = getSunPosition(observer, daynumToMillis(daynum))
+            }
+        }
+        if (sunrise == 0.0) sunrise = daynum
+
+        // Phase 4: fast-forward through the day until sun drops back below threshold.
+        // Start from just after sunrise (small offset) so the sun is clearly above
+        // the threshold. This prevents a bug where Phase 3 converges to a point
+        // slightly below -threshold, causing Phase 4 to skip and Phase 5 to converge
+        // to the same time as sunrise, producing identical sunrise/sunset times.
+        daynum = sunrise + 0.001
+        sunPos = getSunPosition(observer, daynumToMillis(daynum))
+        guard = 0
+        while (sunPos.elevation >= -threshold && guard++ < 500) {
+            daynum += 0.008
+            sunPos = getSunPosition(observer, daynumToMillis(daynum))
+        }
+
+        // Phase 5: converge symmetrically on elevation = -threshold (sunset)
+        var sunset = 0.0
+        guard = 0
+        while (sunset == 0.0 && guard++ < 200) {
+            val delta = sunPos.elevation + threshold
+            if (abs(delta) < 0.01) {
+                sunset = daynum
+            } else {
+                daynum += 0.004 * delta
+                sunPos = getSunPosition(observer, daynumToMillis(daynum))
+            }
+        }
+        if (sunset == 0.0) sunset = daynum
+
+        return RiseSetTimes(daynumToMillis(sunrise), daynumToMillis(sunset))
+    }
+
+    /**
+     * Find the next moonrise and moonset times from [startMillis] for [observer].
+     * Uses the adaptive iteration from PREDICT v2.2.5's PredictMoon().
+     */
+    fun findMoonRiseSet(observer: GeoPos, startMillis: Long): RiseSetTimes {
+        var daynum = millisToDaynum(startMillis)
+        var moonPos = getMoonPosition(observer, daynumToMillis(daynum))
+
+        // If moon is already up, move forward until it sets
+        var guard = 0
+        if (moonPos.elevation > 0) {
+            while (moonPos.elevation > 0 && guard++ < 1000) {
+                daynum += 0.004 * sin(DEG2RAD * (moonPos.elevation + 0.5))
+                moonPos = getMoonPosition(observer, daynumToMillis(daynum))
+            }
+            daynum += 0.4
+            moonPos = getMoonPosition(observer, daynumToMillis(daynum))
+        }
+        // Find moonrise
+        var moonrise = 0.0
+        guard = 0
+        while (moonrise == 0.0 && guard++ < 1000) {
+            if (abs(moonPos.elevation) < 0.03) {
+                moonrise = daynum
+            } else {
+                daynum -= 0.004 * moonPos.elevation
+                moonPos = getMoonPosition(observer, daynumToMillis(daynum))
+            }
+        }
+        if (moonrise == 0.0) moonrise = daynum
+
+        // Find moonset from moonrise
+        daynum = moonrise
+        moonPos = getMoonPosition(observer, daynumToMillis(daynum))
+        guard = 0
+        while (moonPos.elevation > -1 && guard++ < 1000) {
+            daynum += 0.04 * cos(DEG2RAD * (moonPos.elevation + 0.5))
+            moonPos = getMoonPosition(observer, daynumToMillis(daynum))
+        }
+        var moonset = 0.0
+        guard = 0
+        while (moonset == 0.0 && guard++ < 1000) {
+            if (abs(moonPos.elevation) < 0.03) {
+                moonset = daynum
+            } else {
+                daynum += 0.004 * moonPos.elevation
+                moonPos = getMoonPosition(observer, daynumToMillis(daynum))
+            }
+        }
+        if (moonset == 0.0) moonset = daynum
+
+        return RiseSetTimes(daynumToMillis(moonrise), daynumToMillis(moonset))
+    }
+
+    // ── Visual magnitude estimation ──
+
+    /**
+     * Estimate the apparent visual magnitude of a satellite.
+     *
+     * Uses the standard formula from McCants/Heavens-Above:
+     *   apparentMag = stdMag + 5 * log10(range / 1000) - 15 * log10(cos(phaseAngle / 2))
+     *
+     * @param rangeKm slant range from observer to satellite in km
+     * @param phaseAngleDeg Sun-satellite-observer angle in degrees
+     * @param stdMag intrinsic/standard magnitude (default 4.0)
+     * @return estimated apparent visual magnitude
+     */
+    fun estimateVisualMagnitude(rangeKm: Double, phaseAngleDeg: Double, stdMag: Double = 4.0): Double {
+        if (rangeKm <= 0) return stdMag
+        val halfPhaseRad = phaseAngleDeg.toRadians() / 2.0
+        val cosHalfPhase = cos(halfPhaseRad)
+        val phaseTerm = if (cosHalfPhase > 1e-6) -15.0 * log10(cosHalfPhase) else 99.0
+        return stdMag + 5.0 * log10(rangeKm / 1000.0) + phaseTerm
+    }
+
+    /**
+     * Compute the phase angle (Sun-satellite-observer) in degrees.
+     *
+     * @param satPosECI satellite ECI position [x, y, z] in km
+     * @param sunPosECI sun ECI position [x, y, z] in km
+     * @param obsPosECI observer ECI position [x, y, z] in km
+     * @return phase angle in degrees (0 = fully illuminated face toward observer)
+     */
+    fun computePhaseAngle(satPosECI: DoubleArray, sunPosECI: DoubleArray, obsPosECI: DoubleArray): Double {
+        val toSunX = sunPosECI[0] - satPosECI[0]
+        val toSunY = sunPosECI[1] - satPosECI[1]
+        val toSunZ = sunPosECI[2] - satPosECI[2]
+        val toObsX = obsPosECI[0] - satPosECI[0]
+        val toObsY = obsPosECI[1] - satPosECI[1]
+        val toObsZ = obsPosECI[2] - satPosECI[2]
+        val dot = toSunX * toObsX + toSunY * toObsY + toSunZ * toObsZ
+        val magSun = sqrt(toSunX * toSunX + toSunY * toSunY + toSunZ * toSunZ)
+        val magObs = sqrt(toObsX * toObsX + toObsY * toObsY + toObsZ * toObsZ)
+        if (magSun == 0.0 || magObs == 0.0) return 90.0
+        val cosAngle = (dot / (magSun * magObs)).coerceIn(-1.0, 1.0)
+        return acos(cosAngle).toDegrees()
+    }
+
+    // ── Doppler ──
+
+    /**
+     * Compute Doppler shift for a given base frequency and range rate.
+     *
+     * @param frequencyHz base frequency in Hz
+     * @param rangeRateKmS range rate in km/s (negative = approaching)
+     * @return shifted frequency in Hz
+     */
+    fun dopplerShift(frequencyHz: Double, rangeRateKmS: Double): Double {
+        return frequencyHz * (299792.458 - rangeRateKmS) / 299792.458
+    }
+
+    // ── Internal helpers ──
+
+    private fun observerGeodetic(pos: GeoPos): DoubleArray {
+        // [lat_rad, lon_rad, alt_km] — longitude positive east, matching OrbitalObject convention.
+        // LST = thetaGJD(julUtc) + obsGeo[1] = GMST + lon_rad (correct).
+        return doubleArrayOf(pos.latitude * DEG2RAD, pos.longitude * DEG2RAD, pos.altitude / 1000.0)
+    }
+
+    /**
+     * Convert az/el observation to Right Ascension / Declination.
+     * Returns [ra_rad, dec_rad].
+     * Based on Calculate_RADec() from PREDICT v2.2.5 (Escobal method).
+     */
+    private fun calculateRADec(
+        julUtc: Double,
+        targetPos: DoubleArray,
+        targetVel: DoubleArray,
+        obsGeo: DoubleArray
+    ): DoubleArray {
+        val obsSet = computeObsAngles(julUtc, targetPos, targetVel, obsGeo)
+        val az = obsSet[0]
+        val el = obsSet[1]
+        val phi = obsGeo[0]
+        val theta = mod2PI(thetaGJD(julUtc) + obsGeo[1])
+        val sinTheta = sin(theta)
+        val cosTheta = cos(theta)
+        val sinPhi = sin(phi)
+        val cosPhi = cos(phi)
+        val lxh = -cos(az) * cos(el)
+        val lyh = sin(az) * cos(el)
+        val lzh = sin(el)
+        val sx = sinPhi * cosTheta
+        val ex2 = -sinTheta
+        val zx = cosTheta * cosPhi
+        val sy = sinPhi * sinTheta
+        val zy = sinTheta * cosPhi
+        val sz = -cosPhi
+        val lx = sx * lxh + ex2 * lyh + zx * lzh
+        val ly = sy * lxh + cosTheta * lyh + zy * lzh
+        val lz = sz * lxh + 0.0 * lyh + sinPhi * lzh
+        val dec = asin(lz)
+        val cosDelta = sqrt(1.0 - lz * lz)
+        val sinAlpha = ly / cosDelta
+        val cosAlpha = lx / cosDelta
+        val ra = mod2PI(atan2(sinAlpha, cosAlpha))
+        return doubleArrayOf(ra, dec)
+    }
+
+    /**
+     * Compute observer look-angles (az, el, range, rangeRate) to a target at ECI position.
+     * Returns [azimuth_rad, elevation_rad, range_km, rangeRate_km/s].
+     * Azimuth is north-referenced (0=N, π/2=E), matching OrbitalObject's convention.
+     */
+    private fun computeObsAngles(
+        julUtc: Double,
+        targetPos: DoubleArray,
+        targetVel: DoubleArray,
+        obsGeo: DoubleArray // [lat_rad, lon_rad, alt_km]
+    ): DoubleArray {
+        val theta = mod2PI(thetaGJD(julUtc) + obsGeo[1])
+        val c = 1.0 / sqrt(1 + FLAT_FACT * (FLAT_FACT - 2) * sin(obsGeo[0]).pow(2))
+        val sq = (1 - FLAT_FACT).pow(2) * c
+        val achcp = (EARTH_RADIUS * c + obsGeo[2]) * cos(obsGeo[0])
+        val ox = achcp * cos(theta)
+        val oy = achcp * sin(theta)
+        val oz = (EARTH_RADIUS * sq + obsGeo[2]) * sin(obsGeo[0])
+        val ovx = -MFACTOR * oy
+        val ovy = MFACTOR * ox
+
+        val rx = targetPos[0] - ox
+        val ry = targetPos[1] - oy
+        val rz = targetPos[2] - oz
+        val rMag = sqrt(rx * rx + ry * ry + rz * rz)
+        val rvx = targetVel[0] - ovx
+        val rvy = targetVel[1] - ovy
+        val rvz = targetVel[2]
+
+        val sinLat = sin(obsGeo[0])
+        val cosLat = cos(obsGeo[0])
+        val sinTheta = sin(theta)
+        val cosTheta = cos(theta)
+        val topS = sinLat * cosTheta * rx + sinLat * sinTheta * ry - cosLat * rz
+        val topE = -sinTheta * rx + cosTheta * ry
+        val topZ = cosLat * cosTheta * rx + cosLat * sinTheta * ry + sinLat * rz
+
+        // Match north-based convention (0=N, 90=E) used by OrbitalObject.calculateObs
+        // Must use atan(-topE / topS) not atan2(-topE, topS) — they differ in quadrant handling
+        var azim = atan(-topE / topS)
+        if (topS > 0.0) azim += PI
+        if (azim < 0.0) azim += TWO_PI
+        val el = asin(topZ / rMag)
+        val rangeRate = (rx * rvx + ry * rvy + rz * rvz) / rMag
+
+        return doubleArrayOf(azim, el, rMag, rangeRate)
+    }
+
+    private const val MFACTOR = 7.292115E-5
+
+    private fun primeAngle(x: Double) = x - 360.0 * floor(x / 360.0)
+
+    private fun fixAngle(x: Double): Double {
+        var a = x; while (a > TWO_PI) a -= TWO_PI; return a
+    }
+}
@@ -21,6 +21,7 @@ const val ASTRONOMICAL_UNIT = 1.49597870691E8
 const val DEG2RAD = 0.017453292519943295
 const val RAD2DEG = 57.29577951308232
 const val EARTH_RADIUS = 6378.137
+const val EARTH_ROT_PER_SID_DAY = 1.00273790934
 const val EPSILON = 1.0E-12
 const val FLAT_FACT = 3.35281066474748E-3
 const val J3_HARMONIC = -2.53881E-6
@@ -97,40 +97,38 @@ class DeepSpaceObject(data: OrbitalData) : OrbitalObject(data) {
    }

    internal fun calculateSDP4(tSince: Double) {
-        synchronized(this) {
-            val temp = DoubleArray(12)
-            val xmdf = data.xmo + dsv.xmdot * tSince
-            val tsq = tSince * tSince
-            val templ = t2cof * tsq
-            dsv.xll = xmdf + dsv.xnodp * templ
-            dsv.omgadf = data.omegao + dsv.omgdot * tSince
-            val xnoddf = data.xnodeo + dsv.xnodot * tSince
-            dsv.xnode = xnoddf + xnodcf * tsq
-            val tempa = 1.0 - c1 * tSince
-            val tempe = data.bstar * c4 * tSince
-            dsv.xn = dsv.xnodp
-            dsv.t = tSince
-            deep.dpsec(data)
-            val a = (XKE / dsv.xn).pow(TWO_THIRDS) * tempa * tempa
-            dsv.em -= tempe
-            deep.dpper()
-            val xl = dsv.xll + dsv.omgadf + dsv.xnode
-            val beta = sqrt(1.0 - dsv.em * dsv.em)
-            dsv.xn = XKE / a.pow(1.5)
-            // Long period periodics
-            val axn = dsv.em * cos(dsv.omgadf)
-            temp[0] = invert(a * beta * beta)
-            val xll = temp[0] * xlcof * axn
-            val aynl = temp[0] * aycof
-            val xlt = xl + xll
-            val ayn = dsv.em * sin(dsv.omgadf) + aynl
-            // Solve Kepler's equation
-            val capu = mod2PI(xlt - dsv.xnode)
-            temp[2] = capu
-            converge(temp, axn, ayn, capu)
-            calculatePosAndVel(temp, a, axn, ayn)
-            calculatePhase(xlt, dsv.xnode, dsv.omgadf)
-        }
+        val temp = DoubleArray(12)
+        val xmdf = data.xmo + dsv.xmdot * tSince
+        val tsq = tSince * tSince
+        val templ = t2cof * tsq
+        dsv.xll = xmdf + dsv.xnodp * templ
+        dsv.omgadf = data.omegao + dsv.omgdot * tSince
+        val xnoddf = data.xnodeo + dsv.xnodot * tSince
+        dsv.xnode = xnoddf + xnodcf * tsq
+        val tempa = 1.0 - c1 * tSince
+        val tempe = data.bstar * c4 * tSince
+        dsv.xn = dsv.xnodp
+        dsv.t = tSince
+        deep.dpsec(data)
+        val a = (XKE / dsv.xn).pow(TWO_THIRDS) * tempa * tempa
+        dsv.em -= tempe
+        deep.dpper()
+        val xl = dsv.xll + dsv.omgadf + dsv.xnode
+        val beta = sqrt(1.0 - dsv.em * dsv.em)
+        dsv.xn = XKE / a.pow(1.5)
+        // Long period periodics
+        val axn = dsv.em * cos(dsv.omgadf)
+        temp[0] = invert(a * beta * beta)
+        val xll = temp[0] * xlcof * axn
+        val aynl = temp[0] * aycof
+        val xlt = xl + xll
+        val ayn = dsv.em * sin(dsv.omgadf) + aynl
+        // Solve Kepler's equation
+        val capu = mod2PI(xlt - dsv.xnode)
+        temp[2] = capu
+        converge(temp, axn, ayn, capu)
+        calculatePosAndVel(temp, a, axn, ayn)
+        calculatePhase(xlt, dsv.xnode, dsv.omgadf)
    }

    private fun calculatePosAndVel(temp: DoubleArray, a: Double, axn: Double, ayn: Double) {
@@ -141,53 +141,51 @@ class NearEarthObject(data: OrbitalData) : OrbitalObject(data) {
    }

    internal fun calculateSGP4(tSince: Double) {
-        synchronized(this) {
-            val temp = DoubleArray(9)
-            val xmdf = data.xmo + xmdot * tSince
-            val omgadf = data.omegao + omgdot * tSince
-            val xnoddf = data.xnodeo + xnodot * tSince
-            var omega = omgadf
-            var xmp = xmdf
-            val tsq = sqr(tSince)
-            val xnode = xnoddf + xnodcf * tsq
-            val bstar = data.bstar
-            var tempa = 1.0 - c1 * tSince
-            var tempe = bstar * c4 * tSince
-            var templ = t2cof * tsq
-            if (!sgp4Simple) {
-                val delomg = omgcof * tSince
-                val delm = xmcof * ((1.0 + eta * cos(xmdf)).pow(3.0) - delmo)
-                temp[0] = delomg + delm
-                xmp = xmdf + temp[0]
-                omega = omgadf - temp[0]
-                val tcube = tsq * tSince
-                val tfour = tSince * tcube
-                tempa = tempa - d2 * tsq - d3 * tcube - d4 * tfour
-                tempe += bstar * c5 * (sin(xmp) - sinmo)
-                templ += t3cof * tcube + tfour * (t4cof + tSince * t5cof)
-            }
-            val a = aodp * tempa.pow(2.0)
-            val eo = data.eccn
-            val e = eo - tempe
-            val xl = xmp + omega + xnode + xnodp * templ
-            val beta = sqrt(1.0 - e * e)
-            val xn = XKE / a.pow(1.5)
-
-            // Long period periodics
-            val axn = e * cos(omega)
-            temp[0] = invert(a * sqr(beta))
-            val xll = temp[0] * xlcof * axn
-            val aynl = temp[0] * aycof
-            val xlt = xl + xll
-            val ayn = e * sin(omega) + aynl
-
-            // Solve Kepler's equation
-            val capu = mod2PI(xlt - xnode)
-            temp[2] = capu
-            converge(temp, axn, ayn, capu)
-            calculatePosAndVel(temp, xnode, a, xn, axn, ayn)
-            calculatePhase(xlt, xnode, omgadf)
+        val temp = DoubleArray(9)
+        val xmdf = data.xmo + xmdot * tSince
+        val omgadf = data.omegao + omgdot * tSince
+        val xnoddf = data.xnodeo + xnodot * tSince
+        var omega = omgadf
+        var xmp = xmdf
+        val tsq = tSince * tSince
+        val xnode = xnoddf + xnodcf * tsq
+        val bstar = data.bstar
+        var tempa = 1.0 - c1 * tSince
+        var tempe = bstar * c4 * tSince
+        var templ = t2cof * tsq
+        if (!sgp4Simple) {
+            val delomg = omgcof * tSince
+            val delm = xmcof * ((1.0 + eta * cos(xmdf)).pow(3.0) - delmo)
+            temp[0] = delomg + delm
+            xmp = xmdf + temp[0]
+            omega = omgadf - temp[0]
+            val tcube = tsq * tSince
+            val tfour = tSince * tcube
+            tempa = tempa - d2 * tsq - d3 * tcube - d4 * tfour
+            tempe += bstar * c5 * (sin(xmp) - sinmo)
+            templ += t3cof * tcube + tfour * (t4cof + tSince * t5cof)
        }
+        val a = aodp * tempa * tempa
+        val eo = data.eccn
+        val e = eo - tempe
+        val xl = xmp + omega + xnode + xnodp * templ
+        val beta = sqrt(1.0 - e * e)
+        val xn = XKE / a.pow(1.5)
+
+        // Long period periodics
+        val axn = e * cos(omega)
+        temp[0] = invert(a * sqr(beta))
+        val xll = temp[0] * xlcof * axn
+        val aynl = temp[0] * aycof
+        val xlt = xl + xll
+        val ayn = e * sin(omega) + aynl
+
+        // Solve Kepler's equation
+        val capu = mod2PI(xlt - xnode)
+        temp[2] = capu
+        converge(temp, axn, ayn, capu)
+        calculatePosAndVel(temp, xnode, a, xn, axn, ayn)
+        calculatePhase(xlt, xnode, omgadf)
    }

    private fun calculatePosAndVel(
@@ -27,7 +27,8 @@ data class OrbitalData(
    val argper: Double,
    val meanan: Double,
    val catnum: Int,
-    val bstar: Double
+    val bstar: Double,
+    val ndot: Double = 0.0
 ) {
    val xincl: Double = incl * DEG2RAD
    val xnodeo: Double = raan * DEG2RAD
@@ -37,4 +38,29 @@ data class OrbitalData(
    val orbitalPeriod: Double = MIN_PER_DAY / meanmo
    val isDeepSpace: Boolean = orbitalPeriod >= 225.0 // NearEarth (period < 225 min) or DeepSpace (period >= 225 min)
    fun getObject(): OrbitalObject = if (isDeepSpace) DeepSpaceObject(this) else NearEarthObject(this)
+
+    /** Check if satellite has likely decayed by the given time. */
+    fun hasDecayed(currentTimeMillis: Long): Boolean {
+        if (ndot == 0.0) return false
+        val currentDaynum = (currentTimeMillis - 315446400000L) / 86400000.0
+        val epochDaynum = epochToDaynum(epoch)
+        return CelestialComputer.hasDecayed(meanmo, ndot, epochDaynum, currentDaynum)
+    }
+
+    private fun epochToDaynum(epoch: Double): Double {
+        var year = kotlin.math.floor(epoch * 1E-3)
+        val day = (epoch * 1E-3 - year) * 1000.0
+        year = if (year < 57) year + 2000 else year + 1900
+        // daynum = days since 31 Dec 1979, Julian date of 31Dec79 = 2444238.5
+        val jan1Jd = julianDateOfYear(year)
+        return jan1Jd + day - 2444238.5
+    }
+
+    private fun julianDateOfYear(theYear: Double): Double {
+        val aYear = theYear - 1
+        val a = kotlin.math.floor(aYear / 100).toLong()
+        val b = 2 - a + a / 4
+        val i = kotlin.math.floor(365.25 * aYear).toLong()
+        return i + (30.6001 * 14).toLong() + 1720994.5 + b
+    }
 }
@@ -0,0 +1,141 @@
+/*
+ * Look4Sat. Amateur radio satellite tracker and pass predictor.
+ * Copyright (C) 2019-2026 Arty Bishop and contributors.
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <https://www.gnu.org/licenses/>.
+ */
+package com.rtbishop.look4sat.core.domain.predict
+
+import kotlin.math.abs
+import kotlin.math.atan2
+import kotlin.math.cos
+import kotlin.math.floor
+import kotlin.math.sin
+import kotlin.math.sqrt
+
+// ── Shared orbital math utilities ──
+// Used by both CelestialComputer (sun/moon/celestial) and OrbitalObject (SGP4/SDP4).
+// Package-internal — not part of the public API.
+
+/**
+ * Greenwich Mean Sidereal Time from Julian Date, in radians [0, 2π).
+ * Identical algorithm used in PREDICT v2.2.5 for both solar and satellite calculations.
+ */
+internal fun thetaGJD(jd: Double): Double {
+    val ut = fraction(jd + 0.5)
+    val aJD = jd - ut
+    val tu = (aJD - 2451545.0) / 36525.0
+    var gmst = 24110.54841 + tu * (8640184.812866 + tu * (0.093104 - tu * 6.2E-6))
+    gmst = modulus(gmst + SEC_PER_DAY * EARTH_ROT_PER_SID_DAY * ut, SEC_PER_DAY)
+    return TWO_PI * gmst / SEC_PER_DAY
+}
+
+/** Fractional part of [arg]. */
+internal fun fraction(arg: Double): Double = arg - floor(arg)
+
+/** Modulo: returns [arg1] mod [arg2], result always in [0, arg2). */
+internal fun modulus(arg1: Double, arg2: Double): Double {
+    var r = arg1
+    val i = floor(r / arg2).toInt()
+    r -= i * arg2
+    if (r < 0.0) r += arg2
+    return r
+}
+
+/** Reduce [value] to [0, 2π). */
+internal fun mod2PI(value: Double): Double {
+    var r = value
+    val i = (r / TWO_PI).toInt()
+    r -= i * TWO_PI
+    if (r < 0.0) r += TWO_PI
+    return r
+}
+
+/**
+ * Delta-ET: difference between Universal Time and Ephemeris Time (seconds).
+ * Based on least-squares fit from 1950 to 1991 (PREDICT v2.2.5).
+ */
+internal fun deltaET(year: Double): Double =
+    26.465 + 0.747622 * (year - 1950) + 1.886913 * sin(TWO_PI * (year - 1975) / 33)
+
+/**
+ * Convert Unix epoch milliseconds to daynum (days since 31 Dec 1979 00:00:00 UTC).
+ */
+internal fun millisToDaynum(timeMillis: Long): Double =
+    (timeMillis - 315446400000L) / 86400000.0
+
+/** Convert daynum back to Unix epoch milliseconds. */
+internal fun daynumToMillis(daynum: Double): Long =
+    ((daynum + 3651.0) * 86400000.0).toLong()
+
+/**
+ * Compute the Sun's ECI position vector at [julUtc] (Julian UTC).
+ * Returns [x, y, z, magnitude] in km.
+ * Based on Calculate_Solar_Position() / FindSun() from PREDICT v2.2.5.
+ */
+internal fun solarPositionECI(julUtc: Double): DoubleArray {
+    val mjd = julUtc - 2415020.0
+    val year = 1900 + mjd / 365.25
+    val t = (mjd + deltaET(year) / SEC_PER_DAY) / 36525.0
+    val mDeg = mod360(358.47583 + mod360(35999.04975 * t) - (0.000150 + 0.0000033 * t) * t * t)
+    val m = mDeg * DEG2RAD
+    val lDeg = mod360(279.69668 + mod360(36000.76892 * t) + 0.0003025 * t * t)
+    val l = lDeg * DEG2RAD
+    val e = 0.01675104 - (0.0000418 + 0.000000126 * t) * t
+    val cDeg = (1.919460 - (0.004789 + 0.000014 * t) * t) * sin(m) +
+        (0.020094 - 0.000100 * t) * sin(2 * m) + 0.000293 * sin(3 * m)
+    val c = cDeg * DEG2RAD
+    val oDeg = mod360(259.18 - 1934.142 * t)
+    val o = oDeg * DEG2RAD
+    val lsa = mod2PI(l + c - (0.00569 - 0.00479 * sin(o)) * DEG2RAD)
+    val nu = mod2PI(m + c)
+    var r = 1.0000002 * (1.0 - e * e) / (1.0 + e * cos(nu))
+    val epsDeg = 23.452294 - (0.0130125 + (0.00000164 - 0.000000503 * t) * t) * t + 0.00256 * cos(o)
+    val eps = epsDeg * DEG2RAD
+    r *= ASTRONOMICAL_UNIT
+    return doubleArrayOf(r * cos(lsa), r * sin(lsa) * cos(eps), r * sin(lsa) * sin(eps), r)
+}
+
+/**
+ * Convert ECI position [eciPos] = [x, y, z] (km) to geodetic [lat_rad, lon_rad, alt_km].
+ * Based on Calculate_LatLonAlt() from PREDICT v2.2.5.
+ */
+internal fun eciToGeodetic(julUtc: Double, eciPos: DoubleArray): DoubleArray {
+    val thetaPos = atan2(eciPos[1], eciPos[0])
+    val lon = mod2PI(thetaPos - thetaGJD(julUtc))
+    val r = sqrt(eciPos[0] * eciPos[0] + eciPos[1] * eciPos[1])
+    val e2 = FLAT_FACT * (2.0 - FLAT_FACT)
+    var lat = atan2(eciPos[2], r)
+    var phi: Double
+    var c: Double
+    var i = 0
+    do {
+        phi = lat
+        c = 1.0 / sqrt(1.0 - e2 * sin(phi) * sin(phi))
+        lat = atan2(eciPos[2] + EARTH_RADIUS * c * e2 * sin(phi), r)
+    } while (i++ < 10 && abs(lat - phi) >= 1E-10)
+    val alt = r / cos(lat) - EARTH_RADIUS * c
+    if (lat > PI_2) lat -= TWO_PI
+    return doubleArrayOf(lat, lon, alt)
+}
+
+// Private helpers
+
+private fun mod360(x: Double): Double {
+    var r = x
+    val i = (r / 360.0).toInt()
+    r -= i * 360.0
+    if (r < 0.0) r += 360.0
+    return r
+}
@@ -42,6 +42,27 @@ abstract class OrbitalObject(val data: OrbitalData) {
    var qoms24 = 0.0
    var s4 = 0.0

+    // Pre-allocated reusable vectors to avoid GC pressure in hot loops
+    private val obsPos = Vector4()
+    private val obsVel = Vector4()
+    private val rangeVector = Vector4()
+    private val rgvelVector = Vector4()
+    private val squintVector = Vector4()
+
+    // Cached observer position data to avoid recalculation when observer hasn't moved
+    private var cachedGsLat = Double.NaN
+    private var cachedGsLon = Double.NaN
+    private var cachedGsAlt = Double.NaN
+    private var cachedSinLat = 0.0
+    private var cachedCosLat = 0.0
+    private var cachedObsC = 0.0
+    private var cachedObsSq = 0.0
+    private var cachedObsAchFactor = 0.0
+    private var cachedObsZFactor = 0.0
+
+    // Cache for julian epoch to avoid recomputing every call
+    private val julEpoch: Double = juliandDateOfEpoch(data.epoch)
+
    fun willBeSeen(pos: GeoPos): Boolean {
        return if (data.meanmo < 1e-8) false
        else {
@@ -57,15 +78,13 @@ abstract class OrbitalObject(val data: OrbitalData) {
        orbitalPos = OrbitalPos()
        // Date/time at which the position and velocity were calculated
        julUTC = calcCurrentDaynum(time) + 2444238.5
-        // Convert satellite's epoch time to Julian and calculate time since epoch in minutes
-        val julEpoch = juliandDateOfEpoch(data.epoch)
+        // Calculate time since epoch in minutes
        val tsince = (julUTC - julEpoch) * MIN_PER_DAY
        calculateSDP4orSGP4(tsince)
        // Scale position and velocity vectors to km and km/sec
        convertSatState(position, velocity)
        // Calculate velocity of satellite
        magnitude(velocity)
-        val squintVector = Vector4()
        // Angles in rads, dist in km, vel in km/S. Calculate sat Az, El, Range and Range-rate.
        calculateObs(julUTC, position, velocity, pos, squintVector)
        calculateLatLonAlt(julUTC)
@@ -75,6 +94,38 @@ abstract class OrbitalObject(val data: OrbitalData) {
        return orbitalPos
    }

+    /**
+     * Lightweight elevation-only check for pass finding. Avoids full lat/lon/alt,
+     * eclipse, and squint calculations that aren't needed when just searching for
+     * horizon crossings.
+     */
+    fun getElevation(pos: GeoPos, time: Long): Double {
+        julUTC = calcCurrentDaynum(time) + 2444238.5
+        val tsince = (julUTC - julEpoch) * MIN_PER_DAY
+        calculateSDP4orSGP4(tsince)
+        convertSatState(position, velocity)
+        magnitude(velocity)
+        calculateObs(julUTC, position, velocity, pos, squintVector)
+        return orbitalPos.elevation
+    }
+
+    /**
+     * Full position calculation that also populates azimuth, altitude, etc.
+     * Used when we need all fields (AOS/LOS refinement, track computation).
+     */
+    fun getFullPosition(pos: GeoPos, time: Long): OrbitalPos {
+        orbitalPos = OrbitalPos()
+        julUTC = calcCurrentDaynum(time) + 2444238.5
+        val tsince = (julUTC - julEpoch) * MIN_PER_DAY
+        calculateSDP4orSGP4(tsince)
+        convertSatState(position, velocity)
+        magnitude(velocity)
+        calculateObs(julUTC, position, velocity, pos, squintVector)
+        calculateLatLonAlt(julUTC)
+        orbitalPos.time = time
+        return orbitalPos
+    }
+
    private fun calcCurrentDaynum(now: Long): Double {
        val then = 315446400000 // time in millis on 31Dec79 00:00:00 UTC (daynum 0)
        return (now - then) / 1000.0 / 60.0 / 60.0 / 24.0
@@ -117,38 +168,34 @@ abstract class OrbitalObject(val data: OrbitalData) {
        gsPos: GeoPos,
        squintVector: Vector4
    ) {
-        val obsPos = Vector4()
-        val obsVel = Vector4()
-        val range = Vector4()
-        val rgvel = Vector4()
        calculateUserPosVel(julianUTC, gsPos, obsPos, obsVel)
-        range.setXYZ(
+        rangeVector.setXYZ(
            positionVector.x - obsPos.x,
            positionVector.y - obsPos.y,
            positionVector.z - obsPos.z
        )
        // Save these values globally for calculating squint angles later
-        squintVector.setXYZ(range.x, range.y, range.z)
-        rgvel.setXYZ(
+        squintVector.setXYZ(rangeVector.x, rangeVector.y, rangeVector.z)
+        rgvelVector.setXYZ(
            velocityVector.x - obsVel.x,
            velocityVector.y - obsVel.y,
            velocityVector.z - obsVel.z
        )
-        magnitude(range)
-        val sinLat = sin(DEG2RAD * gsPos.latitude)
-        val cosLat = cos(DEG2RAD * gsPos.latitude)
+        magnitude(rangeVector)
+        val sinLat = cachedSinLat
+        val cosLat = cachedCosLat
        val sinTheta = sin(gsPosTheta)
        val cosTheta = cos(gsPosTheta)
-        val topS = sinLat * cosTheta * range.x + sinLat * sinTheta * range.y - cosLat * range.z
-        val topE = -sinTheta * range.x + cosTheta * range.y
-        val topZ = cosLat * cosTheta * range.x + cosLat * sinTheta * range.y + sinLat * range.z
+        val topS = sinLat * cosTheta * rangeVector.x + sinLat * sinTheta * rangeVector.y - cosLat * rangeVector.z
+        val topE = -sinTheta * rangeVector.x + cosTheta * rangeVector.y
+        val topZ = cosLat * cosTheta * rangeVector.x + cosLat * sinTheta * rangeVector.y + sinLat * rangeVector.z
        var azim = atan(-topE / topS)
        if (topS > 0.0) azim += PI
        if (azim < 0.0) azim += TWO_PI
        orbitalPos.azimuth = azim
-        orbitalPos.elevation = asin(topZ / range.w)
-        orbitalPos.distance = range.w
-        orbitalPos.distanceRate = dot(range, rgvel) / range.w
+        orbitalPos.elevation = asin(topZ / rangeVector.w)
+        orbitalPos.distance = rangeVector.w
+        orbitalPos.distanceRate = dot(rangeVector, rgvelVector) / rangeVector.w
        var elevation = orbitalPos.elevation / TWO_PI * 360.0
        if (elevation > 90) elevation = 180 - elevation
        orbitalPos.aboveHorizon = elevation - 0 > EPSILON
@@ -163,12 +210,24 @@ abstract class OrbitalObject(val data: OrbitalData) {
    ) {
        val mFactor = 7.292115E-5
        gsPosTheta = mod2PI(thetaGJD(time) + DEG2RAD * gsPos.longitude)
-        val c = invert(sqrt(1.0 + FLAT_FACT * (FLAT_FACT - 2) * sqr(sin(DEG2RAD * gsPos.latitude))))
-        val sq = sqr(1.0 - FLAT_FACT) * c
-        val achcp = (EARTH_RADIUS * c + gsPos.altitude / 1000.0) * cos(DEG2RAD * gsPos.latitude)
+
+        // Cache trig and position factors when observer position changes
+        if (gsPos.latitude != cachedGsLat || gsPos.longitude != cachedGsLon || gsPos.altitude != cachedGsAlt) {
+            cachedGsLat = gsPos.latitude
+            cachedGsLon = gsPos.longitude
+            cachedGsAlt = gsPos.altitude
+            cachedSinLat = sin(DEG2RAD * gsPos.latitude)
+            cachedCosLat = cos(DEG2RAD * gsPos.latitude)
+            cachedObsC = invert(sqrt(1.0 + FLAT_FACT * (FLAT_FACT - 2) * sqr(cachedSinLat)))
+            cachedObsSq = sqr(1.0 - FLAT_FACT) * cachedObsC
+            cachedObsAchFactor = (EARTH_RADIUS * cachedObsC + gsPos.altitude / 1000.0) * cachedCosLat
+            cachedObsZFactor = (EARTH_RADIUS * cachedObsSq + gsPos.altitude / 1000.0) * cachedSinLat
+        }
+
        obsPos.setXYZ(
-            achcp * cos(gsPosTheta), achcp * sin(gsPosTheta),
-            (EARTH_RADIUS * sq + gsPos.altitude / 1000.0) * sin(DEG2RAD * gsPos.latitude)
+            cachedObsAchFactor * cos(gsPosTheta),
+            cachedObsAchFactor * sin(gsPosTheta),
+            cachedObsZFactor
        )
        obsVel.setXYZ(-mFactor * obsPos.y, mFactor * obsPos.x, 0.0)
        magnitude(obsPos)
@@ -255,14 +314,8 @@ abstract class OrbitalObject(val data: OrbitalData) {
        return 1.0 / value
    }

-    // Calculates the modulus of 2 * PI
-    internal fun mod2PI(value: Double): Double {
-        var retVal = value
-        val i = (retVal / TWO_PI).toInt()
-        retVal -= i * TWO_PI
-        if (retVal < 0.0) retVal += TWO_PI
-        return retVal
-    }
+    // Delegates to package-level mod2PI in OrbitalMath.kt
+    internal fun mod2PI(value: Double): Double = com.rtbishop.look4sat.core.domain.predict.mod2PI(value)

    // Solves Keplers' Equation
    internal fun converge(temp: DoubleArray, axn: Double, ayn: Double, capu: Double) {
@@ -364,19 +417,8 @@ abstract class OrbitalObject(val data: OrbitalData) {
        return acos(dot(v1, v2) / (v1.w * v2.w))
    }

-    /**
-     * The function Delta_ET has been added to allow calculations on the
-     * position of the sun. It provides the difference between UT (approximately
-     * the same as UTC) and ET (now referred to as TDT) This function is based
-     * on a least squares fit of data from 1950 to 1991 and will need to be
-     * updated periodically.
-     *
-     * Values determined using data from 1950-1991 in the 1990 Astronomical
-     * Almanac. See DELTA_ET.WQ1 for details.
-     */
-    private fun deltaEt(year: Double): Double {
-        return 26.465 + 0.747622 * (year - 1950) + (1.886913 * sin(TWO_PI * (year - 1975) / 33))
-    }
+    // Delegates to package-level deltaET in OrbitalMath.kt
+    private fun deltaEt(year: Double): Double = deltaET(year)

    private fun radians(degrees: Double): Double {
        return degrees * DEG2RAD
@@ -387,23 +429,13 @@ abstract class OrbitalObject(val data: OrbitalData) {
        return v1.x * v2.x + v1.y * v2.y + v1.z * v2.z
    }

-    // Returns fractional part of double argument
-    private fun fraction(arg: Double): Double {
-        return arg - floor(arg)
-    }
-
    // Calculates scalar magnitude of a vector4 argument
    private fun magnitude(v: Vector4) {
        v.w = sqrt(sqr(v.x) + sqr(v.y) + sqr(v.z))
    }

-    private fun modulus(arg1: Double, arg2: Double = SEC_PER_DAY): Double {
-        var returnValue = arg1
-        val i = floor(returnValue / arg2).toInt()
-        returnValue -= i * arg2
-        if (returnValue < 0.0) returnValue += arg2
-        return returnValue
-    }
+    private fun modulus(arg1: Double, arg2: Double = SEC_PER_DAY): Double =
+        com.rtbishop.look4sat.core.domain.predict.modulus(arg1, arg2)

    // Multiplies the vector v1 by the scalar k
    private fun scaleVector(k: Double, v: Vector4) {
@@ -411,13 +443,6 @@ abstract class OrbitalObject(val data: OrbitalData) {
        magnitude(v)
    }

-    private fun thetaGJD(theJD: Double): Double {
-        val earthRotPerSidDay = 1.00273790934
-        val ut = fraction(theJD + 0.5)
-        val aJD = theJD - ut
-        val tu = (aJD - 2451545.0) / 36525.0
-        var gmst = 24110.54841 + tu * (8640184.812866 + tu * (0.093104 - tu * 6.2E-6))
-        gmst = modulus(gmst + SEC_PER_DAY * earthRotPerSidDay * ut)
-        return TWO_PI * gmst / SEC_PER_DAY
-    }
+    // Delegates to package-level thetaGJD in OrbitalMath.kt
+    private fun thetaGJD(theJD: Double): Double = com.rtbishop.look4sat.core.domain.predict.thetaGJD(theJD)
 }
@@ -25,9 +25,10 @@ data class OrbitalPass(
    val altitude: Int = 1000,
    val maxElevation: Double = 75.0,
    val orbitalObject: OrbitalObject,
-    var progress: Float = 0.0f
+    val progress: Float = 0.0f,
+    val hasDecayed: Boolean = false
 ) {
    val catNum: Int = orbitalObject.data.catnum
-    val name: String = orbitalObject.data.name
+    val name: String = if (hasDecayed) "${orbitalObject.data.name} (decayed?)" else orbitalObject.data.name
    val isDeepSpace: Boolean = orbitalObject.data.isDeepSpace
 }
@@ -21,7 +21,6 @@ import kotlin.math.acos
 import kotlin.math.asin
 import kotlin.math.atan2
 import kotlin.math.cos
-import kotlin.math.pow
 import kotlin.math.sin
 import kotlin.math.sqrt

@@ -50,23 +49,30 @@ data class OrbitalPos(
    }

    fun getOrbitalVelocity(): Double {
-        val earthG = 6.674 * 10.0.pow(-11)
-        val earthM = 5.98 * 10.0.pow(24)
-        val radius = 6.37 * 10.0.pow(6) + altitude * 10.0.pow(3)
-        return sqrt(earthG * earthM / radius) / 1000
+        val radius = EARTH_RADIUS_M + altitude * 1000.0
+        return sqrt(GM_EARTH / radius) / 1000.0
    }

    fun getRangeCircle(): List<GeoPos> {
-        val rangeCirclePoints = mutableListOf<GeoPos>()
-        val beta = acos(EARTH_RADIUS / (EARTH_RADIUS + altitude)) // * EARTH_RADIUS = radiusKm
+        val pointCount = 721
+        val rangeCirclePoints = ArrayList<GeoPos>(pointCount)
+        val beta = acos(EARTH_RADIUS / (EARTH_RADIUS + altitude))
+        val sinLat = sin(latitude)
+        val cosLat = cos(latitude)
+        val cosBeta = cos(beta)
+        val sinBeta = sin(beta)
        for (azimuth in 0..720) {
            val rads = azimuth * DEG2RAD
-            val lat = asin(sin(latitude) * cos(beta) + (cos(latitude) * sin(beta) * cos(rads)))
-            val lon = (longitude + atan2(
-                sin(rads) * sin(beta) * cos(latitude), cos(beta) - sin(latitude) * sin(lat)
-            ))
+            val lat = asin(sinLat * cosBeta + cosLat * sinBeta * cos(rads))
+            val lon = longitude + atan2(sin(rads) * sinBeta * cosLat, cosBeta - sinLat * sin(lat))
            rangeCirclePoints.add(GeoPos(lat * RAD2DEG, lon * RAD2DEG))
        }
        return rangeCirclePoints
    }
+
+    companion object {
+        // Pre-computed constants for orbital velocity calculation
+        private const val GM_EARTH = 3.986004418E14 // m^3/s^2
+        private const val EARTH_RADIUS_M = 6.37E6 // meters
+    }
 }
@@ -0,0 +1,23 @@
+package com.rtbishop.look4sat.core.domain.repository
+
+import com.rtbishop.look4sat.core.domain.model.AmSatReportSubmission
+import com.rtbishop.look4sat.core.domain.model.AmSatReportSubmitResult
+import com.rtbishop.look4sat.core.domain.model.SatStatusPage
+
+/** AMSAT satellite status data source */
+interface IAmSatRepository {
+    /** Cached AMSAT status page for the current foreground session, if any. */
+    fun getCachedStatus(): SatStatusPage?
+
+    /** Fetch and parse the AMSAT status page; null on failure. */
+    suspend fun fetchStatus(forceRefresh: Boolean = false): SatStatusPage?
+
+    /** Warm the foreground-session cache without forcing a network reload. */
+    suspend fun prefetchStatus()
+
+    /** Clear the foreground-session status cache. */
+    fun clearStatusCache()
+
+    /** Submit a public AMSAT satellite status report. */
+    suspend fun submitReport(submission: AmSatReportSubmission): AmSatReportSubmitResult
+}
@@ -18,8 +18,8 @@
 package com.rtbishop.look4sat.core.domain.repository

 interface IDatabaseRepo {
-    suspend fun updateTLEFromFile(uri: String)
-    suspend fun updateTransceiversFromFile(uri: String)
+    suspend fun updateTLEFromFile(uri: String): Int
+    suspend fun updateTransceiversFromFile(uri: String): Int
    suspend fun updateFromRemote()
    suspend fun clearAllData()
 }
@@ -0,0 +1,72 @@
+/*
+ * Look4Sat. Amateur radio satellite tracker and pass predictor.
+ * Copyright (C) 2019-2026 Arty Bishop and contributors.
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <https://www.gnu.org/licenses/>.
+ */
+package com.rtbishop.look4sat.core.domain.repository
+
+/** Fetches confirmed gridsquares directly from ARRL LoTW. */
+interface ILoTWRepository {
+
+    /**
+     * Fetch all confirmed (QSL_RCVD=Y) gridsquares for the given LoTW account.
+     * Returns the 4-char grid set with an explicit failure cause on error.
+     */
+    suspend fun fetchConfirmedGrids(callsign: String, password: String): LoTWResult
+
+    /**
+     * Same report, but keeps the per-QSO detail of every confirmed satellite
+     * QSO (call / time / satellite / mode / bands), grouped by worked 4-char
+     * gridsquare. Failure cause is kept explicit.
+     *
+     * @param since   QSL-since date ("yyyyMMdd" or "yyyy-MM-dd"); use an early
+     *                date for a full report, or the last sync date for an
+     *                incremental pull. Empty falls back to a full report.
+     * @param onProgress  streamed download progress (phase + bytes + estimate),
+     *                invoked from the IO dispatcher; may be called on every
+     *                read chunk.
+     */
+    suspend fun fetchConfirmedGridQsos(
+        callsign: String,
+        password: String,
+        since: String = "",
+        onProgress: (LoTWProgress) -> Unit = {}
+    ): LoTWResult
+}
+
+/** Streamed progress of a LoTW report download. */
+data class LoTWProgress(
+    val phase: LoTWPhase,
+    /** Bytes read so far (uncompressed body). */
+    val bytesRead: Long = 0,
+    /** Estimated total body bytes, derived from <APP_LoTW_NUMREC>; 0 before known. */
+    val expectedBytes: Long = 0,
+    /** Smoothed download speed in bytes/second; 0 while unknown. */
+    val speedBps: Long = 0,
+    /** Total QSL records reported in the header (<APP_LoTW_NUMREC>); 0 before known. */
+    val qsoCount: Long = 0
+) {
+    /** Fraction 0..1 of the estimated body already read; 0 while unknown. */
+    val fraction: Float
+        get() = if (expectedBytes > 0 && bytesRead > 0)
+            (bytesRead.toFloat() / expectedBytes).coerceIn(0f, 1f) else 0f
+
+    /** Estimated seconds remaining; 0 while size or speed is unknown. */
+    val remainingSeconds: Long
+        get() = if (expectedBytes > 0 && speedBps > 0)
+            ((expectedBytes - bytesRead) / speedBps).coerceAtLeast(0) else 0L
+}
+
+enum class LoTWPhase { Connecting, Downloading }
@@ -1,8 +1,28 @@
+/*
+ * Look4Sat. Amateur radio satellite tracker and pass predictor.
+ * Copyright (C) 2019-2026 Arty Bishop and contributors.
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <https://www.gnu.org/licenses/>.
+ */
 package com.rtbishop.look4sat.core.domain.repository
-
+import com.rtbishop.look4sat.core.domain.model.SatRadio
 import com.rtbishop.look4sat.core.domain.usecase.IAddToCalendar
+import com.rtbishop.look4sat.core.domain.usecase.IAudioCapture
+import com.rtbishop.look4sat.core.domain.usecase.ISaveImage
 import com.rtbishop.look4sat.core.domain.usecase.IShowToast
 import kotlinx.coroutines.CoroutineScope
+import kotlinx.coroutines.flow.StateFlow

 interface IMainContainer {
    val appScope: CoroutineScope
@@ -10,13 +30,43 @@ interface IMainContainer {
    val selectionRepo: ISelectionRepo
    val satelliteRepo: ISatelliteRepo
    val databaseRepo: IDatabaseRepo
+    val amSatRepo: IAmSatRepository
+    val updateRepo: IUpdateRepository
+    val wavelogRepo: IWavelogRepository
+    val lotwRepo: com.rtbishop.look4sat.core.domain.repository.ILoTWRepository
+    val radioTrackingService: IRadioTrackingService
+    val mutualPassData: StateFlow<MutualPassData>
+    fun setMutualPassData(data: MutualPassData)
    fun provideAddToCalendar(): IAddToCalendar
    fun provideShowToast(): IShowToast
-    fun provideBluetoothReporter(): IReporterRepo<WithoutExtParams>
-    fun provideNetworkReporter(): IReporterRepo<ExtendedParams>
+    fun provideBluetoothReporter(): IReporter
+    fun provideNetworkReporter(): IReporter
    fun provideSensorsRepo(): ISensorsRepo
+    fun provideTxRadioController(): IRadioController
+    fun provideRxRadioController(): IRadioController
+    fun provideAudioCapture(): IAudioCapture
+    fun provideSaveImage(): ISaveImage
 }

+data class MutualPassData(
+    val samples: List<Pair<Long, Pair<Double, Double>>> = emptyList(),
+    val trackSamples: List<TrackSampleData> = emptyList(),
+    val startTime: Long = 0L,
+    val endTime: Long = 0L,
+    val maxElev: Double = 10.0,
+    val labelA: String = "你",
+    val labelB: String = "友台"
+)
+
+/** Minimal track sample for cross-module sharing (angles in degrees). */
+data class TrackSampleData(
+    val time: Long = 0L,
+    val azimuthA: Double,
+    val elevationA: Double,
+    val azimuthB: Double,
+    val elevationB: Double
+)
+
 interface IContainerProvider {
    fun getMainContainer(): IMainContainer
 }
@@ -0,0 +1,88 @@
+/*
+ * Look4Sat. Amateur radio satellite tracker and pass predictor.
+ * Copyright (C) 2019-2026 Arty Bishop and contributors.
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <https://www.gnu.org/licenses/>.
+ */
+package com.rtbishop.look4sat.core.domain.repository
+
+interface IRadioController {
+
+    val isConnected: Boolean
+
+    suspend fun connect(): Boolean
+
+    suspend fun disconnect()
+
+    suspend fun setFrequency(frequencyHz: Long): Boolean
+
+    suspend fun setMode(mode: String): Boolean
+
+    suspend fun setCtcssMode(enabled: Boolean): Boolean
+
+    suspend fun setCtcssTone(toneHz: Double): Boolean
+
+    suspend fun readFrequencyAndMode(): Pair<Long, String>?
+
+    suspend fun pttOn(): Boolean
+
+    suspend fun pttOff(): Boolean
+
+    // ── Extended operations (IC-705 / CI-V) ──────────────────────────────
+
+    /**
+     * Select the band matching [frequencyHz] via the band stacking register.
+     * Must be called before [setFrequency] and [setMode] when first tracking.
+     * Default: no-op (Yaesu radios auto-switch band via frequency).
+     */
+    suspend fun setBand(frequencyHz: Long): Boolean = false
+
+    /**
+     * Select the active VFO.
+     * @param vfoA true → VFO-A (main/RX), false → VFO-B (sub/TX in split).
+     */
+    suspend fun setVfo(vfoA: Boolean): Boolean = false
+
+    /**
+     * Enable or disable SPLIT mode (TX on sub-VFO, RX on main VFO).
+     * Default: not supported.
+     */
+    suspend fun setSplitMode(enabled: Boolean): Boolean = false
+
+    /**
+     * Set the frequency of the currently active VFO (IC-705: CMD 0x25 sub 0x00).
+     * Default: delegates to [setFrequency].
+     */
+    suspend fun setWorkingFrequency(frequencyHz: Long): Boolean = setFrequency(frequencyHz)
+
+    /**
+     * Set the frequency of the inactive/TX VFO (IC-705: CMD 0x25 sub 0x01).
+     * Sent every tracking cycle alongside [setWorkingFrequency] in split mode.
+     * Default: delegates to [setWorkingFrequency].
+     */
+    suspend fun setTxVfoFrequency(frequencyHz: Long): Boolean = setWorkingFrequency(frequencyHz)
+
+    /**
+     * Read the frequency of the currently active VFO (IC-705: CMD 0x25 sub 0x00).
+     * Default: delegates to [readFrequencyAndMode].
+     */
+    suspend fun readWorkingFrequency(): Long? = readFrequencyAndMode()?.first
+
+    /**
+     * Read the frequency of the inactive/TX VFO (IC-705: CMD 0x25 sub 0x01).
+     * Used for tuning detection in split mode.
+     * Default: delegates to [readWorkingFrequency].
+     */
+    suspend fun readTxVfoFrequency(): Long? = readWorkingFrequency()
+}
@@ -0,0 +1,55 @@
+/*
+ * Look4Sat. Amateur radio satellite tracker and pass predictor.
+ * Copyright (C) 2019-2026 Arty Bishop and contributors.
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <https://www.gnu.org/licenses/>.
+ */
+package com.rtbishop.look4sat.core.domain.repository
+
+import com.rtbishop.look4sat.core.domain.model.SatRadio
+import com.rtbishop.look4sat.core.domain.predict.OrbitalObject
+import com.rtbishop.look4sat.core.domain.predict.OrbitalPass
+import kotlinx.coroutines.flow.StateFlow
+
+data class RadioTrackingState(
+    val isActive: Boolean = false,
+    val txConnected: Boolean = false,
+    val rxConnected: Boolean = false,
+    val txFrequencyHz: Long? = null,
+    val rxFrequencyHz: Long? = null,
+    val txMode: String? = null,
+    val rxMode: String? = null,
+    val ctcssTone: Double? = null,
+    val txBaseFrequencyHz: Long? = null,
+    val selectedTransponder: SatRadio? = null,
+    val currentPass: OrbitalPass? = null,
+    val azimuth: Double = 0.0,
+    val elevation: Double = 0.0,
+    val distance: Double = 0.0,
+    val errorMessage: String? = null
+)
+
+interface IRadioTrackingService {
+    val state: StateFlow<RadioTrackingState>
+
+    suspend fun connectRadios()
+    suspend fun disconnectRadios()
+    fun startTracking(pass: OrbitalPass, transponder: SatRadio, txBaseFreqHz: Long?)
+    fun stopTracking()
+    fun setTransponder(transponder: SatRadio)
+    fun setTxBaseFrequency(frequencyHz: Long)
+    fun adjustTxBaseFrequency(deltaHz: Long)
+    fun setCtcssTone(toneHz: Double?)
+    fun setMode(txMode: String, rxMode: String)
+}
@@ -17,18 +17,7 @@
 */
 package com.rtbishop.look4sat.core.domain.repository

-interface IReporterParams
-
-interface IReporterRepo<T : IReporterParams> {
-    fun isConnected(service: BtService): Boolean
-    fun isConnecting(service: BtService): Boolean
-    fun connect(service: BtService, deviceId: String)
-    fun reportRotation(format: String, azimuth: Double, elevation: Double, params: T)
-    fun reportFrequency(format: String, frequency: Long, params: T)
+interface IReporter {
+    fun reportRotation(format: String, azimuth: Double, elevation: Double)
+    fun reportFrequency(format: String, frequency: Long)
 }
-
-data class ExtendedParams(val server: String, val port: Int) : IReporterParams
-
-data class WithoutExtParams(val dummy: Int) : IReporterParams
-
-enum class BtService { ROTATOR, FREQUENCY }
@@ -25,13 +25,44 @@ import com.rtbishop.look4sat.core.domain.predict.OrbitalPos
 import kotlinx.coroutines.flow.StateFlow

 interface ISatelliteRepo {
-    val passes: StateFlow<List<OrbitalPass>>
+    /** All selected OrbitalObjects, updated when the selection changes. */
    val satellites: StateFlow<List<OrbitalObject>>
-    suspend fun getRadiosWithId(id: Int): List<SatRadio>
+
+    /** Raw calculated passes (without live progress). Updated on selection/filter change. */
+    val passes: StateFlow<List<OrbitalPass>>
+
+    /** Whether the repo is currently calculating passes. */
+    val isCalculating: StateFlow<Boolean>
+
+    /** Currently selected pass (catNum + aosTime), persisted across screen navigations. */
+    val selectedPass: StateFlow<Pair<Int, Long>>
+
+    /** Set the currently selected pass. */
+    fun selectPass(catNum: Int, aosTime: Long)
+
+    /** Load satellite objects from DB based on the current selection. */
    suspend fun initRepository()
+
+    /** Recalculate passes with the given filter parameters. */
+    suspend fun calculatePasses(
+        time: Long,
+        hoursAhead: Int,
+        minElevation: Double,
+        aosStartMinute: Int,
+        aosEndMinute: Int,
+        invertAosTimeWindow: Boolean,
+        modes: List<String>
+    )
+
+    /** Get the current position of a single satellite. */
    suspend fun getPosition(sat: OrbitalObject, pos: GeoPos, time: Long): OrbitalPos
+
+    /** Get the ground track for a satellite over a time range. */
    suspend fun getTrack(sat: OrbitalObject, pos: GeoPos, start: Long, end: Long): List<OrbitalPos>
+
+    /** Get Doppler-shifted radio frequencies for a satellite at the given time. */
    suspend fun getRadios(sat: OrbitalObject, pos: GeoPos, radios: List<SatRadio>, time: Long): List<SatRadio>
-    suspend fun processPasses(passList: List<OrbitalPass>, time: Long): List<OrbitalPass>
-    suspend fun calculatePasses(time: Long, hoursAhead: Int, minElevation: Double, modes: List<String>)
+
+    /** Fetch radio transceivers for a satellite by its catalog number. */
+    suspend fun getRadiosWithId(id: Int): List<SatRadio>
 }
@@ -20,8 +20,19 @@ package com.rtbishop.look4sat.core.domain.repository
 import com.rtbishop.look4sat.core.domain.predict.GeoPos
 import kotlinx.coroutines.flow.StateFlow

+/** 指南针校准精度等级, 由磁场传感器 accuracy 事件映射而来. */
+enum class CompassAccuracy {
+    UNAVAILABLE,
+    UNRELIABLE,
+    LOW,
+    MEDIUM,
+    HIGH
+}
+
 interface ISensorsRepo {
-    val orientation: StateFlow<Pair<Float, Float>>
+    val sensorData: StateFlow<Pair<Float, Float>>
+    /** 指南针当前校准精度 (磁场传感器 accuracy), 用于校准对话框进度. */
+    val compassAccuracy: StateFlow<CompassAccuracy>
    fun getMagDeclination(geoPos: GeoPos, time: Long = System.currentTimeMillis()): Float
    fun enableSensor()
    fun disableSensor()
@@ -22,6 +22,8 @@ import com.rtbishop.look4sat.core.domain.model.DatabaseState
 import com.rtbishop.look4sat.core.domain.model.OtherSettings
 import com.rtbishop.look4sat.core.domain.model.PassesSettings
 import com.rtbishop.look4sat.core.domain.model.RCSettings
+import com.rtbishop.look4sat.core.domain.model.RadioControlSettings
+import com.rtbishop.look4sat.core.domain.model.WavelogSettings
 import com.rtbishop.look4sat.core.domain.predict.GeoPos
 import kotlinx.coroutines.flow.StateFlow

@@ -57,39 +59,62 @@ interface ISettingsRepo {

    //region # RC settings
    val rcSettings: StateFlow<RCSettings>
-    fun setBluetoothRotatorAddress(value: String)
-    fun setBluetoothRotatorFormat(value: String)
-    fun setBluetoothRotatorName(value: String)
-    fun setBluetoothRotatorState(value: Boolean)
-    fun setBluetoothFrequencyAddress(value: String)
-    fun setBluetoothFrequencyFormat(value: String)
-    fun setBluetoothFrequencyState(value: Boolean)
-    fun setRotatorAddress(value: String)
-    fun setRotatorPort(value: String)
-    fun setRotatorState(value: Boolean)
-    fun setRotatorFormat(value: String)
-    fun setFrequencyAddress(value: String)
-    fun setFrequencyPort(value: String)
-    fun setFrequencyState(value: Boolean)
-    fun setFrequencyFormat(value: String)
+    fun updateRCSettings(settings: RCSettings)
    //endregion

    //region # Other settings
    val otherSettings: StateFlow<OtherSettings>
-    fun setStateOfAutoUpdate(value: Boolean)
-    fun setStateOfSensors(value: Boolean)
-    fun setStateOfSweep(value: Boolean)
-    fun setStateOfUtc(value: Boolean)
-    fun setStateOfLightTheme(value: Boolean)
-    fun setWarningDismissed()
-    fun setWhatsNewDismissed()
+    fun updateOtherSettings(transform: (OtherSettings) -> OtherSettings)
+    fun setWarningDismissed() = updateOtherSettings { it.copy(shouldSeeWarning = false) }
+    fun setWhatsNewDismissed() = updateOtherSettings { it.copy(shouldSeeWhatsNew = false) }
    //endregion

    //region # Transceivers settings
    val dataSourcesSettings: StateFlow<DataSourcesSettings>
-    fun setUseCustomTle(value: Boolean)
-    fun setUseCustomTransceivers(value: Boolean)
-    fun setTleUrl(value: String)
-    fun setTransceiversUrl(value: String)
+    fun updateDataSourcesSettings(settings: DataSourcesSettings)
+    //endregion
+
+    //region # Data sources status
+    val dataSourcesStatus: StateFlow<Map<String, Int>>
+    fun updateDataSourcesStatus(status: Map<String, Int>)
+    //endregion
+
+    //region # Radio control settings
+    val radioControlSettings: StateFlow<RadioControlSettings>
+    fun updateRadioControlSettings(settings: RadioControlSettings)
+    //endregion
+
+    //region # Per-satellite calculator offset settings
+    fun getSatelliteOffset(catnum: Int): String
+    fun setSatelliteOffset(catnum: Int, offset: String)
+    //endregion
+
+    //region # AMSAT status report settings
+    fun getAmSatCallsign(): String
+    fun setAmSatCallsign(callsign: String)
+    //endregion
+
+    //region # Wavelog worked-grids settings
+    val wavelogSettings: StateFlow<WavelogSettings>
+    fun updateWavelogSettings(settings: WavelogSettings)
+    fun getWorkedGrids(): Set<String>
+    fun setWorkedGrids(grids: Set<String>)
+    /** Confirmed satellite QSOs grouped by worked 4-char gridsquare (map tap detail). */
+    fun getWorkedGridQsos(): Map<String, List<com.rtbishop.look4sat.core.domain.model.GridQso>>
+    fun setWorkedGridQsos(qsos: Map<String, List<com.rtbishop.look4sat.core.domain.model.GridQso>>)
+    /** Distinct 4-char gridsquares the account operated from (LoTW <MY_GRIDSQUARE>). */
+    fun getRoamedGrids(): Set<String>
+    fun setRoamedGrids(grids: Set<String>)
+    //endregion
+
+    //region # LoTW confirmed-grids settings
+    val lotwSettings: StateFlow<com.rtbishop.look4sat.core.domain.model.LoTWSettings>
+    fun updateLoTWSettings(settings: com.rtbishop.look4sat.core.domain.model.LoTWSettings)
+    /** Last successful LoTW sync date ("yyyyMMdd", empty when never synced). */
+    fun getLastLotwSyncDate(): String
+    fun setLastLotwSyncDate(date: String)
+    /** Callsign of the last successful LoTW sync (empty when never synced). */
+    fun getLastLotwSyncCallsign(): String
+    fun setLastLotwSyncCallsign(callsign: String)
    //endregion
 }
@@ -0,0 +1,12 @@
+package com.rtbishop.look4sat.core.domain.repository
+
+import com.rtbishop.look4sat.core.domain.model.LatestRelease
+import java.io.File
+
+interface IUpdateRepository {
+    /** Fetch the latest release of the fork repo from GitHub; null on failure. */
+    suspend fun getLatestRelease(): LatestRelease?
+
+    /** Download the release APK from [url] into [dest]; true on success. */
+    suspend fun downloadApk(url: String, dest: File): Boolean
+}
@@ -0,0 +1,28 @@
+/*
+ * Look4Sat. Amateur radio satellite tracker and pass predictor.
+ * Copyright (C) 2019-2026 Arty Bishop and contributors.
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <https://www.gnu.org/licenses/>.
+ */
+package com.rtbishop.look4sat.core.domain.repository
+
+/** Fetches worked gridsquares from a self-hosted Wavelog instance (API v2). */
+interface IWavelogRepository {
+
+    /**
+     * Fetch worked grids for the configured Wavelog URL/token.
+     * Returns the grid set, or null on any failure.
+     */
+    suspend fun fetchWorkedGrids(url: String, token: String): Set<String>?
+}
@@ -0,0 +1,169 @@
+/*
+ * Look4Sat. Amateur radio satellite tracker and pass predictor.
+ * Copyright (C) 2019-2026 Arty Bishop and contributors.
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <https://www.gnu.org/licenses/>.
+ */
+package com.rtbishop.look4sat.core.domain.repository
+
+import com.rtbishop.look4sat.core.domain.model.GridQso
+import kotlinx.coroutines.Dispatchers
+import kotlinx.coroutines.withContext
+import java.text.SimpleDateFormat
+import java.util.Date
+import java.util.Locale
+import java.util.TimeZone
+
+/**
+ * Shared LoTW sync orchestration used by BOTH the manual sync (settings screen)
+ * and the automatic sync on app start (MainApplication), so the two paths can
+ * never drift apart:
+ *
+ * - [LoTWSyncMode.Incremental] pulls only the confirmations since the last sync
+ *   and MERGES them into the stored grids/QSOs (grids only grow; QSO detail is
+ *   deduped by call + QSO time).
+ * - [LoTWSyncMode.Full] pulls everything and REPLACES the stored data.
+ */
+
+/**
+ * UTC date ("yyyyMMdd") of the given instant — the "already synced today"
+ * gate granularity.
+ */
+fun lotwSyncToday(now: Long = System.currentTimeMillis()): String =
+    SimpleDateFormat("yyyyMMdd", Locale.US)
+        .apply { timeZone = TimeZone.getTimeZone("UTC") }
+        .format(Date(now))
+
+/**
+ * Full UTC timestamp cursor ("yyyy-MM-dd HH:mm:ss") written after a
+ * successful sync. This is exactly the format LoTW's qso_qslsince accepts
+ * (measured live 2026-09-17: the legacy "yyyyMMdd" cursor is silently
+ * ignored by LoTW, which falls back to its own system-supplied default),
+ * and it keeps enough precision to display the last-sync time like the
+ * ephemeris update time.
+ */
+fun lotwSyncCursor(now: Long = System.currentTimeMillis()): String =
+    SimpleDateFormat("yyyy-MM-dd HH:mm:ss", Locale.US)
+        .apply { timeZone = TimeZone.getTimeZone("UTC") }
+        .format(Date(now))
+
+/** Date part of a stored cursor as "yyyyMMdd", tolerating the legacy
+ *  "yyyyMMdd" format and the current "yyyy-MM-dd HH:mm:ss" format. */
+fun lotwCursorDate(cursor: String): String = when {
+    cursor.length >= 10 && cursor[4] == '-' -> cursor.substring(0, 10).replace("-", "")
+    else -> cursor.take(8)
+}
+
+/** qso_qslsince value for the API: passes the full timestamp through and
+ *  normalizes a legacy "yyyyMMdd" cursor to the documented "yyyy-MM-dd". */
+fun lotwCursorApi(cursor: String): String = when {
+    cursor.isBlank() -> ""
+    cursor.length >= 10 && cursor[4] == '-' -> cursor
+    else -> "${cursor.take(4)}-${cursor.substring(4, 6)}-${cursor.substring(6, 8)}"
+}
+
+/** Stored cursor parsed to UTC epoch ms for display; 0 when unparseable. */
+fun lotwCursorEpochMs(cursor: String): Long = try {
+    val pattern = if (cursor.length >= 10 && cursor[4] == '-') "yyyy-MM-dd HH:mm:ss" else "yyyyMMdd"
+    SimpleDateFormat(pattern, Locale.US)
+        .apply { timeZone = TimeZone.getTimeZone("UTC") }
+        .parse(cursor)?.time ?: 0L
+} catch (_: Exception) {
+    0L
+}
+
+/**
+ * Resolves the effective sync mode for a given request:
+ * - an explicit [LoTWSyncMode.Full] request is always honored;
+ * - an [LoTWSyncMode.Incremental] request is honored only when the callsign
+ *   matches the last sync — a first sync, an unknown/empty record or a
+ *   callsign change falls back to [LoTWSyncMode.Full] so no stale grids from
+ *   another account linger.
+ * With [requested] == null (automatic sync) it picks incremental whenever
+ * possible and full otherwise.
+ */
+fun resolveLoTWSyncMode(
+    lastSyncCallsign: String,
+    callsign: String,
+    requested: LoTWSyncMode?
+): LoTWSyncMode {
+    if (requested == LoTWSyncMode.Full) return LoTWSyncMode.Full
+    val sameCall = lastSyncCallsign.isNotBlank() && lastSyncCallsign == callsign
+    return if (sameCall) LoTWSyncMode.Incremental else LoTWSyncMode.Full
+}
+
+/**
+ * Whether the automatic LoTW sync should run now — mirrors the ephemeris
+ * auto-update check: credentials configured, the LoTW auto-sync toggle on, at
+ * least one prior manual sync (the first sync stays manual/full), and not
+ * already synced today (ARRL limits report pulls, ~once a day per account).
+ */
+fun shouldAutoSyncLoTW(
+    isConfigured: Boolean,
+    autoLotwSyncEnabled: Boolean,
+    lastSyncDate: String,
+    today: String
+): Boolean {
+    val lastDate = lotwCursorDate(lastSyncDate)
+    return isConfigured && autoLotwSyncEnabled && lastDate.isNotBlank() && lastDate != today
+}
+
+/**
+ * Applies a successful LoTW report to the stored grid data and advances the
+ * sync cursor so the next incremental pull asks LoTW for only the
+ * confirmations since today. Persistence runs on the IO dispatcher — building
+ * the per-grid QSO JSON and writing SharedPreferences blocks the calling
+ * thread, and for large accounts (multi-MB JSON) that froze the main thread
+ * after a manual sync ('bar done but app stuck').
+ *
+ * @return the resulting number of worked grids.
+ */
+suspend fun applyLoTWGridResult(
+    settingsRepo: ISettingsRepo,
+    result: LoTWResult.Success,
+    mode: LoTWSyncMode,
+    callsign: String,
+    now: Long = System.currentTimeMillis()
+): Int {
+    val existingGrids = settingsRepo.getWorkedGrids()
+    val existingQsos = settingsRepo.getWorkedGridQsos()
+    val existingRoamed = settingsRepo.getRoamedGrids()
+    val mergedGrids = if (mode == LoTWSyncMode.Incremental) existingGrids + result.grids else result.grids
+    val mergedQsos = if (mode == LoTWSyncMode.Incremental) mergeGridQsos(existingQsos, result.qsos) else result.qsos
+    val mergedRoamed = if (mode == LoTWSyncMode.Incremental) existingRoamed + result.roamedGrids else result.roamedGrids
+    settingsRepo.setLastLotwSyncDate(lotwSyncCursor(now))
+    settingsRepo.setLastLotwSyncCallsign(callsign)
+    withContext(Dispatchers.IO) {
+        settingsRepo.setWorkedGrids(mergedGrids)
+        settingsRepo.setWorkedGridQsos(mergedQsos)
+        settingsRepo.setRoamedGrids(mergedRoamed)
+    }
+    return mergedGrids.size
+}
+
+/** Merge fresh QSO detail into existing per-grid lists, dedup by call + QSO time. */
+fun mergeGridQsos(
+    existing: Map<String, List<GridQso>>,
+    fresh: Map<String, List<GridQso>>
+): Map<String, List<GridQso>> {
+    val merged = existing.mapValues { (_, list) -> list.toMutableList() }.toMutableMap()
+    fresh.forEach { (grid, list) ->
+        val target = merged.getOrPut(grid) { mutableListOf() }
+        val known = target.mapTo(mutableSetOf()) { it.call to it.epochMs }
+        list.forEach { qso ->
+            if (known.add(qso.call to qso.epochMs)) target.add(qso)
+        }
+    }
+    return merged
+}
@@ -0,0 +1,51 @@
+/*
+ * Look4Sat. Amateur radio satellite tracker and pass predictor.
+ * Copyright (C) 2019-2026 Arty Bishop and contributors.
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <https://www.gnu.org/licenses/>.
+ */
+package com.rtbishop.look4sat.core.domain.repository
+
+/** Result of a LoTW report fetch, with the failure cause kept explicit. */
+sealed class LoTWResult {
+
+    /** Report downloaded and parsed successfully. */
+    data class Success(
+        val grids: Set<String>,
+        val qsos: Map<String, List<com.rtbishop.look4sat.core.domain.model.GridQso>>,
+        /** Distinct 4-char gridsquares the account itself operated from
+         *  (ADIF <MY_GRIDSQUARE>, satellite QSOs only) — "roamed/activated" grids. */
+        val roamedGrids: Set<String> = emptySet()
+    ) : LoTWResult()
+
+    /** HTTP 200 but LoTW replied with its login-error page (bad callsign/password). */
+    data object BadCredentials : LoTWResult()
+
+    /**
+     * Report endpoint refused the request without a usable error page. LoTW
+     * limits downloads to one in progress per user id and flags accounts that
+     * pull the full report too often; the server answers those with a bare
+     * non-ADIF body (no <eoh>).
+     */
+    data object RateLimited : LoTWResult()
+
+    /** Connect/read timed out — typically a slow route to the ARRL servers. */
+    data object Timeout : LoTWResult()
+
+    /** Any other network-level failure (DNS, TLS, connection reset, HTTP 5xx). */
+    data class NetworkError(val detail: String) : LoTWResult()
+}
+
+/** What a LoTW sync does: pull everything, or only new QSLs since the last sync. */
+enum class LoTWSyncMode { Full, Incremental }
@@ -31,6 +31,9 @@ interface ILocalSource {
    suspend fun getIdsWithModes(modes: List<String>): List<Int>
    suspend fun getRadiosTotal(): Int
    suspend fun getRadiosWithId(id: Int): List<SatRadio>
-    suspend fun insertRadios(radios: List<SatRadio>)
+    suspend fun insertRadios(radios: List<SatRadio>, isCustom: Boolean = false)
+
+    /** Delete all non-custom transceivers, keeping manually imported ones. */
+    suspend fun deleteManagedRadios()
    suspend fun deleteRadios()
 }
@@ -19,7 +19,18 @@ package com.rtbishop.look4sat.core.domain.source

 import java.io.InputStream

+/** Result of a network download: the HTTP status code and the response body stream. */
+data class NetworkResult(val code: Int, val stream: InputStream?) {
+    companion object {
+        /** Code used when a request fails before any HTTP response is received. */
+        const val CONNECTION_ERROR = -1
+    }
+}
+
 interface IRemoteSource {
    suspend fun getFileStream(uri: String): InputStream?
-    suspend fun getNetworkStream(url: String): InputStream?
+    suspend fun getNetworkStream(url: String): NetworkResult
+    suspend fun getAmSatCatalog(): String?
+    suspend fun getAmSatReports(hours: Int, limit: Int): String?
+    suspend fun submitAmSatReport(payloadJson: String): Pair<Int, String>?
 }
@@ -18,9 +18,11 @@
 package com.rtbishop.look4sat.core.domain.source

 object Sources {
-    const val RADIO_DATA_URL = "https://db.satnogs.org/api/transmitters/?format=json&status=active"
    val satelliteDataUrls = mapOf(
+        "LAPAN-A2" to "https://www.kaggle.com/api/v1/datasets/download/muazamnugroho/lapan-a2-satellite-two-line-element-tle-dataset/LAPAN-A2_TLE_latest.txt",
+        "R4UAB" to "https://r4uab.ru/satonline.txt",
        "All" to "https://celestrak.org/NORAD/elements/gp.php?GROUP=active&FORMAT=csv",
+        "SatNOGS" to "https://db.satnogs.org/api/tle/?format=3le",
        "Amateur" to "https://celestrak.org/NORAD/elements/gp.php?GROUP=amateur&FORMAT=csv",
        "Brightest" to "https://celestrak.org/NORAD/elements/gp.php?GROUP=visual&FORMAT=csv",
        "Cubesat" to "https://celestrak.org/NORAD/elements/gp.php?GROUP=cubesat&FORMAT=csv",
@@ -36,7 +38,7 @@ object Sources {
        "OneWeb" to "https://celestrak.org/NORAD/elements/gp.php?GROUP=oneweb&FORMAT=csv",
        "Orbcomm" to "https://celestrak.org/NORAD/elements/gp.php?GROUP=orbcomm&FORMAT=csv",
        "Resource" to "https://celestrak.org/NORAD/elements/gp.php?GROUP=resource&FORMAT=csv",
-        "SatNOGS" to "https://celestrak.org/NORAD/elements/gp.php?GROUP=satnogs&FORMAT=csv",
+        "CelesTrak SatNOGS" to "https://celestrak.org/NORAD/elements/gp.php?GROUP=satnogs&FORMAT=csv",
        "Science" to "https://celestrak.org/NORAD/elements/gp.php?GROUP=science&FORMAT=csv",
        "Spire" to "https://celestrak.org/NORAD/elements/gp.php?GROUP=spire&FORMAT=csv",
        "Starlink" to "https://celestrak.org/NORAD/elements/gp.php?GROUP=starlink&FORMAT=csv",
@@ -46,7 +48,11 @@ object Sources {
        "Amsat" to "https://amsat.org/tle/current/nasabare.txt",
        "Classified" to "https://www.mmccants.org/tles/classfd.zip",
        "McCants" to "https://www.mmccants.org/tles/inttles.zip",
-        "R4UAB" to "https://r4uab.ru/satonline.txt",
+        "ARISS" to "https://live.ariss.org/iss.txt",
        "Other" to "" // key for sats filter
    )
+    val transceiversDataUrls = mapOf(
+        "SatNOGS" to "https://db.satnogs.org/api/transmitters/?format=json&status=active",
+        "R4UAB" to "https://r4uab.ru/transmitters.json"
+    )
 }