feat: rebrand to Look4Sat Pro, bump version to 4.4.4

App display name changed from Look4Sat to Look4Sat Pro (fork identity). Version follows upstream scheme without suffix: 4.4.3 -> 4.4.4, versionCode 443 -> 444.

.github/workflows/release.yml

@@ -4,10 +4,15 @@ on:
   push:
     tags:
       - v**
+  workflow_dispatch:
+    inputs:
+      tag_name:
+        description: 'Release tag name (e.g. v4.4.3)'
+        required: false
+        default: ''
 
 env:
-  TAG_NAME: ${{ github.ref_name }}
+  TAG_NAME: ${{ github.event.inputs.tag_name || github.ref_name }}
-  GITHUB_TOKEN: ${{ secrets.RELEASE_TOKEN }}
 
 jobs:
   release:
@@ -16,19 +21,19 @@ jobs:
       contents: write
     steps:
       - name: Checkout Repository
-        uses: actions/checkout@v7
+        uses: actions/checkout@v4
 
       - name: Setup Java
-        uses: actions/setup-java@v5
+        uses: actions/setup-java@v4
         with:
           distribution: 'temurin'
           java-version: '21'
 
       - name: Setup Gradle
-        uses: gradle/actions/setup-gradle@v6
+        uses: gradle/actions/setup-gradle@v4
 
-      - name: Assemble Artifacts
+      - name: Assemble APK
-        run: ./gradlew assembleRelease bundleRelease
+        run: ./gradlew assembleRelease
 
       - name: Sign APK
         run: |
@@ -44,38 +49,9 @@ jobs:
             "$APK"
           rm keystore.jks
 
-      - name: Sign Bundle
-        run: |
-          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: Setup Ruby
-        uses: ruby/setup-ruby@v1
-        with:
-          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
+        env:
+          GH_TOKEN: ${{ github.token }}
         run: |
           gh release create $TAG_NAME --title=$TAG_NAME --generate-notes
           gh release upload $TAG_NAME app/build/outputs/apk/release/look4sat.apk

.gitignore

@@ -1,6 +1,9 @@
 # Built application files
 *.ap_
 
+# Hermes AI plans and metadata
+.hermes/
+
 # Files for the ART/Dalvik VM
 *.dex
 

app/src/main/AndroidManifest.xml

@@ -25,6 +25,7 @@
         <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" />
@@ -42,7 +43,7 @@
 
         <meta-data
             android:name="android.telephony.PROPERTY_SATELLITE_DATA_OPTIMIZED"
-            android:value="com.rtbishop.look4sat" />
+            android:value="com.rtbishop.look4sat.bg7nta" />
 
     </application>
 </manifest>

app/src/main/java/com/rtbishop/look4sat/MainScreen.kt

@@ -63,13 +63,16 @@ import androidx.compose.ui.res.stringResource
 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
@@ -78,6 +81,8 @@ 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.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
@@ -125,12 +130,17 @@ fun MainScreen(navigateToRadar: () -> Unit = {}) {
     val currentKey = backStack.lastOrNull()
     val navigateBack: () -> Unit = { backStack.removeLastOrNull() }
     val fadeTransition = fadeIn(animationSpec = tween(350)) togetherWith fadeOut(animationSpec = tween(350))
-    val navItems = listOf(Screen.Satellites, Screen.Passes, Screen.Radar, Screen.Map, Screen.Settings)
+    val navItems = listOf(Screen.Satellites, Screen.Passes, Screen.Radar, Screen.Mutual, Screen.Map, 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)
+    )
 
     CompositionLocalProvider(
         LocalElevationThresholds provides ElevationThresholds(
@@ -145,6 +155,7 @@ fun MainScreen(navigateToRadar: () -> Unit = {}) {
                         is Screen.Satellites -> screen is Screen.Satellites
                         is Screen.Passes -> screen is Screen.Passes
                         is Screen.Radar -> screen is Screen.Radar
+                        is Screen.Mutual -> screen is Screen.Mutual
                         is Screen.Map -> screen is Screen.Map
                         is Screen.Settings -> screen is Screen.Settings
                         else -> false
@@ -190,6 +201,7 @@ fun MainScreen(navigateToRadar: () -> Unit = {}) {
                         }
                         entry<Screen.Passes> {
                             PassesDestination { catNum, aosTime ->
+                                container.setMutualPassData(MutualPassData())
                                 container.satelliteRepo.selectPass(catNum, aosTime)
                                 backStack.add(Screen.Radar)
 //                            navigateToRadar()
@@ -201,6 +213,17 @@ fun MainScreen(navigateToRadar: () -> Unit = {}) {
                         entry<Screen.Map> {
                             MapDestination()
                         }
+                        entry<Screen.Mutual> {
+                            MutualScreen(
+                                viewModel = mutualViewModel,
+                                navigateUp = navigateBack,
+                                navigateToRadar = { catNum, aosTime, pass ->
+                                    container.setMutualPassData(pass ?: MutualPassData())
+                                    container.satelliteRepo.selectPass(catNum, aosTime)
+                                    backStack.add(Screen.Radar)
+                                }
+                            )
+                        }
                         entry<Screen.Settings> {
                             SettingsDestination()
                         }
@@ -224,6 +247,7 @@ fun MainScreen(navigateToRadar: () -> Unit = {}) {
                             .clickable {
                                 val pass = trackingState.currentPass
                                 if (pass != null) {
+                                    container.setMutualPassData(MutualPassData())
                                     container.satelliteRepo.selectPass(pass.catNum, pass.aosTime)
                                     backStack.add(Screen.Radar)
                                 }

build-logic/convention/src/main/java/com/rtbishop/look4sat/convention/ApplicationPlugin.kt

@@ -32,6 +32,7 @@ internal class ApplicationPlugin : Plugin<Project> {
             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"))

build-logic/convention/src/main/java/com/rtbishop/look4sat/convention/PluginSetupUtils.kt

@@ -57,7 +57,7 @@ internal fun Project.setupAndroidApp() {
         namespace = libs.versions.packageName.get()
         compileSdk = libs.versions.compileSdk.get().toInt()
         defaultConfig {
-            applicationId = libs.versions.packageName.get()
+            applicationId = libs.versions.applicationId.get()
             minSdk = libs.versions.minSdk.get().toInt()
             versionCode = libs.versions.appVersionCode.get().toInt()
             versionName = libs.versions.appVersionName.get()

core/data/src/main/java/com/rtbishop/look4sat/core/data/injection/MainContainer.kt

@@ -50,6 +50,7 @@ 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.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
@@ -61,6 +62,9 @@ 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 {
@@ -77,6 +81,13 @@ class MainContainer(private val context: Context) : IMainContainer {
         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)

core/data/src/main/java/com/rtbishop/look4sat/core/data/repository/SatelliteRepo.kt

@@ -95,14 +95,8 @@ class SatelliteRepo(
         }
     }
 
-    override suspend fun getRadios(
+    override suspend fun getRadios(satPos: OrbitalPos, radios: List<SatRadio>): List<SatRadio> {
-        sat: OrbitalObject,
-        pos: GeoPos,
-        radios: List<SatRadio>,
-        time: Long
-    ): List<SatRadio> {
         return withContext(dispatcher) {
-            val satPos = sat.getPosition(pos, time)
             radios.map { transmitter ->
                 transmitter.copy(
                     downlinkLow = transmitter.downlinkLow?.let { satPos.getDownlinkFreq(it) },
@@ -242,13 +236,16 @@ class SatelliteRepo(
             if (elevation > maxElevation) maxElevation = elevation
         } while (elevation < 0.0)
 
-        // refine AOS to ~500ms precision
+        // refine AOS to ~500ms precision via binary search.
-        calendarTimeMillis -= 60L * 1000L
+        // Elevation is monotonic across the horizon crossing, so binary search
-        do {
+        // finds the crossing in ~8 SGP4 calls instead of up to 120 linear steps.
-            calendarTimeMillis += 500L
+        var aosLo = calendarTimeMillis - 60L * 1000L // elevation < 0 (below horizon)
-            elevation = sat.getElevation(pos, calendarTimeMillis)
+        var aosHi = calendarTimeMillis // elevation >= 0 (above horizon)
-            if (elevation > maxElevation) maxElevation = elevation
+        while (aosHi - aosLo > 500L) {
-        } while (elevation < 0.0)
+            val mid = (aosLo + aosHi) / 2
+            if (sat.getElevation(pos, mid) < 0.0) aosLo = mid else aosHi = mid
+        }
+        calendarTimeMillis = aosHi
 
         // Get full position for AOS data (azimuth, altitude)
         val aosPos = sat.getFullPosition(pos, calendarTimeMillis)
@@ -262,13 +259,14 @@ class SatelliteRepo(
             if (elevation > maxElevation) maxElevation = elevation
         } while (elevation > 0.0)
 
-        // refine LOS to ~500ms precision
+        // refine LOS to ~500ms precision via binary search (same monotonic argument)
-        calendarTimeMillis -= 30L * 1000L
+        var losLo = calendarTimeMillis - 30L * 1000L // elevation > 0 (above horizon)
-        do {
+        var losHi = calendarTimeMillis // elevation <= 0 (below horizon)
-            calendarTimeMillis += 500L
+        while (losHi - losLo > 500L) {
-            elevation = sat.getElevation(pos, calendarTimeMillis)
+            val mid = (losLo + losHi) / 2
-            if (elevation > maxElevation) maxElevation = elevation
+            if (sat.getElevation(pos, mid) > 0.0) losLo = mid else losHi = mid
-        } while (elevation > 0.0)
+        }
+        calendarTimeMillis = losHi
 
         // Get full position for LOS data (azimuth, altitude)
         val losPos = sat.getFullPosition(pos, calendarTimeMillis)

core/data/src/main/java/com/rtbishop/look4sat/core/data/repository/SettingsRepo.kt

@@ -213,8 +213,8 @@ class SettingsRepo(
     }
 
     private fun setStationPosition(latitude: Double, longitude: Double, altitude: Double, locator: String) {
-        val newLat = latitude.round(4)
+        val newLat = latitude.round(5)
-        val newLon = longitude.round(4)
+        val newLon = longitude.round(5)
         val newAlt = altitude.round(1)
         val timestamp = System.currentTimeMillis()
         println("Received new Position($newLat, $newLon, $newAlt) & Locator $locator")

core/domain/src/main/java/com/rtbishop/look4sat/core/domain/cw/CwBayesianDecoder.kt

@@ -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)

core/domain/src/main/java/com/rtbishop/look4sat/core/domain/cw/CwChannelTracker.kt

@@ -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)
+        }
+    }
+}

core/domain/src/main/java/com/rtbishop/look4sat/core/domain/cw/CwDecoder.kt

@@ -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
+    }
+}

core/domain/src/main/java/com/rtbishop/look4sat/core/domain/cw/CwDsp.kt

@@ -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()
+    }
+}

core/domain/src/main/java/com/rtbishop/look4sat/core/domain/cw/CwFFT.kt

@@ -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
+    }
+}

core/domain/src/main/java/com/rtbishop/look4sat/core/domain/cw/CwFilter.kt

@@ -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 }
+}

core/domain/src/main/java/com/rtbishop/look4sat/core/domain/cw/CwGoertzel.kt

@@ -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
+    }
+}

core/domain/src/main/java/com/rtbishop/look4sat/core/domain/cw/CwResampler.kt

@@ -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
+    }
+}

core/domain/src/main/java/com/rtbishop/look4sat/core/domain/cw/CwSTFFT.kt

@@ -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
+    }
+}

core/domain/src/main/java/com/rtbishop/look4sat/core/domain/cw/CwSpectrogram.kt

@@ -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)
+    }
+}

core/domain/src/main/java/com/rtbishop/look4sat/core/domain/repository/IMainContainer.kt

@@ -16,12 +16,13 @@
  * 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
