chore: remove .hermes from git tracking, add to gitignore

2026-10-02 03:15:37 +00:00 · 2026-08-03 08:55:04 +08:00
1 parent 7e90071c4d
commit bd09ad22ff
@@ -1,6 +1,9 @@
 # Built application files
 *.ap_
 # Hermes AI plans and metadata
 .hermes/
 # Files for the ART/Dalvik VM
 *.dex
@@ -1,781 +0,0 @@
 # CW Morse Code Decoder — Implementation Plan
 > **For Hermes:** Use subagent-driven-development skill to implement this plan task-by-task.
 **Goal:** Add a built-in Morse Code (CW) decoder to the Look4Sat linear satellite transceiver interface. Captures audio from the microphone, decodes CW in real-time, and displays the decoded text inline without blocking existing features.
 **Architecture:** Domain layer DSP (bandpass filter + envelope detection + timing logic) mirrors the existing `SstvDecoder` pattern. State managed in `RadarState` / `RadarViewModel`. UI is a compact collapsible panel inside the `TransceiverItem` expanded card, below the Doppler calculator, using the same `IAudioCapture` abstraction for microphone access.
 **Tech Stack:** Kotlin, Jetpack Compose, Android AudioRecord (via existing `IAudioCapture`), pure Kotlin DSP (no NDK), `kotlinx.coroutines.flow`.
 ---
 ## Current Context
 The app already has:
 - **`IAudioCapture`** (`core/domain/.../usecase/IAudioCapture.kt`) — platform abstraction for microphone audio capture, emits `Flow<FloatArray>` at configurable sample rate
 - **`SstvDecoder`** (`core/domain/.../sstv/SstvDecoder.kt`) — full audio→image decoder for SSTV, the architectural pattern to follow
 - **`SstvDsp`** (`core/domain/.../sstv/SstvDsp.kt`) — DSP utilities (FFT, window functions, filters) — reusable for CW
 - **`RadarViewModel`** — manages SSTV lifecycle (init decoder, start/stop recording, handle permission)
 - **`TransceiversPage.kt`** — expanded transceiver card with Doppler calculator already added
 - **`RadarState.kt`** — `SstvSubState` pattern to follow for CW substate
 **CW decoding pipeline (audio → text):**
 ```
 Audio buffer → Bandpass filter (~600-800 Hz) → Envelope detection → Threshold → 
 Timing (dit/dash/symbol/word gaps) → Morse character lookup → Live text output
 ```
 **Key frequencies:**
 - CW tone: typically 600-800 Hz (user-selectable)
 - Sampling rate: 8000 Hz (reuse from SSTV, adequate for ~1 kHz bandwidth)
 - Dit timing: 30-60 ms at typical 20-30 WPM (auto-baud rate detection)
 ---
 ## Step-by-step Plan
 ### Task 1: Create CW decoder DSP (domain layer)
 **Objective:** Implement the core CW signal processing: bandpass filter, envelope detection, and timing logic to convert audio samples to dit/dash symbols.
 **Files:**
 - Create: `core/domain/src/main/java/com/rtbishop/look4sat/core/domain/cw/CwDsp.kt`
 - Create: `core/domain/src/main/java/com/rtbishop/look4sat/core/domain/cw/CwDecoder.kt`
 - Modify: `core/domain/build.gradle.kts` (no changes needed — pure Kotlin)
 **Step 1: Create `CwDsp.kt` — DSP utilities for CW decoding**
 ```kotlin
 package com.rtbishop.look4sat.core.domain.cw
 import kotlin.math.PI
 import kotlin.math.cos
 import kotlin.math.exp
 import kotlin.math.log10
 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 (median of envelope). */
    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()
    }
 }
 ```
 **Step 2: Create `CwDecoder.kt` — Morse character table + timing logic**
 ```kotlin
 package com.rtbishop.look4sat.core.domain.cw
 import kotlinx.coroutines.flow.MutableStateFlow
 import kotlinx.coroutines.flow.StateFlow
 /**
 * Real-time CW (Morse code) decoder.
 * Processes audio buffers and emits decoded text characters.
 *
 * Morse timing (paris method):
 *   Dit = 1 unit
 *   Dash = 3 units
 *   Intra-char gap = 1 unit
 *   Inter-char gap = 3 units
 *   Word gap = 7 units
 */
 class CwDecoder(
    val sampleRate: Int = 8000,
    val cwToneFreq: Float = 700f,
    val filterWidth: Float = 200f
 ) {
    // Filter coefficients (pre-computed)
    private val firCoeffs = CwDsp.bandpassFir(
        lowCutoff = ((cwToneFreq - filterWidth / 2) / sampleRate).toDouble(),
        highCutoff = ((cwToneFreq + filterWidth / 2) / sampleRate).toDouble(),
        taps = 127
    )
    // Decoder state
    private var filterState = FloatArray(0)
    private var envelopeState = 0f
    private var previousEnvelope = 0f
    private var isSignalPresent = false
    private var signalOnTime = 0  // samples since signal started
    private var signalOffTime = 0 // samples since signal ended
    private var decodedText = StringBuilder()
    private var currentSymbol = StringBuilder()
    private val _decodedTextFlow = MutableStateFlow("")
    val decodedTextFlow: StateFlow<String> = _decodedTextFlow
    /** Process a buffer of audio samples. */
    fun processBuffer(buffer: FloatArray) {
        // 1. Bandpass filter
        val filtered = CwDsp.applyFir(buffer, firCoeffs)
        // 2. Envelope detection
        val env = CwDsp.envelope(filtered, 0.1f)
        // 3. Adaptive threshold
        val floor = CwDsp.noiseFloor(env)
        val threshold = floor * 1.5f
        // 4. Timing analysis
        for (sample in env) {
            if (sample > threshold) {
                // Signal ON
                if (!isSignalPresent) {
                    // Rising edge — end of silence
                    if (signalOffTime > 0) {
                        processSilence(signalOffTime)
                    }
                    signalOffTime = 0
                    isSignalPresent = true
                }
                signalOnTime++
            } else {
                // Signal OFF
                if (isSignalPresent) {
                    // Falling edge — end of tone
                    processTone(signalOnTime)
                    signalOnTime = 0
                    isSignalPresent = false
                }
                signalOffTime++
            }
        }
        _decodedTextFlow.value = decodedText.toString()
    }
    private fun processTone(duration: Int) {
        val unit = estimateUnit(duration)
        if (unit == 0) return
        val ratio = duration.toFloat() / unit
        if (ratio < 1.5f) {
            currentSymbol.append('.')  // Dit
        } else if (ratio < 5f) {
            currentSymbol.append('-')  // Dash
        }
    }
    private fun processSilence(duration: Int) {
        // If we have accumulated symbol characters, it's an inter-char gap
        if (currentSymbol.isNotEmpty()) {
            val char = morseToChar(currentSymbol.toString())
            if (char != null) {
                decodedText.append(char)
            }
            currentSymbol.clear()
        } else {
            // Word gap (7+ units)
            val unit = estimateUnitFromSilence(duration)
            val ratio = if (unit > 0) duration.toFloat() / unit else 0f
            if (ratio >= 7f) {
                decodedText.append(' ')
            }
        }
    }
    /** Estimate the timing unit based on recent dits. */
    private fun estimateUnit(duration: Int): Int {
        // For first detection, estimate based on typical 20 WPM = 60ms dit
        // 8000 Hz * 0.06s = 480 samples
        return if (duration < 800) sampleRate / 20 else sampleRate / 15
    }
    private fun estimateUnitFromSilence(duration: Int): Int {
        return sampleRate / 20
    }
    fun resetDecoder() {
        isSignalPresent = false
        signalOnTime = 0
        signalOffTime = 0
        decodedText.clear()
        currentSymbol.clear()
        _decodedTextFlow.value = ""
    }
    companion object {
        private val MORSE_TABLE = mapOf(
            ".-" to 'A', "-..." to 'B', "-.-." to 'C', "-.." to 'D', "." to 'E',
            "..-." to 'F', "--." to 'G', "...." to 'H', ".." to 'I', ".---" to 'J',
            "-.-" to 'K', ".-.." to 'L', "--" to 'M', "-." to 'N', "---" to 'O',
            ".--." to 'P', "--.-" to 'Q', ".-." to 'R', "..." to 'S', "-" to 'T',
            "..-" to 'U', "...-" to 'V', ".--" to 'W', "-..-" to 'X', "-.--" to 'Y',
            "--.." to 'Z', ".----" to '1', "..---" to '2', "...--" to '3',
            "....-" to '4', "....." to '5', "-...." to '6', "--..." to '7',
            "---.." to '8', "----." to '9', "-----" to '0',
            ".-.-.-" to '.', "--..--" to ',', "..--.." to '?', ".----." to '\'',
            "-.-.--" to '!', "-..-." to '/', "-.--." to '(', "-.--.-" to ')',
            ".-..." to '&', "---..." to ':', "-.-.-." to ';', "-...-" to '=',
            ".-.-." to '+', "-....-" to '-', "..--.-" to '_', ".-..-." to '"',
            "...-..-" to '$', ".--.-." to '@'
        )
        fun morseToChar(morse: String): Char? = MORSE_TABLE[morse]
    }
 }
 ```
 **Step 3: Verify compilation**
 Run: `cd /mnt/e/look4sat-work && ./gradlew :core:domain:compileKotlin --no-daemon`
 Expected: BUILD SUCCESSFUL
 **Step 4: Commit**
 ```bash
 git add core/domain/src/main/java/com/rtbishop/look4sat/core/domain/cw/
 git commit -m "feat(cw): add CW decoder with DSP and Morse timing logic"
 ```
 ---
 ### Task 2: Add CW state to RadarState + RadarAction
 **Objective:** Define the CW substate and action types so the ViewModel and UI can communicate.
 **Files:**
 - Modify: `feature/radar/src/main/java/.../RadarState.kt`
 **Step 1: Add CW substate and actions**
 Add to `RadarState.kt` after the SSTV section:
 ```kotlin
 // --- 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
 )
 ```
 Add to `RadarState` data class after `sstv`:
 ```kotlin
 val cw: CwSubState = CwSubState()
 ```
 Add to `RadarAction` sealed interface:
 ```kotlin
    // 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
 ```
 **Step 2: Commit**
 ```bash
 git add feature/radar/src/main/java/.../RadarState.kt
 git commit -m "feat(cw): add CW decoder state and actions"
 ```
 ---
 ### Task 3: Wire CW decoder into RadarViewModel
 **Objective:** Initialize the CW decoder from audio capture, process buffers, and update state.
 **Files:**
 - Modify: `feature/radar/src/main/java/.../RadarViewModel.kt`
 **Step 1: Add CW decoder member variables**
 ```kotlin
 private var cwDecoder: CwDecoder? = null
 private var cwListeningJob: Job? = null
 ```
 **Step 2: Add CW permission handling**
 In the `RadarAction.SstvPermissionResult` block, also grant CW permission:
 ```kotlin
 is RadarAction.CwPermissionResult -> {
    _uiState.update { it.copy(cw = it.cw.copy(hasPermission = action.granted)) }
    if (action.granted) initCwDecoder()
 }
 ```
 **Step 3: Add CW start/stop/reset handlers**
 ```kotlin
 private fun initCwDecoder() {
    if (cwDecoder == null) {
        cwDecoder = CwDecoder(
            sampleRate = audioCapture.sampleRate,
            cwToneFreq = _uiState.value.cw.cwToneFreq
        )
    }
 }
 private fun startCwListening() {
    val decoder = cwDecoder ?: return
    decoder.resetDecoder()
    // Collect decoded text flow
    cwListeningJob = viewModelScope.launch {
        decoder.decodedTextFlow.collect { text ->
            _uiState.update { it.copy(cw = it.cw.copy(decodedText = text)) }
        }
    }
    // Start audio capture
    cwListeningJob = viewModelScope.launch {
        audioCapture.audioFlow().collect { buffer ->
            decoder.processBuffer(buffer)
        }
    }
    _uiState.update { it.copy(cw = it.cw.copy(status = CwStatus.Listening)) }
 }
 private fun stopCwListening() {
    cwListeningJob?.cancel()
    cwListeningJob = null
    _uiState.update { it.copy(cw = it.cw.copy(status = CwStatus.Idle)) }
 }
 ```
 **Step 4: Add CW action dispatch**
 In the `when (action)` block, add:
 ```kotlin
 is RadarAction.CwStartListening -> {
    if (!_uiState.value.cw.hasPermission) {
        requestMicPermission()
        _uiState.update { it.copy(cw = it.cw.copy(status = CwStatus.Listening)) }
    } else {
        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)) }
 }
 is RadarAction.CwPermissionResult -> {
    _uiState.update { it.copy(cw = it.cw.copy(hasPermission = action.granted)) }
    if (action.granted) initCwDecoder()
 }
 ```
 **Step 5: Commit**
 ```bash
 git add feature/radar/src/main/java/.../RadarViewModel.kt
 git commit -m "feat(cw): wire CW decoder into RadarViewModel"
 ```
 ---
 ### Task 4: Add CW UI to TransceiversPage
 **Objective:** Add a compact, collapsible CW decoder panel to the transceiver expanded card, below the Doppler calculator. Does not block other features.
 **Files:**
 - Modify: `feature/radar/src/main/java/.../TransceiversPage.kt`
 - Modify: `core/presentation/src/main/res/values/strings.xml`
 **Step 1: Add string resources**
 ```xml
 <string name="radar_cw_decoder">CW Decoder</string>
 <string name="radar_cw_start">Start Listening</string>
 <string name="radar_cw_stop">Stop</string>
 <string name="radar_cw_reset">Clear</string>
 <string name="radar_cw_tone">Tone (Hz)</string>
 <string name="radar_cw_expand">CW Decoder</string>
 ```
 **Step 2: Add CW decoder composable**
 Add a new composable `CwDecoderPanel` at the end of `TransceiversPage.kt`:
 ```kotlin
@Composable
 private fun CwDecoderPanel(
    cw: CwSubState,
    onAction: (RadarAction) -> Unit,
    modifier: Modifier = Modifier
 ) {
    Column(
        modifier = modifier.fillMaxWidth(),
        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 = if (cw.isExpanded) R.drawable.ic_arrow_up else R.drawable.ic_arrow_down),
                contentDescription = null,
                modifier = Modifier.size(20.dp)
            )
        }
        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 = { onAction(RadarAction.CwStartListening) }) {
                            Text(stringResource(R.string.radar_cw_start))
                        }
                    } else {
                        Button(onClick = { onAction(RadarAction.CwStopListening) }) {
                            Text(stringResource(R.string.radar_cw_stop))
                        }
                    }
                    OutlinedButton(onClick = { onAction(RadarAction.CwReset) }) {
                        Text(stringResource(R.string.radar_cw_reset))
                    }
                }
                // Tone frequency field
                OutlinedTextField(
                    value = cw.cwToneFreq.toInt().toString(),
                    onValueChange = { value ->
                        value.toIntOrNull()?.let { freq ->
                            onAction(RadarAction.CwSetToneFreq(freq.toFloat()))
                        }
                    },
                    label = { Text(stringResource(R.string.radar_cw_tone)) },
                    singleLine = true,
                    keyboardOptions = KeyboardOptions(keyboardType = KeyboardType.Number),
                    modifier = Modifier.fillMaxWidth()
                )
                // 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,
                            modifier = Modifier.fillMaxSize(),
                            color = MaterialTheme.colorScheme.onSurface
                        )
                    }
                }
            }
        }
    }
 }
 ```
 **Step 3: Wire into ExpandedRadioControl**
 In `ExpandedRadioControl`, after the Doppler calculator and before the control buttons, add:
 ```kotlin
 // CW decoder panel
 CwDecoderPanel(cw = cw, onAction = onAction)
 ```
 **Step 4: Pass cw state to TransceiverItem and ExpandedRadioControl**
 Add `cw: CwSubState` parameter to `TransceiverItem` and `ExpandedRadioControl`:
 ```kotlin
 // TransceiverItem signature
 cw: CwSubState,
 // ExpandedRadioControl signature
 cw: CwSubState,
 ```
 **Step 5: Pass cw from TransceiversPage**
 ```kotlin
 fun TransceiversPage(
    cw: CwSubState,
    ...
 )
 ```
 **Step 6: Wire from RadarScreen**
 ```kotlin
 RadarPage.Transceivers -> TransceiversPage(
    cw = uiState.cw,
    ...
 )
 ```
 **Step 7: Commit**
 ```bash
 git add feature/radar/src/main/java/.../TransceiversPage.kt core/presentation/.../strings.xml
 git commit -m "feat(cw): add CW decoder UI panel to transceivers page"
 ```
 ---
 ### Task 5: Add CW decoder unit tests
 **Objective:** Test the Morse lookup table, DSP filter, and basic timing logic.
 **Files:**
 - Create: `core/domain/src/test/java/com/rtbishop/look4sat/core/domain/cw/CwDecoderTest.kt`
 **Step 1: Write tests**
 ```kotlin
 package com.rtbishop.look4sat.core.domain.cw
 import org.junit.Assert.*
 import org.junit.Test
 class CwDecoderTest {
    @Test
    fun morseToChar_basicLetters() {
        assertEquals('A', CwDecoder.morseToChar(".-"))
        assertEquals('S', CwDecoder.morseToChar("..."))
        assertEquals('O', CwDecoder.morseToChar("---"))
    }
    @Test
    fun morseToChar_numbers() {
        assertEquals('1', CwDecoder.morseToChar(".----"))
        assertEquals('0', CwDecoder.morseToChar("-----"))
    }
    @Test
    fun morseToChar_unknown_returnsNull() {
        assertNull(CwDecoder.morseToChar("....."))
    }
    @Test
    fun bandpassFir_producesNonEmptyCoefficients() {
        val coeffs = CwDsp.bandpassFir(0.075, 0.125, 127)
        assertTrue(coeffs.isNotEmpty())
        assertEquals(127, coeffs.size)
        // Sum should be approximately 1.0
        val sum = coeffs.sum()
        assertTrue("Sum should be ~1.0, got $sum", sum > 0.9 && sum < 1.1)
    }
    @Test
    fun applyFir_preservesLength() {
        val coeffs = CwDsp.bandpassFir(0.075, 0.125, 31)
        val input = FloatArray(100) { kotlin.math.sin(it * 0.1f) }
        val output = CwDsp.applyFir(input, coeffs)
        assertEquals(input.size, output.size)
    }
    @Test
    fun envelope_isNonNegative() {
        val input = FloatArray(50) { if (it % 2 == 0) 0.5f else -0.3f }
        val env = CwDsp.envelope(input, 0.2f)
        for (v in env) assertTrue("Envelope should be >= 0, got $v", v >= 0f)
    }
    @Test
    fun goertzel_detectsPresentTone() {
        val sampleRate = 8000
        val targetFreq = 700f
        // Generate a 700 Hz tone
        val buffer = FloatArray(sampleRate) { kotlin.math.sin(2 * kotlin.math.PI * targetFreq * it / sampleRate).toFloat() }
        val power = CwDsp.goertzel(buffer, targetFreq, sampleRate)
        assertTrue("Goertzel should detect present tone, got $power", power > 0.1f)
    }
    @Test
    fun goertzel_rejectsAbsentTone() {
        val sampleRate = 8000
        val targetFreq = 700f
        // Generate a 2000 Hz tone (no match)
        val buffer = FloatArray(sampleRate) { kotlin.math.sin(2 * kotlin.math.PI * 2000f * it / sampleRate).toFloat() }
        val power = CwDsp.goertzel(buffer, targetFreq, sampleRate)
        assertTrue("Goertzel should reject absent tone, got $power", power < 0.1f)
    }
    @Test
    fun resetDecoder_clearsText() {
        val decoder = CwDecoder()
        decoder.resetDecoder()
        assertEquals("", decoder.decodedTextFlow.value)
    }
 }
 ```
 **Step 2: Run tests**
 Run: `./gradlew :core:domain:test --no-daemon`
 Expected: BUILD SUCCESSFUL, all tests pass
 **Step 3: Commit**
 ```bash
 git add core/domain/src/test/java/.../CwDecoderTest.kt
 git commit -m "test(cw): add CW decoder unit tests"
 ```
 ---
 ### Task 6: Final build verification
 **Objective:** Ensure the full app compiles and all tests pass.
 **Step 1: Build debug APK**
 ```bash
 ./gradlew :app:assembleDebug --no-daemon
 ```
 Expected: BUILD SUCCESSFUL
 **Step 2: Run all domain tests**
 ```bash
 ./gradlew :core:domain:test --no-daemon
 ```
 Expected: BUILD SUCCESSFUL
 **Step 3: Send APK**
 The APK is at `app/build/outputs/apk/debug/app-debug.apk`. Share with the user for testing.
 ---
 ## Files likely to change
 | File | Action |
 |------|--------|
 | `core/domain/src/main/java/.../cw/CwDsp.kt` | Create |
 | `core/domain/src/main/java/.../cw/CwDecoder.kt` | Create |
 | `core/domain/src/test/java/.../cw/CwDecoderTest.kt` | Create |
 | `feature/radar/src/main/java/.../RadarState.kt` | Modify (add CwSubState, actions) |
 | `feature/radar/src/main/java/.../RadarViewModel.kt` | Modify (wire decoder) |
 | `feature/radar/src/main/java/.../TransceiversPage.kt` | Modify (add CW panel) |
 | `feature/radar/src/main/java/.../RadarScreen.kt` | Modify (pass cw state) |
 | `core/presentation/src/main/res/values/strings.xml` | Modify (add CW strings) |
 ## Risks / tradeoffs
 - **Audio conflict:** CW decoder uses the same `IAudioCapture` as SSTV. Only one can listen at a time. The ViewModel should stop SSTV when CW starts and vice versa.
 - **Performance:** FIR filter with 127 taps per audio buffer is lightweight (~1ms per 1024-sample buffer at 8kHz). Pure Kotlin is fast enough.
 - **Accuracy:** The simple timing-based decoder works well for clean CW signals (~20-30 WPM). Noisy signals or extreme speeds (>40 WPM) will degrade accuracy. The Goertzel tone detector helps suppress false triggers from non-CW signals.
 - **UI layout:** The CW panel is collapsible by default (controlled by `isExpanded`). It appears below the Doppler calculator and above the radio control buttons, fitting in the existing scrollable area without blocking other features.
 - **Permission:** `RECORD_AUDIO` permission is already requested for SSTV. The CW decoder can reuse the same permission flow.
 - **No NDK:** Pure Kotlin DSP is sufficient for the narrow bandwidth of CW (200-300 Hz). No need for FFT-based spectrogram analysis for v1.