@@ -30,6 +31,8 @@ interface IMainContainer {
     val satelliteRepo: ISatelliteRepo
     val databaseRepo: IDatabaseRepo
     val radioTrackingService: IRadioTrackingService
+    val mutualPassData: StateFlow<MutualPassData>
+    fun setMutualPassData(data: MutualPassData)
     fun provideAddToCalendar(): IAddToCalendar
     fun provideShowToast(): IShowToast
     fun provideBluetoothReporter(): IReporter
@@ -41,6 +44,25 @@ interface IMainContainer {
     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
 }

core/domain/src/main/java/com/rtbishop/look4sat/core/domain/repository/ISatelliteRepo.kt

@@ -61,7 +61,7 @@ interface ISatelliteRepo {
     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 getRadios(satPos: OrbitalPos, radios: List<SatRadio>): List<SatRadio>
 
     /** Fetch radio transceivers for a satellite by its catalog number. */
     suspend fun getRadiosWithId(id: Int): List<SatRadio>

core/domain/src/main/java/com/rtbishop/look4sat/core/domain/utility/DopplerFrequencyCalculator.kt

@@ -0,0 +1,98 @@
+/* 
+ * 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.domain.utility
+
+import com.rtbishop.look4sat.core.domain.model.SatRadio
+import com.rtbishop.look4sat.core.domain.predict.OrbitalPos
+
+/**
+ * Computes Doppler-corrected reciprocal frequencies for linear transponders.
+ *
+ * For a linear (passband) transponder, uplink and downlink frequencies are
+ * related by a fixed passband offset. When the satellite moves, both are
+ * Doppler-shifted. Given one, we compute the other:
+ *
+ *   downlink → uplink: mapDownlinkToUplink (passband) → getUplinkFreq (Doppler)
+ *   uplink → downlink: mapUplinkToDownlink (passband) → getDownlinkFreq (Doppler)
+ *
+ * Addresses GitHub issue #91 (Custom frequency Doppler correction).
+ */
+object DopplerFrequencyCalculator {
+
+    /**
+     * Given a downlink frequency, compute the Doppler-corrected uplink frequency.
+     * Returns null if the transponder is not a linear passband type.
+     */
+    fun computeUplinkFromDownlink(
+        downlinkHz: Long,
+        transponder: SatRadio,
+        orbitalPos: OrbitalPos
+    ): Long? {
+        if (!isLinearTransponder(transponder)) return null
+        val baseUplink = TransponderMapper.mapDownlinkToUplink(downlinkHz, transponder) ?: return null
+        return orbitalPos.getUplinkFreq(baseUplink)
+    }
+
+    /**
+     * Given a downlink frequency, compute the Doppler-corrected uplink frequency
+     * with an offset applied to the downlink (in Hz).
+     * Returns null if the transponder is not a linear passband type.
+     */
+    fun computeUplinkFromDownlinkWithOffset(
+        downlinkHz: Long,
+        transponder: SatRadio,
+        orbitalPos: OrbitalPos,
+        offsetHz: Long
+    ): Long? {
+        if (!isLinearTransponder(transponder)) return null
+        val baseUplink = TransponderMapper.mapDownlinkToUplink(downlinkHz + offsetHz, transponder) ?: return null
+        return orbitalPos.getUplinkFreq(baseUplink)
+    }
+
+    /**
+     * Given an uplink frequency, compute the Doppler-corrected downlink frequency.
+     * Returns null if the transponder is not a linear passband type.
+     */
+    fun computeDownlinkFromUplink(
+        uplinkHz: Long,
+        transponder: SatRadio,
+        orbitalPos: OrbitalPos
+    ): Long? {
+        if (!isLinearTransponder(transponder)) return null
+        val baseDownlink = TransponderMapper.mapUplinkToDownlink(uplinkHz, transponder) ?: return null
+        return orbitalPos.getDownlinkFreq(baseDownlink)
+    }
+
+    /**
+     * Given an uplink frequency, compute the Doppler-corrected downlink frequency
+     * with an offset applied to the downlink (in Hz).
+     * Returns null if the transponder is not a linear passband type.
+     */
+    fun computeDownlinkFromUplinkWithOffset(
+        uplinkHz: Long,
+        transponder: SatRadio,
+        orbitalPos: OrbitalPos,
+        offsetHz: Long
+    ): Long? {
+        if (!isLinearTransponder(transponder)) return null
+        val baseDownlink = TransponderMapper.mapUplinkToDownlink(uplinkHz, transponder) ?: return null
+        return orbitalPos.getDownlinkFreq(baseDownlink + offsetHz)
+    }
+
+    /** True if this transponder supports linear passband mapping. */
+    fun isLinearTransponder(transponder: SatRadio): Boolean {
+        val upLow = transponder.uplinkLow
+        val upHigh = transponder.uplinkHigh
+        val downLow = transponder.downlinkLow
+        val downHigh = transponder.downlinkHigh
+        return upLow != null && upHigh != null && downLow != null && downHigh != null
+                && upLow != upHigh && downLow != downHigh
+    }
+}

core/domain/src/main/java/com/rtbishop/look4sat/core/domain/utility/QthConverter.kt

@@ -19,31 +19,78 @@ package com.rtbishop.look4sat.core.domain.utility
 
 import com.rtbishop.look4sat.core.domain.predict.GeoPos
 
+/**
+ * Converts a Maidenhead locator (QTH grid square) to a GeoPos.
+ * Supports 6-char (3 pair), 8-char (4 pair) and 10-char (5 pair) locators.
+ * The returned position is the center of the finest cell encoded by the locator:
+ *  - 6 char: 5' lon x 2.5' lat cell center
+ *  - 8 char: 30" lon x 15" lat cell center
+ *  - 10 char: 1.25" lon x 0.625" lat cell center
+ */
 fun qthToPosition(locator: String): GeoPos? {
-    val trimmedQth = locator.take(6)
+    val trimmedQth = locator.trim().uppercase()
     if (!isValidLocator(trimmedQth)) return null
-    val lonFirst = (trimmedQth[0].uppercaseChar().code - 65) * 20
+    val lonFirst = (trimmedQth[0].code - 65) * 20
-    val latFirst = (trimmedQth[1].uppercaseChar().code - 65) * 10
+    val latFirst = (trimmedQth[1].code - 65) * 10
     val lonSecond = trimmedQth[2].toString().toInt() * 2
     val latSecond = trimmedQth[3].toString().toInt()
-    val lonThird = (((trimmedQth[4].lowercaseChar().code - 97) / 12.0) + (1.0 / 24.0)) - 180
+    val lonThird = (trimmedQth[4].lowercaseChar().code - 97) / 12.0
-    val latThird = (((trimmedQth[5].lowercaseChar().code - 97) / 24.0) + (1.0 / 48.0)) - 90
+    val latThird = (trimmedQth[5].lowercaseChar().code - 97) / 24.0
-    val longitude = (lonFirst + lonSecond + lonThird).round(4)
+    var longitude = lonFirst + lonSecond + lonThird - 180
-    val latitude = (latFirst + latSecond + latThird).round(4)
+    var latitude = latFirst + latSecond + latThird - 90
-    return GeoPos(latitude, longitude)
+    // 8-char extension: 4th pair, digits, 30" lon x 15" lat cells
+    if (trimmedQth.length >= 8) {
+        longitude += trimmedQth[6].toString().toInt() / 120.0
+        latitude += trimmedQth[7].toString().toInt() / 240.0
+    }
+    // 10-char extension: 5th pair, letters, 1.25" lon x 0.625" lat cells
+    if (trimmedQth.length >= 10) {
+        longitude += (trimmedQth[8].lowercaseChar().code - 97) / 2880.0
+        latitude += (trimmedQth[9].lowercaseChar().code - 97) / 5760.0
+    }
+    // Offset to the center of the finest encoded cell
+    when (trimmedQth.length) {
+        8 -> {
+            longitude += 1.0 / 240.0
+            latitude += 1.0 / 480.0
+        }
+        10 -> {
+            longitude += 1.0 / 5760.0
+            latitude += 1.0 / 11520.0
+        }
+        else -> {
+            longitude += 1.0 / 24.0
+            latitude += 1.0 / 48.0
+        }
+    }
+    return GeoPos(latitude.round(6), longitude.round(6))
 }
 
-fun positionToQth(latitude: Double, longitude: Double): String? {
+/**
+ * Converts a GeoPos to a Maidenhead locator (QTH grid square).
+ * Default precision is 8 characters (4 pairs) giving 30" lon x 15" lat resolution,
+ * matching common 8-char grid square tools. Pass precision = 6 for the classic
+ * 5' x 2.5' resolution, or precision = 10 for the finest 1.25" x 0.625" resolution.
+ */
+fun positionToQth(latitude: Double, longitude: Double, precision: Int = 8): String? {
     if (!isValidPosition(latitude, longitude)) return null
-    val newLongitude = if (longitude > 180.0) longitude else longitude + 180
+    val newLongitude = longitude + 180
     val newLatitude = latitude + 90
-    val lonFirst = (65 + (newLongitude / 20)).toInt().toChar()
+    val lonFirst = (65 + (newLongitude / 20).toInt().coerceIn(0, 17)).toChar()
-    val latFirst = (65 + (newLatitude / 10)).toInt().toChar()
+    val latFirst = (65 + (newLatitude / 10).toInt().coerceIn(0, 17)).toChar()
-    val lonSecond = ((newLongitude / 2) % 10).toInt()
+    val lonSecond = ((newLongitude % 20) / 2).toInt()
     val latSecond = (newLatitude % 10).toInt()
     val lonThird = (65 + (newLongitude % 2) * 12).toInt().toChar().lowercaseChar()
     val latThird = (65 + (newLatitude % 1) * 24).toInt().toChar().lowercaseChar()
-    return "$lonFirst$latFirst$lonSecond$latSecond$lonThird$latThird"
+    val qth = "$lonFirst$latFirst$lonSecond$latSecond$lonThird$latThird"
+    if (precision < 8) return qth
+    val lonFourth = ((newLongitude % (1.0 / 12.0)) * 120).toInt()
+    val latFourth = ((newLatitude % (1.0 / 24.0)) * 240).toInt()
+    val qth8 = "$qth$lonFourth$latFourth"
+    if (precision < 10) return qth8
+    val lonFifth = (65 + (newLongitude % (1.0 / 120.0)) * 2880).toInt().toChar().lowercaseChar()
+    val latFifth = (65 + (newLatitude % (1.0 / 240.0)) * 5760).toInt().toChar().lowercaseChar()
+    return "$qth8$lonFifth$latFifth"
 }
 
 private fun isValidPosition(lat: Double, lon: Double): Boolean {
@@ -51,5 +98,5 @@ private fun isValidPosition(lat: Double, lon: Double): Boolean {
 }
 
 private fun isValidLocator(locator: String): Boolean {
-    return locator.matches("[a-xA-X][a-xA-X]\\d\\d[a-xA-X][a-xA-X]".toRegex())
+    return locator.matches("[a-xA-X]{2}\\d{2}[a-xA-X]{2}(?:\\d{2}(?:[a-xA-X]{2})?)?".toRegex())
 }

core/domain/src/test/java/com/rtbishop/look4sat/core/domain/DopplerFrequencyCalculatorTest.kt

@@ -0,0 +1,120 @@
+package com.rtbishop.look4sat.core.domain
+
+import com.rtbishop.look4sat.core.domain.model.SatRadio
+import com.rtbishop.look4sat.core.domain.predict.OrbitalPos
+import com.rtbishop.look4sat.core.domain.utility.DopplerFrequencyCalculator
+import org.junit.Assert.*
+import org.junit.Test
+
+class DopplerFrequencyCalculatorTest {
+
+    private fun linearTransponder(
+        upLow: Long = 145_000_000L,
+        upHigh: Long = 145_500_000L,
+        downLow: Long = 435_000_000L,
+        downHigh: Long? = 435_500_000L,
+        inverted: Boolean = false
+    ) = SatRadio(
+        uuid = "linear", info = "Linear Transponder", isAlive = true,
+        downlinkLow = downLow, downlinkHigh = downHigh,
+        downlinkMode = "USB", uplinkLow = upLow, uplinkHigh = upHigh,
+        uplinkMode = "LSB", isInverted = inverted, catnum = 12345
+    )
+
+    private fun fmTransponder() = SatRadio(
+        uuid = "fm", info = "FM Repeater", isAlive = true,
+        downlinkLow = 435_600_000L, downlinkHigh = null,
+        downlinkMode = "FM", uplinkLow = 145_900_000L, uplinkHigh = null,
+        uplinkMode = "FM", isInverted = false, catnum = 99999
+    )
+
+    private fun pos(distanceRateKmS: Double = 0.0) = OrbitalPos().apply {
+        this.distanceRate = distanceRateKmS
+    }
+
+    @Test
+    fun isLinearTransponder_returnsTrueForLinear() {
+        assertTrue(DopplerFrequencyCalculator.isLinearTransponder(linearTransponder()))
+    }
+
+    @Test
+    fun isLinearTransponder_returnsFalseForFM() {
+        assertFalse(DopplerFrequencyCalculator.isLinearTransponder(fmTransponder()))
+    }
+
+    @Test
+    fun isLinearTransponder_returnsFalseForNullDownlinkHigh() {
+        val xpdr = linearTransponder(downHigh = null)
+        assertFalse(DopplerFrequencyCalculator.isLinearTransponder(xpdr))
+    }
+
+    @Test
+    fun computeUplinkFromDownlink_linear_noDoppler() {
+        val xpdr = linearTransponder()
+        val orbitalPos = pos(0.0)
+        val uplink = DopplerFrequencyCalculator.computeUplinkFromDownlink(435_200_000L, xpdr, orbitalPos)
+        assertNotNull(uplink)
+        assertTrue(uplink!! > 0)
+        // With zero Doppler, result equals mapDownlinkToUplink output
+        assertEquals(145_200_000L, uplink)
+    }
+
+    @Test
+    fun computeDownlinkFromUplink_linear_noDoppler() {
+        val xpdr = linearTransponder()
+        val orbitalPos = pos(0.0)
+        val downlink = DopplerFrequencyCalculator.computeDownlinkFromUplink(145_200_000L, xpdr, orbitalPos)
+        assertNotNull(downlink)
+        assertEquals(435_200_000L, downlink)
+    }
+
+    @Test
+    fun computeUplinkFromDownlink_withDoppler_positiveRangeRate() {
+        // Satellite receding (positive range rate) → ground must transmit higher freq to compensate
+        val xpdr = linearTransponder()
+        val orbitalPos = pos(7.0)  // ~7 km/s receding
+        val uplink = DopplerFrequencyCalculator.computeUplinkFromDownlink(435_200_000L, xpdr, orbitalPos)
+        assertNotNull(uplink)
+        // Uplink freq should be Doppler shifted UP (compensating for receding)
+        assertTrue(uplink!! > 145_200_000L)
+    }
+
+    @Test
+    fun computeUplinkFromDownlink_fm_transponder_returnsNull() {
+        val orbitalPos = pos()
+        val result = DopplerFrequencyCalculator.computeUplinkFromDownlink(435_600_000L, fmTransponder(), orbitalPos)
+        assertNull(result)
+    }
+
+    @Test
+    fun computeDownlinkFromUplink_fm_transponder_returnsNull() {
+        val orbitalPos = pos()
+        val result = DopplerFrequencyCalculator.computeDownlinkFromUplink(145_900_000L, fmTransponder(), orbitalPos)
+        assertNull(result)
+    }
+
+    @Test
+    fun computeUplinkFromDownlink_invertedTransponder() {
+        val xpdr = linearTransponder(inverted = true, downHigh = 435_500_000L)
+        val orbitalPos = pos(0.0)
+        val uplink = DopplerFrequencyCalculator.computeUplinkFromDownlink(435_200_000L, xpdr, orbitalPos)
+        assertNotNull(uplink)
+        // Inverted: offset from high end → maps to high end of uplink
+        assertEquals(145_300_000L, uplink)
+    }
+
+    @Test
+    fun computeUplinkFromDownlink_roundTrip() {
+        // downlink → uplink → downlink should round-trip
+        val xpdr = linearTransponder()
+        val orbitalPos = pos(3.5)
+        val originalDownlink = 435_250_000L
+        val uplink = DopplerFrequencyCalculator.computeUplinkFromDownlink(originalDownlink, xpdr, orbitalPos)
+        assertNotNull(uplink)
+        val roundTripDownlink = DopplerFrequencyCalculator.computeDownlinkFromUplink(uplink!!, xpdr, orbitalPos)
+        assertNotNull(roundTripDownlink)
+        // Doppler round-trip: small residual due to freq-dependent Doppler
+        val error = kotlin.math.abs(roundTripDownlink!! - originalDownlink)
+        assertTrue("Round-trip error too large: $error", error < 10000)
+    }
+}

core/domain/src/test/java/com/rtbishop/look4sat/core/domain/QthConverterTest.kt

@@ -26,21 +26,36 @@ class QthConverterTest {
     @Test
     fun `Given valid QTH returns correct POS`() {
         var result = qthToPosition("io91VL39FX")
-        assert(result?.latitude == 51.4792 && result.longitude == -0.2083)
+        assert(result?.latitude == 51.499913 && result.longitude == -0.22309)
         result = qthToPosition("gf15vc")
-        assert(result?.latitude == -34.8958 && result.longitude == -56.2083)
+        assert(result?.latitude == -34.895833 && result.longitude == -56.208333)
+        // 8-char locators: finer 30" x 15" cell center
+        result = qthToPosition("io91vl47")
+        assert(result?.latitude == 51.489583 && result.longitude == -0.2125)
+        result = qthToPosition("jn58td25")
+        assert(result?.latitude == 48.147917 && result.longitude == 11.604167)
     }
 
     @Test
     fun `Given invalid QTH returns null`() {
         assert(qthToPosition("ZZ00zz") == null)
         assert(qthToPosition("JN58") == null)
+        assert(qthToPosition("io9") == null)
+        assert(qthToPosition("IO91VL7") == null)
+        assert(qthToPosition("IO91VL4X") == null)
     }
 
     @Test
     fun `Given valid POS returns correct QTH`() {
-        assert(positionToQth(51.4878, -0.2146) == "IO91vl")
+        // default precision is 8 chars
-        assert(positionToQth(48.1466, 11.6083) == "JN58td")
+        assert(positionToQth(51.4878, -0.2146) == "IO91vl47")
+        assert(positionToQth(48.1466, 11.6083) == "JN58td25")
+        // 6-char precision still available for backwards compatibility
+        assert(positionToQth(51.4878, -0.2146, 6) == "IO91vl")
+        assert(positionToQth(48.1466, 11.6083, 6) == "JN58td")
+        // 10-char precision
+        assert(positionToQth(51.4878, -0.2146, 10) == "IO91vl47fb")
+        assert(positionToQth(48.1466, 11.6083, 10) == "JN58td25xe")
     }
 
     @Test
@@ -48,4 +63,23 @@ class QthConverterTest {
         assert(positionToQth(91.0542, -170.1142) == null)
         assert(positionToQth(89.0542, -240.1142) == null)
     }
+
+    @Test
+    fun `Given boundary POS stays in valid grid`() {
+        // antipodal / edge cases must not overflow the A-R / 0-9 / a-x alphabet
+        assert(positionToQth(-90.0, -180.0, 8) == "AA00aa00")
+        assert(positionToQth(90.0, 180.0, 8) == "RR00aa00")
+        assert(positionToQth(0.0, 0.0, 8) == "JJ00aa00")
+        // roundtrip stability: 8-char roundtrip is stable across a sample of positions
+        val positions = listOf(
+            Pair(51.4878, -0.2146), Pair(48.1466, 11.6083), Pair(-33.8688, 151.2093),
+            Pair(39.9042, 116.4074), Pair(35.6895, 139.6917), Pair(41.714, -72.727)
+        )
+        positions.forEach { (lat, lon) ->
+            val qth = positionToQth(lat, lon, 8)
+            val pos = qthToPosition(qth!!)
+            val qth2 = positionToQth(pos!!.latitude, pos.longitude, 8)
+            assert(qth == qth2) { "Roundtrip failed for ($lat, $lon): $qth -> $qth2" }
+        }
+    }
 }

core/domain/src/test/java/com/rtbishop/look4sat/core/domain/cw/CwDecoderTest.kt

@@ -0,0 +1,301 @@
+/*
+ * 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 org.junit.Assert.*
+import org.junit.Test
+import kotlin.math.PI
+import kotlin.math.sin
+
+class CwDecoderTest {
+
+    // --- Morse table ---
+
+    @Test
+    fun morseToChar_basicLetters() {
+        assertEquals('A', CwBayesianDecoder.morseToChar("01"))
+        assertEquals('S', CwBayesianDecoder.morseToChar("000"))
+        assertEquals('O', CwBayesianDecoder.morseToChar("111"))
+    }
+
+    @Test
+    fun morseToChar_numbers() {
+        assertEquals('1', CwBayesianDecoder.morseToChar("01111"))
+        assertEquals('0', CwBayesianDecoder.morseToChar("11111"))
+    }
+
+    @Test
+    fun morseToChar_unknown_returnsNull() {
+        assertNull(CwBayesianDecoder.morseToChar("......."))
+        assertNull(CwBayesianDecoder.morseToChar(""))
+    }
+
+    // --- FFT ---
+
+    @Test
+    fun fft_magnitudeSpectrum_detectsTone() {
+        val fft = CwFFT(256)
+        val sampleRate = 8000f
+        val freq = 700f
+        val buffer = FloatArray(256) { (sin(2.0 * PI * freq * it / sampleRate)).toFloat() }
+        val mag = fft.magnitudeSpectrum(buffer)
+        // Peak should be at bin around 700 * 256 / 8000 ≈ 22.4
+        var maxBin = 0
+        var maxVal = 0f
+        for (i in mag.indices) {
+            if (mag[i] > maxVal) { maxVal = mag[i]; maxBin = i }
+        }
+        assertTrue("Peak bin $maxBin should be near 22", maxBin in 18..26)
+        assertTrue("Peak value $maxVal should be positive", maxVal > 0.01f)
+    }
+
+    @Test
+    fun fft_magnitudeSpectrum_silence_isFlat() {
+        val fft = CwFFT(256)
+        val buffer = FloatArray(256) { 0f }
+        val mag = fft.magnitudeSpectrum(buffer)
+        for (v in mag) assertEquals("Silence spectrum should be 0, got $v", 0f, v, 1e-6f)
+    }
+
+    @Test
+    fun fft_rejectsWrongSize() {
+        assertThrows(IllegalArgumentException::class.java) { CwFFT(100) }
+    }
+
+    // --- Spectrogram ---
+
+    @Test
+    fun spectrogram_addSamples_updatesEnergy() {
+        val spec = CwSpectrogram(sampleRate = 8000)
+        val freq = 700f
+        // Feed multiple frames to stabilize energy normalization
+        for (i in 0..5) {
+            val buffer = FloatArray(256) { (sin(2.0 * PI * freq * it / 8000.0)).toFloat() }
+            spec.addSamples(buffer)
+        }
+        val col = spec.getCurrentColumn()
+        val peakBin = spec.findPeakBin()
+        assertTrue("Peak bin $peakBin should be >= 0", peakBin >= 0)
+    }
+
+    @Test
+    fun spectrogram_findPeakBin_returnsValidBin() {
+        val spec = CwSpectrogram(sampleRate = 8000)
+        // Add multiple frames of 700 Hz tone
+        for (i in 0..5) {
+            val buffer = FloatArray(256) { (sin(2.0 * PI * 700.0 * it / 8000.0)).toFloat() }
+            spec.addSamples(buffer)
+        }
+        val peakBin = spec.findPeakBin()
+        assertTrue("Peak bin should be >= 0, got $peakBin", peakBin >= 0)
+    }
+
+    @Test
+    fun spectrogram_freqToBin_roundtrip() {
+        val spec = CwSpectrogram(sampleRate = 8000)
+        val freq = 700f
+        val bin = spec.freqToBin(freq)
+        val backFreq = spec.binToFreq(bin)
+        assertTrue("Freq $freq → bin $bin → freq $backFreq", backFreq > 600f && backFreq < 800f)
+    }
+
+    @Test
+    fun spectrogram_getBinEnergy_returnsCorrectLength() {
+        val spec = CwSpectrogram(sampleRate = 8000)
+        val energy = spec.getBinEnergy(0, 10)
+        assertEquals(10, energy.size)
+    }
+
+    @Test
+    fun spectrogram_reset() {
+        val spec = CwSpectrogram(sampleRate = 8000)
+        spec.addSamples(FloatArray(256) { 1f })
+        spec.reset()
+        assertEquals(-1, spec.findPeakBin())
+    }
+
+    // --- Bayesian decoder ---
+
+    @Test
+    fun bayesian_processTone_dit() {
+        val decoder = CwBayesianDecoder()
+        // At 20 WPM, dot = 60 ms
+        val result = decoder.processTone(60f)
+        assertEquals('0', result.symbol)
+        assertTrue("Dit probability should be positive", result.probability > 0.1f)
+    }
+
+    @Test
+    fun bayesian_processTone_dash() {
+        val decoder = CwBayesianDecoder()
+        // Dash = 3 * dot = 180 ms
+        val result = decoder.processTone(180f)
+        assertEquals('1', result.symbol)
+        assertTrue("Dash probability should be positive", result.probability > 0.1f)
+    }
+
+    @Test
+    fun bayesian_processTone_unknown_returnsNull() {
+        val decoder = CwBayesianDecoder()
+        // Very long tone — low probability for both dit and dash
+        val result = decoder.processTone(5000f)
+        assertNull(result.symbol)
+    }
+
+    @Test
+    fun bayesian_processGap_interChar_returnsChar() {
+        val decoder = CwBayesianDecoder()
+        decoder.processTone(60f) // dit
+        decoder.processTone(60f) // dit
+        decoder.processTone(60f) // dit
+        // 3 dots = "000" = 'S'
+        val char = decoder.processGap(180f) // 3 * dot = inter-char gap
+        assertEquals('S', char)
+    }
+
+    @Test
+    fun bayesian_processGap_wordGap_addsSpace() {
+        val decoder = CwBayesianDecoder()
+        decoder.processTone(60f) // dit = 'E'
+        decoder.processGap(180f) // inter-char gap
+        // Now word gap
+        val space = decoder.processGap(420f) // 7 * dot
+        assertEquals(' ', space)
+    }
+
+    @Test
+    fun bayesian_decodedText_accumulates() {
+        val decoder = CwBayesianDecoder()
+        decoder.processTone(60f) // dit = 'E'
+        decoder.processGap(180f) // inter-char
+        assertTrue(decoder.decodedText.isNotEmpty())
+    }
+
+    @Test
+    fun bayesian_reset() {
+        val decoder = CwBayesianDecoder()
+        decoder.processTone(60f)
+        decoder.reset()
+        assertEquals("", decoder.decodedText)
+    }
+
+    @Test
+    fun bayesian_getSpeed() {
+        val decoder = CwBayesianDecoder()
+        // Send 3 dits at 20 WPM (60 ms each)
+        decoder.processTone(60f)
+        decoder.processTone(60f)
+        decoder.processTone(60f)
+        val speed = decoder.getSpeed()
+        assertTrue("Speed should be ~20 WPM, got $speed", speed > 15f && speed < 30f)
+    }
+
+    // --- Channel tracker ---
+
+    @Test
+    fun channelTracker_initialState() {
+        val spec = CwSpectrogram(sampleRate = 8000)
+        val tracker = CwChannelTracker(spec)
+        val channels = tracker.update()
+        assertTrue("No channels should be active initially", channels.isEmpty())
+    }
+
+    @Test
+    fun channelTracker_detectsTone() {
+        val spec = CwSpectrogram(sampleRate = 8000)
+        // Feed a tone
+        for (i in 0..5) {
+            spec.addSamples(FloatArray(256) { (sin(2.0 * PI * 700.0 * it / 8000.0)).toFloat() })
+        }
+        val tracker = CwChannelTracker(spec)
+        val channels = tracker.update()
+        assertTrue("Should detect at least 1 channel", channels.isNotEmpty())
+    }
+
+    @Test
+    fun channelTracker_bestChannel() {
+        val spec = CwSpectrogram(sampleRate = 8000)
+        for (i in 0..5) {
+            spec.addSamples(FloatArray(256) { (sin(2.0 * PI * 700.0 * it / 8000.0)).toFloat() })
+        }
+        val tracker = CwChannelTracker(spec)
+        tracker.update()
+        val best = tracker.getBestChannel()
+        assertNotNull("Best channel should exist", best)
+        if (best != null) assertTrue(best.frequency in 600f..800f)
+    }
+
+    @Test
+    fun channelTracker_reset() {
+        val spec = CwSpectrogram(sampleRate = 8000)
+        for (i in 0..5) {
+            spec.addSamples(FloatArray(256) { (sin(2.0 * PI * 700.0 * it / 8000.0)).toFloat() })
+        }
+        val tracker = CwChannelTracker(spec)
+        tracker.update()
+        tracker.reset()
+        assertNull(tracker.getBestChannel())
+    }
+
+    // --- Full decoder ---
+
+    @Test
+    fun decoder_initialState() {
+        val decoder = CwDecoder()
+        assertEquals("", decoder.decodedTextFlow.value)
+        assertEquals(0f, decoder.signalStrength.value, 0.001f)
+    }
+
+    @Test
+    fun decoder_processSilence_doesNotCrash() {
+        val decoder = CwDecoder()
+        decoder.processBuffer(FloatArray(256) { 0f })
+        assertEquals("", decoder.decodedTextFlow.value)
+    }
+
+    @Test
+    fun decoder_processNoise_doesNotCrash() {
+        val decoder = CwDecoder()
+        decoder.processBuffer(FloatArray(256) { (Math.random() * 2 - 1).toFloat() * 0.1f })
+        assertNotNull(decoder.decodedTextFlow.value)
+    }
+
+    @Test
+    fun decoder_processTone_doesNotCrash() {
+        val decoder = CwDecoder()
+        for (i in 0..20) {
+            decoder.processBuffer(FloatArray(256) { (sin(2.0 * PI * 700.0 * it / 8000.0)).toFloat() })
+        }
+        assertNotNull(decoder.decodedTextFlow.value)
+    }
+
+    @Test
+    fun decoder_reset() {
+        val decoder = CwDecoder()
+        decoder.processBuffer(FloatArray(256) { 1f })
+        decoder.resetDecoder()
+        assertEquals("", decoder.decodedTextFlow.value)
+        assertEquals(0f, decoder.signalStrength.value, 0.001f)
+    }
+
+    @Test
+    fun decoder_withFixedPitch() {
+        val decoder = CwDecoder(sampleRate = 8000, cwToneFreq = 700f)
+        assertEquals(700f, decoder.estimatedPitch.value)
+    }
+}

core/presentation/src/main/java/com/rtbishop/look4sat/core/presentation/Components.kt

@@ -157,16 +157,13 @@ fun RowScope.NextPassRow(pass: OrbitalPass, modifier: Modifier = Modifier, isUtc
                 .padding(start = 6.dp, top = 1.dp, end = 6.dp, bottom = 0.dp)
         ) {
             Row(verticalAlignment = Alignment.CenterVertically) {
-                Text(
-                    text = "${stringResource(R.string.pass_satId, pass.catNum)} - ",
-                    color = MaterialTheme.colorScheme.primary
-                )
                 Text(
                     text = pass.name,
                     modifier = Modifier
                         .weight(1f)
                         .padding(end = 6.dp)
                         .infiniteMarquee(),
+                    color = MaterialTheme.colorScheme.primary,
                     fontWeight = FontWeight.Medium,
                     maxLines = 1,
                     overflow = TextOverflow.Ellipsis

core/presentation/src/main/java/com/rtbishop/look4sat/core/presentation/Navigation.kt

@@ -35,6 +35,9 @@ sealed class Screen(val iconResId: Int, val titleResId: Int) : NavKey {
     @Serializable
     data object Map : Screen(R.drawable.ic_map, R.string.nav_map)
 
+    @Serializable
+    data object Mutual : Screen(R.drawable.ic_match, R.string.nav_mutual)
+
     @Serializable
     data object Settings : Screen(R.drawable.ic_settings, R.string.nav_prefs)
 }

core/presentation/src/main/res/drawable/ic_match.xml

@@ -0,0 +1,22 @@
+<vector xmlns:android="http://schemas.android.com/apk/res/android"
+    android:width="24dp"
+    android:height="24dp"
+    android:viewportWidth="96"
+    android:viewportHeight="96">
+
+    <path
+        android:fillColor="@android:color/transparent"
+        android:strokeColor="@android:color/white"
+        android:strokeWidth="6"
+        android:strokeLineCap="round"
+        android:strokeLineJoin="round"
+        android:pathData="M 8 76 C 8 44, 21 24, 39 24 C 57 24, 70 44, 70 76" />
+
+    <path
+        android:fillColor="@android:color/transparent"
+        android:strokeColor="@android:color/white"
+        android:strokeWidth="6"
+        android:strokeLineCap="round"
+        android:strokeLineJoin="round"
+        android:pathData="M 30 76 C 30 54, 44 42, 62 42 C 80 42, 94 54, 94 76" />
+</vector>

core/presentation/src/main/res/values-zh/strings.xml

@@ -9,6 +9,7 @@
     <string name="nav_sat">卫星</string>
     <string name="nav_pass">过境</string>
     <string name="nav_radar">雷达</string>
+    <string name="nav_mutual">匹配</string>
     <string name="nav_map">地图</string>
     <string name="nav_prefs">设置</string>
 
@@ -57,6 +58,17 @@
     <string name="radar_string_yes">是</string>
     <string name="radar_visible">日照中</string>
 
+    <string name="radar_doppler_calc">多普勒频率计算器</string>
+    <string name="radar_doppler_tx_hint">输入上行频率 (MHz)</string>
+    <string name="radar_doppler_rx_hint">输入下行频率 (MHz)</string>
+    <string name="radar_doppler_offset_hint">偏移 (kHz)</string>
+    <string name="radar_doppler_info">线性转发器：输入一个频率即可算出另一个</string>
+
+    <string name="radar_cw_decoder">CW 解码器</string>
+    <string name="radar_cw_start">开始</string>
+    <string name="radar_cw_stop">停止</string>
+    <string name="radar_cw_reset">清空</string>
+
     <!-- Map screen -->
     <string name="map_prev">上一个</string>
     <string name="map_next">下一个</string>
@@ -103,6 +115,9 @@
     <string name="prefs_data_clear_success">数据清空成功</string>
     <string name="prefs_data_update_success">更新成功</string>
 
+    <string name="prefs_data_import_satellites_error">未导入卫星。请选择有效的 TLE/3LE (.txt) 或 OMM (.csv) 文件。</string>
+    <string name="prefs_data_import_transceivers_error">未导入收发器。请选择有效的 SatNOGS (.json) 文件。</string>
+
     <string name="prefs_data_sources_title">自定义数据源</string>
     <string name="prefs_data_sources_tle_switch">自定义TLE URL</string>
     <string name="prefs_data_sources_transceivers_switch">自定义收发器URL</string>
@@ -110,6 +125,7 @@
     <string name="prefs_data_output_title">数据输出</string>
     <string name="prefs_net_output">网络</string>
     <string name="prefs_bt_output">蓝牙</string>
+    <string name="prefs_cat_output">CAT</string>
 
     <string name="prefs_net_title">网络数据输出</string>
     <string name="prefs_net_rotator_switch">启用方位俯仰角输出</string>
@@ -129,6 +145,16 @@
     <string name="prefs_bt_perm_error">请检查蓝牙权限</string>
     <string name="prefs_net_perm_error">请检查网络权限</string>
 
+    <!-- Radio Control -->
+    <string name="nav_radiocontrol">电台控制</string>
+    <string name="rc_settings_title">CAT 电台控制</string>
+    <string name="rc_radio_model">电台型号</string>
+    <string name="rc_tx_device_hint">发射电台蓝牙地址</string>
+    <string name="rc_rx_device_hint">接收电台蓝牙地址</string>
+    <string name="rc_tx_name_hint">发射电台名称</string>
+    <string name="rc_rx_name_hint">接收电台名称</string>
+    <string name="rc_enable_switch">启用 CAT 控制</string>
+
     <string name="prefs_other_title">其他设置</string>
     <string name="prefs_other_switch_utc">以 UTC 时间显示</string>
     <string name="prefs_other_switch_update">启用卫星数据自动更新</string>
@@ -148,7 +174,8 @@
         \n• Dave Moten (predict4java)
         \n• Alexandru Csete (Gpredict)
         \n• Dr T.S. Kelso (Celestrak)
-        \n• Libre Space Foundation (SatNOGS)</string>
+        \n• Libre Space Foundation (SatNOGS)
+        \n• xdsopl 和 Robot36 贡献者!</string>
     <string name="prefs_outro_license">该应用程序不提供任何保修.</string>
 
 </resources>

core/presentation/src/main/res/values/strings.xml

@@ -1,7 +1,7 @@
 <?xml version="1.0" encoding="utf-8"?>
 <resources>
     <!-- Commmon -->
-    <string name="app_name" translatable="false">Look4Sat</string>
+    <string name="app_name" translatable="false">Look4Sat Pro</string>
     <string name="btn_accept">Accept</string>
     <string name="btn_cancel">Cancel</string>
     <string name="empty_list_message">No data to show</string>
@@ -10,6 +10,7 @@
     <string name="nav_sat">Satellites</string>
     <string name="nav_pass">Passes</string>
     <string name="nav_radar">Radar</string>
+    <string name="nav_mutual">Match</string>
     <string name="nav_map">Map</string>
     <string name="nav_prefs">Settings</string>
 
@@ -80,6 +81,16 @@
     <string name="radar_string_no">No</string>
     <string name="radar_string_yes">Yes</string>
     <string name="radar_visible">Visible</string>
+    <string name="radar_doppler_calc">Doppler Frequency Calculator</string>
+    <string name="radar_doppler_tx_hint">Enter TX freq (MHz)</string>
+    <string name="radar_doppler_rx_hint">Enter RX freq (MHz)</string>
+    <string name="radar_doppler_offset_hint">Offset (kHz)</string>
+    <string name="radar_doppler_info">For linear transponders, type one frequency to see the other</string>
+
+    <string name="radar_cw_decoder">CW Decoder</string>
+    <string name="radar_cw_start">Start</string>
+    <string name="radar_cw_stop">Stop</string>
+    <string name="radar_cw_reset">Clear</string>
 
     <!-- Map screen -->
     <string name="map_prev">Prev</string>

feature/mutual/build.gradle.kts

@@ -0,0 +1,7 @@
+plugins {
+    alias(libs.plugins.convention.featurePlugin)
+}
+
+android {
+    namespace = "com.rtbishop.look4sat.feature.mutual"
+}

feature/mutual/src/main/java/com/rtbishop/look4sat/feature/mutual/ElevationCurveChart.kt

@@ -0,0 +1,262 @@
+/*
+ * 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.feature.mutual
+
+import androidx.compose.foundation.Canvas
+import androidx.compose.foundation.background
+import androidx.compose.foundation.gestures.detectDragGestures
+import androidx.compose.foundation.gestures.detectTapGestures
+import androidx.compose.foundation.layout.Arrangement
+import androidx.compose.foundation.layout.Column
+import androidx.compose.foundation.layout.Row
+import androidx.compose.foundation.layout.fillMaxWidth
+import androidx.compose.foundation.layout.height
+import androidx.compose.foundation.layout.padding
+import androidx.compose.material3.MaterialTheme
+import androidx.compose.material3.Text
+import androidx.compose.runtime.Composable
+import androidx.compose.runtime.remember
+import androidx.compose.ui.Modifier
+import androidx.compose.ui.geometry.Offset
+import androidx.compose.ui.graphics.toArgb
+import androidx.compose.ui.graphics.Path
+import androidx.compose.ui.graphics.drawscope.Stroke
+import androidx.compose.ui.graphics.nativeCanvas
+import androidx.compose.ui.input.pointer.pointerInput
+import androidx.compose.ui.unit.dp
+import androidx.compose.ui.unit.sp
+import java.text.SimpleDateFormat
+import java.util.Date
+import java.util.Locale
+import kotlin.math.roundToInt
+
+/**
+ * Draggable dual-station elevation curve chart.
+ * Controlled component: [progress] (0..1) and [onProgressChange] are owned by the parent,
+ * so the same time cursor can be shared with the radar track view.
+ */
+@Composable
+fun ElevationCurveChart(
+    samples: List<Pair<Long, Pair<Double, Double>>>,
+    startTime: Long,
+    endTime: Long,
+    maxElev: Double,
+    progress: Float = 0.5f,
+    onProgressChange: (Float) -> Unit = {},
+    modifier: Modifier = Modifier
+) {
+    if (samples.isEmpty()) return
+
+    val colorA = MaterialTheme.colorScheme.primary
+    val colorB = MaterialTheme.colorScheme.tertiary
+    val gridColor = MaterialTheme.colorScheme.outlineVariant
+    val textColor = MaterialTheme.colorScheme.onSurfaceVariant
+    val onSurfaceColor = MaterialTheme.colorScheme.onSurface
+    val colorAArgb = colorA.toArgb()
+    val colorBArgb = colorB.toArgb()
+    val textColorArgb = textColor.toArgb()
+    val onSurfaceArgb = onSurfaceColor.toArgb()
+    val gridColorArgb = gridColor.toArgb()
+    val timeFormat = remember { SimpleDateFormat("HH:mm", Locale.getDefault()) }
+
+    Column(modifier = modifier.fillMaxWidth()) {
+        Canvas(
+            modifier = Modifier
+                .fillMaxWidth()
+                .height(200.dp)
+                .background(MaterialTheme.colorScheme.surfaceVariant.copy(alpha = 0.3f))
+                .pointerInput(Unit) {
+                    detectTapGestures { offset ->
+                        onProgressChange((offset.x / size.width.toFloat()).coerceIn(0f, 1f))
+                    }
+                }
+                .pointerInput(Unit) {
+                    detectDragGestures { change, _ ->
+                        onProgressChange((change.position.x / size.width.toFloat()).coerceIn(0f, 1f))
+                    }
+                }
+        ) {
+            val chartWidth = size.width
+            val chartHeight = size.height
+            val padding = 40f
+            val plotLeft = padding
+            val plotRight = chartWidth - 10f
+            val plotTop = 10f
+            val plotBottom = chartHeight - padding
+            val plotWidth = plotRight - plotLeft
+            val plotHeight = plotBottom - plotTop
+
+            if (plotWidth <= 0f || plotHeight <= 0f) return@Canvas
+
+            val minTime = startTime
+            val maxTime = endTime
+            val timeRange = (maxTime - minTime).toFloat()
+            if (timeRange <= 0f) return@Canvas
+
+            // Grid lines
+            val gridSteps = 4
+            for (i in 0..gridSteps) {
+                val y = plotBottom - (plotHeight * i / gridSteps)
+                drawLine(gridColor, Offset(plotLeft, y), Offset(plotRight, y), strokeWidth = 1f)
+                val elev = (maxElev * i / gridSteps).roundToInt()
+                drawContext.canvas.nativeCanvas.drawText(
+                    "$elev°", 2f, y + 4f,
+                    android.graphics.Paint().apply {
+                        color = textColorArgb
+                        textSize = 24f
+                        textAlign = android.graphics.Paint.Align.LEFT
+                    }
+                )
+            }
+
+            // Time axis
+            val timeSteps = 4
+            for (i in 0..timeSteps) {
+                val x = plotLeft + (plotWidth * i / timeSteps)
+                val t = startTime + ((endTime - startTime) * i / timeSteps)
+                drawContext.canvas.nativeCanvas.drawText(
+                    timeFormat.format(Date(t)), x - 20f, chartHeight - 2f,
+                    android.graphics.Paint().apply {
+                        color = textColorArgb
+                        textSize = 22f
+                        textAlign = android.graphics.Paint.Align.LEFT
+                    }
+                )
+            }
+
+            // Elevation curves (smooth cubic Bezier)
+            val pathA = Path()
+            val pathB = Path()
+            val ptsA = mutableListOf<Offset>()
+            val ptsB = mutableListOf<Offset>()
+
+            for ((time, elev) in samples) {
+                val x = plotLeft + ((time - minTime).toFloat() / timeRange) * plotWidth
+                val yA = plotBottom - ((elev.first.toFloat() / maxElev.toFloat()) * plotHeight).coerceIn(0f, plotHeight)
+                val yB = plotBottom - ((elev.second.toFloat() / maxElev.toFloat()) * plotHeight).coerceIn(0f, plotHeight)
+                ptsA.add(Offset(x, yA))
+                ptsB.add(Offset(x, yB))
+            }
+
+            if (ptsA.size >= 2) {
+                pathA.moveTo(ptsA[0].x, ptsA[0].y)
+                pathB.moveTo(ptsB[0].x, ptsB[0].y)
+                for (i in 1 until ptsA.size) {
+                    val p0a = ptsA.getOrNull(i - 2) ?: ptsA[i - 1]
+                    val p1a = ptsA[i - 1]
+                    val p2a = ptsA[i]
+                    val p3a = ptsA.getOrNull(i + 1) ?: ptsA[i]
+                    val cp1a = Offset(p1a.x + (p2a.x - p0a.x) / 6f, p1a.y + (p2a.y - p0a.y) / 6f)
+                    val cp2a = Offset(p2a.x - (p3a.x - p1a.x) / 6f, p2a.y - (p3a.y - p1a.y) / 6f)
+                    pathA.cubicTo(cp1a.x, cp1a.y, cp2a.x, cp2a.y, p2a.x, p2a.y)
+
+                    val p0b = ptsB.getOrNull(i - 2) ?: ptsB[i - 1]
+                    val p1b = ptsB[i - 1]
+                    val p2b = ptsB[i]
+                    val p3b = ptsB.getOrNull(i + 1) ?: ptsB[i]
+                    val cp1b = Offset(p1b.x + (p2b.x - p0b.x) / 6f, p1b.y + (p2b.y - p0b.y) / 6f)
+                    val cp2b = Offset(p2b.x - (p3b.x - p1b.x) / 6f, p2b.y - (p3b.y - p1b.y) / 6f)
+                    pathB.cubicTo(cp1b.x, cp1b.y, cp2b.x, cp2b.y, p2b.x, p2b.y)
+                }
+            }
+
+            drawPath(pathA, colorA, style = Stroke(width = 2.5f))
+            drawPath(pathB, colorB, style = Stroke(width = 2.5f))
+
+            // Drag indicator
+            val dragX = plotLeft + progress * plotWidth
+            val dragTime = startTime + (progress * (endTime - startTime)).toLong()
+
+            drawLine(
+                onSurfaceColor,
+                Offset(dragX, plotTop), Offset(dragX, plotBottom),
+                strokeWidth = 2f
+            )
+
+            val dragElev = getElevationAtTime(samples, dragTime)
+            val dragElevA = (dragElev?.first?.let { (it * 10).roundToInt() / 10.0 } ?: 0.0)
+            val dragElevB = (dragElev?.second?.let { (it * 10).roundToInt() / 10.0 } ?: 0.0)
+
+            drawContext.canvas.nativeCanvas.drawText(
+                timeFormat.format(Date(dragTime)),
+                dragX - 24f, plotBottom + 16f,
+                android.graphics.Paint().apply {
+                    color = onSurfaceArgb
+                    textSize = 24f
+                    textAlign = android.graphics.Paint.Align.LEFT
+                }
+            )
+            drawContext.canvas.nativeCanvas.drawText(
+                "A:${dragElevA}°",
+                dragX + 6f, plotTop + 16f,
+                android.graphics.Paint().apply {
+                    color = colorAArgb
+                    textSize = 24f
+                    textAlign = android.graphics.Paint.Align.LEFT
+                }
+            )
+            drawContext.canvas.nativeCanvas.drawText(
+                "B:${dragElevB}°",
+                dragX + 6f, plotTop + 42f,
+                android.graphics.Paint().apply {
+                    color = colorBArgb
+                    textSize = 24f
+                    textAlign = android.graphics.Paint.Align.LEFT
+                }
+            )
+        }
+
+        // Legend
+        Row(
+            modifier = Modifier.fillMaxWidth().padding(horizontal = 8.dp, vertical = 4.dp),
+            horizontalArrangement = Arrangement.SpaceEvenly
+        ) {
+            Text("● 站点A", color = colorA, fontSize = 12.sp)
+            Text("● 站点B", color = colorB, fontSize = 12.sp)
+        }
+    }
+}
+
+private fun getElevationAtTime(
+    samples: List<Pair<Long, Pair<Double, Double>>>,
+    time: Long
+): Pair<Double, Double>? {
+    if (samples.isEmpty()) return null
+    if (samples.size == 1) return samples[0].second
+    if (time <= samples[0].first) return samples[0].second
+    if (time >= samples.last().first) return samples.last().second
+
+    var lo = 0
+    var hi = samples.size - 1
+    while (hi - lo > 1) {
+        val mid = (lo + hi) / 2
+        if (samples[mid].first <= time) lo = mid
+        else hi = mid
+    }
+
+    val t0 = samples[lo].first
+    val t1 = samples[hi].first
+    val frac = if (t1 > t0) (time - t0).toFloat() / (t1 - t0).toFloat() else 0f
+
+    val e0 = samples[lo].second
+    val e1 = samples[hi].second
+    return Pair(
+        e0.first + (e1.first - e0.first) * frac,
+        e0.second + (e1.second - e0.second) * frac
+    )
+}

feature/mutual/src/main/java/com/rtbishop/look4sat/feature/mutual/MutualPass.kt

@@ -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.feature.mutual
+
+/**
+ * A mutual pass where a satellite is visible from two stations simultaneously.
+ *
+ * @param catNum Satellite catalog number
+ * @param name Satellite name
+ * @param startTime Common AOS time (millis)
+ * @param endTime Common LOS time (millis)
+ * @param maxElevationA Peak elevation for station A
+ * @param maxElevationB Peak elevation for station B
+ * @param elevationSamples List of (time, (elevationA, elevationB)) pairs
+ * @param trackSamples List of radar-track samples (azimuth/elevation for both stations, degrees)
+ */
+data class MutualPass(
+    val catNum: Int,
+    val name: String,
+    val startTime: Long,
+    val endTime: Long,
+    val maxElevationA: Double,
+    val maxElevationB: Double,
+    val elevationSamples: List<Pair<Long, Pair<Double, Double>>>,
+    val trackSamples: List<TrackSample> = emptyList()
+)
+
+/**
+ * One radar-track sample: satellite position as seen from both stations.
+ * All angles are in degrees.
+ */
+data class TrackSample(
+    val time: Long,
+    val azimuthA: Double,
+    val elevationA: Double,
+    val azimuthB: Double,
+    val elevationB: Double
+)

feature/mutual/src/main/java/com/rtbishop/look4sat/feature/mutual/MutualRadarView.kt

@@ -0,0 +1,223 @@
+/*
+ * 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.feature.mutual
+
+import androidx.compose.foundation.Canvas
+import androidx.compose.foundation.layout.Arrangement
+import androidx.compose.foundation.layout.Column
+import androidx.compose.foundation.layout.Row
+import androidx.compose.foundation.layout.aspectRatio
+import androidx.compose.foundation.layout.fillMaxWidth
+import androidx.compose.foundation.layout.padding
+import androidx.compose.material3.MaterialTheme
+import androidx.compose.material3.Text
+import androidx.compose.runtime.Composable
+import androidx.compose.ui.Modifier
+import androidx.compose.ui.geometry.Offset
+import androidx.compose.ui.graphics.Color
+import androidx.compose.ui.graphics.Path
+import androidx.compose.ui.graphics.PathEffect
+import androidx.compose.ui.graphics.drawscope.DrawScope
+import androidx.compose.ui.graphics.drawscope.Stroke
+import androidx.compose.ui.text.TextMeasurer
+import androidx.compose.ui.text.TextStyle
+import androidx.compose.ui.text.drawText
+import androidx.compose.ui.text.rememberTextMeasurer
+import androidx.compose.ui.unit.dp
+import androidx.compose.ui.unit.sp
+import kotlin.math.PI
+import kotlin.math.cos
+import kotlin.math.sin
+
+private const val CIRCLES = 3 // 30°, 60°, 90° rings
+private const val STROKE_WIDTH = 2.5f
+
+/**
+ * Polar radar chart showing the satellite track as seen from both stations
+ * on one plot. Station A is drawn solid, station B dashed.
+ * Controlled: [progress] (0..1) and [onProgressChange] are owned by the parent
+ * so the time cursor can be shared with the elevation curve chart.
+ */
+@Composable
+fun MutualRadarView(
+    trackSamples: List<TrackSample>,
+    progress: Float = 0.5f,
+    labelA: String = "站点A",
+    labelB: String = "站点B",
+    modifier: Modifier = Modifier
+) {
+    if (trackSamples.isEmpty()) return
+
+    val colorA = MaterialTheme.colorScheme.primary
+    val colorB = MaterialTheme.colorScheme.tertiary
+    val gridColor = MaterialTheme.colorScheme.outlineVariant
+    val textColor = MaterialTheme.colorScheme.onSurfaceVariant
+    val measurer = rememberTextMeasurer()
+
+    // Current-time samples (both stations' position at the shared cursor)
+    val t0 = trackSamples.first().time
+    val t1 = trackSamples.last().time
+    val selectedTime = t0 + ((t1 - t0) * progress).toLong()
+    val visibleSamples = trackSamples.filter { it.time <= selectedTime }
+    val currentSample = visibleSamples.lastOrNull() ?: trackSamples.first()
+
+    Column(modifier = modifier.fillMaxWidth()) {
+        Canvas(
+            modifier = Modifier
+                .fillMaxWidth()
+                .aspectRatio(1f)
+                .padding(4.dp)
+        ) {
+            val radius = size.minDimension / 2f * 0.92f
+            val center = Offset(size.width / 2f, size.height / 2f)
+
+            // Grid: elevation rings + azimuth spokes + cardinal labels
+            drawRadarGrid(center, radius, gridColor, textColor, measurer)
+
+            // Track paths (only the above-horizon arc, split at the 0/360° azimuth wrap)
+            val pathA = Path()
+            val pathB = Path()
+            var firstVisibleA = true
+            var firstVisibleB = true
+            var lastAzimA: Double? = null
+            var lastAzimB: Double? = null
+            trackSamples.forEach { sample ->
+                if (sample.elevationA > 0f) {
+                    val p = sph2Cart(center, sample.azimuthA, sample.elevationA, radius)
+                    val wrapA = lastAzimA != null && kotlin.math.abs(azimuthDelta(sample.azimuthA - lastAzimA!!)) > 180.0
+                    if (firstVisibleA || wrapA) {
+                        pathA.moveTo(p.x, p.y)
+                        firstVisibleA = false
+                    } else {
+                        pathA.lineTo(p.x, p.y)
+                    }
+                    lastAzimA = sample.azimuthA
+                }
+                if (sample.elevationB > 0f) {
+                    val p = sph2Cart(center, sample.azimuthB, sample.elevationB, radius)
+                    val wrapB = lastAzimB != null && kotlin.math.abs(azimuthDelta(sample.azimuthB - lastAzimB!!)) > 180.0
+                    if (firstVisibleB || wrapB) {
+                        pathB.moveTo(p.x, p.y)
+                        firstVisibleB = false
+                    } else {
+                        pathB.lineTo(p.x, p.y)
+                    }
+                    lastAzimB = sample.azimuthB
+                }
+            }
+
+            // Solid line for station A, dashed for station B
+            drawPath(pathA, colorA, style = Stroke(STROKE_WIDTH))
+            drawPath(
+                pathB, colorB,
+                style = Stroke(STROKE_WIDTH, pathEffect = PathEffect.dashPathEffect(floatArrayOf(14f, 10f)))
+            )
+
+            // AOS / LOS markers on both tracks
+            val first = trackSamples.first()
+            val last = trackSamples.last()
+            val aosA = sph2Cart(center, first.azimuthA, first.elevationA, radius)
+            val aosB = sph2Cart(center, first.azimuthB, first.elevationB, radius)
+            val losA = sph2Cart(center, last.azimuthA, last.elevationA, radius)
+            val losB = sph2Cart(center, last.azimuthB, last.elevationB, radius)
+            // AOS: hollow circle, LOS: filled circle
+            if (first.elevationA > 0f) drawCircle(colorA, 7f, aosA, style = Stroke(2.5f))
+            if (first.elevationB > 0f) drawCircle(colorB, 7f, aosB, style = Stroke(2.5f))
+            if (last.elevationA > 0f) drawCircle(colorA, 5f, losA)
+            if (last.elevationB > 0f) drawCircle(colorB, 5f, losB)
+
+            // Shared time-cursor positions (both stations at selectedTime)
+            val cursorA = sph2Cart(center, currentSample.azimuthA, currentSample.elevationA, radius)
+            val cursorB = sph2Cart(center, currentSample.azimuthB, currentSample.elevationB, radius)
+            drawCircle(colorA, 14f, cursorA, style = Stroke(3f))
+            drawCircle(colorA, 6f, cursorA)
+            drawCircle(colorB, 14f, cursorB, style = Stroke(3f))
+            drawCircle(colorB, 6f, cursorB)
+
+            // Center dot
+            drawCircle(gridColor, 4f, center)
+        }
+
+        // Legend
+        Row(
+            modifier = Modifier.fillMaxWidth().padding(horizontal = 8.dp, vertical = 4.dp),
+            horizontalArrangement = Arrangement.SpaceEvenly
+        ) {
+            Text("● $labelA", color = colorA, fontSize = 12.sp)
+            Text("- - $labelB", color = colorB, fontSize = 12.sp)
+        }
+    }
+}
+
+private fun DrawScope.drawRadarGrid(
+    center: Offset,
+    radius: Float,
+    color: Color,
+    textColor: Color,
+    measurer: TextMeasurer
+) {
+    // Elevation rings: 30°, 60°, 90°(center) — outer edge is horizon (0°)
+    val step = radius / CIRCLES
+    for (i in 0 until CIRCLES) {
+        drawCircle(color, radius - step * i, center, style = Stroke(1.5f))
+    }
+    // Cardinal spokes
+    drawLine(color, Offset(center.x - radius, center.y), Offset(center.x + radius, center.y), 1.5f)
+    drawLine(color, Offset(center.x, center.y - radius), Offset(center.x, center.y + radius), 1.5f)
+    // Diagonal spokes (lighter)
+    val diag = radius * 0.7071f
+    drawLine(
+        color.copy(alpha = 0.5f),
+        Offset(center.x - diag, center.y - diag), Offset(center.x + diag, center.y + diag), 1f
+    )
+    drawLine(
+        color.copy(alpha = 0.5f),
+        Offset(center.x - diag, center.y + diag), Offset(center.x + diag, center.y - diag), 1f
+    )
+
+    // Elevation ring labels: 30° on the outer ring, 60° on the middle ring, 90° at center
+    // (outer edge is the 0° horizon). Labels sit just above their ring.
+    val style = TextStyle(color = textColor, fontSize = 11.sp)
+    drawText(measurer, "30°", Offset(center.x + 6f, (center.y - (radius - step)) - 24f), style = style)
+    drawText(measurer, "60°", Offset(center.x + 6f, (center.y - (radius - 2 * step)) - 24f), style = style)
+    drawText(measurer, "90°", Offset(center.x + 6f, center.y - 18f), style = style)
+    // Cardinal labels
+    drawText(measurer, "N", Offset(center.x - 8f, center.y - radius - 20f), style = style)
+    drawText(measurer, "E", Offset(center.x + radius + 4f, center.y - 10f), style = style)
+    drawText(measurer, "S", Offset(center.x - 6f, center.y + radius + 2f), style = style)
+    drawText(measurer, "W", Offset(center.x - radius - 24f, center.y - 10f), style = style)
+}
+
+/** Normalize an azimuth delta (degrees) into the [-180, 180] range. */
+private fun azimuthDelta(deltaDeg: Double): Double {
+    var d = deltaDeg % 360.0
+    if (d > 180.0) d -= 360.0
+    if (d < -180.0) d += 360.0
+    return d
+}
+
+/** Convert azimuth (deg, 0=N, clockwise) and elevation (deg) to canvas offset. */
+private fun sph2Cart(center: Offset, azimDeg: Double, elevDeg: Double, r: Float): Offset {
+    val azimRad = azimDeg * PI / 180.0
+    val elevRad = elevDeg * PI / 180.0
+    val radius = r * (PI / 2 - elevRad) / (PI / 2)
+    return Offset(
+        x = center.x + (radius * cos(PI / 2 - azimRad)).toFloat(),
+        y = center.y - (radius * sin(PI / 2 - azimRad)).toFloat()
+    )
+}

feature/mutual/src/main/java/com/rtbishop/look4sat/feature/mutual/MutualScreen.kt

@@ -0,0 +1,590 @@
+/*
+ * 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.feature.mutual
+
+import androidx.compose.animation.AnimatedVisibility
+import androidx.compose.animation.expandVertically
+import androidx.compose.animation.shrinkVertically
+import androidx.compose.foundation.clickable
+import androidx.compose.foundation.layout.Arrangement
+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.height
+import androidx.compose.foundation.layout.padding
+import androidx.compose.foundation.layout.width
+import androidx.compose.foundation.lazy.LazyColumn
+import androidx.compose.foundation.lazy.itemsIndexed
+import androidx.compose.foundation.text.KeyboardOptions
+import androidx.compose.material3.Button
+import androidx.compose.material3.CardDefaults
+import androidx.compose.material3.CircularProgressIndicator
+import androidx.compose.material3.ElevatedCard
+import androidx.compose.material3.FilterChip
+import androidx.compose.material3.HorizontalDivider
+import androidx.compose.material3.Icon
+import androidx.compose.material3.MaterialTheme
+import androidx.compose.material3.OutlinedButton
+import androidx.compose.material3.OutlinedTextField
+import androidx.compose.material3.Slider
+import androidx.compose.material3.Text
+import androidx.compose.runtime.Composable
+import androidx.compose.runtime.collectAsState
+import androidx.compose.runtime.getValue
+import androidx.compose.runtime.mutableFloatStateOf
+import androidx.compose.runtime.remember
+import androidx.compose.runtime.setValue
+import androidx.compose.ui.Alignment
+import androidx.compose.ui.Modifier
+import androidx.compose.ui.res.painterResource
+import androidx.compose.ui.res.stringResource
+import androidx.compose.ui.text.font.FontWeight
+import androidx.compose.ui.text.input.KeyboardType
+import androidx.compose.ui.unit.dp
+import androidx.compose.ui.unit.sp
+import com.rtbishop.look4sat.core.domain.repository.MutualPassData
+import com.rtbishop.look4sat.core.domain.repository.TrackSampleData
+import com.rtbishop.look4sat.core.presentation.IconCard
+import com.rtbishop.look4sat.core.presentation.R
+import com.rtbishop.look4sat.core.presentation.ScreenColumn
+import com.rtbishop.look4sat.core.presentation.TopBar
+import com.rtbishop.look4sat.core.presentation.isVerticalLayout
+import java.text.SimpleDateFormat
+import java.util.Date
+import java.util.Locale
+
+@Composable
+fun MutualScreen(
+    viewModel: MutualViewModel,
+    navigateUp: () -> Unit = {},
+    navigateToRadar: (Int, Long, MutualPassData?) -> Unit = { _, _, _ -> },
+    modifier: Modifier = Modifier
+) {
+    val state by viewModel.uiState.collectAsState()
+
+    ScreenColumn(
+        topBar = { isVertical ->
+            TopBar(
+                isVerticalLayout = isVertical,
+                startAction = {
+                    IconCard(action = navigateUp, resId = R.drawable.ic_back)
+                },
+                topInfo = {
+                    Text(
+                        text = "过境匹配",
+                        style = MaterialTheme.typography.titleMedium,
+                        fontWeight = FontWeight.Bold
+                    )
+                },
+                bottomInfo = {
+                    if (state.mutualPasses.isNotEmpty()) {
+                        Text(
+                            text = "找到 ${state.mutualPasses.size} 个匹配",
+                            style = MaterialTheme.typography.bodySmall,
+                            color = MaterialTheme.colorScheme.onSurfaceVariant
+                        )
+                    }
+                },
+                endAction = {
+                    if (state.isCalculating) {
+                        CircularProgressIndicator(
+                            modifier = Modifier
+                                .height(24.dp)
+                                .width(24.dp),
+                            strokeWidth = 2.dp
+                        )
+                    }
+                }
+            )
+        }
+    ) { isVertical ->
+        MutualContent(
+            state = state,
+            isVertical = isVertical,
+            onQuery = viewModel::queryMutualPasses,
+            onSelectPass = viewModel::onSelectPass,
+            onNavigateToRadar = navigateToRadar,
+            onStationALat = viewModel::onStationALat,
+            onStationALon = viewModel::onStationALon,
+            onStationAGrid = viewModel::onStationAGrid,
+            onStationAMinElev = viewModel::onStationAMinElev,
+            onStationBLat = viewModel::onStationBLat,
+            onStationBLon = viewModel::onStationBLon,
+            onStationBGrid = viewModel::onStationBGrid,
+            onStationBMinElev = viewModel::onStationBMinElev,
+            onUseCurrentPosition = viewModel::onUseCurrentPosition,
+            onHoursAhead = viewModel::onHoursAhead,
+            onClearError = viewModel::clearError
+        )
+    }
+}
+
+@Composable
+private fun MutualContent(
+    state: MutualUiState,
+    isVertical: Boolean,
+    onQuery: () -> Unit,
+    onSelectPass: (Int) -> Unit,
+    onNavigateToRadar: (Int, Long, MutualPassData?) -> Unit,
+    onStationALat: (String) -> Unit,
+    onStationALon: (String) -> Unit,
+    onStationAGrid: (String) -> Unit,
+    onStationAMinElev: (Double) -> Unit,
+    onStationBLat: (String) -> Unit,
+    onStationBLon: (String) -> Unit,
+    onStationBGrid: (String) -> Unit,
+    onStationBMinElev: (Double) -> Unit,
+    onUseCurrentPosition: () -> Unit,
+    onHoursAhead: (Int) -> Unit,
+    onClearError: () -> Unit
+) {
+    val timeFormat = remember { SimpleDateFormat("MM/dd HH:mm", Locale.getDefault()) }
+
+    LazyColumn(
+        modifier = Modifier.fillMaxSize(),
+        verticalArrangement = Arrangement.spacedBy(6.dp)
+    ) {
+        // Error message
+        val errorMsg = state.errorMessage
+        if (errorMsg != null) {
+            item {
+                ElevatedCard(
+                    modifier = Modifier.fillMaxWidth(),
+                    colors = CardDefaults.elevatedCardColors(
+                        containerColor = MaterialTheme.colorScheme.errorContainer
+                    )
+                ) {
+                    Text(
+                        text = errorMsg,
+                        color = MaterialTheme.colorScheme.onErrorContainer,
+                        modifier = Modifier.padding(12.dp),
+                        style = MaterialTheme.typography.bodyMedium
+                    )
+                }
+            }
+        }
+
+        // Input form
+        item {
+            Column(
+                modifier = Modifier.fillMaxWidth(),
+                verticalArrangement = Arrangement.spacedBy(6.dp)
+            ) {
+                MatchIntroCard()
+
+                if (isVertical) {
+                    StationInputCard(
+                        title = "你的位置",
+                        titleColor = MaterialTheme.colorScheme.primary,
+                        lat = state.stationALat,
+                        lon = state.stationALon,
+                        grid = state.stationAGrid,
+                        minElev = state.stationAMinElev,
+                        latPlaceholder = "39.9042",
+                        lonPlaceholder = "116.4074",
+                        gridPlaceholder = "ON79uj",
+                        onLatChange = onStationALat,
+                        onLonChange = onStationALon,
+                        onGridChange = onStationAGrid,
+                        onMinElevChange = onStationAMinElev,
+                        currentPositionAction = onUseCurrentPosition
+                    )
+                    StationInputCard(
+                        title = "友台位置",
+                        titleColor = MaterialTheme.colorScheme.tertiary,
+                        lat = state.stationBLat,
+                        lon = state.stationBLon,
+                        grid = state.stationBGrid,
+                        minElev = state.stationBMinElev,
+                        latPlaceholder = "34.0522",
+                        lonPlaceholder = "-118.2437",
+                        gridPlaceholder = "PM01tv",
+                        onLatChange = onStationBLat,
+                        onLonChange = onStationBLon,
+                        onGridChange = onStationBGrid,
+                        onMinElevChange = onStationBMinElev
+                    )
+                } else {
+                    Row(
+                        modifier = Modifier.fillMaxWidth(),
+                        horizontalArrangement = Arrangement.spacedBy(6.dp)
+                    ) {
+                        StationInputCard(
+                            title = "你的位置",
+                            titleColor = MaterialTheme.colorScheme.primary,
+                            lat = state.stationALat,
+                            lon = state.stationALon,
+                            grid = state.stationAGrid,
+                            minElev = state.stationAMinElev,
+                            latPlaceholder = "39.9042",
+                            lonPlaceholder = "116.4074",
+                            gridPlaceholder = "ON79uj",
+                            onLatChange = onStationALat,
+                            onLonChange = onStationALon,
+                            onGridChange = onStationAGrid,
+                            onMinElevChange = onStationAMinElev,
+                            currentPositionAction = onUseCurrentPosition,
+                            modifier = Modifier.weight(1f)
+                        )
+                        StationInputCard(
+                            title = "友台位置",
+                            titleColor = MaterialTheme.colorScheme.tertiary,
+                            lat = state.stationBLat,
+                            lon = state.stationBLon,
+                            grid = state.stationBGrid,
+                            minElev = state.stationBMinElev,
+                            latPlaceholder = "34.0522",
+                            lonPlaceholder = "-118.2437",
+                            gridPlaceholder = "PM01tv",
+                            onLatChange = onStationBLat,
+                            onLonChange = onStationBLon,
+                            onGridChange = onStationBGrid,
+                            onMinElevChange = onStationBMinElev,
+                            modifier = Modifier.weight(1f)
+                        )
+                    }
+                }
+
+                MatchSearchCard(
+                    hoursAhead = state.hoursAhead,
+                    isCalculating = state.isCalculating,
+                    onHoursAhead = onHoursAhead,
+                    onQuery = onQuery
+                )
+            }
+        }
+
+        // Results
+        itemsIndexed(state.mutualPasses) { index, pass ->
+            val mutualData = MutualPassData(
+                samples = pass.elevationSamples,
+                trackSamples = pass.trackSamples.map {
+                    TrackSampleData(
+                        time = it.time,
+                        azimuthA = it.azimuthA,
+                        elevationA = it.elevationA,
+                        azimuthB = it.azimuthB,
+                        elevationB = it.elevationB
+                    )
+                },
+                startTime = pass.startTime,
+                endTime = pass.endTime,
+                maxElev = maxOf(pass.maxElevationA, pass.maxElevationB, 10.0),
+                labelA = "你",
+                labelB = "友台"
+            )
+            MutualPassCard(
+                pass = pass,
+                isExpanded = state.selectedPassIndex == index,
+                timeFormat = timeFormat,
+                minElevA = state.stationAMinElev,
+                minElevB = state.stationBMinElev,
+                onClick = { onSelectPass(if (state.selectedPassIndex == index) -1 else index) },
+                onNavigateToRadar = { onNavigateToRadar(pass.catNum, pass.startTime, mutualData) }
+            )
+        }
+    }
+}
+
+@Composable
+private fun MatchIntroCard(modifier: Modifier = Modifier) {
+    ElevatedCard(modifier = modifier.fillMaxWidth()) {
+        Column(
+            modifier = Modifier.padding(12.dp),
+            verticalArrangement = Arrangement.spacedBy(4.dp)
+        ) {
+            Text(
+                text = "位置匹配",
+                style = MaterialTheme.typography.titleSmall,
+                fontWeight = FontWeight.Medium,
+                color = MaterialTheme.colorScheme.primary
+            )
+            Text(
+                text = "输入双方位置，查找共同可见的卫星过境窗口",
+                style = MaterialTheme.typography.bodySmall,
+                color = MaterialTheme.colorScheme.onSurfaceVariant
+            )
+        }
+    }
+}
+
+@Composable
+private fun StationInputCard(
+    title: String,
+    titleColor: androidx.compose.ui.graphics.Color,
+    lat: String,
+    lon: String,
+    grid: String,
+    minElev: Double,
+    latPlaceholder: String,
+    lonPlaceholder: String,
+    gridPlaceholder: String,
+    onLatChange: (String) -> Unit,
+    onLonChange: (String) -> Unit,
+    onGridChange: (String) -> Unit,
+    onMinElevChange: (Double) -> Unit,
+    modifier: Modifier = Modifier,
+    currentPositionAction: (() -> Unit)? = null
+) {
+    ElevatedCard(modifier = modifier.fillMaxWidth()) {
+        Column(
+            modifier = Modifier.padding(12.dp),
+            verticalArrangement = Arrangement.spacedBy(8.dp)
+        ) {
+            Row(
+                modifier = Modifier.fillMaxWidth(),
+                horizontalArrangement = Arrangement.SpaceBetween,
+                verticalAlignment = Alignment.CenterVertically
+            ) {
+                Text(
+                    text = title,
+                    style = MaterialTheme.typography.titleSmall,
+                    fontWeight = FontWeight.Medium,
+                    color = titleColor
+                )
+                if (currentPositionAction != null) {
+                    OutlinedButton(onClick = currentPositionAction) {
+                        Text("填入当前位置", style = MaterialTheme.typography.bodySmall)
+                    }
+                }
+            }
+
+            Row(
+                modifier = Modifier.fillMaxWidth(),
+                horizontalArrangement = Arrangement.spacedBy(8.dp)
+            ) {
+                OutlinedTextField(
+                    value = lat,
+                    onValueChange = onLatChange,
+                    label = { Text("纬度") },
+                    placeholder = { Text(latPlaceholder) },
+                    keyboardOptions = KeyboardOptions(keyboardType = KeyboardType.Decimal),
+                    singleLine = true,
+                    modifier = Modifier.weight(1f)
+                )
+                OutlinedTextField(
+                    value = lon,
+                    onValueChange = onLonChange,
+                    label = { Text("经度") },
+                    placeholder = { Text(lonPlaceholder) },
+                    keyboardOptions = KeyboardOptions(keyboardType = KeyboardType.Decimal),
+                    singleLine = true,
+                    modifier = Modifier.weight(1f)
+                )
+            }
+
+            OutlinedTextField(
+                value = grid,
+                onValueChange = onGridChange,
+                label = { Text("网格") },
+                placeholder = { Text(gridPlaceholder) },
+                supportingText = { Text("支持 4/6/8 位 Maidenhead 网格；也可直接输入经纬度") },
+                singleLine = true,
+                modifier = Modifier.fillMaxWidth()
+            )
+
+            Text(
+                text = "最小仰角：${minElev.toInt()}°",
+                style = MaterialTheme.typography.bodySmall,
+                color = MaterialTheme.colorScheme.onSurfaceVariant
+            )
+            Slider(
+                value = minElev.toFloat(),
+                onValueChange = { onMinElevChange(it.toDouble()) },
+                valueRange = 0f..90f,
+                steps = 17
+            )
+        }
+    }
+}
+
+@Composable
+private fun MatchSearchCard(
+    hoursAhead: Int,
+    isCalculating: Boolean,
+    onHoursAhead: (Int) -> Unit,
+    onQuery: () -> Unit,
+    modifier: Modifier = Modifier
+) {
+    ElevatedCard(modifier = modifier.fillMaxWidth()) {
+        Column(
+            modifier = Modifier.padding(12.dp),
+            verticalArrangement = Arrangement.spacedBy(10.dp)
+        ) {
+            Text(
+                text = "时间范围",
+                style = MaterialTheme.typography.titleSmall,
+                fontWeight = FontWeight.Medium
+            )
+            Row(
+                modifier = Modifier.fillMaxWidth(),
+                horizontalArrangement = Arrangement.spacedBy(8.dp)
+            ) {
+                listOf(6, 12, 24, 48, 72).forEach { hours ->
+                    FilterChip(
+                        selected = hoursAhead == hours,
+                        onClick = { onHoursAhead(hours) },
+                        label = { Text("${hours}h") }
+                    )
+                }
+            }
+            Button(
+                onClick = onQuery,
+                enabled = !isCalculating,
+                modifier = Modifier.fillMaxWidth()
+            ) {
+                if (isCalculating) {
+                    CircularProgressIndicator(
+                        modifier = Modifier
+                            .height(18.dp)
+                            .width(18.dp),
+                        strokeWidth = 2.dp,
+                        color = MaterialTheme.colorScheme.onPrimary
+                    )
+                    Spacer(Modifier.width(8.dp))
+                }
+                Text(if (isCalculating) "计算中..." else "查询匹配")
+            }
+        }
+    }
+}
+
+@Composable
+private fun MutualPassCard(
+    pass: MutualPass,
+    isExpanded: Boolean,
+    timeFormat: SimpleDateFormat,
+    minElevA: Double,
+    minElevB: Double,
+    onClick: () -> Unit,
+    onNavigateToRadar: () -> Unit
+) {
+    // Shared time cursor: both the elevation curve and the radar track view
+    // are controlled by this single progress value for bidirectional drag sync.
+    var dragProgress by remember(pass) { mutableFloatStateOf(0.5f) }
+
+    // Filter to only show the portion where both stations are above their minElev
+    val visibleSamples = remember(pass, minElevA, minElevB) {
+        pass.elevationSamples.filter { (_, elev) ->
+            elev.first >= minElevA && elev.second >= minElevB
+        }
+    }
+    val visibleTracks = remember(pass, minElevA, minElevB) {
+        pass.trackSamples.filter { it.elevationA >= minElevA && it.elevationB >= minElevB }
+    }
+    val visibleStart = visibleSamples.firstOrNull()?.first ?: pass.startTime
+    val visibleEnd = visibleSamples.lastOrNull()?.first ?: pass.endTime
+    val adjustedMaxElev = maxOf(
+        visibleSamples.maxOfOrNull { (_, elev) -> elev.first } ?: 10.0,
+        visibleSamples.maxOfOrNull { (_, elev) -> elev.second } ?: 10.0,
+        10.0
+    )
+    ElevatedCard(
+        modifier = Modifier
+            .fillMaxWidth()
+            .clickable(onClick = onClick)
+    ) {
+        Column(modifier = Modifier.padding(12.dp)) {
+            Row(
+                modifier = Modifier.fillMaxWidth(),
+                horizontalArrangement = Arrangement.SpaceBetween,
+                verticalAlignment = Alignment.CenterVertically
+            ) {
+                Text(
+                    text = pass.name,
+                    style = MaterialTheme.typography.bodyLarge,
+                    fontWeight = FontWeight.Medium,
+                    color = MaterialTheme.colorScheme.primary,
+                    modifier = Modifier.weight(1f)
+                )
+                Text(
+                    text = "${timeFormat.format(Date(pass.startTime))} - ${timeFormat.format(Date(pass.endTime))}",
+                    style = MaterialTheme.typography.bodySmall,
+                    color = MaterialTheme.colorScheme.onSurfaceVariant
+                )
+            }
+            Spacer(Modifier.height(4.dp))
+            Row(
+                modifier = Modifier.fillMaxWidth(),
+                horizontalArrangement = Arrangement.SpaceBetween
+            ) {
+                Text(
+                    text = "你: ${pass.maxElevationA}°",
+                    style = MaterialTheme.typography.bodySmall,
+                    color = MaterialTheme.colorScheme.primary
+                )
+                Text(
+                    text = "友台: ${pass.maxElevationB}°",
+                    style = MaterialTheme.typography.bodySmall,
+                    color = MaterialTheme.colorScheme.tertiary
+                )
+            }
+
+            AnimatedVisibility(
+                visible = isExpanded,
+                enter = expandVertically(),
+                exit = shrinkVertically()
+            ) {
+                Column {
+                    HorizontalDivider(modifier = Modifier.padding(vertical = 8.dp))
+                    // Dual-station radar track (polar plot)
+                    if (visibleTracks.isNotEmpty()) {
+                        Text(
+                            text = "双方轨迹",
+                            style = MaterialTheme.typography.titleSmall,
+                            fontWeight = FontWeight.Medium,
+                            color = MaterialTheme.colorScheme.onSurfaceVariant
+                        )
+                        MutualRadarView(
+                            trackSamples = visibleTracks,
+                            progress = dragProgress,
+                            labelA = "你",
+                            labelB = "友台"
+                        )
+                        Spacer(Modifier.height(8.dp))
+                    }
+                    if (visibleSamples.isNotEmpty()) {
+                        ElevationCurveChart(
+                            samples = visibleSamples,
+                            startTime = visibleStart,
+                            endTime = visibleEnd,
+                            maxElev = adjustedMaxElev,
+                            progress = dragProgress,
+                            onProgressChange = { dragProgress = it }
+                        )
+                    }
+                    Spacer(Modifier.height(8.dp))
+                    OutlinedButton(
+                        onClick = onNavigateToRadar,
+                        modifier = Modifier.fillMaxWidth()
+                    ) {
+                        Icon(
+                            painter = painterResource(id = R.drawable.ic_radar),
+                            contentDescription = null,
+                            modifier = Modifier.height(16.dp).width(16.dp)
+                        )
+                        Spacer(Modifier.width(6.dp))
+                        Text("查看雷达")
+                    }
+                }
+            }
+        }
+    }
+}

feature/mutual/src/main/java/com/rtbishop/look4sat/feature/mutual/MutualViewModel.kt

@@ -0,0 +1,560 @@
+/*
+ * 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.feature.mutual
+
+import androidx.lifecycle.ViewModel
+import androidx.lifecycle.ViewModelProvider
+import androidx.lifecycle.viewModelScope
+import com.rtbishop.look4sat.core.domain.predict.GeoPos
+import com.rtbishop.look4sat.core.domain.predict.OrbitalObject
+import com.rtbishop.look4sat.core.domain.predict.OrbitalPass
+import com.rtbishop.look4sat.core.domain.repository.IMainContainer
+import com.rtbishop.look4sat.core.domain.repository.ISatelliteRepo
+import com.rtbishop.look4sat.core.domain.repository.ISettingsRepo
+import kotlinx.coroutines.Dispatchers
+import kotlinx.coroutines.flow.MutableStateFlow
+import kotlinx.coroutines.flow.StateFlow
+import kotlinx.coroutines.flow.asStateFlow
+import kotlinx.coroutines.flow.update
+import kotlinx.coroutines.launch
+import kotlinx.coroutines.withContext
+import kotlin.math.PI
+import kotlin.math.floor
+import kotlin.math.roundToInt
+
+data class MutualUiState(
+    val stationALat: String = "",
+    val stationALon: String = "",
+    val stationAGrid: String = "",
+    val stationAMinElev: Double = 10.0,
+    val stationBLat: String = "",
+    val stationBLon: String = "",
+    val stationBGrid: String = "",
+    val stationBMinElev: Double = 10.0,
+    val hoursAhead: Int = 24,
+    val mutualPasses: List<MutualPass> = emptyList(),
+    val isCalculating: Boolean = false,
+    val selectedPassIndex: Int = -1,
+    val errorMessage: String? = null
+)
+
+class MutualViewModel(
+    private val satelliteRepo: ISatelliteRepo,
+    private val settingsRepo: ISettingsRepo
+) : ViewModel() {
+
+    private val _uiState = MutableStateFlow(MutualUiState())
+    val uiState: StateFlow<MutualUiState> = _uiState.asStateFlow()
+
+    init {
+        // Pre-fill station A with the user's current station position (as grid),
+        // and default min elevation to the same value used by the main radar passes
+        val pos = settingsRepo.stationPosition.value
+        val grid = latLonToGrid(pos.latitude, pos.longitude)
+        _uiState.update { it.copy(
+            stationAGrid = grid,
+            stationALat = "%.4f".format(pos.latitude),
+            stationALon = "%.4f".format(pos.longitude),
+            stationAMinElev = 0.0,
+            stationBMinElev = 0.0
+        ) }
+    }
+
+    fun onStationALat(value: String) {
+        _uiState.update { it.copy(stationALat = value) }
+        val lat = value.toDoubleOrNull()
+        val lon = _uiState.value.stationALon.toDoubleOrNull()
+        if (lat != null && lon != null) {
+            _uiState.update { it.copy(stationAGrid = latLonToGrid(lat, lon)) }
+        }
+    }
+
+    fun onStationALon(value: String) {
+        _uiState.update { it.copy(stationALon = value) }
+        val lat = _uiState.value.stationALat.toDoubleOrNull()
+        val lon = value.toDoubleOrNull()
+        if (lat != null && lon != null) {
+            _uiState.update { it.copy(stationAGrid = latLonToGrid(lat, lon)) }
+        }
+    }
+
+    fun onStationAGrid(value: String) {
+        val old = _uiState.value.stationAGrid
+        _uiState.update { it.copy(stationAGrid = value) }
+        if (value.trim().uppercase() == old.trim().uppercase()) return
+        val pos = gridToLatLon(value.trim().uppercase())
+        if (pos != null) {
+            _uiState.update { it.copy(
+                stationALat = "%.4f".format(pos.latitude),
+                stationALon = "%.4f".format(pos.longitude)
+            )}
+        }
+    }
+
+    fun onStationBLat(value: String) {
+        _uiState.update { it.copy(stationBLat = value) }
+        val lat = value.toDoubleOrNull()
+        val lon = _uiState.value.stationBLon.toDoubleOrNull()
+        if (lat != null && lon != null) {
+            _uiState.update { it.copy(stationBGrid = latLonToGrid(lat, lon)) }
+        }
+    }
+
+    fun onStationBLon(value: String) {
+        _uiState.update { it.copy(stationBLon = value) }
+        val lat = _uiState.value.stationBLat.toDoubleOrNull()
+        val lon = value.toDoubleOrNull()
+        if (lat != null && lon != null) {
+            _uiState.update { it.copy(stationBGrid = latLonToGrid(lat, lon)) }
+        }
+    }
+
+    fun onStationBGrid(value: String) {
+        val old = _uiState.value.stationBGrid
+        _uiState.update { it.copy(stationBGrid = value) }
+        if (value.trim().uppercase() == old.trim().uppercase()) return
+        val pos = gridToLatLon(value.trim().uppercase())
+        if (pos != null) {
+            _uiState.update { it.copy(
+                stationBLat = "%.4f".format(pos.latitude),
+                stationBLon = "%.4f".format(pos.longitude)
+            )}
+        }
+    }
+    fun onStationAMinElev(value: Double) = _uiState.update { it.copy(stationAMinElev = value) }
+    fun onStationBMinElev(value: Double) = _uiState.update { it.copy(stationBMinElev = value) }
+    fun onUseCurrentPosition() {
+        val pos = settingsRepo.stationPosition.value
+        _uiState.update { it.copy(
+            stationALat = "%.4f".format(pos.latitude),
+            stationALon = "%.4f".format(pos.longitude),
+            stationAGrid = latLonToGrid(pos.latitude, pos.longitude)
+        ) }
+    }
+    fun onHoursAhead(value: Int) = _uiState.update { it.copy(hoursAhead = value) }
+    fun onSelectPass(index: Int) = _uiState.update { it.copy(selectedPassIndex = index) }
+
+    fun queryMutualPasses() {
+        val state = _uiState.value
+
+        // Resolve positions from lat/lon or grid
+        var posA = resolvePosition(state.stationALat, state.stationALon, state.stationAGrid)
+        var posB = resolvePosition(state.stationBLat, state.stationBLon, state.stationBGrid)
+
+        if (posA == null || posB == null) {
+            _uiState.update { it.copy(errorMessage = "请输入有效的位置坐标或网格（4/6/8位）") }
+            return
+        }
+
+        val satellites = satelliteRepo.satellites.value
+        if (satellites.isEmpty()) {
+            _uiState.update { it.copy(errorMessage = "没有卫星数据，请先在卫星列表中选择卫星") }
+            return
+        }
+
+        _uiState.update { it.copy(isCalculating = true, errorMessage = null, mutualPasses = emptyList()) }
+
+        viewModelScope.launch {
+            val time = System.currentTimeMillis()
+            val minElevA = state.stationAMinElev
+            val minElevB = state.stationBMinElev
+            val hours = state.hoursAhead
+
+            val results = withContext(Dispatchers.Default) {
+                findMutualPasses(satellites, posA, posB, minElevA, minElevB, time, hours)
+            }
+
+            val errorMsg = if (results.isEmpty()) {
+                // Debug: check if the main pass list is the culprit
+                val passCount = satelliteRepo.passes.value.size
+                val satCount = satellites.size
+                when {
+                    passCount == 0 -> "过境列表为空，请先在卫星列表中选择卫星"
+                    satCount == 0 -> "没有已选中的卫星"
+                    else -> "未找到共同过境（${passCount}个过境，${satCount}颗卫星）"
+                }
+            } else null
+
+            _uiState.update {
+                it.copy(
+                    mutualPasses = results.sortedBy { mp -> mp.startTime },
+                    isCalculating = false,
+                    errorMessage = errorMsg
+                )
+            }
+        }
+    }
+
+    /** Resolve a position from lat/lon text or grid square text. */
+    private fun resolvePosition(latText: String, lonText: String, gridText: String): GeoPos? {
+        val trimmed = gridText.trim().uppercase()
+        if (trimmed.length in listOf(4, 6, 8) && trimmed.all { it.isLetterOrDigit() }) {
+            return gridToLatLon(trimmed)
+        }
+        val lat = latText.toDoubleOrNull()
+        val lon = lonText.toDoubleOrNull()
+        return if (lat != null && lon != null) GeoPos(lat, lon) else null
+    }
+
+    /** Convert lat/lon to Maidenhead grid (6-char). */
+    private fun latLonToGrid(lat: Double, lon: Double): String {
+        var adjLon = (lon + 180.0) % 360.0
+        var adjLat = (lat + 90.0) % 180.0
+
+        val fieldLon = (adjLon / 20.0).toInt()
+        val fieldLat = (adjLat / 10.0).toInt()
+        adjLon -= fieldLon * 20.0
+        adjLat -= fieldLat * 10.0
+
+        val squareLon = (adjLon / 2.0).toInt()
+        val squareLat = (adjLat / 1.0).toInt()
+        adjLon -= squareLon * 2.0
+        adjLat -= squareLat * 1.0
+
+        val subLon = (adjLon * 60.0 / 5.0).toInt()
+        val subLat = (adjLat * 60.0 / 2.5).toInt()
+
+        return buildString {
+            append('A' + fieldLon)
+            append('A' + fieldLat)
+            append('0' + squareLon)
+            append('0' + squareLat)
+            append('A' + subLon)
+            append('A' + subLat)
+        }
+    }
+
+    /** Convert Maidenhead grid (4, 6, or 8 chars) to lat/lon center of the square. */
+    private fun gridToLatLon(grid: String): GeoPos? {
+        val g = grid.uppercase()
+        if (g.length < 4) return null
+        val lonField = (g[0] - 'A').toDouble() * 20.0
+        val latField = (g[1] - 'A').toDouble() * 10.0
+        if (lonField < 0 || lonField > 340 || latField < 0 || latField > 170) return null
+
+        val lonSquare = (g[2] - '0').toDouble() * 2.0
+        val latSquare = (g[3] - '0').toDouble() * 1.0
+        if (lonSquare < 0 || lonSquare > 18 || latSquare < 0 || latSquare > 9) return null
+
+        var lon = lonField + lonSquare
+        var lat = latField + latSquare
+
+        if (g.length >= 6) {
+            val lonSub = (g[4] - 'A').toDouble() * 5.0 / 60.0
+            val latSub = (g[5] - 'A').toDouble() * 2.5 / 60.0
+            if (lonSub < 0 || lonSub > 115.0 / 60.0 || latSub < 0 || latSub > 57.5 / 60.0) return null
+            lon += lonSub
+            lat += latSub
+
+            if (g.length >= 8) {
+                val lonExt = (g[6] - '0').toDouble() * 30.0 / 3600.0
+                val latExt = (g[7] - '0').toDouble() * 15.0 / 3600.0
+                if (lonExt < 0 || lonExt > 270.0 / 3600.0 || latExt < 0 || latExt > 135.0 / 3600.0) return null
+                lon += lonExt + 15.0 / 3600.0
+                lat += latExt + 7.5 / 3600.0
+            } else {
+                lon += 2.5 / 60.0
+                lat += 1.25 / 60.0
+            }
+        } else {
+            lon += 1.0
+            lat += 0.5
+        }
+
+        lon = lon - 180.0
+        lat = lat - 90.0
+        return GeoPos(lat, lon)
+    }
+
+    private fun findMutualPasses(
+        satellites: List<OrbitalObject>,
+        posA: GeoPos, posB: GeoPos,
+        minElevADeg: Double, minElevBDeg: Double,
+        time: Long, hours: Int
+    ): List<MutualPass> {
+        val endTime = time + hours * 60L * 60L * 1000L
+        val sampleInterval = 5_000L
+
+        // Use the main page's pass list for AOS/LOS times, then sample the curves
+        // using the actual positions. The passes list is already computed by getLeoPass
+        // and its AOS/LOS times match the Passes page exactly.
+        val existingPasses = satelliteRepo.passes.value
+        val results = findMutualPassesFromList(existingPasses, satellites, posA, posB,
+            minElevADeg, minElevBDeg, time, endTime, sampleInterval)
+        if (results.isNotEmpty()) return results
+
+        // Fallback: try the independent search.
+        return findMutualPassesFallback(satellites, posA, posB,
+            minElevADeg, minElevBDeg, time, endTime, sampleInterval)
+    }
+
+    /** Reuse the main page's pass list. Uses AOS/LOS times directly (no refineEdge) */
+    private fun findMutualPassesFromList(
+        existingPasses: List<OrbitalPass>,
+        satellites: List<OrbitalObject>,
+        posA: GeoPos, posB: GeoPos,
+        minElevADeg: Double, minElevBDeg: Double,
+        time: Long, endTime: Long, sampleInterval: Long
+    ): List<MutualPass> {
+        val results = mutableListOf<MutualPass>()
+        for (pass in existingPasses) {
+            if (pass.losTime <= time || pass.aosTime >= endTime) continue
+            if (pass.isDeepSpace) continue
+            if (pass.orbitalObject.data.meanmo < 1e-8) continue
+
+            val sat = pass.orbitalObject
+            // Refine the AOS/LOS to the actual posA/posB (0° horizon).
+            // This ensures the elevation curve starts from ~0°.
+            val refinedAos = refineEdge(sat, posA, posB, pass.aosTime, 1_000L, goingUp = true)
+            val refinedLos = refineEdge(sat, posA, posB, pass.losTime, 1_000L, goingUp = false)
+            if (refinedLos <= refinedAos) continue
+
+            val samples = mutableListOf<Pair<Long, Pair<Double, Double>>>()
+            val tracks = mutableListOf<TrackSample>()
+            var maxElevA = 0.0
+            var maxElevB = 0.0
+
+            var tSample = refinedAos
+            while (tSample <= refinedLos) {
+                // Use getElevation (same function used by getLeoPass) for elevation,
+                // and getFullPosition only for azimuth.
+                val elevA = sat.getElevation(posA, tSample) * 180.0 / PI
+                val elevB = sat.getElevation(posB, tSample) * 180.0 / PI
+                val fullA = sat.getFullPosition(posA, tSample)
+                val fullB = sat.getFullPosition(posB, tSample)
+                if (elevA > maxElevA) maxElevA = elevA
+                if (elevB > maxElevB) maxElevB = elevB
+                samples.add(tSample to (elevA to elevB))
+                tracks.add(
+                    TrackSample(
+                        time = tSample,
+                        azimuthA = fullA.azimuth * 180.0 / PI,
+                        elevationA = elevA,
+                        azimuthB = fullB.azimuth * 180.0 / PI,
+                        elevationB = elevB
+                    )
+                )
+                tSample += sampleInterval
+            }
+
+            // Search uses the 0° horizon as the pass boundary, but the user sliders are
+            // a final visibility filter. Both stations must exceed their own threshold;
+            // otherwise the result would expand to an empty filtered chart.
+            if (maxElevA > minElevADeg && maxElevB > minElevBDeg) {
+                results.add(
+                    MutualPass(
+                        catNum = pass.catNum,
+                        name = pass.orbitalObject.data.name,
+                        startTime = refinedAos,
+                        endTime = refinedLos,
+                        maxElevationA = (maxElevA * 10).roundToInt() / 10.0,
+                        maxElevationB = (maxElevB * 10).roundToInt() / 10.0,
+                        elevationSamples = samples,
+                        trackSamples = tracks
+                    )
+                )
+            }
+        }
+        return results
+    }
+
+    /** Fallback: search passes independently (same logic as original findMutualPasses). */
+    private fun findMutualPassesFallback(
+        satellites: List<OrbitalObject>,
+        posA: GeoPos, posB: GeoPos,
+        minElevADeg: Double, minElevBDeg: Double,
+        time: Long, endTime: Long, sampleInterval: Long
+    ): List<MutualPass> {
+        val results = mutableListOf<MutualPass>()
+        for (sat in satellites) {
+            if (sat.data.meanmo < 1e-8) continue
+            var searchStart = time
+            while (true) {
+                val t = findNextMutualPass(sat, posA, posB, searchStart, endTime)
+                if (t == null) break
+                val (aos, los) = t
+
+                val refinedAos = refineEdge(sat, posA, posB, aos, 1_000L, true)
+                val refinedLos = refineEdge(sat, posA, posB, los, 1_000L, false)
+                if (refinedLos <= refinedAos) continue
+
+                val mutualPass = sampleMutualPass(sat, posA, posB, refinedAos, refinedLos,
+                    minElevADeg, minElevBDeg, sampleInterval)
+                if (mutualPass != null) results.add(mutualPass)
+                searchStart = refinedLos + 120_000L
+            }
+        }
+        return results
+    }
+
+    /** Sample elevation/azimuth data for one mutual pass window. */
+    private fun sampleMutualPass(
+        sat: OrbitalObject, posA: GeoPos, posB: GeoPos,
+        refinedAos: Long, refinedLos: Long,
+        minElevADeg: Double, minElevBDeg: Double,
+        sampleInterval: Long
+    ): MutualPass? {
+        val samples = mutableListOf<Pair<Long, Pair<Double, Double>>>()
+        val tracks = mutableListOf<TrackSample>()
+        var maxElevA = 0.0
+        var maxElevB = 0.0
+
+        var tSample = refinedAos
+        while (tSample <= refinedLos) {
+            // Use getElevation for elevation, matching the main pass predictor; use
+            // getFullPosition only for azimuth needed by the radar plot.
+            val elevA = elevationDeg(sat, posA, tSample)
+            val elevB = elevationDeg(sat, posB, tSample)
+            val fullA = sat.getFullPosition(posA, tSample)
+            val fullB = sat.getFullPosition(posB, tSample)
+            if (elevA > maxElevA) maxElevA = elevA
+            if (elevB > maxElevB) maxElevB = elevB
+            samples.add(tSample to (elevA to elevB))
+            tracks.add(
+                TrackSample(
+                    time = tSample,
+                    azimuthA = fullA.azimuth * 180.0 / PI,
+                    elevationA = elevA,
+                    azimuthB = fullB.azimuth * 180.0 / PI,
+                    elevationB = elevB
+                )
+            )
+            tSample += sampleInterval
+        }
+
+        if (maxElevA > minElevADeg && maxElevB > minElevBDeg) {
+            return MutualPass(
+                catNum = sat.data.catnum,
+                name = sat.data.name,
+                startTime = refinedAos,
+                endTime = refinedLos,
+                maxElevationA = (maxElevA * 10).roundToInt() / 10.0,
+                maxElevationB = (maxElevB * 10).roundToInt() / 10.0,
+                elevationSamples = samples,
+                trackSamples = tracks
+            )
+        }
+        return null
+    }
+
+    /** Refine the AOS (goingUp=true) or LOS (goingUp=false) to ~1s precision at the 0° horizon. */
+    private fun refineEdge(
+        sat: OrbitalObject, posA: GeoPos, posB: GeoPos,
+        approxTime: Long, step: Long, goingUp: Boolean
+    ): Long {
+        if (goingUp) {
+            // AOS: walk backward from approxTime to find the last sample where either is below
+            // the horizon, then AOS is the next step after that.
+            var t = approxTime
+            while (t > approxTime - 70_000L) {
+                val eA = elevationDeg(sat, posA, t)
+                val eB = elevationDeg(sat, posB, t)
+                if (eA > 0.0 && eB > 0.0) {
+                    t -= step
+                } else {
+                    return t + step
+                }
+            }
+            return approxTime - 70_000L + step
+        } else {
+            // LOS: walk forward from approxTime to find the first sample where either drops
+            // below the horizon, then LOS is the step before that.
+            var t = approxTime
+            while (t < approxTime + 70_000L) {
+                val eA = elevationDeg(sat, posA, t)
+                val eB = elevationDeg(sat, posB, t)
+                if (eA > 0.0 && eB > 0.0) {
+                    t += step
+                } else {
+                    return t - step
+                }
+            }
+            return approxTime + 70_000L - step
+        }
+    }
+
+    private fun elevationDeg(sat: OrbitalObject, pos: GeoPos, time: Long): Double {
+        return sat.getElevation(pos, time) * 180.0 / PI
+    }
+
+    private fun findNextMutualPass(
+        sat: OrbitalObject,
+        posA: GeoPos, posB: GeoPos,
+        startTime: Long, endTime: Long
+    ): Pair<Long, Long>? {
+        var t = startTime
+        val step = 60_000L
+
+        // Skip an in-progress mutual window at the search start (same as getLeoPass):
+        // walk forward until either station drops below the horizon, then keep searching.
+        if (elevationDeg(sat, posA, t) > 0.0 && elevationDeg(sat, posB, t) > 0.0) {
+            while (t < endTime) {
+                if (elevationDeg(sat, posA, t) <= 0.0 || elevationDeg(sat, posB, t) <= 0.0) break
+                t += step
+            }
+        }
+
+        while (t < endTime) {
+            val elevA = elevationDeg(sat, posA, t)
+            val elevB = elevationDeg(sat, posB, t)
+
+            if (elevA > 0.0 && elevB > 0.0) {
+                var aos = t
+                var rew = t
+                while (rew > startTime - 600_000L) {
+                    val eA = elevationDeg(sat, posA, rew)
+                    val eB = elevationDeg(sat, posB, rew)
+                    if (eA <= 0.0 || eB <= 0.0) {
+                        aos = rew + step
+                        break
+                    }
+                    rew -= step
+                }
+
+                var los = t
+                var fwd = t
+                while (fwd < endTime + 600_000L) {
+                    val eA = elevationDeg(sat, posA, fwd)
+                    val eB = elevationDeg(sat, posB, fwd)
+                    if (eA <= 0.0 || eB <= 0.0) {
+                        los = fwd
+                        break
+                    }
+                    fwd += step
+                }
+
+                if (los > aos) return Pair(aos, los)
+            }
+            t += step
+        }
+        return null
+    }
+
+    fun clearError() = _uiState.update { it.copy(errorMessage = null) }
+
+    companion object {
+        fun factory(container: IMainContainer) = object : ViewModelProvider.Factory {
+            @Suppress("UNCHECKED_CAST")
+            override fun <T : ViewModel> create(modelClass: Class<T>): T =
+                MutualViewModel(
+                    satelliteRepo = container.satelliteRepo,
+                    settingsRepo = container.settingsRepo
+                ) as T
+        }
+    }
+}

feature/passes/src/main/java/com/rtbishop/look4sat/feature/passes/PassesScreen.kt

@@ -316,13 +316,12 @@ private fun PassItem(
     isVerticalLayout: Boolean = true,
     isUtc: Boolean = false
 ) {
-    val passSatId = stringResource(id = R.string.pass_satId, pass.catNum)
     val horizontalPadding = if (isVerticalLayout) 6.dp else 10.dp
     val timeZone = remember(isUtc) {
         if (isUtc) TimeZone.getTimeZone("UTC") else TimeZone.getDefault()
     }
     val sdfTime = remember(isUtc) {
-        SimpleDateFormat("HH:mm:ss", Locale.ENGLISH).also { it.timeZone = timeZone }
+        SimpleDateFormat("HH:mm:ss", Locale.getDefault()).also { it.timeZone = timeZone }
     }
     val aosTimeStr = remember(pass.aosTime, isUtc) { sdfTime.format(Date(pass.aosTime)) }
     val losTimeStr = remember(pass.losTime, isUtc) { sdfTime.format(Date(pass.losTime)) }
@@ -342,10 +341,6 @@ private fun PassItem(
                 .padding(horizontal = horizontalPadding, vertical = 4.dp)
         ) {
             Row(verticalAlignment = Alignment.CenterVertically) {
-                Text(
-                    text = "$passSatId - ",
-                    color = MaterialTheme.colorScheme.primary
-                )
                 Text(
                     text = pass.name,
                     modifier = Modifier
@@ -355,7 +350,7 @@ private fun PassItem(
                     fontWeight = FontWeight.Medium,
                     maxLines = 1,
                     overflow = TextOverflow.Ellipsis,
-                    color = MaterialTheme.colorScheme.onSurface
+                    color = MaterialTheme.colorScheme.primary
                 )
                 val elevColor = elevationColor(pass.maxElevation)
                 Icon(

feature/passes/src/main/java/com/rtbishop/look4sat/feature/passes/PassesViewModel.kt

@@ -152,12 +152,22 @@ class PassesViewModel(
         }
     }
 
+    /** Returns a locale-appropriate date format for pass grouping headers. */
+    private fun dateFormat(tz: TimeZone): SimpleDateFormat {
+        val pattern = if (Locale.getDefault().language == "zh") {
+            "yyyy'年'M'月'd'日' EEEE"
+        } else {
+            "EEE, dd MMM yyyy"
+        }
+        return SimpleDateFormat(pattern, Locale.getDefault()).also { it.timeZone = tz }
+    }
+
     // Computes sunrise/sunset strings for each unique calendar day in the pass list, plus today for DeepSpace
     private fun computeSunTimes(passes: List<OrbitalPass>, isUtc: Boolean): Map<String, Pair<String, String>> {
         val stationPos = settingsRepo.stationPosition.value
         val tz = if (isUtc) TimeZone.getTimeZone("UTC") else TimeZone.getDefault()
-        val sdfDate = SimpleDateFormat("EEE, dd MMM yyyy", Locale.ENGLISH).also { it.timeZone = tz }
+        val sdfDate = dateFormat(tz)
-        val sdfTime = SimpleDateFormat("HH:mm", Locale.ENGLISH).also { it.timeZone = tz }
+        val sdfTime = SimpleDateFormat("HH:mm", Locale.getDefault()).also { it.timeZone = tz }
         val result = LinkedHashMap<String, Pair<String, String>>()
         // DeepSpace group always shows today's sun times
         if (passes.any { it.isDeepSpace }) {
@@ -180,7 +190,7 @@ class PassesViewModel(
 
     private fun groupPasses(passes: List<OrbitalPass>, isUtc: Boolean): Map<String, List<OrbitalPass>> {
         val tz = if (isUtc) TimeZone.getTimeZone("UTC") else TimeZone.getDefault()
-        val sdfDate = SimpleDateFormat("EEE, dd MMM yyyy", Locale.ENGLISH).also { it.timeZone = tz }
+        val sdfDate = dateFormat(tz)
         val ordered = LinkedHashMap<String, List<OrbitalPass>>()
         val deepSpace = passes.filter { it.isDeepSpace }
         if (deepSpace.isNotEmpty()) ordered["DeepSpace (period >225min)"] = deepSpace

feature/radar/build.gradle.kts

@@ -5,3 +5,7 @@ plugins {
 android {
     namespace = "com.rtbishop.look4sat.feature.radar"
 }
+
+dependencies {
+    implementation(project(":feature:mutual"))
+}

feature/radar/src/main/java/com/rtbishop/look4sat/feature/radar/RadarScreen.kt

@@ -45,6 +45,7 @@ import androidx.compose.material3.Text
 import androidx.compose.runtime.Composable
 import androidx.compose.runtime.LaunchedEffect
 import androidx.compose.runtime.getValue
+import androidx.compose.runtime.remember
 import androidx.compose.runtime.rememberCoroutineScope
 import androidx.compose.ui.Alignment
 import androidx.compose.ui.Modifier
@@ -59,6 +60,7 @@ import androidx.lifecycle.compose.collectAsStateWithLifecycle
 import androidx.lifecycle.viewmodel.compose.viewModel
 import com.rtbishop.look4sat.core.domain.predict.OrbitalPos
 import com.rtbishop.look4sat.core.domain.repository.IContainerProvider
+import com.rtbishop.look4sat.core.domain.repository.MutualPassData
 import com.rtbishop.look4sat.core.domain.utility.toDegrees
 import com.rtbishop.look4sat.core.presentation.EmptyListCard
 import com.rtbishop.look4sat.core.presentation.IconCard
@@ -71,6 +73,8 @@ import com.rtbishop.look4sat.core.presentation.getDefaultPass
 import com.rtbishop.look4sat.core.presentation.isVerticalLayout
 import com.rtbishop.look4sat.core.presentation.layoutPadding
 import kotlinx.coroutines.launch
+import kotlinx.coroutines.delay
+import kotlin.math.PI
 
 private enum class RadarPage(val title: String) {
     Transceivers("Transceivers"),
@@ -83,17 +87,39 @@ fun RadarDestination(navigateUp: () -> Unit) {
     val container = (context.applicationContext as IContainerProvider).getMainContainer()
     val viewModel: RadarViewModel = viewModel(factory = RadarViewModel.factory(container))
     val uiState by viewModel.uiState.collectAsStateWithLifecycle()
+    val mutualData by container.mutualPassData.collectAsStateWithLifecycle()
+    val navigateUpAndClearMutual = {
+        if (container.mutualPassData.value.endTime > 0L) {
+            container.setMutualPassData(MutualPassData())
+        }
+        navigateUp()
+    }
+    LaunchedEffect(mutualData.endTime) {
+        if (mutualData.endTime <= 0L) return@LaunchedEffect
+        while (true) {
+            val remainingMs = mutualData.endTime - System.currentTimeMillis()
+            if (remainingMs <= 0L) {
+                navigateUpAndClearMutual()
+                return@LaunchedEffect
+            }
+            delay(remainingMs.coerceAtMost(1000L))
+        }
+    }
     // Sync actual permission state on every recomposition so it survives screen re-entry
     val hasPermission = ContextCompat.checkSelfPermission(
         context, Manifest.permission.RECORD_AUDIO
     ) == PackageManager.PERMISSION_GRANTED
     LaunchedEffect(hasPermission) {
         viewModel.onAction(RadarAction.SstvPermissionResult(hasPermission))
+        viewModel.onAction(RadarAction.CwPermissionResult(hasPermission))
     }
     val permissionLauncher = rememberLauncherForActivityResult(
         ActivityResultContracts.RequestPermission()
-    ) { granted -> viewModel.onAction(RadarAction.SstvPermissionResult(granted)) }
+    ) { granted ->
-    RadarScreen(uiState, viewModel::onAction, navigateUp, requestMicPermission = {
+        viewModel.onAction(RadarAction.SstvPermissionResult(granted))
+        viewModel.onAction(RadarAction.CwPermissionResult(granted))
+    }
+    RadarScreen(uiState, viewModel::onAction, navigateUpAndClearMutual, mutualData, requestMicPermission = {
         permissionLauncher.launch(Manifest.permission.RECORD_AUDIO)
     })
 }
@@ -103,12 +129,37 @@ private fun RadarScreen(
     uiState: RadarState,
     onAction: (RadarAction) -> Unit,
     navigateUp: () -> Unit,
+    mutualData: MutualPassData,
     requestMicPermission: () -> Unit
 ) {
     val upcomingPass = uiState.currentPass ?: getDefaultPass()
     val addToCalendar: () -> Unit = {
         uiState.currentPass?.let { onAction(RadarAction.AddToCalendar(it.name, it.aosTime, it.losTime)) }
     }
+    // Station-B overlay: full track line (only where B's elevation > 0) + live position dot
+    // at the current moment, same display mode as the local station.
+    val trackB = remember(mutualData.trackSamples) {
+        mutualData.trackSamples
+            .filter { it.elevationB > 0.0 }
+            .map {
+                OrbitalPos(
+                    azimuth = it.azimuthB * PI / 180.0,
+                    elevation = it.elevationB * PI / 180.0,
+                    time = it.time
+                )
+            }
+    }
+    val timeNow = System.currentTimeMillis()
+    val trackBPosition = mutualData.trackSamples
+        .filter { it.time <= timeNow }
+        .lastOrNull()
+        ?.let {
+            OrbitalPos(
+                azimuth = it.azimuthB * PI / 180.0,
+                elevation = it.elevationB * PI / 180.0,
+                time = it.time
+            )
+        }
     Column(
         modifier = Modifier
             .layoutPadding()
@@ -132,11 +183,11 @@ private fun RadarScreen(
             }
         }
         if (isVertical) {
-            RadarCard(uiState, Modifier.weight(1f))
+            RadarCard(uiState, trackB, trackBPosition, Modifier.weight(1f))
             PagerCard(uiState, onAction, requestMicPermission, Modifier.weight(1f))
         } else {
             Row(horizontalArrangement = Arrangement.spacedBy(6.dp)) {
-                RadarCard(uiState, Modifier.weight(1f))
+                RadarCard(uiState, trackB, trackBPosition, Modifier.weight(1f))
                 PagerCard(uiState, onAction, requestMicPermission, Modifier.weight(1f))
             }
         }
@@ -171,11 +222,14 @@ private fun PagerCard(
             ) { pageIndex ->
                 when (pages[pageIndex]) {
                     RadarPage.Transceivers -> TransceiversPage(
-                        transceivers = uiState.transceivers.transmitters,
+                                    transceivers = uiState.transceivers.transmitters,
-                        selectedUuid = uiState.transceivers.selectedUuid,
+                                    selectedUuid = uiState.transceivers.selectedUuid,
-                        radioControl = uiState.radioControl,
+                                    orbitalPos = uiState.orbitalPos,
-                        onAction = onAction
+                                    cw = uiState.cw,
-                    )
+                                    radioControl = uiState.radioControl,
+                                    onAction = onAction,
+                                    requestMicPermission = requestMicPermission
+                                )
                     RadarPage.Sstv -> SstvPage(
                         sstv = uiState.sstv,
                         dopplerFrequency = uiState.transceivers.selectedFrequency?.let { formatFrequency(it) },
@@ -189,7 +243,12 @@ private fun PagerCard(
 }
 
 @Composable
-private fun RadarCard(uiState: RadarState, modifier: Modifier = Modifier) {
+private fun RadarCard(
+    uiState: RadarState,
+    trackB: List<OrbitalPos> = emptyList(),
+    trackBPosition: OrbitalPos? = null,
+    modifier: Modifier = Modifier
+) {
     val satellitePos = uiState.orbitalPos
     val shouldAnimateBorder = satellitePos?.aboveHorizon == true && satellitePos.eclipsed
     // Always call these composables unconditionally — conditional composable calls violate
@@ -222,6 +281,8 @@ private fun RadarCard(uiState: RadarState, modifier: Modifier = Modifier) {
                 RadarViewCompose(
                     item = position,
                     items = uiState.satTrack,
+                    trackB = trackB.takeIf { it.isNotEmpty() },
+                    trackBPosition = trackBPosition,
                     azimElev = uiState.orientationValues,
                     shouldShowSweep = uiState.shouldShowSweep,
                     shouldUseCompass = uiState.shouldUseCompass,

feature/radar/src/main/java/com/rtbishop/look4sat/feature/radar/RadarState.kt

@@ -62,7 +62,14 @@ data class RadarState(
     val moonPosition: CelestialComputer.MoonPosition? = null,
     val transceivers: TransceiverSubState = TransceiverSubState(),
     val radioControl: RadioControlSubState = RadioControlSubState(),
-    val sstv: SstvSubState = SstvSubState()
+    val sstv: SstvSubState = SstvSubState(),
+    val cw: CwSubState = CwSubState(),
+    val mutualSamples: List<Pair<Long, Pair<Double, Double>>> = emptyList(),
+    val mutualStartTime: Long = 0L,
+    val mutualEndTime: Long = 0L,
+    val mutualMaxElev: Double = 10.0,
+    val mutualLabelA: String = "你",
+    val mutualLabelB: String = "友台"
 )
 
 enum class SstvStatus { Idle, Recording }
@@ -77,6 +84,19 @@ data class SstvSubState(
     val diagnosticsMetrics: SstvQualityMetrics? = null
 )
 
+// --- CW Decoder ---
+
+enum class CwStatus { Idle, Listening }
+
+data class CwSubState(
+    val status: CwStatus = CwStatus.Idle,
+    val hasPermission: Boolean = false,
+    val decodedText: String = "",
+    val cwToneFreq: Float = 700f,
+    val isExpanded: Boolean = false,
+    val signalStrength: Float = 0f
+)
+
 sealed interface RadarAction {
     data class AddToCalendar(val name: String, val aosTime: Long, val losTime: Long) : RadarAction
     data class SelectTransmitter(val uuid: String) : RadarAction
@@ -96,4 +116,12 @@ sealed interface RadarAction {
     data object SstvReset : RadarAction
     data class SstvSelectMode(val modeName: String) : RadarAction
     data class SstvPermissionResult(val granted: Boolean) : RadarAction
+
+    // CW actions
+    data object CwStartListening : RadarAction
+    data object CwStopListening : RadarAction
+    data object CwReset : RadarAction
+    data class CwSetToneFreq(val freq: Float) : RadarAction
+    data class CwToggleExpanded(val expanded: Boolean) : RadarAction
+    data class CwPermissionResult(val granted: Boolean) : RadarAction
 }

feature/radar/src/main/java/com/rtbishop/look4sat/feature/radar/RadarView.kt

@@ -60,6 +60,8 @@ import com.rtbishop.look4sat.core.domain.predict.OrbitalPos
 import com.rtbishop.look4sat.core.domain.predict.PI_2
 import com.rtbishop.look4sat.core.domain.utility.toRadians
 import com.rtbishop.look4sat.core.presentation.R
+import kotlin.math.PI
+import kotlin.math.abs
 import kotlin.math.cos
 import kotlin.math.sin
 
@@ -71,6 +73,9 @@ private const val SWEEP_DURATION_MS = 8_000
 fun RadarViewCompose(
     item: OrbitalPos,
     items: List<OrbitalPos>,
+    trackB: List<OrbitalPos>? = null,
+    trackBColor: Color = MaterialTheme.colorScheme.tertiary,
+    trackBPosition: OrbitalPos? = null,
     azimElev: Pair<Float, Float>,
     shouldShowSweep: Boolean,
     shouldUseCompass: Boolean,
@@ -89,14 +94,21 @@ fun RadarViewCompose(
         animationSpec = infiniteRepeatable(tween(1000)),
         label = "animScale"
     )
-    // Drive the sweep from the animation framework to eliminate state mutation inside the draw block
+    // Drive the sweep from the animation framework to eliminate state mutation inside the draw block.
-    val sweepTransition = rememberInfiniteTransition(label = "sweep")
+    // Only create the infinite transition when the sweep is enabled — otherwise the canvas would
-    val sweepDegrees by sweepTransition.animateFloat(
+    // be invalidated every frame for an effect that isn't visible, wasting GPU and battery.
-        initialValue = 0f,
+    val sweepDegrees = if (shouldShowSweep) {
-        targetValue = 360f,
+        val sweepTransition = rememberInfiniteTransition(label = "sweep")
-        animationSpec = infiniteRepeatable(tween(SWEEP_DURATION_MS, easing = LinearEasing)),
+        val animatedSweep by sweepTransition.animateFloat(
-        label = "sweepDegrees"
+            initialValue = 0f,
-    )
+            targetValue = 360f,
+            animationSpec = infiniteRepeatable(tween(SWEEP_DURATION_MS, easing = LinearEasing)),
+            label = "sweepDegrees"
+        )
+        animatedSweep
+    } else {
+        0f
+    }
     val measurer = rememberTextMeasurer()
     val sunPainter = painterResource(R.drawable.ic_sun)
     val moonPainter = painterResource(R.drawable.ic_moon)
@@ -107,18 +119,23 @@ fun RadarViewCompose(
     var cachedSweepColor by remember { mutableStateOf(Color.Unspecified) }
     var trackPath by remember { mutableStateOf(Path()) }
     var trackEffect by remember { mutableStateOf(PathEffect.cornerPathEffect(0f)) }
+    // Station-B overlay track (dashed)
+    var cachedTrackBRef by remember { mutableStateOf<List<OrbitalPos>?>(null) }
+    var trackBPath by remember { mutableStateOf(Path()) }
     // ShaderBrush is cached to avoid allocating a new GPU shader object every frame
     var cachedSweepBrush by remember { mutableStateOf<ShaderBrush?>(null) }
 
     Canvas(modifier = modifier.aspectRatio(1f)) {
         val radius = size.minDimension / 2f * 0.95f
         // Rebuild track path and sweep brush when canvas size or track data changes
-        if (radius != cachedRadius || items !== cachedItemsRef) {
+        if (radius != cachedRadius || items !== cachedItemsRef || trackB !== cachedTrackBRef) {
             trackPath = createTrackPath(items, radius)
             trackEffect = createTrackEffect(trackPath)
+            trackBPath = trackB?.let { createTrackPath(it, radius) } ?: Path()
             cachedSweepBrush = makeSweepBrush(center, primaryColor)
             cachedRadius = radius
             cachedItemsRef = items
+            cachedTrackBRef = trackB
             cachedSweepColor = primaryColor
         } else if (primaryColor != cachedSweepColor) {
             // Rebuild brush on theme change without waiting for a size change
@@ -131,6 +148,19 @@ fun RadarViewCompose(
             drawElevationLabels(radius, primaryColor, measurer)
             translate(center.x, center.y) {
                 drawTrack(trackPath, trackEffect, aimColor, primaryColor)
+                // Station-B overlay: full dashed track + live position dot
+                // (same display mode as the local station: track line + pulsing dot)
+                if (trackB != null && trackB.isNotEmpty() && !trackBPath.isEmpty) {
+                    drawPath(
+                        trackBPath, trackBColor,
+                        style = Stroke(STROKE_WIDTH, pathEffect = PathEffect.dashPathEffect(floatArrayOf(18f, 12f)))
+                    )
+                }
+                trackBPosition?.let { posB ->
+                    if (posB.elevation > 0) {
+                        drawPosition(posB, radius, animScale, trackBColor)
+                    }
+                }
                 if (item.elevation > 0) {
                     drawPosition(item, radius, animScale, primaryColor)
                 }
@@ -205,13 +235,25 @@ private fun DrawScope.drawSweep(center: Offset, degrees: Float, radius: Float, b
 
 private fun createTrackPath(positions: List<OrbitalPos>, radius: Float): Path {
     val trackPath = Path()
+    var lastAzim: Double? = null
     positions.forEachIndexed { index, pos ->
         val offset = sph2Cart(pos.azimuth, pos.elevation, radius.toDouble())
-        if (index == 0) trackPath.moveTo(offset.x, offset.y) else trackPath.lineTo(offset.x, offset.y)
+        // Split the path when azimuth wraps 0°/360° to avoid a line across the plot
+        val wrap = lastAzim != null && abs(azimuthDeltaRad(pos.azimuth - lastAzim!!)) > PI
+        if (index == 0 || wrap) trackPath.moveTo(offset.x, offset.y) else trackPath.lineTo(offset.x, offset.y)
+        lastAzim = pos.azimuth
     }
     return trackPath
 }
 
+/** Normalize an azimuth delta (radians) into the [-PI, PI] range. */
+private fun azimuthDeltaRad(deltaRad: Double): Double {
+    var d = deltaRad % (2 * PI)
+    if (d > PI) d -= 2 * PI
+    if (d < -PI) d += 2 * PI
+    return d
+}
+
 private fun createTrackEffect(trackPath: Path): PathEffect {
     val shapeRadius = 24f
     val angle = 120.0.toRadians()

feature/radar/src/main/java/com/rtbishop/look4sat/feature/radar/RadarViewModel.kt

@@ -34,6 +34,7 @@ import com.rtbishop.look4sat.core.domain.repository.ISensorsRepo
 import com.rtbishop.look4sat.core.domain.repository.ISettingsRepo
 import com.rtbishop.look4sat.core.domain.sstv.LineRecoveryStrategy
 import com.rtbishop.look4sat.core.domain.sstv.SstvDecoder
+import com.rtbishop.look4sat.core.domain.cw.CwDecoder
 import com.rtbishop.look4sat.core.domain.usecase.IAudioCapture
 import com.rtbishop.look4sat.core.domain.usecase.IAddToCalendar
 import com.rtbishop.look4sat.core.domain.usecase.ISaveImage
@@ -70,6 +71,8 @@ class RadarViewModel(
     private var transponders: List<SatRadio> = emptyList()
     private var sstvDecoder: SstvDecoder? = null
     private var sstvRecordingJob: Job? = null
+    private var cwDecoder: CwDecoder? = null
+    private var cwListeningJob: Job? = null
 
     // Celestial positions change slowly, recompute at most once per minute
     private var lastCelestialUpdateMs = 0L
@@ -136,6 +139,8 @@ class RadarViewModel(
         val passes = satelliteRepo.passes.value
         val (catNum, aosTime) = satelliteRepo.selectedPass.value
         return passes.find { it.catNum == catNum && it.aosTime == aosTime }
+            ?: passes.find { it.catNum == catNum && aosTime in it.aosTime..it.losTime }
+            ?: passes.find { it.catNum == catNum }
             ?: passes.firstOrNull()
     }
 
@@ -176,7 +181,7 @@ class RadarViewModel(
                 orbitalPos = pos, sunPosition = cachedSunPos, moonPosition = cachedMoonPos
             )
         }
-        processRadios(allRadios, pass.orbitalObject, timeNow)
+        processRadios(allRadios, pos)
         sendPassData(pos)
     }
 
@@ -272,6 +277,25 @@ class RadarViewModel(
                 sstvDecoder?.clearPixels()
                 _uiState.update { it.copy(sstv = it.sstv.copy(currentFrame = null)) }
             }
+
+            // CW actions
+            is RadarAction.CwPermissionResult -> {
+                _uiState.update { it.copy(cw = it.cw.copy(hasPermission = action.granted)) }
+                if (action.granted) initCwDecoder()
+            }
+            RadarAction.CwStartListening -> startCwListening()
+            RadarAction.CwStopListening -> stopCwListening()
+            RadarAction.CwReset -> {
+                cwDecoder?.resetDecoder()
+                _uiState.update { it.copy(cw = it.cw.copy(decodedText = "")) }
+            }
+            is RadarAction.CwSetToneFreq -> {
+                _uiState.update { it.copy(cw = it.cw.copy(cwToneFreq = action.freq)) }
+                cwDecoder = CwDecoder(sampleRate = audioCapture.sampleRate, cwToneFreq = action.freq)
+            }
+            is RadarAction.CwToggleExpanded -> {
+                _uiState.update { it.copy(cw = it.cw.copy(isExpanded = action.expanded)) }
+            }
         }
     }
 
@@ -318,8 +342,8 @@ class RadarViewModel(
         }
     }
 
-    private suspend fun processRadios(radios: List<SatRadio>, orbitalObject: OrbitalObject, time: Long) {
+    private suspend fun processRadios(radios: List<SatRadio>, satPos: OrbitalPos) {
-        val transmitters = satelliteRepo.getRadios(orbitalObject, stationPos, radios, time)
+        val transmitters = satelliteRepo.getRadios(satPos, radios)
         _uiState.update { state ->
             val freq = if (state.transceivers.selectedUuid != null) {
                 val selectedRadio = transmitters.firstOrNull { it.uuid == state.transceivers.selectedUuid }
@@ -392,6 +416,52 @@ class RadarViewModel(
         _uiState.update { it.copy(sstv = it.sstv.copy(status = SstvStatus.Idle)) }
     }
 
+    private fun initCwDecoder() {
+        if (cwDecoder == null) {
+            cwDecoder = CwDecoder(
+                sampleRate = audioCapture.sampleRate,
+                cwToneFreq = _uiState.value.cw.cwToneFreq
+            )
+        }
+    }
+
+    private fun startCwListening() {
+        if (cwListeningJob?.isActive == true) return
+        if (!_uiState.value.cw.hasPermission) {
+            // Permission not yet granted — request it (launcher handles the result)
+            return
+        }
+        // Stop SSTV if running (audio capture is shared)
+        stopSstvRecording()
+        initCwDecoder()
+        cwDecoder?.resetDecoder()
+        _uiState.update { it.copy(cw = it.cw.copy(status = CwStatus.Listening)) }
+        cwListeningJob = viewModelScope.launch {
+            // Collect decoded text flow
+            launch {
+                cwDecoder?.decodedTextFlow?.collect { text ->
+                    _uiState.update { it.copy(cw = it.cw.copy(decodedText = text)) }
+                }
+            }
+            // Collect signal strength
+            launch {
+                cwDecoder?.signalStrength?.collect { strength ->
+                    _uiState.update { it.copy(cw = it.cw.copy(signalStrength = strength)) }
+                }
+            }
+            // Capture audio and feed to decoder
+            audioCapture.audioFlow().collect { buffer ->
+                cwDecoder?.processBuffer(buffer)
+            }
+        }
+    }
+
+    private fun stopCwListening() {
+        cwListeningJob?.cancel()
+        cwListeningJob = null
+        _uiState.update { it.copy(cw = it.cw.copy(status = CwStatus.Idle)) }
+    }
+
     companion object {
         // SSTV Decoder Tuning Parameters
         // ==============================

feature/radar/src/main/java/com/rtbishop/look4sat/feature/radar/TransceiversPage.kt

@@ -39,14 +39,22 @@ import androidx.compose.foundation.lazy.LazyColumn
 import androidx.compose.foundation.lazy.itemsIndexed
 import androidx.compose.foundation.lazy.rememberLazyListState
 import androidx.compose.foundation.shape.CircleShape
+import androidx.compose.foundation.text.KeyboardOptions
+import androidx.compose.material3.Button
+import androidx.compose.material3.ElevatedCard
 import androidx.compose.material3.FilterChip
 import androidx.compose.material3.HorizontalDivider
 import androidx.compose.material3.Icon
 import androidx.compose.material3.MaterialTheme
+import androidx.compose.material3.OutlinedButton
+import androidx.compose.material3.OutlinedTextField
 import androidx.compose.material3.Text
 import androidx.compose.runtime.Composable
 import androidx.compose.runtime.LaunchedEffect
+import androidx.compose.runtime.getValue
+import androidx.compose.runtime.mutableStateOf
 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
@@ -55,11 +63,14 @@ import androidx.compose.ui.graphics.Color
 import androidx.compose.ui.res.painterResource
 import androidx.compose.ui.res.stringResource
 import androidx.compose.ui.text.font.FontWeight
+import androidx.compose.ui.text.input.KeyboardType
 import androidx.compose.ui.text.style.TextAlign
 import androidx.compose.ui.text.style.TextOverflow
 import androidx.compose.ui.unit.dp
 import androidx.compose.ui.unit.sp
 import com.rtbishop.look4sat.core.domain.model.SatRadio
+import com.rtbishop.look4sat.core.domain.predict.OrbitalPos
+import com.rtbishop.look4sat.core.domain.utility.DopplerFrequencyCalculator
 import com.rtbishop.look4sat.core.presentation.CardButton
 import com.rtbishop.look4sat.core.presentation.R
 import com.rtbishop.look4sat.core.presentation.formatFrequency
@@ -71,8 +82,11 @@ import kotlin.time.Duration.Companion.milliseconds
 fun TransceiversPage(
     transceivers: List<SatRadio>,
     selectedUuid: String?,
+    orbitalPos: OrbitalPos?,
+    cw: CwSubState,
     radioControl: RadioControlSubState,
     onAction: (RadarAction) -> Unit,
+    requestMicPermission: () -> Unit = {},
     modifier: Modifier = Modifier
 ) {
     if (transceivers.isEmpty()) {
@@ -95,8 +109,11 @@ fun TransceiversPage(
                 TransceiverItem(
                     radio = radio,
                     isExpanded = isExpanded,
+                    orbitalPos = orbitalPos,
+                    cw = cw,
                     radioControl = radioControl,
                     onAction = onAction,
+                    requestMicPermission = requestMicPermission,
                     onToggle = { onAction(RadarAction.SelectTransmitter(radio.uuid)) }
                 )
             }
@@ -131,8 +148,11 @@ private fun EmptyTransceiversContent(modifier: Modifier = Modifier) {
 private fun TransceiverItem(
     radio: SatRadio,
     isExpanded: Boolean,
+    orbitalPos: OrbitalPos?,
+    cw: CwSubState,
     radioControl: RadioControlSubState,
     onAction: (RadarAction) -> Unit,
+    requestMicPermission: () -> Unit,
     onToggle: () -> Unit
 ) {
     val bgColor = if (isExpanded) MaterialTheme.colorScheme.surfaceContainerHighest
@@ -225,8 +245,11 @@ private fun TransceiverItem(
         ) {
             ExpandedRadioControl(
                 radio = radio,
+                orbitalPos = orbitalPos,
+                cw = cw,
                 radioControl = radioControl,
-                onAction = onAction
+                onAction = onAction,
+                requestMicPermission = requestMicPermission
             )
         }
 
@@ -295,8 +318,11 @@ private fun UnifiedFrequencyRow(
 @Composable
 private fun ExpandedRadioControl(
     radio: SatRadio,
+    orbitalPos: OrbitalPos?,
+    cw: CwSubState,
     radioControl: RadioControlSubState,
-    onAction: (RadarAction) -> Unit
+    onAction: (RadarAction) -> Unit,
+    requestMicPermission: () -> Unit = {},
 ) {
     Column(
         modifier = Modifier
@@ -405,6 +431,23 @@ private fun ExpandedRadioControl(
             }
         }
 
+        // Doppler frequency calculator (linear transponders only)
+        DopplerFrequencyCalculator(
+            transponder = radio,
+            orbitalPos = orbitalPos,
+            modifier = Modifier.fillMaxWidth()
+        )
+
+        // CW decoder panel (linear transponders only)
+        if (DopplerFrequencyCalculator.isLinearTransponder(radio)) {
+            CwDecoderPanel(
+                cw = cw,
+                onAction = onAction,
+                requestMicPermission = requestMicPermission,
+                modifier = Modifier.fillMaxWidth()
+            )
+        }
+
         // Control buttons
         Row(horizontalArrangement = Arrangement.spacedBy(4.dp)) {
             if (!radioControl.txPanel.isConnected && !radioControl.rxPanel.isConnected) {
@@ -436,6 +479,266 @@ private fun ExpandedRadioControl(
     }
 }
 
+@Composable
+private fun DopplerFrequencyCalculator(
+    transponder: SatRadio,
+    orbitalPos: OrbitalPos?,
+    modifier: Modifier = Modifier
+) {
+    if (orbitalPos == null || !DopplerFrequencyCalculator.isLinearTransponder(transponder)) return
+
+    var txInputMHz by remember { mutableStateOf("") }
+    var rxInputMHz by remember { mutableStateOf("") }
+    var offsetKHz by remember { mutableStateOf("") }
+    var lastEditedBy by remember { mutableStateOf(EditedField.TX) }
+
+    val offsetHz = offsetKHz.toDoubleOrNull()?.let { it * 1000 }?.toLong() ?: 0L
+
+    // Real-time refresh: when orbitalPos changes (1Hz), recompute the opposite field
+    LaunchedEffect(orbitalPos) {
+        if (lastEditedBy == EditedField.TX) {
+            val txMHz = txInputMHz.toDoubleOrNull()
+            if (txMHz != null && txMHz > 0) {
+                val txHz = (txMHz * 1_000_000).toLong()
+                val rxHz = DopplerFrequencyCalculator.computeDownlinkFromUplinkWithOffset(
+                    txHz, transponder, orbitalPos, offsetHz
+                )
+                if (rxHz != null) {
+                    rxInputMHz = String.format(Locale.ENGLISH, "%.6f", rxHz / 1_000_000.0)
+                }
+            }
+        } else {
+            val rxMHz = rxInputMHz.toDoubleOrNull()
+            if (rxMHz != null && rxMHz > 0) {
+                val rxHz = (rxMHz * 1_000_000).toLong()
+                val txHz = DopplerFrequencyCalculator.computeUplinkFromDownlinkWithOffset(
+                    rxHz, transponder, orbitalPos, offsetHz
+                )
+                if (txHz != null) {
+                    txInputMHz = String.format(Locale.ENGLISH, "%.6f", txHz / 1_000_000.0)
+                }
+            }
+        }
+    }
+
+    Column(
+        modifier = modifier,
+        verticalArrangement = Arrangement.spacedBy(4.dp)
+    ) {
+        Text(
+            text = stringResource(R.string.radar_doppler_calc),
+            fontSize = 14.sp,
+            fontWeight = FontWeight.Medium,
+            color = MaterialTheme.colorScheme.primary
+        )
+        Text(
+            text = stringResource(R.string.radar_doppler_info),
+            fontSize = 12.sp,
+            color = MaterialTheme.colorScheme.onSurfaceVariant
+        )
+
+        // Offset input
+        OutlinedTextField(
+            value = offsetKHz,
+            onValueChange = { newVal ->
+                offsetKHz = newVal
+                // Trigger recompute based on last edited field
+                if (lastEditedBy == EditedField.TX) {
+                    val txMHz = txInputMHz.toDoubleOrNull()
+                    if (txMHz != null && txMHz > 0) {
+                        val txHz = (txMHz * 1_000_000).toLong()
+                        val rxHz = DopplerFrequencyCalculator.computeDownlinkFromUplinkWithOffset(
+                            txHz, transponder, orbitalPos, offsetHz
+                        )
+                        rxInputMHz = if (rxHz != null) String.format(Locale.ENGLISH, "%.6f", rxHz / 1_000_000.0) else ""
+                    }
+                } else {
+                    val rxMHz = rxInputMHz.toDoubleOrNull()
+                    if (rxMHz != null && rxMHz > 0) {
+                        val rxHz = (rxMHz * 1_000_000).toLong()
+                        val txHz = DopplerFrequencyCalculator.computeUplinkFromDownlinkWithOffset(
+                            rxHz, transponder, orbitalPos, offsetHz
+                        )
+                        txInputMHz = if (txHz != null) String.format(Locale.ENGLISH, "%.6f", txHz / 1_000_000.0) else ""
+                    }
+                }
+            },
+            label = { Text(stringResource(R.string.radar_doppler_offset_hint)) },
+            singleLine = true,
+            keyboardOptions = KeyboardOptions(keyboardType = KeyboardType.Decimal),
+            modifier = Modifier.fillMaxWidth()
+        )
+
+        // TX and RX inputs on the same row
+        Row(
+            horizontalArrangement = Arrangement.spacedBy(8.dp),
+            modifier = Modifier.fillMaxWidth()
+        ) {
+            // TX input → compute RX
+            OutlinedTextField(
+                value = txInputMHz,
+                onValueChange = { newVal ->
+                    txInputMHz = newVal
+                    lastEditedBy = EditedField.TX
+                    val mhz = newVal.toDoubleOrNull()
+                    if (mhz != null && mhz > 0) {
+                        val txHz = (mhz * 1_000_000).toLong()
+                        val rxHz = DopplerFrequencyCalculator.computeDownlinkFromUplinkWithOffset(
+                            txHz, transponder, orbitalPos, offsetHz
+                        )
+                        rxInputMHz = if (rxHz != null) String.format(Locale.ENGLISH, "%.6f", rxHz / 1_000_000.0) else ""
+                    } else if (newVal.isEmpty()) {
+                        rxInputMHz = ""
+                    }
+                },
+                label = { Text(stringResource(R.string.radar_doppler_tx_hint)) },
+                singleLine = true,
+                keyboardOptions = KeyboardOptions(keyboardType = KeyboardType.Decimal),
+                modifier = Modifier.weight(1f)
+            )
+
+            // RX input → compute TX
+            OutlinedTextField(
+                value = rxInputMHz,
+                onValueChange = { newVal ->
+                    rxInputMHz = newVal
+                    lastEditedBy = EditedField.RX
+                    val mhz = newVal.toDoubleOrNull()
+                    if (mhz != null && mhz > 0) {
+                        val rxHz = (mhz * 1_000_000).toLong()
+                        val txHz = DopplerFrequencyCalculator.computeUplinkFromDownlinkWithOffset(
+                            rxHz, transponder, orbitalPos, offsetHz
+                        )
+                        txInputMHz = if (txHz != null) String.format(Locale.ENGLISH, "%.6f", txHz / 1_000_000.0) else ""
+                    } else if (newVal.isEmpty()) {
+                        txInputMHz = ""
+                    }
+                },
+                label = { Text(stringResource(R.string.radar_doppler_rx_hint)) },
+                singleLine = true,
+                keyboardOptions = KeyboardOptions(keyboardType = KeyboardType.Decimal),
+                modifier = Modifier.weight(1f)
+            )
+        }
+    }
+}
+
+private enum class EditedField { TX, RX }
+
+@Composable
+private fun CwDecoderPanel(
+    cw: CwSubState,
+    onAction: (RadarAction) -> Unit,
+    requestMicPermission: () -> Unit = {},
+    modifier: Modifier = Modifier
+) {
+    Column(
+        modifier = modifier,
+        verticalArrangement = Arrangement.spacedBy(4.dp)
+    ) {
+        // Header row: expand/collapse toggle
+        Row(
+            modifier = Modifier
+                .fillMaxWidth()
+                .clickable { onAction(RadarAction.CwToggleExpanded(!cw.isExpanded)) },
+            horizontalArrangement = Arrangement.SpaceBetween,
+            verticalAlignment = Alignment.CenterVertically
+        ) {
+            Text(
+                text = stringResource(R.string.radar_cw_decoder),
+                fontSize = 14.sp,
+                fontWeight = FontWeight.Medium,
+                color = MaterialTheme.colorScheme.primary
+            )
+            Icon(
+                painter = painterResource(id = R.drawable.ic_arrow),
+                contentDescription = null,
+                tint = MaterialTheme.colorScheme.onSurfaceVariant,
+                modifier = Modifier
+                    .size(20.dp)
+                    .rotate(if (cw.isExpanded) 270f else 90f)
+            )
+        }
+
+        AnimatedVisibility(visible = cw.isExpanded) {
+            Column(verticalArrangement = Arrangement.spacedBy(8.dp)) {
+                // Control buttons row
+                Row(
+                    horizontalArrangement = Arrangement.spacedBy(8.dp),
+                    modifier = Modifier.fillMaxWidth()
+                ) {
+                    if (cw.status == CwStatus.Idle) {
+                        Button(
+                            onClick = {
+                                if (!cw.hasPermission) {
+                                    requestMicPermission()
+                                } else {
+                                    onAction(RadarAction.CwStartListening)
+                                }
+                            },
+                            modifier = Modifier.weight(1f)
+                        ) {
+                            Text(stringResource(R.string.radar_cw_start))
+                        }
+                    } else {
+                        Button(
+                            onClick = { onAction(RadarAction.CwStopListening) },
+                            modifier = Modifier.weight(1f)
+                        ) {
+                            Text(stringResource(R.string.radar_cw_stop))
+                        }
+                    }
+                    OutlinedButton(
+                        onClick = { onAction(RadarAction.CwReset) },
+                        modifier = Modifier.weight(1f)
+                    ) {
+                        Text(stringResource(R.string.radar_cw_reset))
+                    }
+                }
+
+                // Signal strength indicator
+                if (cw.status == CwStatus.Listening && cw.signalStrength > 0f) {
+                    val strengthPct = (cw.signalStrength * 100).toInt()
+                    Text(
+                        text = "Signal: $strengthPct%",
+                        fontSize = 12.sp,
+                        color = if (cw.signalStrength > 0.5f) Color(0xFF4CAF50)
+                        else if (cw.signalStrength > 0.2f) Color(0xFFFFC107)
+                        else MaterialTheme.colorScheme.onSurfaceVariant
+                    )
+                }
+
+                // Decoded text output
+                ElevatedCard(
+                    modifier = Modifier
+                        .fillMaxWidth()
+                        .height(120.dp)
+                ) {
+                    Column(
+                        modifier = Modifier
+                            .fillMaxSize()
+                            .padding(8.dp)
+                    ) {
+                        Text(
+                            text = "Decoded:",
+                            fontSize = 12.sp,
+                            fontWeight = FontWeight.Bold,
+                            color = MaterialTheme.colorScheme.onSurfaceVariant
+                        )
+                        Spacer(modifier = Modifier.height(4.dp))
+                        Text(
+                            text = cw.decodedText.ifEmpty { "Waiting for CW signal..." },
+                            fontSize = 16.sp,
+                            fontWeight = FontWeight.Medium,
+                            color = MaterialTheme.colorScheme.onSurface
+                        )
+                    }
+                }
+            }
+        }
+    }
+}
+
 @Composable
 private fun FrequencyText(frequency: Long?, modifier: Modifier = Modifier) {
     val text = frequency?.let {

feature/satellites/src/main/java/com/rtbishop/look4sat/feature/satellites/SatellitesScreen.kt

@@ -290,14 +290,17 @@ private fun Satellite(
                 .background(MaterialTheme.colorScheme.surface)
                 .padding(start = 14.dp, top = 8.dp, end = 12.dp, bottom = 8.dp)
         ) {
-            Text(text = "$passSatId - ", color = MaterialTheme.colorScheme.primary)
+            Text(
+                text = "$passSatId - ",
+                color = MaterialTheme.colorScheme.primary
+            )
             Text(
                 text = item.name,
                 modifier = Modifier.weight(1f),
                 fontWeight = FontWeight.Medium,
                 maxLines = 1,
                 overflow = TextOverflow.Ellipsis,
-                color = MaterialTheme.colorScheme.onSurface
+                color = MaterialTheme.colorScheme.primary
             )
             Checkbox(
                 checked = item.isSelected,

gradle/libs.versions.toml

@@ -1,8 +1,8 @@
 [versions]
 #noinspection UnusedVersionCatalogEntry
-appVersionCode = "443"
+appVersionCode = "444"
 #noinspection UnusedVersionCatalogEntry
-appVersionName = "4.4.3"
+appVersionName = "4.4.4"
 #noinspection UnusedVersionCatalogEntry
 compileSdk = "37"
 #noinspection UnusedVersionCatalogEntry
@@ -11,6 +11,11 @@ minSdk = "24"
 jdkVersion = "21"
 #noinspection UnusedVersionCatalogEntry
 packageName = "com.rtbishop.look4sat"
+# Fork application ID: official app uses com.rtbishop.look4sat with a different
+# signing cert. Installing a fork with the same applicationId would conflict
+# with the official build (signature mismatch / cannot overwrite), so the fork
+# ships under its own applicationId suffix.
+applicationId = "com.rtbishop.look4sat.bg7nta"
 
 android-gradle-plugin = "9.3.1"
 

settings.gradle.kts

@@ -22,6 +22,7 @@ include(
 )
 include(
     ":feature:map",
+    ":feature:mutual",
     ":feature:passes",
     ":feature:radar",
     ":feature:satellites",