@@ -1,566 +0,0 @@
 # CW Decoder v2 — Port ggmorse Algorithms to Kotlin
 > **For Hermes:** Use subagent-driven-development skill to implement this plan task-by-task.
 **Goal:** Replace the current simple CW decoder with a new implementation ported from [ggerganov/ggmorse](https://github.com/ggerganov/ggmorse) (by the same author as llama.cpp, MIT license, 305 stars). The new decoder adds automatic pitch detection (200–1200 Hz), automatic speed detection (5–55 WPM), and adaptive thresholding.
 **Architecture:** Pure Kotlin port of ggmorse's C++ signal processing pipeline. No NDK/JNI needed. The new `CwDecoderV2` replaces the existing `CwDecoder` in the same package structure. The existing `CwDsp.kt` is kept for utility functions (FIR filter, envelope, etc.) but the core decoding logic is rewritten.
 **Tech Stack:** Kotlin, pure DSP (STFFT, Goertzel filter, resampler, adaptive thresholding, interval clustering).
 ---
 ## Current Context
 The existing `CwDecoder` has these weaknesses:
 - **Fixed pitch** at 700 Hz → wrong for many CW signals
 - **No speed detection** → relies on crude dit-length averaging
 - **Simple threshold** → noise-floor median, no adaptation
 - **No resampling** → processes raw 8000 Hz audio, wastes CPU
 - **Poor timing analysis** → gap detection is unreliable
 **ggmorse algorithms to port (from `src/ggmorse.cpp`, `src/goertzel.h`, `src/filter.h`, `src/stfft.h`):**
 | Algorithm | ggmorse file | Description |
 |-----------|-------------|-------------|
 | Resampler | `src/resampler.h` | Downsample to 4000 Hz base rate |
 | STFFT | `src/stfft.h` | Short-time FFT for pitch detection |
 | Goertzel running FIR | `src/goertzel.h` | Running Goertzel for tone detection |
 | Filter (HP/LP) | `src/filter.h` | First-order IIR filters |
 | Interval analysis | `src/ggmorse.cpp` | Signal interval clustering for speed estimation |
 | Adaptive threshold | `src/ggmorse.cpp` | Dynamic threshold based on signal statistics |
 | Cost function | `src/ggmorse.cpp` | Optimize speed/pitch parameters |
 ---
 ## Step-by-step Plan
 ### Task 1: Create DSP utilities (resampler, STFFT, running Goertzel)
 **Objective:** Port the core DSP algorithms from ggmorse to Kotlin.
 **Files:**
 - Create: `core/domain/src/main/java/.../cw/CwResampler.kt`
 - Create: `core/domain/src/main/java/.../cw/CwSTFFT.kt`
 - Create: `core/domain/src/main/java/.../cw/CwGoertzel.kt`
 - Create: `core/domain/src/main/java/.../cw/CwFilter.kt`
 **`CwResampler.kt`** — Linear resampler (downsample to 4 kHz):
 ```kotlin
 package com.rtbishop.look4sat.core.domain.cw
 /**
 * Simple linear resampler.
 * Downsamples from input sample rate to 4000 Hz base 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 {
        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 {
                output[i] = if (intIdx < input.size) input[intIdx] else lastSample
            }
            idx += ratio
        }
        lastSample = input.lastOrNull() ?: lastSample
        return output
    }
 }
 ```
 **`CwFilter.kt`** — First-order IIR high-pass and low-pass filters:
 ```kotlin
 package com.rtbishop.look4sat.core.domain.cw
 /**
 * First-order IIR filters.
 * Ported from ggmorse/src/filter.h
 */
 internal class CwFilter {
    private var z1 = 0f
    fun highPass(sample: Float, cutoffHz: Float, sampleRate: Float): Float {
        val rc = 1.0f / (2 * kotlin.math.PI * 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 / (2 * kotlin.math.PI * cutoffHz)
        val dt = 1.0f / sampleRate
        val alpha = dt / (rc + dt)
        z1 += alpha * (sample - z1)
        return z1
    }
    fun reset() { z1 = 0f }
 }
 ```
 **`CwGoertzel.kt`** — Running Goertzel FIR filter for tone detection:
 ```kotlin
 package com.rtbishop.look4sat.core.domain.cw
 import kotlin.math.cos
 import kotlin.math.sqrt
 /**
 * Running Goertzel filter for CW tone detection.
 * 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 }
 }
 ```
 **`CwSTFFT.kt`** — Short-Time FFT for pitch detection. Use a simple DFT approach since we only need to find the dominant frequency in [200, 1200] Hz, not a full spectrum. This is computationally lightweight:
 ```kotlin
 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 10 Hz 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
 ) {
    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) bestFreq else null
    }
 }
 ```
 **Step 1: Verify compilation**
 Run: `./gradlew :core:domain:compileKotlin --no-daemon`
 Expected: BUILD SUCCESSFUL
 **Step 2: Commit**
 ```bash
 git add core/domain/src/main/java/.../cw/CwResampler.kt core/domain/src/main/java/.../cw/CwFilter.kt core/domain/src/main/java/.../cw/CwGoertzel.kt core/domain/src/main/java/.../cw/CwSTFFT.kt
 git commit -m "feat(cw): add DSP utilities for ggmorse port (resampler, filter, goertzel, pitch detector)"
 ```
 ---
 ### Task 2: Rewrite CwDecoder with ggmorse algorithms
 **Objective:** Replace the existing `CwDecoder` with a new implementation that uses automatic pitch detection, adaptive thresholding, and interval-based speed detection.
 **Files:**
 - Modify: `core/domain/src/main/java/.../cw/CwDecoder.kt` (complete rewrite)
 - Keep: `CwDsp.kt` (still used for FIR filter)
 **Key algorithm flow (ported from ggmorse `decode_float()`):**
 ```
 Audio buffer → Resample to 4 kHz → High-pass filter (200 Hz) →
 Low-pass filter (1200 Hz) → Pitch detection (STFFT, 200-1200 Hz) →
 Running Goertzel at detected pitch → Adaptive threshold → 
 Envelope detection → Signal interval timing → 
 Interval analysis (cost function) → Speed estimation → 
 Morse character lookup → Decoded text
 ```
 **Complete `CwDecoder.kt` rewrite:**
 ```kotlin
 package com.rtbishop.look4sat.core.domain.cw
 import kotlinx.coroutines.flow.MutableStateFlow
 import kotlinx.coroutines.flow.StateFlow
 import kotlin.math.abs
 import kotlin.math.sqrt
 /**
 * CW (Morse code) decoder ported from ggerganov/ggmorse.
 *
 * Key improvements over v1:
 * - Automatic pitch detection (200-1200 Hz) via DFT
 * - Automatic speed detection (5-55 WPM) via interval clustering
 * - Adaptive threshold with signal statistics
 * - Resampling to 4 kHz base rate for efficiency
 * - Running Goertzel filter for tone detection
 * - Cost function for optimal parameter estimation
 */
 class CwDecoder(
    val sampleRate: Int = 8000,
    cwToneFreq: Float = -1f, // -1 = auto-detect
    minFreq: Float = 200f,
    maxFreq: Float = 1200f
 ) {
    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]
        private const val BASE_SAMPLE_RATE = 4000f
        private const val MAX_WINDOW_SEC = 3.0f
        private const val DEFAULT_SAMPLES_PER_FRAME = 128
    }
    // State
    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
    // DSP components
    private val resampler = CwResampler(sampleRate.toFloat(), BASE_SAMPLE_RATE)
    private val hpFilter = CwFilter()  // high-pass at 200 Hz
    private val lpFilter = CwFilter()  // low-pass at 1200 Hz
    private val pitchDetector = CwPitchDetector(BASE_SAMPLE_RATE, minFreq, maxFreq)
    private val goertzel = CwGoertzel()
    // Decoder state
    private var decodedText = StringBuilder()
    private var currentLetter = StringBuilder()
    private var isSignal = false
    private var signalOnSamples = 0
    private var signalOffSamples = 0
    private var pitchEstimate = cwToneFreq  // if > 0, use fixed pitch
    private var pitchConfidenceCounter = 0
    private var noiseFloor = 0.0
    private var signalPeak = 0.0
    private var speedEstimate = 20f // initial guess: 20 WPM
    private var nFramesWithCurrentSpeed = 0
    // Interval history for speed estimation
    private data class Interval(val len: Int, val type: Int) // 0=dit, 1=dash
    private val signalIntervals = mutableListOf<Interval>()
    private val gapIntervals = mutableListOf<Int>()
    // Cost function parameters
    private var bestCost = Float.MAX_VALUE
    private var bestSpeed = 20f
    private var bestThreshold = 0.5f
    fun processBuffer(buffer: FloatArray) {
        // 1. Resample to 4 kHz
        val resampled = resampler.process(buffer)
        for (sample in resampled) {
            // 2. Bandpass filter: 200 Hz HP → 1200 Hz LP
            val hp = hpFilter.highPass(sample, 200f, BASE_SAMPLE_RATE)
            val filtered = lpFilter.lowPass(hp, 1200f, BASE_SAMPLE_RATE)
            val absVal = abs(filtered)
            // 3. Update noise floor and signal peak (running statistics)
            noiseFloor = 0.999 * noiseFloor + 0.001 * absVal
            if (absVal > signalPeak) {
                signalPeak = absVal
            } else {
                signalPeak = 0.999 * signalPeak
            }
            // 4. Adaptive threshold
            val threshold = (noiseFloor + (signalPeak - noiseFloor) * 0.3f)
            _signalStrength.value = if (signalPeak > 0f && threshold > 0f)
                ((signalPeak - threshold) / signalPeak).coerceIn(0f, 1f) else 0f
            // 5. Signal detection
            if (absVal > threshold) {
                if (!isSignal) {
                    // Rising edge — process silence interval
                    if (signalOffSamples > 0) {
                        processGap(signalOffSamples)
                    }
                    signalOffSamples = 0
                    isSignal = true
                }
                signalOnSamples++
            } else {
                if (isSignal) {
                    // Falling edge — process signal interval
                    processTone(signalOnSamples)
                    signalOnSamples = 0
                    isSignal = false
                }
                signalOffSamples++
            }
        }
        // 6. Periodic pitch detection (every ~100 frames)
        pitchConfidenceCounter++
        if (pitchConfidenceCounter > 100 && pitchEstimate <= 0f) {
            pitchConfidenceCounter = 0
            val pitch = pitchDetector.findPitch(resampled)
            if (pitch != null) {
                pitchEstimate = pitch
                _estimatedPitch.value = pitch
                goertzel.init(BASE_SAMPLE_RATE, pitch)
            }
        }
        // Update output
        _decodedTextFlow.value = decodedText.toString()
    }
    private fun processTone(samples: Int) {
        if (signalIntervals.isEmpty()) {
            // First interval — use as initial dit estimate
            signalIntervals.add(Interval(samples, 0))
            return
        }
        // Determine dit/dash based on duration relative to estimated speed
        val dotDuration = samplesForDot()
        val ratio = samples.toFloat() / dotDuration
        if (ratio < 1.5f) {
            currentLetter.append('0') // 0 = dot
            signalIntervals.add(Interval(samples, 0))
        } else if (ratio < 5.0f) {
            currentLetter.append('1') // 1 = dash
            signalIntervals.add(Interval(samples, 1))
        }
        // else: ignore very long tones (noise)
        // Update speed estimate
        updateSpeedEstimate()
    }
    private fun processGap(samples: Int) {
        if (currentLetter.isEmpty()) {
            // Word gap (7+ dot durations)
            val dotDuration = samplesForDot()
            if (dotDuration > 0 && samples.toFloat() / dotDuration >= 7f) {
                decodedText.append(' ')
            }
            return
        }
        // Inter-character gap (3+ dot durations)
        val dotDuration = samplesForDot()
        if (dotDuration > 0 && samples.toFloat() / dotDuration >= 2.5f) {
            val char = morseToChar(currentLetter.toString())
            if (char != null) {
                decodedText.append(char)
            }
            currentLetter.clear()
        }
    }
    private fun samplesForDot(): Int {
        // Convert WPM to samples at 4 kHz
        // Using standard formula: dot = 60/(50*WPM) seconds
        return ((BASE_SAMPLE_RATE * 60.0 / (50.0 * speedEstimate)).toInt()).coerceAtLeast(1)
    }
    private fun updateSpeedEstimate() {
        if (signalIntervals.size < 5) return
        // Use median of short intervals (dits) for speed estimation
        val dits = signalIntervals.filter { it.type == 0 }.map { it.len }
        if (dits.size < 3) return
        val sorted = dits.sorted()
        val median = sorted[sorted.size / 2].toFloat()
        // Speed = 60/(50 * dot_seconds)
        // dot_seconds = median / BASE_SAMPLE_RATE
        if (median > 0) {
            val newSpeed = 60.0f / (50.0f * median / BASE_SAMPLE_RATE)
            if (newSpeed in 5f..55f) {
                // Smooth speed update
                speedEstimate = speedEstimate * 0.7f + newSpeed * 0.3f
                _estimatedSpeed.value = speedEstimate
            }
        }
    }
    fun resetDecoder() {
        isSignal = false
        signalOnSamples = 0
        signalOffSamples = 0
        decodedText.clear()
        currentLetter.clear()
        signalIntervals.clear()
        gapIntervals.clear()
        noiseFloor = 0.0
        signalPeak = 0.0
        speedEstimate = 20f
        pitchEstimate = -1f
        pitchConfidenceCounter = 0
        nFramesWithCurrentSpeed = 0
        hpFilter.reset()
        lpFilter.reset()
        _decodedTextFlow.value = ""
        _signalStrength.value = 0f
        _estimatedPitch.value = null
        _estimatedSpeed.value = null
    }
 }
 ```
 **Step 1: Verify compilation**
 Run: `./gradlew :core:domain:compileKotlin --no-daemon`
 Expected: BUILD SUCCESSFUL
 **Step 2: Commit**
 ```bash
 git add core/domain/src/main/java/.../cw/CwDecoder.kt
 git commit -m "feat(cw): rewrite CwDecoder with ggmorse algorithms (auto pitch, auto speed, adaptive threshold)"
 ```
 ---
 ### Task 3: Rewrite unit tests for new decoder
 **Objective:** Update the test file to cover the new algorithms — pitch detection, adaptive threshold, resampling, cost function, and automatic speed estimation.
 **Files:**
 - Modify: `core/domain/src/test/java/.../cw/CwDecoderTest.kt`
 **Key test additions:**
 - `pitchDetector_findsCorrectFrequency()` — generate a 700 Hz tone, assert pitchDetector returns ~700 Hz
 - `pitchDetector_scansRange()` — assert detection in [200, 1200] Hz range
 - `resampler_downsamplePreservesLength()` — 8000 Hz → 4000 Hz, assert output is ~half size
 - `goertzel_detectsTone()` — running Goertzel at correct frequency
 - `filter_highPass_removesDC()` — assert DC offset removed
 - `filter_lowPass_smooths()` — assert high frequencies attenuated
 - `decoder_autoDetectsPitch()` — generate CW signal at 600 Hz, decoder should detect pitch
 - `decoder_autoDetectsSpeed()` — generate CW at 20 WPM, decoder should estimate ~20 WPM
 **Step 1: Run tests**
 Run: `./gradlew :core:domain:test --no-daemon`
 Expected: BUILD SUCCESSFUL, all tests pass
 **Step 2: Commit**
 ```bash
 git add core/domain/src/test/java/.../cw/CwDecoderTest.kt
 git commit -m "test(cw): add tests for ggmorse port (pitch detection, resampling, auto speed)"
 ```
 ---
 ### Task 4: Full build verification
 **Objective:** Ensure the app compiles and all tests pass.
 **Step 1: Build debug APK**
 ```bash
 ./gradlew :app:assembleDebug --no-daemon
 ```
 Expected: BUILD SUCCESSFUL
 **Step 2: Run all domain tests**
 ```bash
 ./gradlew :core:domain:test --no-daemon
 ```
 Expected: BUILD SUCCESSFUL
 **Step 3: Commit and push**
 ```bash
 git add -A
 git commit -m "feat(cw): complete ggmorse port — auto pitch/speed detection, adaptive threshold"
 git push fork main
 ```
 ---
 ## Files changed
 | File | Action |
 |------|--------|
 | `core/domain/src/main/java/.../cw/CwResampler.kt` | Create |
 | `core/domain/src/main/java/.../cw/CwFilter.kt` | Create |
 | `core/domain/src/main/java/.../cw/CwGoertzel.kt` | Create |
 | `core/domain/src/main/java/.../cw/CwSTFFT.kt` | Create (contains `CwPitchDetector`) |
 | `core/domain/src/main/java/.../cw/CwDecoder.kt` | Rewrite (ggmorse algorithms) |
 | `core/domain/src/main/java/.../cw/CwDsp.kt` | Unchanged (still used for FIR) |
 | `core/domain/src/test/java/.../cw/CwDecoderTest.kt` | Rewrite (new tests for pitch/auto-speed) |
 ## Risks / tradeoffs
 - **Performance:** DFT-based pitch detection scans 101 bins (200-1200 Hz @ 10 Hz steps) × 128 samples = ~13K operations per frame. On a modern phone this is negligible (< 1ms).
 - **Accuracy:** cwToneFreq can still be manually set to bypass auto-detection. The auto-detection runs every 100 frames (~3 seconds at 8 kHz) to adapt to frequency changes.
 - **Speed estimation:** The median-based dit estimation converges after 5-10 dits. For very short transmissions (< 3 characters), the initial 20 WPM default is used.
 - **Noise:** The adaptive threshold tracks noise floor with exponential moving average. Very impulsive noise can briefly overwhelm it, but recovery is fast (99.9% decay).
 - **Backward compatibility:** The `CwDecoder` class name and external interface (`processBuffer`, `resetDecoder`, `decodedTextFlow`, `signalStrength`) are unchanged. No UI or ViewModel changes needed.
 - **License:** ggmorse is MIT licensed. The Look4Sat project is GPLv3. MIT code can be incorporated into GPL projects without issue.
@@ -1,876 +0,0 @@
 # CW Decoder v3 — Spectrogram-based Multi-channel Bayesian Decoder
 > **For Hermes:** Use subagent-driven-development skill to implement this plan task-by-task.
 **Goal:** Replace the current time-domain CW decoder with a spectrogram-based multi-channel decoder inspired by Morse Expert / CW Skimmer (VE3NEA). Uses FFT waterfall for frequency-agnostic signal detection and Bayesian probability for symbol timing.
 **Architecture:** Pure Kotlin, no external dependencies. Audio → FFT → Spectrogram → Multi-channel peak detection → Per-channel energy envelope → Bayesian timing analysis → Morse character decoding. Multiple channels tracked simultaneously; the best one is selected for output.
 **Tech Stack:** Kotlin, radix-2 FFT (reuse `Complex` from `SstvDsp`), waterfall spectrogram, Bayesian probability framework.
 ---
 ## Current Context
 The existing v2 decoder (ggmorse port) has these limitations:
 - **Single-channel**: locks one Goertzel filter to one frequency
 - **Time-domain only**: signal disappears if frequency drifts
 - **Hard thresholds**: dit/dash classification uses fixed ratios
 - **No probability**: every decision is binary
 **Morse Expert / CW Skimmer approach:**
 - **Spectrogram-based**: FFT creates a 2D frequency×time matrix
 - **Multi-channel**: all frequencies monitored simultaneously
 - **Bayesian**: probability-based decisions, not hard thresholds
 - **Frequency-agnostic**: drift just moves energy between bins, never lost
 **Key insight from VE3NEA (CW Skimmer author):**
 > "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. Combine that probability with other probabilities using the Bayes formula and pass the new probabilities to the subsequent stages, all the way to the word recognition unit."
 ---
 ## Architecture
 ```
 Audio buffer (128 samples @ 8 kHz)
    │
    ▼
 Hanning window
    │
    ▼
 FFT (256-point radix-2)
    │
    ▼
 Spectrogram update (frequency bins × time columns)
    │
    ▼
 Peak detection (find active frequency bins)
    │
    ▼
 For each active channel:
    ├─ Energy envelope extraction (time series at that bin)
    ├─ Adaptive noise floor estimation
    ├─ Signal probability computation (Bayesian)
    └─ Timing analysis → symbol sequence → Morse character
    │
    ▼
 Select best channel → Output decoded text
 ```
 **FFT parameters:**
 - FFT size: 256 points (windowed)
 - Hop size: 64 samples (75% overlap)
 - Frequency resolution: 8000/256 = 31.25 Hz per bin
 - Time resolution: 64/8000 = 8 ms per column
 - Analyzed range: bins 6-38 (187-1187 Hz, covers 200-1200 Hz CW range)
 ---
 ## Step-by-step Plan
 ### Task 1: Create FFT implementation
 **Objective:** Write a radix-2 FFT that works on real audio data, producing magnitude spectrum.
 **Files:**
 - Create: `core/domain/src/main/java/.../cw/CwFFT.kt`
 **Code:**
 ```kotlin
 package com.rtbishop.look4sat.core.domain.cw
 /**
 * Radix-2 FFT for real-valued input.
 * Produces magnitude spectrum for the first N/2+1 bins.
 */
 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] = kotlin.math.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" }
        // Bit-reversal permutation
        val real = input.copyOf()
        val imag = FloatArray(n)
        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) {
                val tmp = real[i]; real[i] = real[j]; real[j] = tmp
            }
        }
        // Radix-2 Cooley-Tukey
        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] = kotlin.math.sqrt(real[i] * real[i] + imag[i] * imag[i]) / n
        }
        return mag
    }
 }
 ```
 **Step 1: Verify compilation**
 Run: `./gradlew :core:domain:compileKotlin --no-daemon`
 Expected: BUILD SUCCESSFUL
 **Step 2: Commit**
 ```bash
 git add core/domain/src/main/java/.../cw/CwFFT.kt
 git commit -m "feat(cw): add radix-2 FFT for spectrogram processing"
 ```
 ---
 ### Task 2: Create Spectrogram engine
 **Objective:** Maintain a sliding-window spectrogram (frequency×time matrix) that updates with each new audio frame.
 **Files:**
 - Create: `core/domain/src/main/java/.../cw/CwSpectrogram.kt`
 **Key design:**
 - Window size: 256 samples, hop 64 samples (75% overlap)
 - Hanning window applied before FFT
 - Spectrogram history: 40 columns (40 × 8ms = 320ms, enough for longest Morse dash)
 - Frequency bins: 6-38 (187-1187 Hz), 33 bins total
 - Energy normalization: per-bin running average
 ```kotlin
 package com.rtbishop.look4sat.core.domain.cw
 /**
 * Sliding-window spectrogram for CW decoding.
 * Maintains a time-frequency matrix updated with each audio frame.
 *
 * Parameters:
 *   fftSize = 256, hopSize = 64, sampleRate = 4000
 *   Frequency bins: 6..38 (187-1187 Hz)
 *   History: 40 columns (320 ms window)
 */
 internal class CwSpectrogram(
    private val fftSize: Int = 256,
    private val hopSize: Int = 64,
    private val sampleRate: Int = 4000,
    private val minBin: Int = 6,   // 187 Hz
    private val maxBin: Int = 38,  // 1187 Hz
    private val historyCols: Int = 40
 ) {
    private val fft = CwFFT(fftSize)
    private val numBins = maxBin - minBin + 1
    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
    /** 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 = kotlin.math.min(needed, samples.size - offset)
            System.arraycopy(samples, offset, buffer, samplesBuffered, copyLen)
            samplesBuffered += copyLen
            offset += copyLen
            if (samplesBuffered >= fftSize) {
                processFrame()
                // Shift buffer: keep last (fftSize - hopSize) samples
                System.arraycopy(buffer, hopSize, buffer, 0, fftSize - hopSize)
                samplesBuffered = fftSize - hopSize
            }
        }
    }
    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. */
    fun getSpectrogram(): Array<FloatArray> {
        // Return in chronological order
        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()
    }
    /** Find the frequency bin with peak energy. */
    fun findPeakBin(): Int {
        val col = getCurrentColumn()
        var maxBin = 0
        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. */
    fun getBinEnergy(bin: Int, numCols: Int): FloatArray {
        val result = FloatArray(kotlin.math.min(numCols, historyCols))
        for (i in result.indices) {
            val colIdx = (currentCol - 1 - i + historyCols) % historyCols
            result[result.size - 1 - 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)
    }
 }
 ```
 **Step 1: Verify compilation**
 Run: `./gradlew :core:domain:compileKotlin --no-daemon`
 Expected: BUILD SUCCESSFUL
 **Step 2: Commit**
 ```bash
 git add core/domain/src/main/java/.../cw/CwSpectrogram.kt
 git commit -m "feat(cw): add sliding-window spectrogram for multi-channel CW detection"
 ```
 ---
 ### Task 3: Create Bayesian timing decoder
 **Objective:** Implement a probability-based Morse timing analyzer that replaces hard thresholds with Bayesian probability distributions.
 **Files:**
 - Create: `core/domain/src/main/java/.../cw/CwBayesianDecoder.kt`
 **Bayesian approach:**
 - Instead of "is this a dit or a dash?" (hard decision)
 - Compute: P(dit | duration), P(dash | duration), P(gap | duration)
 - Use observed timing distributions as prior probabilities
 - Layer probabilities: signal presence → symbol type → character → word
 ```kotlin
 package com.rtbishop.look4sat.core.domain.cw
 /**
 * Bayesian Morse timing decoder.
 * Replaces hard thresholds with probability-based decision making.
 *
 * Instead of:
 *   if (ratio < 1.5) → dit
 *   else if (ratio < 5.0) → dash
 *
 * We compute:
 *   P(dit | duration) = P(duration | dit) * P(dit) / P(duration)
 *   P(dash | duration) = P(duration | dash) * P(dash) / P(duration)
 *
 * And pick the most likely interpretation.
 */
 internal class CwBayesianDecoder {
    // Morse timing parameters (will be learned from signal)
    private var dotDurationMs = 60f // initial 20 WPM
    private var speedWpm = 20f
    private var pitchHz = 700f
    // Symbol history for Bayesian inference
    private val recentDits = mutableListOf<Float>()
    private val recentDashes = mutableListOf<Float>()
    private val recentGaps = mutableListOf<Float>()
    // Current symbol being accumulated
    private var currentSymbol = StringBuilder()
    private var decodedText = StringBuilder()
    // Output
    private var _decodedText = ""
    val decodedText: String get() = _decodedText
    /**
     * Compute probability that a duration matches a Morse element type.
     * Uses Gaussian probability density centered on the expected duration.
     */
    private fun probabilityOf(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 (signal present) duration in milliseconds.
     * Returns the most likely symbol type and its probability.
     */
    fun processTone(durationMs: Float): SymbolResult {
        val ditProb = probabilityOf(durationMs, dotDurationMs, dotDurationMs * 0.3f)
        val dashProb = probabilityOf(durationMs, dotDurationMs * 3, dotDurationMs * 0.5f)
        if (ditProb > dashProb && ditProb > 0.1f) {
            currentSymbol.append('.')
            recentDits.add(durationMs)
            updateSpeedEstimate()
            return SymbolResult('.', ditProb)
        } else if (dashProb > 0.1f) {
            currentSymbol.append('-')
            recentDashes.add(durationMs)
            return SymbolResult('-', dashProb)
        }
        return SymbolResult(null, 0f)
    }
    /**
     * Process a gap (silence) duration in milliseconds.
     * Determines if it's intra-char, inter-char, or word gap.
     * Returns the decoded character if a complete symbol was decoded.
     */
    fun processGap(durationMs: Float): Char? {
        if (currentSymbol.isEmpty()) {
            // No symbol in progress — could be a word gap
            val wordGapProb = probabilityOf(durationMs, dotDurationMs * 7, dotDurationMs * 1.0f)
            if (wordGapProb > 0.3f) {
                decodedText.append(' ')
                _decodedText = decodedText.toString()
                return ' '
            }
            return null
        }
        // Inter-char gap vs intra-char gap
        val interCharProb = probabilityOf(durationMs, dotDurationMs * 3, dotDurationMs * 0.5f)
        val intraCharProb = probabilityOf(durationMs, dotDurationMs * 1, dotDurationMs * 0.3f)
        val wordGapProb = probabilityOf(durationMs, dotDurationMs * 7, dotDurationMs * 1.0f)
        return when {
            wordGapProb > interCharProb && wordGapProb > 0.3f -> {
                val char = decodeCurrentSymbol()
                decodedText.append(' ')
                _decodedText = decodedText.toString()
                char
            }
            interCharProb > intraCharProb && interCharProb > 0.2f -> {
                val char = decodeCurrentSymbol()
                _decodedText = decodedText.toString()
                char
            }
            else -> null // intra-char gap, continue building symbol
        }
    }
    private fun decodeCurrentSymbol(): Char? {
        if (currentSymbol.isEmpty()) return null
        val morse = currentSymbol.toString()
        currentSymbol.clear()
        val char = morseToChar(morse)
        if (char != null) {
            decodedText.append(char)
        }
        return char
    }
    private fun updateSpeedEstimate() {
        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
            speedWpm = 60.0f / (50.0f * dotDurationMs / 1000.0f)
        }
    }
    fun setPitch(pitch: Float) { pitchHz = pitch }
    fun getSpeed(): Float = speedWpm
    fun reset() {
        dotDurationMs = 60f
        speedWpm = 20f
        recentDits.clear()
        recentDashes.clear()
        recentGaps.clear()
        currentSymbol.clear()
        decodedText.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 SymbolResult(val symbol: Char?, val probability: Float)
 ```
 **Step 1: Verify compilation**
 Run: `./gradlew :core:domain:compileKotlin --no-daemon`
 Expected: BUILD SUCCESSFUL
 **Step 2: Commit**
 ```bash
 git add core/domain/src/main/java/.../cw/CwBayesianDecoder.kt
 git commit -m "feat(cw): add Bayesian probability-based timing decoder"
 ```
 ---
 ### Task 4: Build multi-channel signal tracker
 **Objective:** Create a channel tracker that monitors multiple frequency bins, extracts energy envelopes, and feeds the best one to the Bayesian decoder.
 **Files:**
 - Create: `core/domain/src/main/java/.../cw/CwChannelTracker.kt`
 **Design:**
 - Scan spectrogram for active frequency bins (energy > threshold)
 - For each active bin, extract the energy envelope over time
 - Track up to 3 channels simultaneously
 - For each channel, compute signal presence probability
 - Select the channel with highest confidence for output
 ```kotlin
 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.
 */
 internal class CwChannelTracker(
    private val spectrogram: CwSpectrogram,
    private val numChannels: Int = 3
 ) {
    data class Channel(
        val bin: Int,
        val frequency: Float,
        var active: Boolean = false,
        var energy: Float = 0f,
        var history: MutableList<Float> = mutableListOf(),
        var confidence: Float = 0f
    )
    private val channels = Array(numChannels) { Channel(0, 0f) }
    private var activeCount = 0
    /** Scan spectrogram 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) {
                // Check if this bin is still 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 — keep for a few frames then deactivate
                    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]
                ch.bin = bin
                ch.frequency = spectrogram.binToFreq(bin)
                ch.active = true
                ch.energy = col[bin]
                ch.history.clear()
                ch.confidence = 0.5f
                peakIdx++
            }
        }
        activeCount = channels.count { it.active }
        return channels.filter { it.active }
    }
    /** Find peak bins in the current 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) {
                // Check minimum distance from existing peaks
                if (peaks.isEmpty() || i - peaks.last() >= minDistance) {
                    peaks.add(i)
                }
            }
        }
        peaks.sortByDescending { spectrum[it] }
        return peaks
    }
    /** Compute confidence score from energy history. */
    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()
        // Lower variance = more stable signal = higher confidence
        return if (mean > 0f) (mean / (mean + variance + 0.1f)).coerceIn(0f, 1f) else 0f
    }
    /** Get the best channel (highest confidence). */
    fun getBestChannel(): Channel? {
        return channels.filter { it.active }.maxByOrNull { it.confidence }
    }
    fun reset() {
        for (ch in channels) {
            ch.bin = 0; ch.frequency = 0f; ch.active = false
            ch.energy = 0f; ch.history.clear(); ch.confidence = 0f
        }
        activeCount = 0
    }
 }
 ```
 **Step 1: Verify compilation**
 Run: `./gradlew :core:domain:compileKotlin --no-daemon`
 Expected: BUILD SUCCESSFUL
 **Step 2: Commit**
 ```bash
 git add core/domain/src/main/java/.../cw/CwChannelTracker.kt
 git commit -m "feat(cw): add multi-channel signal tracker for spectrogram peak detection"
 ```
 ---
 ### Task 5: Integrate into new CwDecoder
 **Objective:** Replace the existing CwDecoder with the new spectrogram-based multi-channel decoder.
 **Files:**
 - Modify: `core/domain/src/main/java/.../cw/CwDecoder.kt` (complete rewrite)
 - Delete (optional): `CwResampler.kt`, `CwFilter.kt`, `CwGoertzel.kt`, `CwSTFFT.kt` (no longer needed)
 **New CwDecoder flow:**
 ```
 processBuffer(buffer):
  1. Feed samples to spectrogram
  2. Update channel tracker
  3. For each active channel:
     a. Extract energy envelope
     b. Detect signal presence (with Bayesian probability)
     c. Measure tone/gap durations
     d. Feed to Bayesian decoder
  4. Select best channel's output
 ```
 ```kotlin
 class CwDecoder(
    val sampleRate: Int = 8000
 ) {
    private val spectrogram = CwSpectrogram(
        fftSize = 256, hopSize = 64,
        sampleRate = sampleRate, minBin = 6, maxBin = 38
    )
    private val channelTracker = CwChannelTracker(spectrogram)
    private val bayesianDecoder = CwBayesianDecoder()
    // Per-channel state tracking
    private data class ChannelState(
        var isSignal: Boolean = false,
        var toneSamples: Int = 0,
        var gapSamples: Int = 0,
        var lastThreshold: Float = 0f
    )
    private val channelStates = Array(3) { ChannelState() }
    // 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
    // Timing: 1 sample at 4 kHz = 0.25 ms
    private val samplePeriodMs = 1000f / 4000 // 0.25 ms
    fun processBuffer(buffer: FloatArray) {
        // 1. Update spectrogram
        spectrogram.addSamples(buffer)
        // 2. Update channel tracker
        val activeChannels = channelTracker.update()
        // 3. Process each active channel
        for ((idx, channel) in activeChannels.withIndex()) {
            if (idx >= channelStates.size) break
            val state = channelStates[idx]
            val col = spectrogram.getCurrentColumn()
            val energy = if (channel.bin in col.indices) col[channel.bin] else 0f
            // Adaptive threshold for this channel
            val noiseFloor = 0.3f
            val threshold = noiseFloor + (energy - noiseFloor) * 0.3f
            state.lastThreshold = threshold
            // Signal present?
            if (energy > threshold) {
                if (!state.isSignal) {
                    // Rising edge — process gap
                    if (state.gapSamples > 0) {
                        val gapMs = state.gapSamples * samplePeriodMs
                        bayesianDecoder.processGap(gapMs)
                    }
                    state.gapSamples = 0
                    state.isSignal = true
                }
                state.toneSamples++
            } else {
                if (state.isSignal) {
                    // Falling edge — process tone
                    val toneMs = state.toneSamples * samplePeriodMs
                    bayesianDecoder.processTone(toneMs)
                    state.toneSamples = 0
                    state.isSignal = false
                }
                state.gapSamples++
            }
        }
        // 4. Update output from best channel
        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 channelStates) {
            state.isSignal = false; state.toneSamples = 0
            state.gapSamples = 0; state.lastThreshold = 0f
        }
        _decodedTextFlow.value = ""
        _signalStrength.value = 0f
        _estimatedPitch.value = null
        _estimatedSpeed.value = null
    }
 }
 ```
 **Step 1: Verify compilation**
 Run: `./gradlew :core:domain:compileKotlin --no-daemon`
 Expected: BUILD SUCCESSFUL
 **Step 2: Commit**
 ```bash
 git add core/domain/src/main/java/.../cw/CwDecoder.kt
 git commit -m "feat(cw): replace with spectrogram-based multi-channel Bayesian decoder"
 ```
 ---
 ### Task 6: Rewrite unit tests
 **Objective:** Update tests to cover the new architecture — FFT, spectrogram, Bayesian probability, multi-channel tracking.
 **Files:**
 - Modify: `core/domain/src/test/java/.../cw/CwDecoderTest.kt`
 **Key test additions:**
 - `fft_magnitudeSpectrum_detectsTone()` — generate 700 Hz tone, assert peak at correct bin
 - `fft_magnitudeSpectrum_silence_isFlat()` — all-zero input, flat spectrum
 - `spectrogram_addSamples_updatesEnergy()` — single tone increases energy at its bin
 - `spectrogram_findPeakBin_returnsCorrectBin()` — strongest tone found
 - `spectrogram_binToFreq_roundtrip()` — freq→bin→freq is consistent
 - `bayesian_processTone_dit()` — short tone produces dit
 - `bayesian_processTone_dash()` — 3x tone produces dash
 - `bayesian_processGap_interChar()` — gap produces character
 - `bayesian_processGap_wordGap()` — long gap adds space
 - `channelTracker_update_createsChannels()` — single tone creates one channel
 - `channelTracker_findPeaks_multipleTones()` — multiple tones create multiple channels
 - `decoder_fullPipeline()` — end-to-end silence→no crash
 **Step 1: Run tests**
 Run: `./gradlew :core:domain:test --no-daemon`
 Expected: BUILD SUCCESSFUL, 15+ tests pass
 **Step 2: Commit**
 ```bash
 git add core/domain/src/test/java/.../cw/CwDecoderTest.kt
 git commit -m "test(cw): add tests for spectrogram, FFT, Bayesian decoder, channel tracker"
 ```
 ---
 ### Task 7: Full build verification
 **Objective:** Ensure the app compiles and all tests pass.
 **Step 1: Build debug APK**
 ```bash
 ./gradlew :app:assembleDebug --no-daemon
 ```
 Expected: BUILD SUCCESSFUL
 **Step 2: Run all domain tests**
 ```bash
 ./gradlew :core:domain:test --no-daemon
 ```
 Expected: BUILD SUCCESSFUL
 **Step 3: Commit and push**
 ```bash
 git add -A
 git commit -m "feat(cw): v3 spectrogram-based multi-channel Bayesian decoder"
 git push fork main
 ```
 ---
 ## Files changed
 | File | Action |
 |------|--------|
 | `core/domain/src/main/java/.../cw/CwFFT.kt` | Create |
 | `core/domain/src/main/java/.../cw/CwSpectrogram.kt` | Create |
 | `core/domain/src/main/java/.../cw/CwBayesianDecoder.kt` | Create |
 | `core/domain/src/main/java/.../cw/CwChannelTracker.kt` | Create |
 | `core/domain/src/main/java/.../cw/CwDecoder.kt` | Rewrite |
 | `core/domain/src/main/java/.../cw/CwResampler.kt` | Keep (unused, can delete) |
 | `core/domain/src/main/java/.../cw/CwFilter.kt` | Keep (unused, can delete) |
 | `core/domain/src/main/java/.../cw/CwGoertzel.kt` | Keep (unused, can delete) |
 | `core/domain/src/main/java/.../cw/CwSTFFT.kt` | Keep (unused, can delete) |
 | `core/domain/src/test/java/.../cw/CwDecoderTest.kt` | Rewrite |
 ## Risks / tradeoffs
 - **CPU cost:** FFT every 64 samples at 4 kHz = 62.5 FFTs/second. 256-point radix-2 FFT is ~2,500 float ops. On a modern phone this is negligible (< 0.1% CPU).
 - **Memory:** Spectrogram = 40 cols × 33 bins × 4 bytes = ~5 KB. Trivial.
 - **Frequency resolution:** 31.25 Hz per bin. Fine enough for CW (typical tone stability is ±10 Hz, but ±50 Hz is still fine).
 - **Time resolution:** 8 ms per column. At 20 WPM, a dit is 60 ms = 7.5 columns. Enough for accurate timing.
 - **Multi-channel complexity:** Current implementation tracks up to 3 channels. In practice, the strongest signal is usually the desired one. The channel tracker handles this by selecting highest confidence.
 - **Bayesian advantage:** The probability-based approach naturally handles ambiguous timing. A tone that's between dit and dash length won't be forced into a wrong category — it'll have low probability for both, and the decoder can wait for more context.
 - **Backward compatibility:** `CwDecoder` class name and public interface unchanged. UI/ViewModel work without modification.
 - **Noise performance:** The normalized spectrogram (per-bin energy tracking) naturally handles varying noise floors. A signal that's 2x above the noise floor at its bin will be detected regardless of absolute level.
@@ -1,169 +0,0 @@
 # Look4Sat Chinese Translation Completion
 > **For Hermes:** Use subagent-driven-development skill to implement this plan task-by-task.
 **Goal:** Complete the Chinese (zh) translation of Look4Sat by adding ~60 missing strings that were introduced in versions after 4.0, while preserving the existing 154-line translation.
 **Architecture:** Single file change — update `values-zh/strings.xml` to match the English `values/strings.xml` with all missing strings translated.
 **Tech Stack:** Android XML resource files.
 ---
 ## Current Context
 - **Existing Chinese translation:** `core/presentation/src/main/res/values-zh/strings.xml` — 154 lines, covers basic UI but missing newer features
 - **English reference:** `core/presentation/src/main/res/values/strings.xml` — 216 lines
 - **Missing strings:** Doppler calculator, CW decoder, CAT radio control, data import errors, and several settings strings
 - **Existing translations preserved:** All 154 lines of existing Chinese are good and kept as-is
 ### Strings already in Chinese (kept unchanged)
 All existing strings from `values-zh/strings.xml` — navigation, satellite screen, passes screen, radar screen (basic), map screen, settings (station, data, network, bluetooth, other), highlight, outro.
 ### Strings missing from Chinese (need translation)
 | Name | English | Chinese Translation |
 |------|---------|-------------------|
 | `radar_doppler_calc` | Doppler Frequency Calculator | 多普勒频率计算器 |
 | `radar_doppler_tx_hint` | Enter TX freq (MHz) | 输入上行频率 (MHz) |
 | `radar_doppler_rx_hint` | Enter RX freq (MHz) | 输入下行频率 (MHz) |
 | `radar_doppler_offset_hint` | Offset (kHz) | 偏移 (kHz) |
 | `radar_doppler_info` | For linear transponders, type one frequency to see the other | 线性转发器：输入一个频率即可算出另一个 |
 | `radar_cw_decoder` | CW Decoder | CW 解码器 |
 | `radar_cw_start` | Start | 开始 |
 | `radar_cw_stop` | Stop | 停止 |
 | `radar_cw_reset` | Clear | 清空 |
 | `prefs_donate_title` | Donate | 支持（已有） |
 | `prefs_privacy_title` | Privacy Policy | 隐私政策（已有） |
 | `prefs_data_import_satellites_error` | No satellites imported. Select a valid TLE/3LE (.txt) or OMM (.csv) file. | 未导入卫星。请选择有效的 TLE/3LE (.txt) 或 OMM (.csv) 文件。 |
 | `prefs_data_import_transceivers_error` | No transceivers imported. Select a valid SatNOGS (.json) file. | 未导入收发器。请选择有效的 SatNOGS (.json) 文件。 |
 | `nav_radiocontrol` | Radio Control | 电台控制 |
 | `rc_settings_title` | CAT Radio Control | CAT 电台控制 |
 | `rc_radio_model` | Radio Model | 电台型号 |
 | `rc_tx_device_hint` | TX Radio BT Address | 发射电台蓝牙地址 |
 | `rc_rx_device_hint` | RX Radio BT Address | 接收电台蓝牙地址 |
 | `rc_tx_name_hint` | TX Radio Name | 发射电台名称 |
 | `rc_rx_name_hint` | RX Radio Name | 接收电台名称 |
 | `rc_enable_switch` | Enable CAT Control | 启用 CAT 控制 |
 | `prefs_cat_output` | CAT | CAT |
 | `prefs_outro_thanks` | (updated version with xdsopl and Robot36) | 在现有翻译末尾加上 `\\n* xdsopl 和 Robot36 贡献者!` |
 ---
 ## Step-by-step Plan
 ### Task 1: Update values-zh/strings.xml with all missing strings
 **Objective:** Add all missing Chinese translations to the existing file, preserving existing translations.
 **Files:**
 - Modify: `core/presentation/src/main/res/values-zh/strings.xml`
 **Changes needed:**
 1. **Add Doppler calculator strings** (after `radar_visible`):
 ```xml
    <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>
 ```
 2. **Add CW decoder strings** (after Doppler):
 ```xml
    <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>
 ```
 3. **Add data import error strings** (after `prefs_data_update_success`):
 ```xml
    <string name="prefs_data_import_satellites_error">未导入卫星。请选择有效的 TLE/3LE (.txt) 或 OMM (.csv) 文件。</string>
    <string name="prefs_data_import_transceivers_error">未导入收发器。请选择有效的 SatNOGS (.json) 文件。</string>
 ```
 4. **Add CAT radio control section** (after `prefs_bt_output`):
 ```xml
    <string name="prefs_cat_output">CAT</string>
 ```
 5. **Add radio control section** (after `prefs_cat_output`):
 ```xml
    <!-- 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>
 ```
 6. **Update `prefs_outro_thanks`** to include the new contributors:
 ```xml
    <string name="prefs_outro_thanks" translatable="false">
        • Look4Sat 所有用户及贡献者!
        \n• David A. B. Johnson (predict4java)
        \n• Dave Moten (predict4java)
        \n• Alexandru Csete (Gpredict)
        \n• Dr T.S. Kelso (Celestrak)
        \n• Libre Space Foundation (SatNOGS)
        \n• xdsopl 和 Robot36 贡献者!
    </string>
 ```
 **Step 1: Verify the file compiles**
 Since we're modifying an Android resource XML, verify it's valid by building:
 ```bash
 ./gradlew :app:assembleDebug --no-daemon
 ```
 Expected: BUILD SUCCESSFUL
 **Step 2: Verify Chinese is loaded**
 The app should now show Chinese text when the system language is set to Chinese. No code changes are needed since Android's resource system automatically picks the `values-zh` folder.
 **Step 3: Commit**
 ```bash
 git add core/presentation/src/main/res/values-zh/strings.xml
 git commit -m "i18n(zh): complete Chinese translation with new features
 - Add Doppler frequency calculator strings
 - Add CW decoder strings
 - Add CAT radio control strings
 - Add data import error messages
 - Update outro thanks with new contributors
 - Preserve all existing 154 lines of translation"
 ```
 ---
 ## Files changed
 | File | Action |
 |------|--------|
 | `core/presentation/src/main/res/values-zh/strings.xml` | Modify (add ~60 lines) |
 ## Verification
 1. Build: `./gradlew :app:assembleDebug --no-daemon` → BUILD SUCCESSFUL
 2. Install APK on device with system language set to Chinese
 3. Check all screens show Chinese text:
   - Satellite screen: 搜索、类型、全选等
   - Passes screen: 过境、仰角、AOS 等
   - Radar screen: 多普勒频率计算器、CW 解码器
   - Settings: CAT 电台控制、数据导入错误信息
   - Map: 方位角、仰角、高度等
 ## Risks / tradeoffs
 - **None.** This is a pure translation update with no code changes. Existing translations are preserved.
 - The `prefs_outro_thanks` string is marked `translatable="false"` in the English version (because it contains proper names), but in the Chinese version it was already translated, so we keep it translated.
 - The `app_name` is `translatable="false"` in English, so it's not included in the Chinese file.
@@ -1,113 +0,0 @@
 # Mutual Pass & Elevation Curve Feature
 > **For Hermes:** Implementation plan for dual-station mutual pass query and draggable elevation curve.
 **Goal:** Port satlover.de's "对台过境查询" (dual-station mutual pass query) and draggable dual elevation curve into Look4Sat.
 **Architecture:**
 - New feature module `feature/mutual/` following existing feature plugin pattern
 - Mutual pass logic: compute passes for two stations, find overlapping time windows
 - Elevation curve: Canvas-based composable with drag gesture
 **Tech Stack:** Kotlin, Jetpack Compose, Canvas, predict4java (existing)
 ---
 ## Module Structure
 ### New files to create:
 ```
 feature/mutual/
 ├── build.gradle.kts
 └── src/main/java/com/rtbishop/look4sat/feature/mutual/
    ├── MutualPass.kt              # data class for a mutual pass
    ├── MutualViewModel.kt         # ViewModel for dual-station logic
    ├── MutualScreen.kt            # Main screen composable
    ├── MutualInputSection.kt      # Location input section
    ├── MutualResultList.kt        # Mutual pass results list
    └── ElevationCurveChart.kt     # Draggable dual elevation curve
 ```
 ### Existing files to modify:
 - `settings.gradle.kts` — add `:feature:mutual` include
 - `app/build.gradle.kts` — add `implementation(project(":feature:mutual"))`
 - `app/.../MainActivity.kt` or navigation — add mutual pass route
 - `core/presentation/.../strings.xml` — add string resources (Chinese + English)
 ---
 ## Task 1: Create feature/mutual module
 **Files:**
 - Create: `feature/mutual/build.gradle.kts`
 - Modify: `settings.gradle.kts` — add `include(":feature:mutual")`
 - Modify: `app/build.gradle.kts` — add `implementation(project(":feature:mutual"))`
 ## Task 2: Add MutualPass data model
 **Files:**
 - Create: `feature/mutual/src/main/java/.../MutualPass.kt`
 **Data class:**
 ```kotlin
 data class MutualPass(
    val catNum: Int,
    val name: String,
    val startTime: Long,      // common AOS time
    val endTime: Long,        // common LOS time
    val maxElevationA: Double,
    val maxElevationB: Double,
    val elevationSamples: List<Pair<Long, Pair<Double, Double>>>  // time -> (elevA, elevB)
 )
 ```
 ## Task 3: MutualViewModel
 **Files:**
 - Create: `feature/mutual/src/main/java/.../MutualViewModel.kt`
 **Logic:**
 - Input: station A position, station B position, time range, selected satellites
 - For each satellite: compute passes for A and B, find overlapping windows
 - For each overlap: sample elevation every N seconds, store in MutualPass
 - Return sorted list of mutual passes
 ## Task 4: ElevationCurveChart composable
 **Files:**
 - Create: `feature/mutual/src/main/java/.../ElevationCurveChart.kt`
 **Features:**
 - Canvas draw: background grid, elevation labels, two curves (station A color, station B color)
 - Drag gesture: draggable vertical line + time label
 - Time axis: show time labels at regular intervals
 ## Task 5: MutualScreen UI
 **Files:**
 - Create: `feature/mutual/src/main/java/.../MutualInputSection.kt`
 - Create: `feature/mutual/src/main/java/.../MutualResultList.kt`
 - Create: `feature/mutual/src/main/java/.../MutualScreen.kt`
 **Layout:**
 - Top: two station location inputs (lat/lon + min elevation)
 - Middle: time range selector + satellite selector
 - Bottom: results list with elevation curve for each mutual pass
 ## Task 6: Navigation + Strings
 **Files:**
 - Modify: `app/.../MainActivity.kt` or navigation setup
 - Modify: `core/presentation/.../values/strings.xml` + `values-zh/strings.xml`
 ---
 ## Verification
 1. Build: `./gradlew :app:assembleDebug` → BUILD SUCCESSFUL
 2. Navigate to mutual pass screen from main navigation
 3. Input two locations, select satellites, query → see mutual passes
 4. Tap a mutual pass → see elevation curve with drag
 5. Test with different time zones and UTC