feat(discovery): mesh network discovery (#5275)

Co-authored-by: Copilot <223556219+Copilot@users.noreply.github.com>

feature/discovery/build.gradle.kts

@@ -0,0 +1,57 @@
+/*
+ * Copyright (c) 2025-2026 Meshtastic LLC
+ *
+ * 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/>.
+ */
+
+plugins {
+    alias(libs.plugins.meshtastic.kmp.feature)
+    alias(libs.plugins.meshtastic.kotlinx.serialization)
+}
+
+kotlin {
+    jvm()
+
+    @Suppress("UnstableApiUsage")
+    android {
+        namespace = "org.meshtastic.feature.discovery"
+        androidResources.enable = false
+        withHostTest { isIncludeAndroidResources = true }
+    }
+
+    sourceSets {
+        commonMain.dependencies {
+            implementation(libs.jetbrains.navigation3.ui)
+            implementation(projects.core.common)
+            implementation(projects.core.data)
+            implementation(projects.core.database)
+            implementation(projects.core.di)
+            implementation(projects.core.model)
+            implementation(projects.core.navigation)
+            implementation(projects.core.network)
+            implementation(projects.core.prefs)
+            implementation(projects.core.proto)
+            implementation(projects.core.repository)
+            implementation(projects.core.resources)
+            implementation(projects.core.service)
+            implementation(projects.core.ui)
+
+            implementation(libs.kotlinx.collections.immutable)
+        }
+
+        commonTest.dependencies { implementation(projects.core.testing) }
+
+        androidMain.dependencies { implementation(libs.mlkit.genai.prompt) }
+    }
+}

feature/discovery/src/androidMain/kotlin/org/meshtastic/feature/discovery/ai/GeminiNanoSummaryProvider.kt

@@ -0,0 +1,114 @@
+/*
+ * Copyright (c) 2026 Meshtastic LLC
+ *
+ * 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 org.meshtastic.feature.discovery.ai
+
+import co.touchlab.kermit.Logger
+import com.google.mlkit.genai.prompt.Generation
+import com.google.mlkit.genai.prompt.GenerativeModel
+import com.google.mlkit.genai.prompt.TextPart
+import com.google.mlkit.genai.prompt.generateContentRequest
+import org.koin.core.annotation.Single
+import org.meshtastic.core.database.entity.DiscoveryPresetResultEntity
+import org.meshtastic.core.database.entity.DiscoverySessionEntity
+import org.meshtastic.feature.discovery.DiscoverySummaryGenerator
+
+/**
+ * Android provider that uses Gemini Nano via ML Kit GenAI Prompt API for on-device AI summaries.
+ *
+ * Falls back to [DiscoverySummaryGenerator] when:
+ * - The on-device model is unavailable (unsupported hardware or not downloaded)
+ * - Generation fails for any reason
+ */
+@Single(binds = [DiscoverySummaryAiProvider::class])
+class GeminiNanoSummaryProvider(private val generator: DiscoverySummaryGenerator) : DiscoverySummaryAiProvider {
+
+    private val log = Logger.withTag("GeminiNanoSummary")
+
+    private val generativeModel: GenerativeModel? by lazy {
+        @Suppress("TooGenericExceptionCaught") // ML Kit throws undocumented RuntimeExceptions
+        try {
+            Generation.getClient()
+        } catch (e: Exception) {
+            log.w(e) { "Failed to get GenerativeModel client" }
+            null
+        }
+    }
+
+    override val isAvailable: Boolean
+        get() = checkAvailability()
+
+    override suspend fun generateSessionSummary(
+        session: DiscoverySessionEntity,
+        presetResults: List<DiscoveryPresetResultEntity>,
+    ): String {
+        val model = generativeModel
+        if (model == null || !isAvailable) {
+            log.d { "Gemini Nano unavailable, using algorithmic fallback" }
+            return generator.generateSessionSummary(session, presetResults)
+        }
+
+        val prompt = generator.buildSessionPrompt(session, presetResults)
+        return generateOrFallback(model, prompt) { generator.generateSessionSummary(session, presetResults) }
+    }
+
+    override suspend fun generatePresetSummary(result: DiscoveryPresetResultEntity): String {
+        val model = generativeModel
+        if (model == null || !isAvailable) {
+            return generator.generatePresetSummary(result)
+        }
+
+        val prompt = generator.buildPresetPrompt(result)
+        return generateOrFallback(model, prompt) { generator.generatePresetSummary(result) }
+    }
+
+    private suspend fun generateOrFallback(model: GenerativeModel, prompt: String, fallback: () -> String): String =
+        try {
+            val request =
+                generateContentRequest(TextPart(prompt)) {
+                    temperature = TEMPERATURE
+                    topK = TOP_K
+                    maxOutputTokens = MAX_OUTPUT_TOKENS
+                }
+            val response = model.generateContent(request)
+            val text = response.candidates.firstOrNull()?.text
+            if (text.isNullOrBlank()) {
+                log.w { "Gemini Nano returned empty response, using fallback" }
+                fallback()
+            } else {
+                text
+            }
+        } catch (@Suppress("TooGenericExceptionCaught") e: Exception) {
+            log.w(e) { "Gemini Nano generation failed, using fallback" }
+            fallback()
+        }
+
+    private fun checkAvailability(): Boolean = try {
+        // FeatureStatus is an IntDef — check synchronously via the lazy model field.
+        // Note: checkStatus() is suspend in the API; we use a non-suspend heuristic here
+        // by catching and falling back if unavailable. The actual availability is confirmed
+        // in generateOrFallback when the suspend call succeeds.
+        generativeModel != null
+    } catch (_: Exception) {
+        false
+    }
+
+    private companion object {
+        const val TEMPERATURE = 0.3f
+        const val TOP_K = 16
+        const val MAX_OUTPUT_TOKENS = 200
+    }
+}

feature/discovery/src/androidMain/kotlin/org/meshtastic/feature/discovery/export/ExportSaver.android.kt

@@ -0,0 +1,65 @@
+/*
+ * Copyright (c) 2026 Meshtastic LLC
+ *
+ * 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 org.meshtastic.feature.discovery.export
+
+import android.content.Intent
+import androidx.activity.compose.rememberLauncherForActivityResult
+import androidx.activity.result.contract.ActivityResultContracts
+import androidx.compose.runtime.Composable
+import androidx.compose.runtime.mutableStateOf
+import androidx.compose.runtime.remember
+import androidx.compose.runtime.rememberCoroutineScope
+import androidx.compose.ui.platform.LocalContext
+import co.touchlab.kermit.Logger
+import kotlinx.coroutines.Dispatchers
+import kotlinx.coroutines.launch
+import kotlinx.coroutines.withContext
+
+@Composable
+actual fun rememberExportSaver(): ExportSaverLauncher {
+    val context = LocalContext.current
+    val scope = rememberCoroutineScope()
+    val pendingExport = remember { mutableStateOf<ExportResult.Success?>(null) }
+
+    val launcher =
+        rememberLauncherForActivityResult(ActivityResultContracts.StartActivityForResult()) { result ->
+            val uri = result.data?.data ?: return@rememberLauncherForActivityResult
+            val export = pendingExport.value ?: return@rememberLauncherForActivityResult
+            pendingExport.value = null
+            scope.launch {
+                withContext(Dispatchers.IO) {
+                    @Suppress("TooGenericExceptionCaught")
+                    try {
+                        context.contentResolver.openOutputStream(uri)?.use { it.write(export.content) }
+                    } catch (e: Exception) {
+                        Logger.e(throwable = e) { "Failed to write export file" }
+                    }
+                }
+            }
+        }
+
+    return ExportSaverLauncher { result ->
+        pendingExport.value = result
+        val intent =
+            Intent(Intent.ACTION_CREATE_DOCUMENT).apply {
+                addCategory(Intent.CATEGORY_OPENABLE)
+                type = result.mimeType
+                putExtra(Intent.EXTRA_TITLE, result.fileName)
+            }
+        launcher.launch(intent)
+    }
+}

feature/discovery/src/androidMain/kotlin/org/meshtastic/feature/discovery/export/PdfDiscoveryExporter.kt

@@ -0,0 +1,230 @@
+/*
+ * Copyright (c) 2026 Meshtastic LLC
+ *
+ * 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 org.meshtastic.feature.discovery.export
+
+import android.graphics.Paint
+import android.graphics.pdf.PdfDocument
+import kotlinx.coroutines.withContext
+import org.koin.core.annotation.Single
+import org.meshtastic.core.common.util.ioDispatcher
+import java.io.ByteArrayOutputStream
+
+private const val PAGE_WIDTH = 612
+private const val PAGE_HEIGHT = 792
+private const val MARGIN_LEFT = 40f
+private const val MARGIN_TOP = 50f
+private const val LINE_HEIGHT = 18f
+private const val SECTION_GAP = 12f
+private const val TITLE_SIZE = 18f
+private const val HEADING_SIZE = 14f
+private const val BODY_SIZE = 10f
+private const val LABEL_SIZE = 9f
+private const val FOOTER_SIZE = 8f
+private const val PAGE_BOTTOM_MARGIN = 60f
+private const val LABEL_COLUMN_WIDTH = 160f
+
+@Single
+class PdfDiscoveryExporter : DiscoveryExporter {
+
+    override suspend fun export(data: DiscoveryExportData): ExportResult = withContext(ioDispatcher) {
+        @Suppress("TooGenericExceptionCaught")
+        try {
+            val bytes = renderPdf(data)
+            val fileName = DiscoveryReportFormatter.generateFileName(data.session, "pdf")
+            ExportResult.Success(content = bytes, mimeType = "application/pdf", fileName = fileName)
+        } catch (e: Exception) {
+            ExportResult.Error("PDF generation failed: ${e.message}")
+        }
+    }
+
+    private fun renderPdf(data: DiscoveryExportData): ByteArray {
+        val document = PdfDocument()
+        val renderer = PageRenderer(document)
+
+        renderer.drawTitle("Meshtastic Discovery Report")
+        renderer.advanceLine()
+
+        // Session overview
+        renderer.drawHeading("Session Overview")
+        for ((label, value) in DiscoveryReportFormatter.formatSessionOverviewLines(data.session)) {
+            renderer.drawLabelValue(label, value)
+        }
+        renderer.advanceSection()
+
+        // Per-preset sections
+        for (result in data.presetResults) {
+            renderer.drawHeading("Preset: ${result.presetName}")
+            for ((label, value) in DiscoveryReportFormatter.formatPresetLines(result)) {
+                renderer.drawLabelValue(label, value)
+            }
+
+            val nodes = data.nodesByPreset[result.id].orEmpty()
+            if (nodes.isNotEmpty()) {
+                renderer.advanceLine()
+                renderer.drawSubheading("Discovered Nodes (${nodes.size})")
+                for (node in nodes) {
+                    renderer.drawBody(DiscoveryReportFormatter.formatNodeLine(node))
+                }
+            }
+            renderer.advanceSection()
+        }
+
+        // AI summary
+        val summary = data.session.aiSummary
+        if (!summary.isNullOrBlank()) {
+            renderer.drawHeading("AI Analysis")
+            renderer.drawWrappedBody(summary)
+            renderer.advanceSection()
+        }
+
+        renderer.drawFooter("Generated by Meshtastic Android")
+        renderer.finishCurrentPage()
+
+        val outputStream = ByteArrayOutputStream()
+        document.writeTo(outputStream)
+        document.close()
+        return outputStream.toByteArray()
+    }
+
+    @Suppress("TooManyFunctions")
+    private class PageRenderer(private val document: PdfDocument) {
+        private var pageNumber = 0
+        private var currentPage: PdfDocument.Page? = null
+        private var yPosition = MARGIN_TOP
+
+        private val titlePaint =
+            Paint().apply {
+                textSize = TITLE_SIZE
+                isFakeBoldText = true
+                isAntiAlias = true
+            }
+        private val headingPaint =
+            Paint().apply {
+                textSize = HEADING_SIZE
+                isFakeBoldText = true
+                isAntiAlias = true
+            }
+        private val bodyPaint =
+            Paint().apply {
+                textSize = BODY_SIZE
+                isAntiAlias = true
+            }
+        private val labelPaint =
+            Paint().apply {
+                textSize = LABEL_SIZE
+                isAntiAlias = true
+                color = android.graphics.Color.DKGRAY
+            }
+        private val footerPaint =
+            Paint().apply {
+                textSize = FOOTER_SIZE
+                isAntiAlias = true
+                color = android.graphics.Color.GRAY
+            }
+
+        private fun ensurePage() {
+            if (currentPage == null) {
+                pageNumber++
+                val pageInfo = PdfDocument.PageInfo.Builder(PAGE_WIDTH, PAGE_HEIGHT, pageNumber).create()
+                currentPage = document.startPage(pageInfo)
+                yPosition = MARGIN_TOP
+            }
+        }
+
+        private fun checkPageBreak(linesNeeded: Int = 1) {
+            if (yPosition + linesNeeded * LINE_HEIGHT > PAGE_HEIGHT - PAGE_BOTTOM_MARGIN) {
+                finishCurrentPage()
+                ensurePage()
+            }
+        }
+
+        fun finishCurrentPage() {
+            currentPage?.let { document.finishPage(it) }
+            currentPage = null
+        }
+
+        fun drawTitle(text: String) {
+            ensurePage()
+            currentPage?.canvas?.drawText(text, MARGIN_LEFT, yPosition, titlePaint)
+            yPosition += LINE_HEIGHT + SECTION_GAP
+        }
+
+        fun drawHeading(text: String) {
+            checkPageBreak(linesNeeded = 2)
+            ensurePage()
+            currentPage?.canvas?.drawText(text, MARGIN_LEFT, yPosition, headingPaint)
+            yPosition += LINE_HEIGHT
+        }
+
+        fun drawSubheading(text: String) {
+            checkPageBreak()
+            ensurePage()
+            currentPage?.canvas?.drawText(text, MARGIN_LEFT, yPosition, bodyPaint.apply { isFakeBoldText = true })
+            bodyPaint.isFakeBoldText = false
+            yPosition += LINE_HEIGHT
+        }
+
+        fun drawBody(text: String) {
+            checkPageBreak()
+            ensurePage()
+            currentPage?.canvas?.drawText(text, MARGIN_LEFT, yPosition, bodyPaint)
+            yPosition += LINE_HEIGHT
+        }
+
+        fun drawLabelValue(label: String, value: String) {
+            checkPageBreak()
+            ensurePage()
+            currentPage?.canvas?.let { canvas ->
+                canvas.drawText("$label:", MARGIN_LEFT, yPosition, labelPaint)
+                canvas.drawText(value, MARGIN_LEFT + LABEL_COLUMN_WIDTH, yPosition, bodyPaint)
+            }
+            yPosition += LINE_HEIGHT
+        }
+
+        fun drawWrappedBody(text: String) {
+            val maxWidth = PAGE_WIDTH - MARGIN_LEFT * 2
+            val words = text.split(" ")
+            var currentLine = StringBuilder()
+
+            for (word in words) {
+                val testLine = if (currentLine.isEmpty()) word else "$currentLine $word"
+                if (bodyPaint.measureText(testLine) > maxWidth && currentLine.isNotEmpty()) {
+                    drawBody(currentLine.toString())
+                    currentLine = StringBuilder(word)
+                } else {
+                    currentLine = StringBuilder(testLine)
+                }
+            }
+            if (currentLine.isNotEmpty()) {
+                drawBody(currentLine.toString())
+            }
+        }
+
+        fun drawFooter(text: String) {
+            ensurePage()
+            currentPage?.canvas?.drawText(text, MARGIN_LEFT, PAGE_HEIGHT - MARGIN_TOP / 2, footerPaint)
+        }
+
+        fun advanceLine() {
+            yPosition += LINE_HEIGHT
+        }
+
+        fun advanceSection() {
+            yPosition += SECTION_GAP
+        }
+    }
+}

feature/discovery/src/commonMain/kotlin/org/meshtastic/feature/discovery/DiscoveryHistoryDetailViewModel.kt

@@ -0,0 +1,61 @@
+/*
+ * Copyright (c) 2026 Meshtastic LLC
+ *
+ * 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 org.meshtastic.feature.discovery
+
+import androidx.lifecycle.ViewModel
+import kotlinx.coroutines.flow.MutableStateFlow
+import kotlinx.coroutines.flow.StateFlow
+import kotlinx.coroutines.flow.asStateFlow
+import org.koin.core.annotation.InjectedParam
+import org.koin.core.annotation.KoinViewModel
+import org.meshtastic.core.database.dao.DiscoveryDao
+import org.meshtastic.core.database.entity.DiscoveredNodeEntity
+import org.meshtastic.core.database.entity.DiscoveryPresetResultEntity
+import org.meshtastic.core.database.entity.DiscoverySessionEntity
+import org.meshtastic.core.ui.viewmodel.safeLaunch
+import org.meshtastic.core.ui.viewmodel.stateInWhileSubscribed
+
+@KoinViewModel
+class DiscoveryHistoryDetailViewModel(
+    @InjectedParam private val sessionId: Long,
+    private val discoveryDao: DiscoveryDao,
+) : ViewModel() {
+
+    val session: StateFlow<DiscoverySessionEntity?> =
+        discoveryDao.getSessionFlow(sessionId).stateInWhileSubscribed(initialValue = null)
+
+    val presetResults: StateFlow<List<DiscoveryPresetResultEntity>> =
+        discoveryDao.getPresetResultsFlow(sessionId).stateInWhileSubscribed(initialValue = emptyList())
+
+    private val _nodesByPreset = MutableStateFlow<Map<Long, List<DiscoveredNodeEntity>>>(emptyMap())
+    val nodesByPreset: StateFlow<Map<Long, List<DiscoveredNodeEntity>>> = _nodesByPreset.asStateFlow()
+
+    init {
+        loadNodes()
+    }
+
+    private fun loadNodes() {
+        safeLaunch(tag = "loadNodes") {
+            val results = discoveryDao.getPresetResults(sessionId)
+            val nodesMap = mutableMapOf<Long, List<DiscoveredNodeEntity>>()
+            for (result in results) {
+                nodesMap[result.id] = discoveryDao.getDiscoveredNodes(result.id)
+            }
+            _nodesByPreset.value = nodesMap
+        }
+    }
+}

feature/discovery/src/commonMain/kotlin/org/meshtastic/feature/discovery/DiscoveryHistoryViewModel.kt

@@ -0,0 +1,36 @@
+/*
+ * Copyright (c) 2026 Meshtastic LLC
+ *
+ * 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 org.meshtastic.feature.discovery
+
+import androidx.lifecycle.ViewModel
+import kotlinx.coroutines.flow.StateFlow
+import org.koin.core.annotation.KoinViewModel
+import org.meshtastic.core.database.dao.DiscoveryDao
+import org.meshtastic.core.database.entity.DiscoverySessionEntity
+import org.meshtastic.core.ui.viewmodel.safeLaunch
+import org.meshtastic.core.ui.viewmodel.stateInWhileSubscribed
+
+@KoinViewModel
+class DiscoveryHistoryViewModel(private val discoveryDao: DiscoveryDao) : ViewModel() {
+
+    val sessions: StateFlow<List<DiscoverySessionEntity>> =
+        discoveryDao.getAllSessions().stateInWhileSubscribed(initialValue = emptyList())
+
+    fun deleteSession(sessionId: Long) {
+        safeLaunch(tag = "deleteSession") { discoveryDao.deleteSession(sessionId) }
+    }
+}

feature/discovery/src/commonMain/kotlin/org/meshtastic/feature/discovery/DiscoveryMapViewModel.kt

@@ -0,0 +1,116 @@
+/*
+ * Copyright (c) 2026 Meshtastic LLC
+ *
+ * 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 org.meshtastic.feature.discovery
+
+import androidx.lifecycle.ViewModel
+import kotlinx.coroutines.flow.MutableStateFlow
+import kotlinx.coroutines.flow.StateFlow
+import kotlinx.coroutines.flow.asStateFlow
+import kotlinx.coroutines.flow.combine
+import org.koin.core.annotation.InjectedParam
+import org.koin.core.annotation.KoinViewModel
+import org.meshtastic.core.database.dao.DiscoveryDao
+import org.meshtastic.core.database.entity.DiscoveredNodeEntity
+import org.meshtastic.core.database.entity.DiscoveryPresetResultEntity
+import org.meshtastic.core.database.entity.DiscoverySessionEntity
+import org.meshtastic.core.ui.viewmodel.safeLaunch
+import org.meshtastic.core.ui.viewmodel.stateInWhileSubscribed
+
+@KoinViewModel
+class DiscoveryMapViewModel(@InjectedParam private val sessionId: Long, private val discoveryDao: DiscoveryDao) :
+    ViewModel() {
+
+    val session: StateFlow<DiscoverySessionEntity?> =
+        discoveryDao.getSessionFlow(sessionId).stateInWhileSubscribed(initialValue = null)
+
+    /** All preset results for this session. Used for filter chip UI. */
+    private val presetResultsState = MutableStateFlow<List<DiscoveryPresetResultEntity>>(emptyList())
+    val presetResults: StateFlow<List<DiscoveryPresetResultEntity>> = presetResultsState.asStateFlow()
+
+    /** Nodes keyed by preset result ID. */
+    private val nodesByPresetState = MutableStateFlow<Map<Long, List<DiscoveredNodeEntity>>>(emptyMap())
+
+    /**
+     * Currently selected preset filter. `null` means "All presets" (deduplicated). Set to a preset result ID to show
+     * only nodes discovered under that preset.
+     */
+    private val selectedPresetFilterState = MutableStateFlow<Long?>(null)
+    val selectedPresetFilter: StateFlow<Long?> = selectedPresetFilterState.asStateFlow()
+
+    /** Whether the topology overlay (neighbor connections) is visible. */
+    private val showTopologyOverlayState = MutableStateFlow(false)
+    val showTopologyOverlay: StateFlow<Boolean> = showTopologyOverlayState.asStateFlow()
+
+    /** Filtered and deduplicated nodes based on the current preset filter. */
+    val filteredNodes: StateFlow<List<DiscoveredNodeEntity>> =
+        combine(nodesByPresetState, selectedPresetFilterState) { nodesByPreset, filter ->
+            val raw =
+                if (filter == null) {
+                    nodesByPreset.values.flatten()
+                } else {
+                    nodesByPreset[filter].orEmpty()
+                }
+            // Deduplicate by nodeNum — keep the entry with strongest signal
+            raw.groupBy { it.nodeNum }.values.map { dupes -> dupes.maxByOrNull { it.snr } ?: dupes.first() }
+        }
+            .stateInWhileSubscribed(initialValue = emptyList())
+
+    /** Map statistics: how many nodes have valid GPS coordinates vs total. */
+    val mapStats: StateFlow<DiscoveryMapStats> =
+        combine(filteredNodes, nodesByPresetState) { filtered, _ ->
+            val mappedCount = filtered.count { hasValidCoordinates(it.latitude, it.longitude) }
+            DiscoveryMapStats(
+                totalNodes = filtered.size,
+                mappedNodes = mappedCount,
+                unmappedNodes = filtered.size - mappedCount,
+            )
+        }
+            .stateInWhileSubscribed(initialValue = DiscoveryMapStats())
+
+    // Keep backward-compatible allNodes as alias to filteredNodes
+    val allNodes: StateFlow<List<DiscoveredNodeEntity>> = filteredNodes
+
+    init {
+        loadAllNodes()
+    }
+
+    fun selectPresetFilter(presetResultId: Long?) {
+        selectedPresetFilterState.value = presetResultId
+    }
+
+    fun toggleTopologyOverlay() {
+        showTopologyOverlayState.value = !showTopologyOverlayState.value
+    }
+
+    private fun loadAllNodes() {
+        safeLaunch(tag = "loadAllNodes") {
+            val results = discoveryDao.getPresetResults(sessionId)
+            presetResultsState.value = results
+            val nodesMap = mutableMapOf<Long, List<DiscoveredNodeEntity>>()
+            for (result in results) {
+                nodesMap[result.id] = discoveryDao.getDiscoveredNodes(result.id)
+            }
+            nodesByPresetState.value = nodesMap
+        }
+    }
+
+    private fun hasValidCoordinates(lat: Double?, lon: Double?): Boolean =
+        lat != null && lon != null && lat != 0.0 && lon != 0.0
+}
+
+/** Presentation model for map node statistics. */
+data class DiscoveryMapStats(val totalNodes: Int = 0, val mappedNodes: Int = 0, val unmappedNodes: Int = 0)

feature/discovery/src/commonMain/kotlin/org/meshtastic/feature/discovery/DiscoveryScanEngine.kt

@@ -0,0 +1,677 @@
+/*
+ * Copyright (c) 2026 Meshtastic LLC
+ *
+ * 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/>.
+ */
+@file:Suppress("TooManyFunctions", "MagicNumber")
+
+package org.meshtastic.feature.discovery
+
+import co.touchlab.kermit.Logger
+import kotlinx.coroutines.CoroutineScope
+import kotlinx.coroutines.Job
+import kotlinx.coroutines.SupervisorJob
+import kotlinx.coroutines.cancel
+import kotlinx.coroutines.delay
+import kotlinx.coroutines.flow.MutableStateFlow
+import kotlinx.coroutines.flow.StateFlow
+import kotlinx.coroutines.flow.asStateFlow
+import kotlinx.coroutines.flow.first
+import kotlinx.coroutines.launch
+import kotlinx.coroutines.sync.Mutex
+import kotlinx.coroutines.sync.withLock
+import kotlinx.coroutines.withTimeoutOrNull
+import org.koin.core.annotation.Single
+import org.meshtastic.core.common.di.ApplicationCoroutineScope
+import org.meshtastic.core.common.util.latLongToMeter
+import org.meshtastic.core.common.util.nowMillis
+import org.meshtastic.core.database.dao.DiscoveryDao
+import org.meshtastic.core.database.entity.DiscoveredNodeEntity
+import org.meshtastic.core.database.entity.DiscoveryPresetResultEntity
+import org.meshtastic.core.database.entity.DiscoverySessionEntity
+import org.meshtastic.core.di.CoroutineDispatchers
+import org.meshtastic.core.model.ChannelOption
+import org.meshtastic.core.model.ConnectionState
+import org.meshtastic.core.model.DataPacket
+import org.meshtastic.core.model.util.decodeOrNull
+import org.meshtastic.core.repository.DiscoveryPacketCollector
+import org.meshtastic.core.repository.DiscoveryPacketCollectorRegistry
+import org.meshtastic.core.repository.NodeRepository
+import org.meshtastic.core.repository.RadioConfigRepository
+import org.meshtastic.core.repository.RadioController
+import org.meshtastic.core.repository.ServiceRepository
+import org.meshtastic.feature.discovery.ai.DiscoverySummaryAiProvider
+import org.meshtastic.proto.Config
+import org.meshtastic.proto.MeshPacket
+import org.meshtastic.proto.NeighborInfo
+import org.meshtastic.proto.PortNum
+import org.meshtastic.proto.Position
+import org.meshtastic.proto.Telemetry
+
+/**
+ * Core scan engine for Local Mesh Discovery.
+ *
+ * Cycles through a queue of LoRa presets, dwells on each for a configured duration while collecting packets, then
+ * persists aggregated results via [DiscoveryDao].
+ */
+@Single
+@Suppress("LongParameterList")
+class DiscoveryScanEngine(
+    private val radioController: RadioController,
+    private val serviceRepository: ServiceRepository,
+    private val nodeRepository: NodeRepository,
+    private val radioConfigRepository: RadioConfigRepository,
+    private val collectorRegistry: DiscoveryPacketCollectorRegistry,
+    private val discoveryDao: DiscoveryDao,
+    private val aiProvider: DiscoverySummaryAiProvider,
+    private val applicationScope: ApplicationCoroutineScope,
+    private val dispatchers: CoroutineDispatchers,
+) : DiscoveryPacketCollector {
+
+    // region Public state
+
+    private val _scanState = MutableStateFlow<DiscoveryScanState>(DiscoveryScanState.Idle)
+    val scanState: StateFlow<DiscoveryScanState> = _scanState.asStateFlow()
+
+    private val _currentSession = MutableStateFlow<DiscoverySessionEntity?>(null)
+    val currentSession: StateFlow<DiscoverySessionEntity?> = _currentSession.asStateFlow()
+
+    override val isActive: Boolean
+        get() =
+            _scanState.value !is DiscoveryScanState.Idle &&
+                _scanState.value !is DiscoveryScanState.Complete &&
+                _scanState.value !is DiscoveryScanState.Failed
+
+    // endregion
+
+    // region Internal scan state
+
+    private val mutex = Mutex()
+    private var scanScope: CoroutineScope? = null
+    private var dwellJob: Job? = null
+    private var originalLoRaConfig: Config.LoRaConfig? = null
+    private var sessionId: Long = 0
+
+    /** Nodes collected for the current preset dwell. Keyed by nodeNum. */
+    private val collectedNodes = mutableMapOf<Long, CollectedNodeData>()
+
+    /** DeviceMetrics entries per node for the 2-packet rule. Keyed by nodeNum. */
+    private val deviceMetricsLog = mutableMapOf<Long, MutableList<DeviceMetricsEntry>>()
+
+    private var currentPresetName: String = ""
+    private var totalDwellSeconds: Long = 0
+    private var lastLocalStats: org.meshtastic.proto.LocalStats? = null
+
+    // endregion
+
+    // region Internal data classes
+
+    private data class CollectedNodeData(
+        var nodeNum: Long,
+        var shortName: String? = null,
+        var longName: String? = null,
+        var neighborType: String = "direct",
+        var latitude: Double? = null,
+        var longitude: Double? = null,
+        var snr: Float = 0f,
+        var rssi: Int = 0,
+        var hopCount: Int = 0,
+        var messageCount: Int = 0,
+        var sensorPacketCount: Int = 0,
+        var isInfrastructure: Boolean = false,
+    )
+
+    private data class DeviceMetricsEntry(val timestamp: Long, val channelUtil: Double, val airUtilTx: Double)
+
+    // endregion
+
+    // region Public API
+
+    /**
+     * Starts a discovery scan across the given [presets].
+     *
+     * @param presets The LoRa presets to cycle through.
+     * @param dwellDurationSeconds How long to listen on each preset.
+     */
+    suspend fun startScan(presets: List<ChannelOption>, dwellDurationSeconds: Long) {
+        require(presets.isNotEmpty()) { "At least one preset is required" }
+        require(dwellDurationSeconds > 0) { "Dwell duration must be positive" }
+
+        mutex.withLock {
+            if (isActive) {
+                Logger.w { "DiscoveryScanEngine: scan already active, ignoring startScan" }
+                return
+            }
+
+            _scanState.value = DiscoveryScanState.Preparing
+
+            // Capture the entire original LoRa config to restore it accurately later
+            val initialLoraConfig = radioConfigRepository.localConfigFlow.first().lora
+            originalLoRaConfig = initialLoraConfig
+
+            val homePresetStr =
+                if (initialLoraConfig?.use_preset == true) {
+                    ChannelOption.from(initialLoraConfig.modem_preset)?.name ?: ChannelOption.DEFAULT.name
+                } else {
+                    "CUSTOM"
+                }
+
+            val myNodeNum = nodeRepository.myNodeInfo.value?.myNodeNum
+            val myPosition = myNodeNum?.let { nodeRepository.nodeDBbyNum.value[it]?.position }
+            val latDouble = (myPosition?.latitude_i ?: 0).toDouble() / POSITION_DIVISOR
+            val lonDouble = (myPosition?.longitude_i ?: 0).toDouble() / POSITION_DIVISOR
+
+            // Create the DB session
+            val session =
+                DiscoverySessionEntity(
+                    timestamp = nowMillis,
+                    presetsScanned = presets.joinToString(",") { it.name },
+                    homePreset = homePresetStr,
+                    completionStatus = "in_progress",
+                    userLatitude = latDouble,
+                    userLongitude = lonDouble,
+                )
+            sessionId = discoveryDao.insertSession(session)
+            _currentSession.value = session.copy(id = sessionId)
+
+            // Register as packet collector
+            collectorRegistry.collector = this
+
+            // Set initial state so the scan loop's isActive guard succeeds
+            _scanState.value = DiscoveryScanState.Shifting(presets.first().name)
+            currentPresetName = presets.first().name
+            totalDwellSeconds = dwellDurationSeconds
+
+            // Launch scan coroutine
+            val scope = CoroutineScope(dispatchers.io + SupervisorJob())
+            scanScope = scope
+            scope.launch { runScanLoop(presets, dwellDurationSeconds) }
+        }
+    }
+
+    /** Stops the active scan and restores the home preset. */
+    suspend fun stopScan() {
+        mutex.withLock {
+            if (!isActive) return
+            Logger.i { "DiscoveryScanEngine: stopping scan" }
+            _scanState.value = DiscoveryScanState.Cancelling
+            cancelScanInternal()
+        }
+        persistCurrentDwellResults()
+        finalizeSession("stopped")
+        _scanState.value = DiscoveryScanState.Complete(DiscoveryScanState.CompletionOutcome.Cancelled)
+
+        // Restore home preset in the background so we don't block the UI with the connection wait
+        applicationScope.launch { restoreHomePreset() }
+    }
+
+    /** Resets engine state after the UI has acknowledged completion. */
+    fun reset() {
+        _scanState.value = DiscoveryScanState.Idle
+        _currentSession.value = null
+    }
+
+    // endregion
+
+    // region DiscoveryPacketCollector
+
+    override suspend fun onPacketReceived(meshPacket: MeshPacket, dataPacket: DataPacket) {
+        if (_scanState.value !is DiscoveryScanState.Dwell) return
+        val fromNum = meshPacket.from.toLong()
+        val portNum = meshPacket.decoded?.portnum ?: return
+
+        mutex.withLock {
+            val node = collectedNodes.getOrPut(fromNum) { CollectedNodeData(nodeNum = fromNum) }
+            // Update signal info from the direct packet
+            if (meshPacket.rx_snr != 0f) node.snr = meshPacket.rx_snr
+            if (meshPacket.rx_rssi != 0) node.rssi = meshPacket.rx_rssi
+            node.hopCount = dataPacket.hopsAway.coerceAtLeast(0)
+
+            when (portNum) {
+                PortNum.TEXT_MESSAGE_APP -> node.messageCount++
+                PortNum.POSITION_APP -> handlePosition(meshPacket, node)
+                PortNum.TELEMETRY_APP -> handleTelemetry(meshPacket, node, fromNum)
+                PortNum.NEIGHBORINFO_APP -> handleNeighborInfo(meshPacket)
+                else -> Unit
+            }
+
+            // Enrich the sending node from the local NodeDB (names/position fallback)
+            enrichNodeFromDb(node)
+        }
+    }
+
+    /** Backfills name, position, and infrastructure role from the local NodeDB when not yet received over-the-air. */
+    private fun enrichNodeFromDb(node: CollectedNodeData) {
+        val dbNode = nodeRepository.nodeDBbyNum.value[node.nodeNum.toInt()] ?: return
+        if (node.shortName == null || node.longName == null) {
+            node.shortName = dbNode.user.short_name.ifBlank { null }
+            node.longName = dbNode.user.long_name.ifBlank { null }
+        }
+        if (!hasValidCoordinates(node.latitude, node.longitude)) {
+            val dbLat = dbNode.position.latitude_i
+            val dbLon = dbNode.position.longitude_i
+            if (dbLat != null && dbLat != 0) node.latitude = dbLat.toDouble() / POSITION_DIVISOR
+            if (dbLon != null && dbLon != 0) node.longitude = dbLon.toDouble() / POSITION_DIVISOR
+        }
+        node.isInfrastructure = dbNode.user.role in INFRASTRUCTURE_ROLES
+    }
+
+    // endregion
+
+    // region Scan loop
+
+    @Suppress("ReturnCount")
+    private suspend fun runScanLoop(presets: List<ChannelOption>, dwellDurationSeconds: Long) {
+        for (preset in presets) {
+            if (!isActive) return
+
+            currentPresetName = preset.name
+            mutex.withLock {
+                collectedNodes.clear()
+                deviceMetricsLog.clear()
+                lastLocalStats = null
+            }
+            totalDwellSeconds = dwellDurationSeconds
+
+            // Shift to the new preset
+            _scanState.value = DiscoveryScanState.Shifting(preset.name)
+            shiftPreset(preset)
+
+            // Wait for reconnection
+            _scanState.value = DiscoveryScanState.Reconnecting(preset.name)
+            if (!waitForConnection()) {
+                pauseAndAbort()
+                return
+            }
+
+            // Request neighbor info at dwell start to seed mesh topology data (D020)
+            requestNeighborInfoAtDwellBoundary()
+
+            // Dwell
+            if (!runDwell(preset.name, dwellDurationSeconds)) {
+                pauseAndAbort()
+                return
+            }
+            if (!isActive) return
+
+            // Persist this preset's results
+            persistCurrentDwellResults()
+        }
+
+        // All presets scanned — unregister packet collector before analysis
+        collectorRegistry.collector = null
+        _scanState.value = DiscoveryScanState.Analysis
+        restoreHomePreset()
+        generateAiSummaries()
+        finalizeSession("complete")
+        _scanState.value = DiscoveryScanState.Complete(DiscoveryScanState.CompletionOutcome.Success)
+    }
+
+    /** Common cleanup path when a scan step fails mid-loop. */
+    private suspend fun pauseAndAbort() {
+        _scanState.value = DiscoveryScanState.Failed("Connection lost during scan")
+        cancelScanInternal()
+        restoreHomePreset()
+        finalizeSession("failed")
+        _scanState.value = DiscoveryScanState.Complete(DiscoveryScanState.CompletionOutcome.Failed)
+    }
+
+    private suspend fun shiftPreset(preset: ChannelOption) {
+        val loraConfig = Config.LoRaConfig(use_preset = true, modem_preset = preset.modemPreset)
+        val config = Config(lora = loraConfig)
+        radioController.setLocalConfig(config)
+        Logger.i { "DiscoveryScanEngine: shifted to ${preset.name} (use_preset=true)" }
+        // The firmware often restarts the radio or reboots after a LoRa config change.
+        // Wait a short moment to ensure we don't consider it 'connected' right before it drops.
+        delay(3000)
+    }
+
+    private suspend fun waitForConnection(): Boolean {
+        val result =
+            withTimeoutOrNull(RECONNECT_TIMEOUT_MS) {
+                serviceRepository.connectionState.first { it is ConnectionState.Connected }
+            }
+        return result != null
+    }
+
+    /**
+     * Requests NeighborInfo from the local node at each dwell boundary to seed mesh topology data. The response arrives
+     * via the normal packet pipeline → [handleNeighborInfo].
+     */
+    private suspend fun requestNeighborInfoAtDwellBoundary() {
+        val myNodeNum = nodeRepository.myNodeInfo.value?.myNodeNum ?: return
+        val packetId = radioController.generatePacketId()
+        radioController.requestNeighborInfo(packetId, myNodeNum)
+        Logger.d { "DiscoveryScanEngine: requested NeighborInfo from local node $myNodeNum (packetId=$packetId)" }
+    }
+
+    private suspend fun runDwell(presetName: String, durationSeconds: Long): Boolean {
+        var remaining = durationSeconds
+        while (remaining > 0 && isActive) {
+            val isConnected = serviceRepository.connectionState.value is ConnectionState.Connected
+            if (!isConnected) {
+                _scanState.value = DiscoveryScanState.Reconnecting(presetName)
+                val reconnected = waitForConnection()
+                if (!reconnected) return false
+                continue
+            }
+
+            _scanState.value =
+                DiscoveryScanState.Dwell(
+                    presetName = presetName,
+                    remainingSeconds = remaining,
+                    totalSeconds = durationSeconds,
+                )
+            delay(TICK_INTERVAL_MS)
+            remaining--
+        }
+        return true
+    }
+
+    // endregion
+
+    // region Packet handlers
+
+    private fun handlePosition(meshPacket: MeshPacket, node: CollectedNodeData) {
+        val payload = meshPacket.decoded?.payload ?: return
+        val pos = Position.ADAPTER.decodeOrNull(payload, Logger) ?: return
+        val lat = pos.latitude_i
+        val lon = pos.longitude_i
+        if (lat != null && lat != 0) node.latitude = lat / POSITION_DIVISOR
+        if (lon != null && lon != 0) node.longitude = lon / POSITION_DIVISOR
+    }
+
+    private fun handleTelemetry(meshPacket: MeshPacket, node: CollectedNodeData, fromNum: Long) {
+        val payload = meshPacket.decoded?.payload ?: return
+        val telemetry = Telemetry.ADAPTER.decodeOrNull(payload, Logger) ?: return
+
+        val deviceMetrics = telemetry.device_metrics
+        if (deviceMetrics != null) {
+            val entries = deviceMetricsLog.getOrPut(fromNum) { mutableListOf() }
+            entries.add(
+                DeviceMetricsEntry(
+                    timestamp = nowMillis,
+                    channelUtil = deviceMetrics.channel_utilization?.toDouble() ?: 0.0,
+                    airUtilTx = deviceMetrics.air_util_tx?.toDouble() ?: 0.0,
+                ),
+            )
+        }
+
+        if (telemetry.local_stats != null) {
+            lastLocalStats = telemetry.local_stats
+        }
+
+        if (telemetry.environment_metrics != null) {
+            node.sensorPacketCount++
+        }
+    }
+
+    private fun handleNeighborInfo(meshPacket: MeshPacket) {
+        val payload = meshPacket.decoded?.payload ?: return
+        val ni = NeighborInfo.ADAPTER.decodeOrNull(payload, Logger) ?: return
+        for (neighbor in ni.neighbors) {
+            val neighborNum = neighbor.node_id.toLong()
+            val node =
+                collectedNodes.getOrPut(neighborNum) { CollectedNodeData(nodeNum = neighborNum, neighborType = "mesh") }
+            // Only mark as mesh if not already seen directly
+            if (node.snr == 0f && node.rssi == 0) {
+                node.neighborType = "mesh"
+            }
+        }
+    }
+
+    // endregion
+
+    // region Persistence
+
+    @Suppress("ReturnCount")
+    private suspend fun generateAiSummaries() {
+        if (sessionId == 0L || !aiProvider.isAvailable) return
+        val session = discoveryDao.getSession(sessionId) ?: return
+        val presetResults = discoveryDao.getPresetResults(sessionId)
+        if (presetResults.isEmpty()) return
+
+        // Generate per-preset AI summaries
+        for (result in presetResults) {
+            val presetSummary = aiProvider.generatePresetSummary(result)
+            if (presetSummary != null) {
+                discoveryDao.updatePresetResult(result.copy(aiSummary = presetSummary))
+            }
+        }
+
+        // Generate session-level AI summary
+        val sessionSummary = aiProvider.generateSessionSummary(session, presetResults)
+        if (sessionSummary != null) {
+            discoveryDao.updateSession(session.copy(aiSummary = sessionSummary))
+        }
+    }
+
+    private suspend fun persistCurrentDwellResults() {
+        if (sessionId == 0L) return
+        mutex.withLock {
+            if (collectedNodes.isEmpty()) {
+                persistEmptyPresetResult()
+                return
+            }
+
+            val presetResultId = persistPresetResult()
+            persistDiscoveredNodes(presetResultId)
+        }
+    }
+
+    private suspend fun persistEmptyPresetResult() {
+        val emptyResult =
+            DiscoveryPresetResultEntity(
+                sessionId = sessionId,
+                presetName = currentPresetName,
+                dwellDurationSeconds = totalDwellSeconds,
+            )
+        discoveryDao.insertPresetResult(emptyResult)
+    }
+
+    private suspend fun persistPresetResult(): Long {
+        val (avgChannelUtil, avgAirUtil) = computeAverageMetrics()
+        val directCount = collectedNodes.values.count { it.neighborType == "direct" }
+        val meshCount = collectedNodes.values.count { it.neighborType == "mesh" }
+        val infraCount = collectedNodes.values.count { it.isInfrastructure }
+
+        val packetsRx = lastLocalStats?.num_packets_rx ?: 0
+        val packetsRxBad = lastLocalStats?.num_packets_rx_bad ?: 0
+        val (successRate, failureRate) = computePacketRates(packetsRx, packetsRxBad)
+
+        val presetResult =
+            DiscoveryPresetResultEntity(
+                sessionId = sessionId,
+                presetName = currentPresetName,
+                dwellDurationSeconds = totalDwellSeconds,
+                uniqueNodes = collectedNodes.size,
+                directNeighborCount = directCount,
+                meshNeighborCount = meshCount,
+                infrastructureNodeCount = infraCount,
+                messageCount = collectedNodes.values.sumOf { it.messageCount },
+                sensorPacketCount = collectedNodes.values.sumOf { it.sensorPacketCount },
+                avgChannelUtilization = avgChannelUtil,
+                avgAirtimeRate = avgAirUtil,
+                packetSuccessRate = successRate,
+                packetFailureRate = failureRate,
+                numPacketsTx = lastLocalStats?.num_packets_tx ?: 0,
+                numPacketsRx = packetsRx,
+                numPacketsRxBad = packetsRxBad,
+                numRxDupe = lastLocalStats?.num_rx_dupe ?: 0,
+                numTxRelay = lastLocalStats?.num_tx_relay ?: 0,
+                numTxRelayCanceled = lastLocalStats?.num_tx_relay_canceled ?: 0,
+                numOnlineNodes = lastLocalStats?.num_online_nodes ?: 0,
+                numTotalNodes = lastLocalStats?.num_total_nodes ?: 0,
+                uptimeSeconds = lastLocalStats?.uptime_seconds ?: 0,
+            )
+        return discoveryDao.insertPresetResult(presetResult)
+    }
+
+    /**
+     * Computes packet success and failure rates as percentages (0–100) from LocalStats counters. Returns (successRate,
+     * failureRate). Both are 0.0 if no packets were received.
+     */
+    private fun computePacketRates(packetsRx: Int, packetsRxBad: Int): Pair<Double, Double> {
+        if (packetsRx <= 0) return 0.0 to 0.0
+        val failureRate = (packetsRxBad.toDouble() / packetsRx) * PERCENT_MULTIPLIER
+        val successRate = PERCENT_MULTIPLIER - failureRate
+        return successRate to failureRate
+    }
+
+    private suspend fun persistDiscoveredNodes(presetResultId: Long) {
+        val session = discoveryDao.getSession(sessionId)
+        val userLat = session?.userLatitude ?: 0.0
+        val userLon = session?.userLongitude ?: 0.0
+
+        val nodeEntities = collectedNodes.values.map { data -> data.toEntity(presetResultId, userLat, userLon) }
+        discoveryDao.insertDiscoveredNodes(nodeEntities)
+    }
+
+    private fun CollectedNodeData.toEntity(
+        presetResultId: Long,
+        userLat: Double,
+        userLon: Double,
+    ): DiscoveredNodeEntity {
+        val distance =
+            if (hasValidCoordinates(latitude, longitude) && hasValidCoordinates(userLat, userLon)) {
+                latLongToMeter(userLat, userLon, latitude!!, longitude!!)
+            } else {
+                null
+            }
+        return DiscoveredNodeEntity(
+            presetResultId = presetResultId,
+            nodeNum = nodeNum,
+            shortName = shortName,
+            longName = longName,
+            neighborType = neighborType,
+            latitude = latitude,
+            longitude = longitude,
+            distanceFromUser = distance,
+            hopCount = hopCount,
+            snr = snr,
+            rssi = rssi,
+            messageCount = messageCount,
+            sensorPacketCount = sensorPacketCount,
+            isInfrastructure = isInfrastructure,
+        )
+    }
+
+    /** Returns true if both [lat] and [lon] are non-null and non-zero (i.e. a valid GPS fix). */
+    private fun hasValidCoordinates(lat: Double?, lon: Double?): Boolean =
+        lat != null && lon != null && lat != 0.0 && lon != 0.0
+
+    /**
+     * Computes average channel utilization and airtime from DeviceMetrics, applying the 2-packet rule (only nodes with
+     * ≥2 reports count).
+     */
+    private fun computeAverageMetrics(): Pair<Double, Double> {
+        val qualifiedEntries = deviceMetricsLog.values.filter { it.size >= MIN_DEVICE_METRICS_PACKETS }
+        if (qualifiedEntries.isEmpty()) return 0.0 to 0.0
+
+        val avgChannel = qualifiedEntries.map { entries -> entries.map { it.channelUtil }.average() }.average()
+
+        // Compute Airtime Rate as (delta air_util_tx / elapsed_time_hours) to match Apple spec FR-008
+        val avgAirRate =
+            qualifiedEntries
+                .mapNotNull { entries ->
+                    val first = entries.first()
+                    val last = entries.last()
+                    val deltaAir = last.airUtilTx - first.airUtilTx
+                    val deltaTimeMs = last.timestamp - first.timestamp
+                    if (deltaTimeMs > 0) {
+                        deltaAir / (deltaTimeMs / 3600000.0)
+                    } else {
+                        null
+                    }
+                }
+                .average()
+                .takeIf { !it.isNaN() } ?: 0.0
+
+        return avgChannel to avgAirRate
+    }
+
+    private suspend fun finalizeSession(status: String) {
+        if (sessionId == 0L) return
+        val uniqueCount = discoveryDao.getUniqueNodeCount(sessionId)
+        val presetResults = discoveryDao.getPresetResults(sessionId)
+        val session = discoveryDao.getSession(sessionId) ?: return
+        val totalDwell = presetResults.sumOf { it.dwellDurationSeconds }
+        val totalMsgs = presetResults.sumOf { it.messageCount }
+        val totalSensor = presetResults.sumOf { it.sensorPacketCount }
+        val maxDistance = discoveryDao.getMaxDistance(sessionId) ?: 0.0
+        val avgChanUtil =
+            presetResults
+                .filter { it.uniqueNodes > 0 }
+                .map { it.avgChannelUtilization }
+                .average()
+                .takeIf { !it.isNaN() } ?: 0.0
+        discoveryDao.updateSession(
+            session.copy(
+                totalUniqueNodes = uniqueCount,
+                totalDwellSeconds = totalDwell,
+                totalMessages = totalMsgs,
+                totalSensorPackets = totalSensor,
+                furthestNodeDistance = maxDistance,
+                avgChannelUtilization = avgChanUtil,
+                completionStatus = status,
+            ),
+        )
+        _currentSession.value = discoveryDao.getSession(sessionId)
+    }
+
+    // endregion
+
+    // region Home preset restoration
+
+    private suspend fun restoreHomePreset() {
+        val config = originalLoRaConfig ?: return
+        val fullConfig = Config(lora = config)
+        radioController.setLocalConfig(fullConfig)
+        Logger.i { "DiscoveryScanEngine: restored original LoRa config" }
+        // The firmware often restarts the radio or reboots after a LoRa config change.
+        delay(3000)
+        // Wait briefly for reconnection after restoring
+        waitForConnection()
+    }
+
+    // endregion
+
+    // region Lifecycle helpers
+
+    private fun cancelScanInternal() {
+        collectorRegistry.collector = null
+        dwellJob?.cancel()
+        dwellJob = null
+        scanScope?.cancel()
+        scanScope = null
+    }
+
+    // endregion
+
+    companion object {
+        private const val RECONNECT_TIMEOUT_MS = 60_000L
+        private const val TICK_INTERVAL_MS = 1_000L
+        private const val POSITION_DIVISOR = 1e7
+        private const val MIN_DEVICE_METRICS_PACKETS = 2
+        private const val PERCENT_MULTIPLIER = 100.0
+
+        /** Node roles that indicate infrastructure (Router, RouterLate, ClientBase). */
+        private val INFRASTRUCTURE_ROLES =
+            setOf(
+                Config.DeviceConfig.Role.ROUTER,
+                Config.DeviceConfig.Role.ROUTER_LATE,
+                Config.DeviceConfig.Role.CLIENT_BASE,
+            )
+    }
+}

feature/discovery/src/commonMain/kotlin/org/meshtastic/feature/discovery/DiscoveryScanState.kt

@@ -0,0 +1,74 @@
+/*
+ * Copyright (c) 2026 Meshtastic LLC
+ *
+ * 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 org.meshtastic.feature.discovery
+
+/**
+ * State machine for a discovery scan lifecycle.
+ *
+ * ```
+ * Idle → Preparing → Shifting → [Reconnecting] → Dwell → Shifting (loop) → Analysis → Complete(Success)
+ * Any scanning → Cancelling → Restoring → Complete(Cancelled)
+ * Any scanning → Failed(reason) → Restoring → Complete(Failed)
+ * Reconnecting timeout → Paused
+ * ```
+ */
+sealed interface DiscoveryScanState {
+    /** No scan is active. */
+    data object Idle : DiscoveryScanState
+
+    /** Validating inputs, capturing home preset snapshot. */
+    data object Preparing : DiscoveryScanState
+
+    /** Radio is switching to a new LoRa preset. */
+    data class Shifting(val presetName: String) : DiscoveryScanState
+
+    /** Waiting for the radio to reconnect after a preset change. */
+    data class Reconnecting(val presetName: String) : DiscoveryScanState
+
+    /** Listening on a preset and counting down the dwell timer. */
+    data class Dwell(val presetName: String, val remainingSeconds: Long, val totalSeconds: Long) : DiscoveryScanState
+
+    /** All presets scanned; aggregating results. */
+    data object Analysis : DiscoveryScanState
+
+    /** Scan finished and results are persisted. */
+    data class Complete(val outcome: CompletionOutcome = CompletionOutcome.Success) : DiscoveryScanState
+
+    /** Scan paused due to an unrecoverable transient condition (e.g. reconnect timeout). */
+    data class Paused(val reason: String) : DiscoveryScanState
+
+    /** User-initiated cancellation in progress; persisting partial results before restoring home preset. */
+    data object Cancelling : DiscoveryScanState
+
+    /** Restoring the home preset after scan stop or completion. */
+    data object Restoring : DiscoveryScanState
+
+    /** Scan failed due to an unrecoverable error. */
+    data class Failed(val reason: String) : DiscoveryScanState
+
+    /** Differentiates how a scan completed. */
+    enum class CompletionOutcome {
+        /** All presets were scanned successfully. */
+        Success,
+
+        /** The user cancelled the scan mid-way. */
+        Cancelled,
+
+        /** The scan failed due to an unrecoverable error. */
+        Failed,
+    }
+}

feature/discovery/src/commonMain/kotlin/org/meshtastic/feature/discovery/DiscoverySummaryGenerator.kt

@@ -0,0 +1,200 @@
+/*
+ * Copyright (c) 2026 Meshtastic LLC
+ *
+ * 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 org.meshtastic.feature.discovery
+
+import org.koin.core.annotation.Single
+import org.meshtastic.core.common.util.NumberFormatter
+import org.meshtastic.core.database.entity.DiscoveryPresetResultEntity
+import org.meshtastic.core.database.entity.DiscoverySessionEntity
+import org.meshtastic.feature.discovery.ai.LoRaPresetReference
+
+@Single
+@Suppress("TooManyFunctions")
+class DiscoverySummaryGenerator {
+
+    fun generateSessionSummary(
+        session: DiscoverySessionEntity,
+        presetResults: List<DiscoveryPresetResultEntity>,
+    ): String {
+        if (presetResults.isEmpty()) return "No presets were scanned during this session."
+
+        val ranked =
+            presetResults.sortedWith(
+                compareByDescending<DiscoveryPresetResultEntity> { it.uniqueNodes }.thenBy { it.avgChannelUtilization },
+            )
+        val best = ranked.first()
+
+        val lines = buildList {
+            add(buildPresetComparisonLine(best, presetResults))
+            for (result in presetResults) {
+                if (result.id != best.id) {
+                    add(buildAlternativeLine(result))
+                }
+            }
+            add(buildCongestionNote(presetResults))
+            add(buildTrafficMixNote(presetResults))
+            add(buildRecommendation(best, session))
+        }
+
+        return lines.filterNotNull().joinToString(" ")
+    }
+
+    fun generatePresetSummary(result: DiscoveryPresetResultEntity): String = buildString {
+        val info = LoRaPresetReference.getInfo(result.presetName)
+        append("${result.presetName}")
+        if (info != null) append(" (${info.dataRate}, ${info.linkBudget} link budget)")
+        append(": ${result.uniqueNodes} nodes")
+        append(" (${result.directNeighborCount} direct, ${result.meshNeighborCount} mesh)")
+        if (result.avgChannelUtilization > 0.0) {
+            append(", ${formatPercent(result.avgChannelUtilization)} channel utilization")
+            if (result.avgChannelUtilization > HIGH_CONGESTION_THRESHOLD) {
+                append(" (congested)")
+            }
+        }
+        if (result.messageCount + result.sensorPacketCount >= TRAFFIC_MIN_PACKET_THRESHOLD) {
+            val dominant = if (result.messageCount >= result.sensorPacketCount) "chat" else "sensor"
+            append(", $dominant-dominated traffic")
+        }
+        append(".")
+    }
+
+    /** Build AI-style prompt for session-level analysis. Used by AI providers. */
+    fun buildSessionPrompt(session: DiscoverySessionEntity, presetResults: List<DiscoveryPresetResultEntity>): String =
+        buildString {
+            appendLine(
+                "Analyze this Meshtastic mesh radio discovery scan and recommend the best modem preset. " +
+                    "Be concise (3-4 sentences).",
+            )
+            appendLine()
+            appendLine("Session: ${session.totalUniqueNodes} unique nodes, status: ${session.completionStatus}")
+            appendLine()
+            append(LoRaPresetReference.buildReferenceBlock(presetResults.map { it.presetName }))
+            appendLine("Channel util >25% indicates congestion; >50% causes significant packet loss.")
+            appendLine()
+            appendLine("Scan Results:")
+            for (result in presetResults) {
+                appendLine(formatPresetDataBlock(result))
+            }
+            appendLine()
+            append(
+                "Based on the scan data and preset reference, recommend which preset is best for this location. " +
+                    "Consider node density, infrastructure count, channel utilization, airtime, and traffic mix. " +
+                    "If congestion is high, recommend a faster preset.",
+            )
+        }
+
+    /** Build AI-style prompt for per-preset analysis. Used by AI providers. */
+    fun buildPresetPrompt(result: DiscoveryPresetResultEntity): String = buildString {
+        appendLine(
+            "Briefly summarize (1-2 sentences) the performance of the ${result.presetName} " +
+                "Meshtastic modem preset based on this scan data.",
+        )
+        appendLine()
+        val ref = LoRaPresetReference.formatReference(result.presetName)
+        if (ref != null) appendLine("Preset info: $ref")
+        appendLine("Channel util >25% indicates congestion; >50% causes significant packet loss.")
+        appendLine()
+        appendLine(formatPresetDataBlock(result))
+        appendLine()
+        append("Note if this preset is well-suited for the observed traffic pattern and node density.")
+    }
+
+    private fun formatPresetDataBlock(result: DiscoveryPresetResultEntity): String = buildString {
+        append("  ${result.presetName}: ")
+        append("Nodes: ${result.uniqueNodes} ")
+        append("(Direct: ${result.directNeighborCount}, Mesh: ${result.meshNeighborCount})")
+        append(", Messages: ${result.messageCount}, Sensor Packets: ${result.sensorPacketCount}")
+        if (result.avgChannelUtilization > 0.0) {
+            append(", Channel Util: ${formatPercent(result.avgChannelUtilization)}")
+        }
+        if (result.avgAirtimeRate > 0.0) {
+            append(", Airtime: ${formatPercent(result.avgAirtimeRate)}")
+        }
+        if (result.packetSuccessRate > 0.0) {
+            append(", Packet Success: ${formatPercent(result.packetSuccessRate * PERCENT_MULTIPLIER)}")
+        }
+    }
+
+    private fun buildPresetComparisonLine(
+        best: DiscoveryPresetResultEntity,
+        allResults: List<DiscoveryPresetResultEntity>,
+    ): String {
+        val info = LoRaPresetReference.getInfo(best.presetName)
+        val rateStr = if (info != null) " (${info.dataRate})" else ""
+        if (allResults.size == 1) {
+            return "${best.presetName}$rateStr discovered ${best.uniqueNodes} node(s) " +
+                "with ${formatPercent(best.avgChannelUtilization)} channel utilization."
+        }
+        return "${best.presetName}$rateStr discovered the most nodes (${best.uniqueNodes}) " +
+            "with ${describeUtilization(best.avgChannelUtilization)} channel utilization " +
+            "(${formatPercent(best.avgChannelUtilization)})."
+    }
+
+    private fun buildAlternativeLine(result: DiscoveryPresetResultEntity): String {
+        val utilDesc = describeUtilization(result.avgChannelUtilization)
+        val utilPct = formatPercent(result.avgChannelUtilization)
+        return "${result.presetName} found ${result.uniqueNodes} node(s) " +
+            "with $utilDesc channel utilization ($utilPct)."
+    }
+
+    private fun buildCongestionNote(results: List<DiscoveryPresetResultEntity>): String? {
+        val congested = results.filter { it.avgChannelUtilization > HIGH_CONGESTION_THRESHOLD }
+        if (congested.isEmpty()) return null
+        return "High congestion detected on ${congested.joinToString { it.presetName }}; " +
+            "consider a faster preset to reduce airtime."
+    }
+
+    private fun buildTrafficMixNote(results: List<DiscoveryPresetResultEntity>): String? {
+        val significantResults =
+            results.filter { it.messageCount + it.sensorPacketCount >= TRAFFIC_MIN_PACKET_THRESHOLD }
+        val chatDominant = significantResults.filter { it.messageCount > it.sensorPacketCount }
+        val sensorDominant = significantResults.filter { it.sensorPacketCount > it.messageCount }
+        val parts = buildList {
+            if (chatDominant.isNotEmpty()) {
+                add("chat-dominated on ${chatDominant.joinToString { it.presetName }}")
+            }
+            if (sensorDominant.isNotEmpty()) {
+                add("sensor-dominated on ${sensorDominant.joinToString { it.presetName }}")
+            }
+        }
+        if (parts.isEmpty()) return null
+        return "Traffic mix: ${parts.joinToString("; ")}."
+    }
+
+    private fun buildRecommendation(best: DiscoveryPresetResultEntity, session: DiscoverySessionEntity): String {
+        val status = if (session.completionStatus == "complete") "completed" else "partially completed"
+        return "Recommendation: Use ${best.presetName} for this location (scan $status)."
+    }
+
+    private fun describeUtilization(percent: Double): String = when {
+        percent < LOW_UTIL_THRESHOLD -> "low"
+        percent < MODERATE_UTIL_THRESHOLD -> "moderate"
+        percent < HIGH_UTIL_THRESHOLD -> "high"
+        else -> "very high"
+    }
+
+    private fun formatPercent(value: Double): String = "${NumberFormatter.format(value, 1)}%"
+
+    companion object {
+        private const val LOW_UTIL_THRESHOLD = 25.0
+        private const val MODERATE_UTIL_THRESHOLD = 50.0
+        private const val HIGH_UTIL_THRESHOLD = 75.0
+        private const val HIGH_CONGESTION_THRESHOLD = 25.0
+        private const val PERCENT_MULTIPLIER = 100.0
+        private const val TRAFFIC_MIN_PACKET_THRESHOLD = 5
+    }
+}

feature/discovery/src/commonMain/kotlin/org/meshtastic/feature/discovery/DiscoverySummaryViewModel.kt

@@ -0,0 +1,204 @@
+/*
+ * Copyright (c) 2026 Meshtastic LLC
+ *
+ * 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 org.meshtastic.feature.discovery
+
+import androidx.lifecycle.ViewModel
+import kotlinx.coroutines.flow.MutableStateFlow
+import kotlinx.coroutines.flow.StateFlow
+import kotlinx.coroutines.flow.asStateFlow
+import org.koin.core.annotation.InjectedParam
+import org.koin.core.annotation.KoinViewModel
+import org.meshtastic.core.database.dao.DiscoveryDao
+import org.meshtastic.core.database.entity.DiscoveredNodeEntity
+import org.meshtastic.core.database.entity.DiscoveryPresetResultEntity
+import org.meshtastic.core.database.entity.DiscoverySessionEntity
+import org.meshtastic.core.ui.viewmodel.safeLaunch
+import org.meshtastic.core.ui.viewmodel.stateInWhileSubscribed
+import org.meshtastic.feature.discovery.ai.DiscoverySummaryAiProvider
+import org.meshtastic.feature.discovery.export.DiscoveryExportData
+import org.meshtastic.feature.discovery.export.DiscoveryExporter
+import org.meshtastic.feature.discovery.export.ExportResult
+import org.meshtastic.feature.discovery.scan.DiscoveryRankingEngine
+import org.meshtastic.feature.discovery.scan.PresetRanking
+import org.meshtastic.feature.discovery.scan.PresetRankingInput
+
+@KoinViewModel
+class DiscoverySummaryViewModel(
+    @InjectedParam private val sessionId: Long,
+    private val discoveryDao: DiscoveryDao,
+    private val summaryGenerator: DiscoverySummaryGenerator,
+    private val rankingEngine: DiscoveryRankingEngine,
+    private val aiProvider: DiscoverySummaryAiProvider,
+    private val exporter: DiscoveryExporter,
+) : ViewModel() {
+
+    val session: StateFlow<DiscoverySessionEntity?> =
+        discoveryDao.getSessionFlow(sessionId).stateInWhileSubscribed(initialValue = null)
+
+    val presetResults: StateFlow<List<DiscoveryPresetResultEntity>> =
+        discoveryDao.getPresetResultsFlow(sessionId).stateInWhileSubscribed(initialValue = emptyList())
+
+    private val _nodesByPreset = MutableStateFlow<Map<Long, List<DiscoveredNodeEntity>>>(emptyMap())
+    val nodesByPreset: StateFlow<Map<Long, List<DiscoveredNodeEntity>>> = _nodesByPreset.asStateFlow()
+
+    private val _rankings = MutableStateFlow<List<PresetRanking>>(emptyList())
+    val rankings: StateFlow<List<PresetRanking>> = _rankings.asStateFlow()
+
+    private val _algorithmicSummary = MutableStateFlow<String?>(null)
+    val algorithmicSummary: StateFlow<String?> = _algorithmicSummary.asStateFlow()
+
+    private val _aiSummary = MutableStateFlow<String?>(null)
+    val aiSummary: StateFlow<String?> = _aiSummary.asStateFlow()
+
+    private val _presetAiSummaries = MutableStateFlow<Map<Long, String>>(emptyMap())
+    val presetAiSummaries: StateFlow<Map<Long, String>> = _presetAiSummaries.asStateFlow()
+
+    private val _isGeneratingAi = MutableStateFlow(false)
+    val isGeneratingAi: StateFlow<Boolean> = _isGeneratingAi.asStateFlow()
+
+    private val _exportResult = MutableStateFlow<ExportResult?>(null)
+    val exportResult: StateFlow<ExportResult?> = _exportResult.asStateFlow()
+
+    init {
+        loadNodes()
+    }
+
+    fun exportReport() {
+        safeLaunch(tag = "exportReport") {
+            val currentSession =
+                discoveryDao.getSession(sessionId)
+                    ?: run {
+                        _exportResult.value = ExportResult.Error("Session not found")
+                        return@safeLaunch
+                    }
+            val results = discoveryDao.getPresetResults(sessionId)
+            val exportData =
+                DiscoveryExportData(
+                    session = currentSession,
+                    presetResults = results,
+                    nodesByPreset = _nodesByPreset.value,
+                )
+            _exportResult.value = exporter.export(exportData)
+        }
+    }
+
+    fun clearExportResult() {
+        _exportResult.value = null
+    }
+
+    /** Re-run all AI analysis, clearing cached results first. */
+    fun rerunAnalysis() {
+        safeLaunch(tag = "rerunAnalysis") {
+            _isGeneratingAi.value = true
+            _aiSummary.value = null
+            _presetAiSummaries.value = emptyMap()
+
+            val currentSession = discoveryDao.getSession(sessionId) ?: return@safeLaunch
+            val results = discoveryDao.getPresetResults(sessionId)
+
+            // Clear persisted AI summaries
+            discoveryDao.updateSession(currentSession.copy(aiSummary = null))
+            for (result in results) {
+                discoveryDao.updatePresetResult(result.copy(aiSummary = null))
+            }
+
+            // Regenerate algorithmic
+            _algorithmicSummary.value = summaryGenerator.generateSessionSummary(currentSession, results)
+
+            // Recompute rankings
+            val rankingInputs =
+                results.map { result ->
+                    PresetRankingInput(
+                        presetResult = result,
+                        discoveredNodes = _nodesByPreset.value[result.id].orEmpty(),
+                    )
+                }
+            _rankings.value = rankingEngine.rank(rankingInputs)
+
+            // Regenerate AI
+            generateAiSummary(currentSession, results)
+            generatePresetAiSummaries(results)
+
+            _isGeneratingAi.value = false
+        }
+    }
+
+    private fun loadNodes() {
+        safeLaunch(tag = "loadNodes") {
+            val results = discoveryDao.getPresetResults(sessionId)
+            val nodesMap = mutableMapOf<Long, List<DiscoveredNodeEntity>>()
+            for (result in results) {
+                nodesMap[result.id] = discoveryDao.getDiscoveredNodes(result.id)
+            }
+            _nodesByPreset.value = nodesMap
+
+            // Compute deterministic rankings
+            val rankingInputs =
+                results.map { result ->
+                    PresetRankingInput(presetResult = result, discoveredNodes = nodesMap[result.id].orEmpty())
+                }
+            _rankings.value = rankingEngine.rank(rankingInputs)
+
+            // Load cached per-preset AI summaries
+            val cachedPresetSummaries =
+                results.filter { !it.aiSummary.isNullOrBlank() }.associate { it.id to it.aiSummary!! }
+            _presetAiSummaries.value = cachedPresetSummaries
+
+            val session = discoveryDao.getSession(sessionId)
+            if (session != null) {
+                _algorithmicSummary.value = summaryGenerator.generateSessionSummary(session, results)
+
+                // Use cached AI summary if available, otherwise generate
+                if (!session.aiSummary.isNullOrBlank()) {
+                    _aiSummary.value = session.aiSummary
+                } else {
+                    generateAiSummary(session, results)
+                }
+
+                // Generate per-preset summaries for any without cached results
+                val uncached = results.filter { it.aiSummary.isNullOrBlank() && it.uniqueNodes > 0 }
+                if (uncached.isNotEmpty()) {
+                    generatePresetAiSummaries(uncached)
+                }
+            }
+        }
+    }
+
+    private fun generateAiSummary(session: DiscoverySessionEntity, results: List<DiscoveryPresetResultEntity>) {
+        if (!aiProvider.isAvailable) return
+        safeLaunch(tag = "aiSummary") {
+            val summary = aiProvider.generateSessionSummary(session, results)
+            if (summary != null) {
+                _aiSummary.value = summary
+                discoveryDao.updateSession(session.copy(aiSummary = summary))
+            }
+        }
+    }
+
+    private fun generatePresetAiSummaries(results: List<DiscoveryPresetResultEntity>) {
+        if (!aiProvider.isAvailable) return
+        safeLaunch(tag = "presetAiSummaries") {
+            for (result in results) {
+                val summary = aiProvider.generatePresetSummary(result)
+                if (summary != null) {
+                    _presetAiSummaries.value = _presetAiSummaries.value + (result.id to summary)
+                    discoveryDao.updatePresetResult(result.copy(aiSummary = summary))
+                }
+            }
+        }
+    }
+}

feature/discovery/src/commonMain/kotlin/org/meshtastic/feature/discovery/DiscoveryViewModel.kt

@@ -0,0 +1,140 @@
+/*
+ * Copyright (c) 2026 Meshtastic LLC
+ *
+ * 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 org.meshtastic.feature.discovery
+
+import androidx.lifecycle.ViewModel
+import kotlinx.coroutines.flow.MutableStateFlow
+import kotlinx.coroutines.flow.StateFlow
+import kotlinx.coroutines.flow.asStateFlow
+import kotlinx.coroutines.flow.map
+import kotlinx.coroutines.flow.update
+import org.koin.core.annotation.KoinViewModel
+import org.meshtastic.core.database.dao.DiscoveryDao
+import org.meshtastic.core.database.entity.DiscoverySessionEntity
+import org.meshtastic.core.model.ChannelOption
+import org.meshtastic.core.model.ConnectionState
+import org.meshtastic.core.repository.DiscoveryPrefs
+import org.meshtastic.core.repository.RadioConfigRepository
+import org.meshtastic.core.repository.ServiceRepository
+import org.meshtastic.core.ui.viewmodel.safeLaunch
+import org.meshtastic.core.ui.viewmodel.stateInWhileSubscribed
+import org.meshtastic.feature.discovery.scan.Check24GhzCapability
+import org.meshtastic.feature.discovery.scan.HardwareCapabilityResult
+import org.meshtastic.proto.Config.LoRaConfig.RegionCode
+
+@KoinViewModel
+class DiscoveryViewModel(
+    private val scanEngine: DiscoveryScanEngine,
+    private val serviceRepository: ServiceRepository,
+    private val discoveryPrefs: DiscoveryPrefs,
+    private val check24GhzCapability: Check24GhzCapability,
+    radioConfigRepository: RadioConfigRepository,
+    discoveryDao: DiscoveryDao,
+) : ViewModel() {
+
+    val scanState: StateFlow<DiscoveryScanState> = scanEngine.scanState
+    val currentSession: StateFlow<DiscoverySessionEntity?> = scanEngine.currentSession
+    val connectionState: StateFlow<ConnectionState> = serviceRepository.connectionState
+
+    val homePreset: StateFlow<ChannelOption> =
+        radioConfigRepository.localConfigFlow
+            .map { localConfig ->
+                val presetEnum = localConfig.lora?.modem_preset
+                ChannelOption.entries.firstOrNull { it.modemPreset == presetEnum } ?: ChannelOption.DEFAULT
+            }
+            .stateInWhileSubscribed(initialValue = ChannelOption.DEFAULT)
+
+    /** True when the radio is configured for LORA_24 region but hardware doesn't support 2.4 GHz. */
+    private val _is24GhzBlocked = MutableStateFlow(false)
+    val is24GhzBlocked: StateFlow<Boolean> = _is24GhzBlocked.asStateFlow()
+
+    /** True when the radio is on the LORA_24 region. */
+    val isLora24Region: StateFlow<Boolean> =
+        radioConfigRepository.localConfigFlow
+            .map { it.lora?.region == RegionCode.LORA_24 }
+            .stateInWhileSubscribed(initialValue = false)
+
+    private val _selectedPresets = MutableStateFlow<Set<ChannelOption>>(restoreSelectedPresets())
+    val selectedPresets: StateFlow<Set<ChannelOption>> = _selectedPresets.asStateFlow()
+
+    private val _dwellDurationMinutes = MutableStateFlow(discoveryPrefs.dwellMinutes.value)
+    val dwellDurationMinutes: StateFlow<Int> = _dwellDurationMinutes.asStateFlow()
+
+    val isConnected: StateFlow<Boolean> =
+        serviceRepository.connectionState
+            .map { it is ConnectionState.Connected }
+            .stateInWhileSubscribed(initialValue = false)
+
+    /** True when the primary channel uses the default (well-known) PSK — scanning is unsafe. */
+    val usesDefaultKey: StateFlow<Boolean> =
+        radioConfigRepository.channelSetFlow
+            .map { channelSet ->
+                val primaryPsk = channelSet.settings.firstOrNull()?.psk
+                primaryPsk == null || primaryPsk.size == 0 || (primaryPsk.size == 1 && primaryPsk[0].toInt() <= 1)
+            }
+            .stateInWhileSubscribed(initialValue = true)
+
+    val sessions: StateFlow<List<DiscoverySessionEntity>> =
+        discoveryDao.getAllSessions().stateInWhileSubscribed(initialValue = emptyList())
+
+    init {
+        safeLaunch(tag = "markInterruptedSessions") { discoveryDao.markInterruptedSessions() }
+        safeLaunch(tag = "check24GhzCapability") {
+            val result = check24GhzCapability()
+            _is24GhzBlocked.value =
+                result is HardwareCapabilityResult.Unsupported || result is HardwareCapabilityResult.Unknown
+        }
+    }
+
+    fun togglePreset(preset: ChannelOption) {
+        _selectedPresets.update { current ->
+            val updated = if (preset in current) current - preset else current + preset
+            discoveryPrefs.setSelectedPresets(updated.map { it.name }.toSet())
+            updated
+        }
+    }
+
+    fun setDwellDuration(minutes: Int) {
+        _dwellDurationMinutes.value = minutes
+        discoveryPrefs.setDwellMinutes(minutes)
+    }
+
+    fun startScan() {
+        safeLaunch(tag = "startScan") {
+            scanEngine.startScan(
+                presets = selectedPresets.value.toList(),
+                dwellDurationSeconds = dwellDurationMinutes.value.toLong() * SECONDS_PER_MINUTE,
+            )
+        }
+    }
+
+    fun stopScan() {
+        safeLaunch(tag = "stopScan") { scanEngine.stopScan() }
+    }
+
+    fun reset() {
+        scanEngine.reset()
+    }
+
+    private fun restoreSelectedPresets(): Set<ChannelOption> = discoveryPrefs.selectedPresets.value
+        .mapNotNull { name -> ChannelOption.entries.firstOrNull { it.name == name } }
+        .toSet()
+
+    companion object {
+        private const val SECONDS_PER_MINUTE = 60L
+    }
+}

feature/discovery/src/commonMain/kotlin/org/meshtastic/feature/discovery/ai/DiscoverySummaryAiProvider.kt

@@ -0,0 +1,40 @@
+/*
+ * Copyright (c) 2026 Meshtastic LLC
+ *
+ * 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 org.meshtastic.feature.discovery.ai
+
+import org.meshtastic.core.database.entity.DiscoveryPresetResultEntity
+import org.meshtastic.core.database.entity.DiscoverySessionEntity
+
+/**
+ * Abstraction for generating natural-language summaries of discovery scan results.
+ *
+ * Platform implementations may use on-device AI (e.g. Gemini Nano on Android) or fall back to the algorithmic
+ * [org.meshtastic.feature.discovery.DiscoverySummaryGenerator].
+ */
+interface DiscoverySummaryAiProvider {
+    /** Whether this provider is ready to generate AI summaries. */
+    val isAvailable: Boolean
+
+    /** Generate a session-level summary across all preset results. Returns `null` on failure. */
+    suspend fun generateSessionSummary(
+        session: DiscoverySessionEntity,
+        presetResults: List<DiscoveryPresetResultEntity>,
+    ): String?
+
+    /** Generate a per-preset summary. Returns `null` on failure. */
+    suspend fun generatePresetSummary(result: DiscoveryPresetResultEntity): String?
+}

feature/discovery/src/commonMain/kotlin/org/meshtastic/feature/discovery/ai/LoRaPresetReference.kt

@@ -0,0 +1,162 @@
+/*
+ * Copyright (c) 2026 Meshtastic LLC
+ *
+ * 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 org.meshtastic.feature.discovery.ai
+
+/**
+ * LoRa modem preset reference data for enriching AI prompts and algorithmic summaries. Data sourced from Meshtastic
+ * radio-settings documentation.
+ */
+internal object LoRaPresetReference {
+
+    data class PresetInfo(
+        val bandwidth: String,
+        val spreadingFactor: String,
+        val dataRate: String,
+        val linkBudget: String,
+        val description: String,
+    )
+
+    private val presets =
+        mapOf(
+            "Long Fast" to
+                PresetInfo(
+                    "250kHz",
+                    "SF11",
+                    "1.07kbps",
+                    "153dB",
+                    "Default. Good range but high airtime per packet; causes congestion in networks >60 nodes.",
+                ),
+            "Long Moderate" to
+                PresetInfo(
+                    "125kHz",
+                    "SF11",
+                    "0.34kbps",
+                    "155.5dB",
+                    "Maximum range but extremely slow; only suitable for very sparse, long-range deployments.",
+                ),
+            "Long Slow" to
+                PresetInfo(
+                    "125kHz",
+                    "SF12",
+                    "0.18kbps",
+                    "158dB",
+                    "Extreme range, extremely slow; only for point-to-point long-range links.",
+                ),
+            "Long Turbo" to
+                PresetInfo(
+                    "500kHz",
+                    "SF9",
+                    "7.03kbps",
+                    "148dB",
+                    "Fast long-range. ~7x LongFast speed, reduced range. Good balance for moderate networks.",
+                ),
+            "Medium Slow" to
+                PresetInfo(
+                    "250kHz",
+                    "SF10",
+                    "1.95kbps",
+                    "150.5dB",
+                    "~2x LongFast speed. Bay Area mesh (150+ nodes) thrives on this preset.",
+                ),
+            "Medium Fast" to
+                PresetInfo(
+                    "250kHz",
+                    "SF9",
+                    "3.52kbps",
+                    "148dB",
+                    "~3.5x LongFast speed. Excellent balance for dense urban/suburban networks.",
+                ),
+            "Short Slow" to
+                PresetInfo(
+                    "250kHz",
+                    "SF8",
+                    "6.25kbps",
+                    "145.5dB",
+                    "~6x LongFast speed. Good for dense networks with adequate node spacing.",
+                ),
+            "Short Fast" to
+                PresetInfo(
+                    "250kHz",
+                    "SF7",
+                    "10.94kbps",
+                    "143dB",
+                    "~10x LongFast speed. Wellington NZ mesh (150+ nodes) switched here with excellent results.",
+                ),
+            "Short Turbo" to
+                PresetInfo(
+                    "500kHz",
+                    "SF7",
+                    "21.88kbps",
+                    "140dB",
+                    "Maximum speed, minimum range. Only for very dense, close-proximity deployments.",
+                ),
+            "Lite Fast" to
+                PresetInfo(
+                    "500kHz",
+                    "SF9",
+                    "7.03kbps",
+                    "148dB",
+                    "2.4 GHz band. Fast with moderate range; requires SX1280 hardware.",
+                ),
+            "Lite Slow" to
+                PresetInfo(
+                    "250kHz",
+                    "SF11",
+                    "1.07kbps",
+                    "153dB",
+                    "2.4 GHz band. Longer range at lower speed; requires SX1280 hardware.",
+                ),
+            "Narrow Fast" to
+                PresetInfo(
+                    "125kHz",
+                    "SF7",
+                    "5.47kbps",
+                    "146dB",
+                    "2.4 GHz band. Narrow bandwidth, fast speed; requires SX1280 hardware.",
+                ),
+            "Narrow Slow" to
+                PresetInfo(
+                    "125kHz",
+                    "SF11",
+                    "0.54kbps",
+                    "155.5dB",
+                    "2.4 GHz band. Narrow bandwidth, max range; requires SX1280 hardware.",
+                ),
+        )
+
+    /** Get reference data for a preset, matching by substring (e.g. "Long Fast" matches "Long Fast"). */
+    fun getInfo(presetName: String): PresetInfo? =
+        presets.entries.firstOrNull { presetName.contains(it.key, ignoreCase = true) }?.value
+
+    /** Format a one-line reference string for a preset. */
+    fun formatReference(presetName: String): String? {
+        val info = getInfo(presetName) ?: return null
+        return "$presetName: ${info.bandwidth} BW, ${info.spreadingFactor}, " +
+            "${info.dataRate}, ${info.linkBudget} link budget. ${info.description}"
+    }
+
+    /** Build a multi-line reference block for all scanned presets. */
+    fun buildReferenceBlock(presetNames: List<String>): String = buildString {
+        appendLine("LoRa Preset Reference:")
+        for (name in presetNames) {
+            val ref = formatReference(name)
+            if (ref != null) {
+                appendLine("  $ref")
+            }
+        }
+    }
+}

feature/discovery/src/commonMain/kotlin/org/meshtastic/feature/discovery/di/FeatureDiscoveryModule.kt

@@ -0,0 +1,24 @@
+/*
+ * Copyright (c) 2026 Meshtastic LLC
+ *
+ * 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 org.meshtastic.feature.discovery.di
+
+import org.koin.core.annotation.ComponentScan
+import org.koin.core.annotation.Module
+
+@Module
+@ComponentScan("org.meshtastic.feature.discovery")
+class FeatureDiscoveryModule

feature/discovery/src/commonMain/kotlin/org/meshtastic/feature/discovery/export/DiscoveryExporter.kt

@@ -0,0 +1,37 @@
+/*
+ * Copyright (c) 2026 Meshtastic LLC
+ *
+ * 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 org.meshtastic.feature.discovery.export
+
+import org.meshtastic.core.database.entity.DiscoveredNodeEntity
+import org.meshtastic.core.database.entity.DiscoveryPresetResultEntity
+import org.meshtastic.core.database.entity.DiscoverySessionEntity
+
+data class DiscoveryExportData(
+    val session: DiscoverySessionEntity,
+    val presetResults: List<DiscoveryPresetResultEntity>,
+    val nodesByPreset: Map<Long, List<DiscoveredNodeEntity>>,
+)
+
+interface DiscoveryExporter {
+    suspend fun export(data: DiscoveryExportData): ExportResult
+}
+
+sealed interface ExportResult {
+    data class Success(val content: ByteArray, val mimeType: String, val fileName: String) : ExportResult
+
+    data class Error(val message: String) : ExportResult
+}

feature/discovery/src/commonMain/kotlin/org/meshtastic/feature/discovery/export/DiscoveryReportFormatter.kt

@@ -0,0 +1,73 @@
+/*
+ * Copyright (c) 2026 Meshtastic LLC
+ *
+ * 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 org.meshtastic.feature.discovery.export
+
+import org.meshtastic.core.common.util.DateFormatter
+import org.meshtastic.core.common.util.NumberFormatter
+import org.meshtastic.core.database.entity.DiscoveredNodeEntity
+import org.meshtastic.core.database.entity.DiscoveryPresetResultEntity
+import org.meshtastic.core.database.entity.DiscoverySessionEntity
+import org.meshtastic.feature.discovery.ui.formatDuration
+
+internal object DiscoveryReportFormatter {
+
+    fun formatSessionDate(session: DiscoverySessionEntity): String = DateFormatter.formatDateTime(session.timestamp)
+
+    fun formatSessionOverviewLines(session: DiscoverySessionEntity): List<Pair<String, String>> = listOf(
+        "Date" to formatSessionDate(session),
+        "Total unique nodes" to session.totalUniqueNodes.toString(),
+        "Total dwell time" to formatDuration(session.totalDwellSeconds),
+        "Status" to session.completionStatus.replaceFirstChar { it.uppercase() },
+        "Channel utilization" to "${NumberFormatter.format(session.avgChannelUtilization, 1)}%",
+        "Total messages" to session.totalMessages.toString(),
+        "Total sensor packets" to session.totalSensorPackets.toString(),
+    )
+
+    fun formatPresetLines(result: DiscoveryPresetResultEntity): List<Pair<String, String>> = buildList {
+        add("Unique nodes" to result.uniqueNodes.toString())
+        add("Direct neighbors" to result.directNeighborCount.toString())
+        add("Mesh neighbors" to result.meshNeighborCount.toString())
+        add("Dwell time" to formatDuration(result.dwellDurationSeconds))
+        add("Channel utilization" to "${NumberFormatter.format(result.avgChannelUtilization, 1)}%")
+        add("Airtime rate" to "${NumberFormatter.format(result.avgAirtimeRate, 1)}%")
+        add("Packet success" to "${NumberFormatter.format(result.packetSuccessRate, 1)}%")
+        add("Messages" to result.messageCount.toString())
+        add("Packets TX" to result.numPacketsTx.toString())
+        add("Packets RX" to result.numPacketsRx.toString())
+        val aiText = result.aiSummary
+        if (!aiText.isNullOrBlank()) {
+            add("Analysis" to aiText)
+        }
+    }
+
+    fun formatNodeLine(node: DiscoveredNodeEntity): String = buildString {
+        append(node.longName ?: node.shortName ?: "!${node.nodeNum.toString(radix = 16)}")
+        append(" | ${node.neighborType}")
+        append(" | SNR: ${NumberFormatter.format(node.snr, 1)}")
+        append(" | RSSI: ${node.rssi}")
+        val distance = node.distanceFromUser
+        if (distance != null) {
+            append(" | ${NumberFormatter.format(distance, 0)}m")
+        }
+    }
+
+    fun generateFileName(session: DiscoverySessionEntity, extension: String): String {
+        val dateStr =
+            DateFormatter.formatDateTime(session.timestamp).replace(" ", "_").replace("/", "-").replace(":", "-")
+        return "meshtastic_discovery_$dateStr.$extension"
+    }
+}

feature/discovery/src/commonMain/kotlin/org/meshtastic/feature/discovery/export/ExportSaverLauncher.kt

@@ -0,0 +1,32 @@
+/*
+ * Copyright (c) 2026 Meshtastic LLC
+ *
+ * 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 org.meshtastic.feature.discovery.export
+
+import androidx.compose.runtime.Composable
+
+/**
+ * Returns a launcher that saves [ExportResult.Success] content to the platform's file system.
+ *
+ * On Android this opens a SAF document-picker (ACTION_CREATE_DOCUMENT). On Desktop this writes to a user-chosen file
+ * via a file dialog.
+ */
+@Composable expect fun rememberExportSaver(): ExportSaverLauncher
+
+/** Platform-agnostic handle for triggering a file-save from export data. */
+fun interface ExportSaverLauncher {
+    fun save(result: ExportResult.Success)
+}

feature/discovery/src/commonMain/kotlin/org/meshtastic/feature/discovery/navigation/DiscoveryNavigation.kt

@@ -0,0 +1,84 @@
+/*
+ * Copyright (c) 2026 Meshtastic LLC
+ *
+ * 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 org.meshtastic.feature.discovery.navigation
+
+import androidx.compose.runtime.Composable
+import androidx.lifecycle.compose.dropUnlessResumed
+import androidx.navigation3.runtime.EntryProviderScope
+import androidx.navigation3.runtime.NavBackStack
+import androidx.navigation3.runtime.NavKey
+import org.koin.compose.viewmodel.koinViewModel
+import org.koin.core.parameter.parametersOf
+import org.meshtastic.core.navigation.DiscoveryRoute
+import org.meshtastic.feature.discovery.DiscoveryHistoryDetailViewModel
+import org.meshtastic.feature.discovery.DiscoveryHistoryViewModel
+import org.meshtastic.feature.discovery.DiscoveryMapViewModel
+import org.meshtastic.feature.discovery.DiscoverySummaryViewModel
+import org.meshtastic.feature.discovery.DiscoveryViewModel
+import org.meshtastic.feature.discovery.ui.DiscoveryHistoryDetailScreen
+import org.meshtastic.feature.discovery.ui.DiscoveryHistoryScreen
+import org.meshtastic.feature.discovery.ui.DiscoveryMapScreen
+import org.meshtastic.feature.discovery.ui.DiscoveryScanScreen
+import org.meshtastic.feature.discovery.ui.DiscoverySummaryScreen
+
+/** Registers the discovery feature screen entries into the Navigation 3 entry provider. */
+fun EntryProviderScope<NavKey>.discoveryGraph(backStack: NavBackStack<NavKey>) {
+    entry<DiscoveryRoute.DiscoveryGraph> { DiscoveryScanScreenEntry(backStack) }
+    entry<DiscoveryRoute.DiscoveryScan> { DiscoveryScanScreenEntry(backStack) }
+    entry<DiscoveryRoute.DiscoverySummary> { route ->
+        val viewModel = koinViewModel<DiscoverySummaryViewModel> { parametersOf(route.sessionId) }
+        DiscoverySummaryScreen(
+            viewModel = viewModel,
+            onNavigateUp = dropUnlessResumed { backStack.removeLastOrNull() },
+            onNavigateToMap = { sessionId -> backStack.add(DiscoveryRoute.DiscoveryMap(sessionId)) },
+        )
+    }
+    entry<DiscoveryRoute.DiscoveryMap> { route ->
+        val viewModel = koinViewModel<DiscoveryMapViewModel> { parametersOf(route.sessionId) }
+        DiscoveryMapScreen(viewModel = viewModel, onNavigateUp = dropUnlessResumed { backStack.removeLastOrNull() })
+    }
+    entry<DiscoveryRoute.DiscoveryHistory> {
+        val viewModel = koinViewModel<DiscoveryHistoryViewModel>()
+        val navigateToDetail: (Long) -> Unit = { sessionId ->
+            backStack.add(DiscoveryRoute.DiscoveryHistoryDetail(sessionId))
+        }
+        DiscoveryHistoryScreen(
+            viewModel = viewModel,
+            onNavigateUp = dropUnlessResumed { backStack.removeLastOrNull() },
+            onNavigateToDetail = navigateToDetail,
+        )
+    }
+    entry<DiscoveryRoute.DiscoveryHistoryDetail> { route ->
+        val viewModel = koinViewModel<DiscoveryHistoryDetailViewModel> { parametersOf(route.sessionId) }
+        DiscoveryHistoryDetailScreen(
+            viewModel = viewModel,
+            onNavigateUp = dropUnlessResumed { backStack.removeLastOrNull() },
+            onNavigateToMap = { sessionId -> backStack.add(DiscoveryRoute.DiscoveryMap(sessionId)) },
+        )
+    }
+}
+
+@Composable
+private fun DiscoveryScanScreenEntry(backStack: NavBackStack<NavKey>) {
+    val viewModel = koinViewModel<DiscoveryViewModel>()
+    DiscoveryScanScreen(
+        viewModel = viewModel,
+        onNavigateUp = dropUnlessResumed { backStack.removeLastOrNull() },
+        onNavigateToSummary = { sessionId -> backStack.add(DiscoveryRoute.DiscoverySummary(sessionId)) },
+        onNavigateToHistory = dropUnlessResumed { backStack.add(DiscoveryRoute.DiscoveryHistory) },
+    )
+}

feature/discovery/src/commonMain/kotlin/org/meshtastic/feature/discovery/scan/Check24GhzCapability.kt

@@ -0,0 +1,94 @@
+/*
+ * Copyright (c) 2026 Meshtastic LLC
+ *
+ * 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 org.meshtastic.feature.discovery.scan
+
+import org.koin.core.annotation.Single
+import org.meshtastic.core.model.DeviceHardware
+import org.meshtastic.core.repository.DeviceHardwareRepository
+import org.meshtastic.core.repository.NodeRepository
+
+/** Result of a 2.4 GHz capability check. */
+sealed interface HardwareCapabilityResult {
+    /** The connected radio supports 2.4 GHz operation. */
+    data object Supported : HardwareCapabilityResult
+
+    /** The connected radio does NOT support 2.4 GHz operation. */
+    data class Unsupported(val reason: String) : HardwareCapabilityResult
+
+    /** Capability could not be determined (hardware data unavailable or ambiguous). */
+    data class Unknown(val reason: String) : HardwareCapabilityResult
+}
+
+/**
+ * Determines whether the currently connected radio supports 2.4 GHz LoRa operation (SX1280 chip).
+ *
+ * Uses a layered heuristic:
+ * 1. Check for explicit `2.4ghz` or `sx1280` tags in the hardware metadata.
+ * 2. Check the platformIO target or slug for `sx1280`, `2.4`, or `2400` patterns.
+ * 3. Default to [HardwareCapabilityResult.Unknown] when no evidence is available.
+ */
+@Single
+class Check24GhzCapability(
+    private val nodeRepository: NodeRepository,
+    private val deviceHardwareRepository: DeviceHardwareRepository,
+) {
+    /**
+     * Checks if the currently connected radio supports 2.4 GHz. Returns [HardwareCapabilityResult.Unknown] if not
+     * connected or hardware data is unavailable.
+     */
+    @Suppress("ReturnCount")
+    suspend operator fun invoke(): HardwareCapabilityResult {
+        val ourNode = nodeRepository.ourNodeInfo.value ?: return HardwareCapabilityResult.Unknown("No radio connected")
+        val hwModel = ourNode.user.hw_model.value
+        if (hwModel == 0) return HardwareCapabilityResult.Unknown("Hardware model unknown")
+
+        val myNodeInfo = nodeRepository.myNodeInfo.value
+        val target = myNodeInfo?.pioEnv
+
+        val hw =
+            deviceHardwareRepository.getDeviceHardwareByModel(hwModel, target).getOrNull()
+                ?: return HardwareCapabilityResult.Unknown("Hardware metadata unavailable for model $hwModel")
+
+        return evaluate(hw)
+    }
+
+    @Suppress("ReturnCount")
+    internal fun evaluate(hw: DeviceHardware): HardwareCapabilityResult {
+        // Layer 1: Check explicit tags
+        val tags = hw.tags.orEmpty().map { it.lowercase() }
+        if (tags.any { it in SUPPORTED_TAGS }) return HardwareCapabilityResult.Supported
+        if (tags.any { it in UNSUPPORTED_TAGS }) {
+            return HardwareCapabilityResult.Unsupported("Hardware tagged as sub-GHz only")
+        }
+
+        // Layer 2: Check platformioTarget or hwModelSlug for SX1280/2.4GHz patterns
+        val targetLower = hw.platformioTarget.lowercase()
+        val slugLower = hw.hwModelSlug.lowercase()
+        if (SUPPORTED_PATTERNS.any { it in targetLower || it in slugLower }) {
+            return HardwareCapabilityResult.Supported
+        }
+
+        // Layer 3: No definitive evidence — default to unknown/unsupported
+        return HardwareCapabilityResult.Unknown("Cannot verify 2.4 GHz support for ${hw.displayName}")
+    }
+
+    companion object {
+        private val SUPPORTED_TAGS = setOf("2.4ghz", "sx1280", "lora24", "2400mhz")
+        private val UNSUPPORTED_TAGS = setOf("sub-ghz-only", "sx1262", "sx1276")
+        private val SUPPORTED_PATTERNS = listOf("sx1280", "2.4", "2400", "lora24")
+    }
+}

feature/discovery/src/commonMain/kotlin/org/meshtastic/feature/discovery/scan/DiscoveryRankingEngine.kt

@@ -0,0 +1,197 @@
+/*
+ * Copyright (c) 2026 Meshtastic LLC
+ *
+ * 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 org.meshtastic.feature.discovery.scan
+
+import org.koin.core.annotation.Single
+import org.meshtastic.core.database.entity.DiscoveredNodeEntity
+import org.meshtastic.core.database.entity.DiscoveryPresetResultEntity
+
+/** Input bundle for ranking: a preset result together with its discovered nodes. */
+data class PresetRankingInput(
+    val presetResult: DiscoveryPresetResultEntity,
+    val discoveredNodes: List<DiscoveredNodeEntity>,
+)
+
+/** Per-criterion score breakdown for a ranked preset. */
+data class RankingScoreBreakdown(
+    /** Criterion 1: unique discovered node count. */
+    val uniqueNodeCount: Int,
+    /** Criterion 2: neighbor-report diversity (direct + mesh neighbor count). */
+    val neighborDiversity: Int,
+    /** Criterion 3: non-duplicate packet count (numPacketsRx - numRxDupe). */
+    val nonDupePacketCount: Int,
+    /** Criterion 4a: median SNR across discovered nodes. */
+    val medianSnr: Float,
+    /** Criterion 4b: median RSSI across discovered nodes (tiebreak within criterion 4). */
+    val medianRssi: Int,
+    /** Criterion 5: best known distance to a valid-position node (metres). */
+    val bestKnownDistance: Double,
+    /** Criterion 6: failure/reconnect penalty (packet failure rate). */
+    val failurePenalty: Double,
+)
+
+/** Output ranking for a single preset. */
+data class PresetRanking(
+    /** 1-based rank (1 = best). Tied presets share the same rank. */
+    val rank: Int,
+    val presetResult: DiscoveryPresetResultEntity,
+    val scoreBreakdown: RankingScoreBreakdown,
+    /** True when this preset tied with at least one other after all 6 criteria. */
+    val isTied: Boolean,
+)
+
+/**
+ * Deterministic 6-level heuristic ranking engine for discovery preset results.
+ *
+ * The ranking order (best-first) is:
+ * 1. Highest unique discovered node count
+ * 2. Highest neighbor-report diversity (direct + mesh neighbor mentions)
+ * 3. Highest non-duplicate packet count
+ * 4. Best median link quality (median SNR first, then median RSSI)
+ * 5. Greatest best-known distance to a valid-position node
+ * 6. Lowest failure / reconnect penalty
+ *
+ * If two presets still tie after all heuristics they are labelled as tied.
+ */
+@Single
+class DiscoveryRankingEngine {
+
+    /**
+     * Rank the given preset inputs best-to-worst using the 6-level heuristic.
+     *
+     * @return sorted list of [PresetRanking] (index 0 = best). Empty input yields empty output.
+     */
+    fun rank(inputs: List<PresetRankingInput>): List<PresetRanking> {
+        if (inputs.isEmpty()) return emptyList()
+
+        val scored = inputs.map { it.toScored() }
+        val sorted = scored.sortedWith(RANKING_COMPARATOR)
+
+        return assignRanks(sorted)
+    }
+
+    // ---- internal helpers ----
+
+    private data class ScoredPreset(val presetResult: DiscoveryPresetResultEntity, val breakdown: RankingScoreBreakdown)
+
+    private fun PresetRankingInput.toScored(): ScoredPreset {
+        val pr = presetResult
+        val nodes = discoveredNodes
+
+        val snrValues = nodes.map { it.snr }.sorted()
+        val rssiValues = nodes.map { it.rssi }.sorted()
+
+        return ScoredPreset(
+            presetResult = pr,
+            breakdown =
+            RankingScoreBreakdown(
+                uniqueNodeCount = pr.uniqueNodes,
+                neighborDiversity = pr.directNeighborCount + pr.meshNeighborCount,
+                nonDupePacketCount = (pr.numPacketsRx - pr.numRxDupe).coerceAtLeast(0),
+                medianSnr = median(snrValues) { it },
+                medianRssi = medianInt(rssiValues),
+                bestKnownDistance = nodes.mapNotNull { it.distanceFromUser }.maxOrNull() ?: 0.0,
+                failurePenalty = pr.packetFailureRate,
+            ),
+        )
+    }
+
+    private fun assignRanks(sorted: List<ScoredPreset>): List<PresetRanking> {
+        if (sorted.isEmpty()) return emptyList()
+
+        // Detect tie groups: consecutive entries that compare as 0.
+        val tieFlags = BooleanArray(sorted.size)
+        for (i in 0 until sorted.size - 1) {
+            if (RANKING_COMPARATOR.compare(sorted[i], sorted[i + 1]) == 0) {
+                tieFlags[i] = true
+                tieFlags[i + 1] = true
+            }
+        }
+
+        val result = mutableListOf<PresetRanking>()
+        var currentRank = 1
+        for (i in sorted.indices) {
+            if (i > 0 && RANKING_COMPARATOR.compare(sorted[i - 1], sorted[i]) != 0) {
+                currentRank = i + 1
+            }
+            result +=
+                PresetRanking(
+                    rank = currentRank,
+                    presetResult = sorted[i].presetResult,
+                    scoreBreakdown = sorted[i].breakdown,
+                    isTied = tieFlags[i],
+                )
+        }
+        return result
+    }
+
+    companion object {
+        /**
+         * Comparator implementing the 6-level heuristic (best-first ordering). "Higher is better" criteria use
+         * descending compare (b vs a). "Lower is better" criteria (penalty) use ascending compare (a vs b).
+         */
+        private val RANKING_COMPARATOR =
+            Comparator<ScoredPreset> { a, b ->
+                // 1. Highest unique node count
+                var cmp = b.breakdown.uniqueNodeCount.compareTo(a.breakdown.uniqueNodeCount)
+                if (cmp != 0) return@Comparator cmp
+
+                // 2. Highest neighbor-report diversity
+                cmp = b.breakdown.neighborDiversity.compareTo(a.breakdown.neighborDiversity)
+                if (cmp != 0) return@Comparator cmp
+
+                // 3. Highest non-duplicate packet count
+                cmp = b.breakdown.nonDupePacketCount.compareTo(a.breakdown.nonDupePacketCount)
+                if (cmp != 0) return@Comparator cmp
+
+                // 4. Best median link quality: SNR first, then RSSI
+                cmp = b.breakdown.medianSnr.compareTo(a.breakdown.medianSnr)
+                if (cmp != 0) return@Comparator cmp
+                cmp = b.breakdown.medianRssi.compareTo(a.breakdown.medianRssi)
+                if (cmp != 0) return@Comparator cmp
+
+                // 5. Greatest best-known distance
+                cmp = b.breakdown.bestKnownDistance.compareTo(a.breakdown.bestKnownDistance)
+                if (cmp != 0) return@Comparator cmp
+
+                // 6. Lowest failure/reconnect penalty
+                a.breakdown.failurePenalty.compareTo(b.breakdown.failurePenalty)
+            }
+
+        /** Compute the median of a sorted float-convertible list. Returns 0 for empty. */
+        internal fun <T> median(sorted: List<T>, toFloat: (T) -> Float): Float {
+            if (sorted.isEmpty()) return 0f
+            val mid = sorted.size / 2
+            return if (sorted.size % 2 == 0) {
+                (toFloat(sorted[mid - 1]) + toFloat(sorted[mid])) / 2f
+            } else {
+                toFloat(sorted[mid])
+            }
+        }
+
+        /** Compute the median of a sorted Int list. Returns 0 for empty. */
+        private fun medianInt(sorted: List<Int>): Int {
+            if (sorted.isEmpty()) return 0
+            val mid = sorted.size / 2
+            return if (sorted.size % 2 == 0) {
+                (sorted[mid - 1] + sorted[mid]) / 2
+            } else {
+                sorted[mid]
+            }
+        }
+    }
+}

feature/discovery/src/commonMain/kotlin/org/meshtastic/feature/discovery/ui/DiscoveryHistoryDetailScreen.kt

@@ -0,0 +1,169 @@
+/*
+ * Copyright (c) 2026 Meshtastic LLC
+ *
+ * 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 org.meshtastic.feature.discovery.ui
+
+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.rememberScrollState
+import androidx.compose.foundation.verticalScroll
+import androidx.compose.material3.Card
+import androidx.compose.material3.CardDefaults
+import androidx.compose.material3.ExperimentalMaterial3Api
+import androidx.compose.material3.HorizontalDivider
+import androidx.compose.material3.Icon
+import androidx.compose.material3.IconButton
+import androidx.compose.material3.MaterialTheme
+import androidx.compose.material3.Scaffold
+import androidx.compose.material3.Text
+import androidx.compose.material3.TopAppBar
+import androidx.compose.runtime.Composable
+import androidx.compose.runtime.getValue
+import androidx.compose.ui.Modifier
+import androidx.compose.ui.unit.dp
+import androidx.lifecycle.compose.collectAsStateWithLifecycle
+import org.jetbrains.compose.resources.stringResource
+import org.meshtastic.core.database.entity.DiscoverySessionEntity
+import org.meshtastic.core.resources.Res
+import org.meshtastic.core.resources.back
+import org.meshtastic.core.resources.discovery_session_detail
+import org.meshtastic.core.resources.discovery_stat_home_preset
+import org.meshtastic.core.resources.discovery_stat_preset_results
+import org.meshtastic.core.resources.discovery_stat_presets_scanned
+import org.meshtastic.core.resources.discovery_stat_status
+import org.meshtastic.core.resources.discovery_stat_total_dwell_time
+import org.meshtastic.core.resources.discovery_stat_total_messages
+import org.meshtastic.core.resources.discovery_stat_unique_nodes
+import org.meshtastic.core.resources.discovery_view_map
+import org.meshtastic.core.ui.icon.ArrowBack
+import org.meshtastic.core.ui.icon.Map
+import org.meshtastic.core.ui.icon.MeshtasticIcons
+import org.meshtastic.feature.discovery.DiscoveryHistoryDetailViewModel
+import org.meshtastic.feature.discovery.ui.component.PresetResultCard
+
+@OptIn(ExperimentalMaterial3Api::class)
+@Composable
+fun DiscoveryHistoryDetailScreen(
+    viewModel: DiscoveryHistoryDetailViewModel,
+    onNavigateUp: () -> Unit,
+    onNavigateToMap: (Long) -> Unit,
+    modifier: Modifier = Modifier,
+) {
+    val session by viewModel.session.collectAsStateWithLifecycle()
+    val presetResults by viewModel.presetResults.collectAsStateWithLifecycle()
+    val nodesByPreset by viewModel.nodesByPreset.collectAsStateWithLifecycle()
+
+    Scaffold(
+        modifier = modifier,
+        topBar = {
+            TopAppBar(
+                title = { Text(stringResource(Res.string.discovery_session_detail)) },
+                navigationIcon = {
+                    IconButton(onClick = onNavigateUp) {
+                        Icon(MeshtasticIcons.ArrowBack, contentDescription = stringResource(Res.string.back))
+                    }
+                },
+                actions = {
+                    val s = session
+                    val hasAnyMappableNodes =
+                        nodesByPreset.values.flatten().any {
+                            it.latitude != null && it.longitude != null && it.latitude != 0.0
+                        }
+                    if (s != null && (s.userLatitude != 0.0 || hasAnyMappableNodes)) {
+                        IconButton(onClick = { onNavigateToMap(s.id) }) {
+                            Icon(
+                                MeshtasticIcons.Map,
+                                contentDescription = stringResource(Res.string.discovery_view_map),
+                            )
+                        }
+                    }
+                },
+            )
+        },
+    ) { padding ->
+        Column(
+            modifier = Modifier.padding(padding).fillMaxSize().verticalScroll(rememberScrollState()).padding(16.dp),
+            verticalArrangement = Arrangement.spacedBy(16.dp),
+        ) {
+            session?.let { s -> SessionMetadataCard(s) }
+
+            if (presetResults.isNotEmpty()) {
+                Text(
+                    text = stringResource(Res.string.discovery_stat_preset_results),
+                    style = MaterialTheme.typography.titleMedium,
+                )
+                presetResults.forEach { result ->
+                    PresetResultCard(result = result, nodes = nodesByPreset[result.id].orEmpty())
+                }
+            }
+        }
+    }
+}
+
+@Composable
+private fun SessionMetadataCard(session: DiscoverySessionEntity) {
+    Card(
+        modifier = Modifier.fillMaxWidth(),
+        colors = CardDefaults.cardColors(containerColor = MaterialTheme.colorScheme.surfaceVariant),
+    ) {
+        Column(modifier = Modifier.padding(16.dp)) {
+            Text(text = formatTimestamp(session.timestamp), style = MaterialTheme.typography.titleMedium)
+            Spacer(Modifier.height(8.dp))
+            MetadataRow(
+                stringResource(Res.string.discovery_stat_status),
+                session.completionStatus.replaceFirstChar { it.uppercase() },
+            )
+            MetadataRow(stringResource(Res.string.discovery_stat_presets_scanned), session.presetsScanned)
+            MetadataRow(stringResource(Res.string.discovery_stat_home_preset), session.homePreset)
+            MetadataRow(stringResource(Res.string.discovery_stat_unique_nodes), session.totalUniqueNodes.toString())
+            MetadataRow(stringResource(Res.string.discovery_stat_total_messages), session.totalMessages.toString())
+            MetadataRow(
+                stringResource(Res.string.discovery_stat_total_dwell_time),
+                formatDuration(session.totalDwellSeconds),
+            )
+            session.aiSummary?.let { summary ->
+                Spacer(Modifier.height(8.dp))
+                HorizontalDivider()
+                Spacer(Modifier.height(8.dp))
+                Text(
+                    text = summary,
+                    style = MaterialTheme.typography.bodyMedium,
+                    color = MaterialTheme.colorScheme.onSurfaceVariant,
+                )
+            }
+        }
+    }
+}
+
+@Composable
+private fun MetadataRow(label: String, value: String) {
+    Row(modifier = Modifier.fillMaxWidth().padding(vertical = 2.dp)) {
+        Text(
+            text = label,
+            style = MaterialTheme.typography.bodyMedium,
+            color = MaterialTheme.colorScheme.onSurfaceVariant,
+            modifier = Modifier.width(140.dp),
+        )
+        Text(text = value, style = MaterialTheme.typography.bodyMedium)
+    }
+}

feature/discovery/src/commonMain/kotlin/org/meshtastic/feature/discovery/ui/DiscoveryHistoryScreen.kt

@@ -0,0 +1,227 @@
+/*
+ * Copyright (c) 2026 Meshtastic LLC
+ *
+ * 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 org.meshtastic.feature.discovery.ui
+
+import androidx.compose.foundation.clickable
+import androidx.compose.foundation.layout.Arrangement
+import androidx.compose.foundation.layout.Box
+import androidx.compose.foundation.layout.Column
+import androidx.compose.foundation.layout.Row
+import androidx.compose.foundation.layout.Spacer
+import androidx.compose.foundation.layout.fillMaxSize
+import androidx.compose.foundation.layout.fillMaxWidth
+import androidx.compose.foundation.layout.height
+import androidx.compose.foundation.layout.padding
+import androidx.compose.foundation.layout.size
+import androidx.compose.foundation.layout.width
+import androidx.compose.foundation.lazy.LazyColumn
+import androidx.compose.foundation.lazy.items
+import androidx.compose.material3.AlertDialog
+import androidx.compose.material3.Card
+import androidx.compose.material3.ExperimentalMaterial3Api
+import androidx.compose.material3.Icon
+import androidx.compose.material3.IconButton
+import androidx.compose.material3.MaterialTheme
+import androidx.compose.material3.Scaffold
+import androidx.compose.material3.Text
+import androidx.compose.material3.TextButton
+import androidx.compose.material3.TopAppBar
+import androidx.compose.runtime.Composable
+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.semantics.contentDescription
+import androidx.compose.ui.semantics.semantics
+import androidx.compose.ui.unit.dp
+import androidx.lifecycle.compose.collectAsStateWithLifecycle
+import org.jetbrains.compose.resources.stringResource
+import org.meshtastic.core.common.util.DateFormatter
+import org.meshtastic.core.database.entity.DiscoverySessionEntity
+import org.meshtastic.core.resources.Res
+import org.meshtastic.core.resources.back
+import org.meshtastic.core.resources.cancel
+import org.meshtastic.core.resources.delete
+import org.meshtastic.core.resources.discovery_delete_session
+import org.meshtastic.core.resources.discovery_delete_session_confirm
+import org.meshtastic.core.resources.discovery_empty_history
+import org.meshtastic.core.resources.discovery_history
+import org.meshtastic.core.resources.discovery_scan_complete
+import org.meshtastic.core.resources.discovery_scan_incomplete
+import org.meshtastic.core.resources.discovery_unique_nodes
+import org.meshtastic.core.ui.icon.ArrowBack
+import org.meshtastic.core.ui.icon.CheckCircle
+import org.meshtastic.core.ui.icon.Delete
+import org.meshtastic.core.ui.icon.History
+import org.meshtastic.core.ui.icon.MeshtasticIcons
+import org.meshtastic.core.ui.icon.Warning
+import org.meshtastic.feature.discovery.DiscoveryHistoryViewModel
+
+@OptIn(ExperimentalMaterial3Api::class)
+@Composable
+fun DiscoveryHistoryScreen(
+    viewModel: DiscoveryHistoryViewModel,
+    onNavigateUp: () -> Unit,
+    onNavigateToDetail: (sessionId: Long) -> Unit,
+    modifier: Modifier = Modifier,
+) {
+    val sessions by viewModel.sessions.collectAsStateWithLifecycle()
+
+    Scaffold(
+        modifier = modifier,
+        topBar = {
+            TopAppBar(
+                title = { Text(stringResource(Res.string.discovery_history)) },
+                navigationIcon = {
+                    IconButton(onClick = onNavigateUp) {
+                        Icon(MeshtasticIcons.ArrowBack, contentDescription = stringResource(Res.string.back))
+                    }
+                },
+            )
+        },
+    ) { padding ->
+        if (sessions.isEmpty()) {
+            EmptyHistoryState(modifier = Modifier.padding(padding).fillMaxSize())
+        } else {
+            LazyColumn(
+                modifier = Modifier.padding(padding).fillMaxSize(),
+                verticalArrangement = Arrangement.spacedBy(8.dp),
+                contentPadding = androidx.compose.foundation.layout.PaddingValues(16.dp),
+            ) {
+                items(sessions, key = { it.id }) { session ->
+                    SessionListItem(
+                        session = session,
+                        onClick = { onNavigateToDetail(session.id) },
+                        onDelete = { viewModel.deleteSession(session.id) },
+                    )
+                }
+            }
+        }
+    }
+}
+
+@Composable
+private fun EmptyHistoryState(modifier: Modifier = Modifier) {
+    Box(modifier = modifier, contentAlignment = Alignment.Center) {
+        Column(horizontalAlignment = Alignment.CenterHorizontally) {
+            Icon(
+                imageVector = MeshtasticIcons.History,
+                contentDescription = null,
+                modifier = Modifier.size(64.dp),
+                tint = MaterialTheme.colorScheme.onSurfaceVariant,
+            )
+            Spacer(Modifier.height(16.dp))
+            Text(
+                text = stringResource(Res.string.discovery_empty_history),
+                style = MaterialTheme.typography.bodyLarge,
+                color = MaterialTheme.colorScheme.onSurfaceVariant,
+            )
+        }
+    }
+}
+
+@Composable
+private fun SessionListItem(session: DiscoverySessionEntity, onClick: () -> Unit, onDelete: () -> Unit) {
+    var showDeleteDialog by remember { mutableStateOf(false) }
+    val sessionDescription =
+        "${formatTimestamp(session.timestamp)}, ${session.presetsScanned}, " +
+            "${session.totalUniqueNodes} unique nodes, " +
+            if (session.completionStatus == "complete") "complete" else "incomplete"
+
+    Card(
+        modifier =
+        Modifier.fillMaxWidth().clickable(onClick = onClick).semantics(mergeDescendants = true) {
+            contentDescription = sessionDescription
+        },
+    ) {
+        Row(modifier = Modifier.padding(16.dp).fillMaxWidth(), verticalAlignment = Alignment.CenterVertically) {
+            CompletionStatusIcon(session.completionStatus)
+            Spacer(Modifier.width(12.dp))
+            Column(modifier = Modifier.weight(1f)) {
+                Text(text = formatTimestamp(session.timestamp), style = MaterialTheme.typography.titleSmall)
+                Spacer(Modifier.height(4.dp))
+                Text(
+                    text = session.presetsScanned,
+                    style = MaterialTheme.typography.bodyMedium,
+                    color = MaterialTheme.colorScheme.onSurfaceVariant,
+                )
+                Spacer(Modifier.height(2.dp))
+                Text(
+                    text = stringResource(Res.string.discovery_unique_nodes, session.totalUniqueNodes),
+                    style = MaterialTheme.typography.bodySmall,
+                    color = MaterialTheme.colorScheme.onSurfaceVariant,
+                )
+            }
+            IconButton(onClick = { showDeleteDialog = true }) {
+                Icon(
+                    imageVector = MeshtasticIcons.Delete,
+                    contentDescription = stringResource(Res.string.discovery_delete_session),
+                    tint = MaterialTheme.colorScheme.error,
+                )
+            }
+        }
+    }
+
+    if (showDeleteDialog) {
+        DeleteConfirmationDialog(
+            onConfirm = {
+                onDelete()
+                showDeleteDialog = false
+            },
+            onDismiss = { showDeleteDialog = false },
+        )
+    }
+}
+
+@Composable
+private fun CompletionStatusIcon(status: String) {
+    if (status == "complete") {
+        Icon(
+            imageVector = MeshtasticIcons.CheckCircle,
+            contentDescription = stringResource(Res.string.discovery_scan_complete),
+            tint = MaterialTheme.colorScheme.primary,
+            modifier = Modifier.size(24.dp),
+        )
+    } else {
+        Icon(
+            imageVector = MeshtasticIcons.Warning,
+            contentDescription = stringResource(Res.string.discovery_scan_incomplete),
+            tint = MaterialTheme.colorScheme.error,
+            modifier = Modifier.size(24.dp),
+        )
+    }
+}
+
+@Composable
+private fun DeleteConfirmationDialog(onConfirm: () -> Unit, onDismiss: () -> Unit) {
+    AlertDialog(
+        onDismissRequest = onDismiss,
+        title = { Text(stringResource(Res.string.discovery_delete_session)) },
+        text = { Text(stringResource(Res.string.discovery_delete_session_confirm)) },
+        confirmButton = {
+            TextButton(onClick = onConfirm) {
+                Text(stringResource(Res.string.delete), color = MaterialTheme.colorScheme.error)
+            }
+        },
+        dismissButton = { TextButton(onClick = onDismiss) { Text(stringResource(Res.string.cancel)) } },
+    )
+}
+
+@Suppress("MagicNumber")
+internal fun formatTimestamp(epochMillis: Long): String = DateFormatter.formatDateTimeShort(epochMillis)

feature/discovery/src/commonMain/kotlin/org/meshtastic/feature/discovery/ui/DiscoveryMapScreen.kt

@@ -0,0 +1,107 @@
+/*
+ * Copyright (c) 2026 Meshtastic LLC
+ *
+ * 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 org.meshtastic.feature.discovery.ui
+
+import androidx.compose.foundation.layout.Box
+import androidx.compose.foundation.layout.fillMaxSize
+import androidx.compose.foundation.layout.padding
+import androidx.compose.material3.CircularProgressIndicator
+import androidx.compose.material3.ExperimentalMaterial3Api
+import androidx.compose.material3.Icon
+import androidx.compose.material3.IconButton
+import androidx.compose.material3.Scaffold
+import androidx.compose.material3.Text
+import androidx.compose.material3.TopAppBar
+import androidx.compose.runtime.Composable
+import androidx.compose.runtime.getValue
+import androidx.compose.ui.Alignment
+import androidx.compose.ui.Modifier
+import androidx.lifecycle.compose.collectAsStateWithLifecycle
+import org.jetbrains.compose.resources.stringResource
+import org.meshtastic.core.resources.Res
+import org.meshtastic.core.resources.back
+import org.meshtastic.core.resources.discovery_map
+import org.meshtastic.core.ui.icon.ArrowBack
+import org.meshtastic.core.ui.icon.MeshtasticIcons
+import org.meshtastic.core.ui.util.DiscoveryMapNode
+import org.meshtastic.core.ui.util.DiscoveryNeighborType
+import org.meshtastic.core.ui.util.LocalDiscoveryMapProvider
+import org.meshtastic.feature.discovery.DiscoveryMapViewModel
+
+/**
+ * Full-screen map showing all discovered nodes from a scan session. Delegates to the flavor-specific map implementation
+ * via [LocalDiscoveryMapProvider].
+ */
+@OptIn(ExperimentalMaterial3Api::class)
+@Composable
+fun DiscoveryMapScreen(viewModel: DiscoveryMapViewModel, onNavigateUp: () -> Unit, modifier: Modifier = Modifier) {
+    val session by viewModel.session.collectAsStateWithLifecycle()
+    val allNodes by viewModel.allNodes.collectAsStateWithLifecycle()
+    val discoveryMap = LocalDiscoveryMapProvider.current
+
+    Scaffold(
+        modifier = modifier,
+        topBar = {
+            TopAppBar(
+                title = { Text(stringResource(Res.string.discovery_map)) },
+                navigationIcon = {
+                    IconButton(onClick = onNavigateUp) {
+                        Icon(MeshtasticIcons.ArrowBack, contentDescription = stringResource(Res.string.back))
+                    }
+                },
+            )
+        },
+    ) { padding ->
+        val currentSession = session
+        if (currentSession == null) {
+            Box(modifier = Modifier.fillMaxSize().padding(padding), contentAlignment = Alignment.Center) {
+                CircularProgressIndicator()
+            }
+            return@Scaffold
+        }
+
+        val mapNodes =
+            allNodes.mapNotNull { entity ->
+                val lat = entity.latitude ?: return@mapNotNull null
+                val lon = entity.longitude ?: return@mapNotNull null
+                if (lat == 0.0 && lon == 0.0) return@mapNotNull null
+                DiscoveryMapNode(
+                    latitude = lat,
+                    longitude = lon,
+                    shortName = entity.shortName,
+                    longName = entity.longName,
+                    neighborType =
+                    if (entity.neighborType == "direct") {
+                        DiscoveryNeighborType.DIRECT
+                    } else {
+                        DiscoveryNeighborType.MESH
+                    },
+                    snr = entity.snr,
+                    rssi = entity.rssi,
+                    messageCount = entity.messageCount,
+                    sensorPacketCount = entity.sensorPacketCount,
+                )
+            }
+
+        discoveryMap(
+            currentSession.userLatitude,
+            currentSession.userLongitude,
+            mapNodes,
+            Modifier.fillMaxSize().padding(padding),
+        )
+    }
+}

feature/discovery/src/commonMain/kotlin/org/meshtastic/feature/discovery/ui/DiscoveryScanScreen.kt

@@ -0,0 +1,465 @@
+/*
+ * Copyright (c) 2026 Meshtastic LLC
+ *
+ * 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/>.
+ */
+@file:Suppress("TooManyFunctions", "MagicNumber")
+
+package org.meshtastic.feature.discovery.ui
+
+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.lazy.LazyColumn
+import androidx.compose.material3.Button
+import androidx.compose.material3.ButtonDefaults
+import androidx.compose.material3.CenterAlignedTopAppBar
+import androidx.compose.material3.DropdownMenuItem
+import androidx.compose.material3.ElevatedCard
+import androidx.compose.material3.ExperimentalMaterial3Api
+import androidx.compose.material3.ExposedDropdownMenuBox
+import androidx.compose.material3.ExposedDropdownMenuDefaults
+import androidx.compose.material3.Icon
+import androidx.compose.material3.IconButton
+import androidx.compose.material3.MaterialTheme
+import androidx.compose.material3.MenuAnchorType
+import androidx.compose.material3.OutlinedButton
+import androidx.compose.material3.OutlinedTextField
+import androidx.compose.material3.Scaffold
+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.saveable.rememberSaveable
+import androidx.compose.runtime.setValue
+import androidx.compose.ui.Alignment
+import androidx.compose.ui.Modifier
+import androidx.compose.ui.semantics.LiveRegionMode
+import androidx.compose.ui.semantics.contentDescription
+import androidx.compose.ui.semantics.heading
+import androidx.compose.ui.semantics.liveRegion
+import androidx.compose.ui.semantics.semantics
+import androidx.compose.ui.unit.dp
+import androidx.lifecycle.compose.collectAsStateWithLifecycle
+import org.jetbrains.compose.resources.stringResource
+import org.meshtastic.core.resources.Res
+import org.meshtastic.core.resources.back
+import org.meshtastic.core.resources.discovery_analysing_results
+import org.meshtastic.core.resources.discovery_cancelling_scan
+import org.meshtastic.core.resources.discovery_connection_warning
+import org.meshtastic.core.resources.discovery_dwell_time
+import org.meshtastic.core.resources.discovery_dwell_time_description
+import org.meshtastic.core.resources.discovery_keep_screen_awake
+import org.meshtastic.core.resources.discovery_keep_screen_awake_description
+import org.meshtastic.core.resources.discovery_local_mesh
+import org.meshtastic.core.resources.discovery_not_connected
+import org.meshtastic.core.resources.discovery_not_connected_description
+import org.meshtastic.core.resources.discovery_paused
+import org.meshtastic.core.resources.discovery_preparing
+import org.meshtastic.core.resources.discovery_reconnecting
+import org.meshtastic.core.resources.discovery_restoring_preset
+import org.meshtastic.core.resources.discovery_scan_failed
+import org.meshtastic.core.resources.discovery_scan_history
+import org.meshtastic.core.resources.discovery_scan_progress
+import org.meshtastic.core.resources.discovery_shifting_to
+import org.meshtastic.core.resources.discovery_start_scan
+import org.meshtastic.core.resources.discovery_start_scan_disabled
+import org.meshtastic.core.resources.discovery_start_scan_reason_24ghz_unsupported
+import org.meshtastic.core.resources.discovery_start_scan_reason_default_key
+import org.meshtastic.core.resources.discovery_start_scan_reason_no_presets
+import org.meshtastic.core.resources.discovery_start_scan_reason_not_connected
+import org.meshtastic.core.resources.discovery_stop_scan
+import org.meshtastic.core.ui.component.SwitchPreference
+import org.meshtastic.core.ui.icon.ArrowBack
+import org.meshtastic.core.ui.icon.Close
+import org.meshtastic.core.ui.icon.History
+import org.meshtastic.core.ui.icon.MeshtasticIcons
+import org.meshtastic.core.ui.icon.PlayArrow
+import org.meshtastic.core.ui.icon.Warning
+import org.meshtastic.core.ui.util.KeepScreenOn
+import org.meshtastic.feature.discovery.DiscoveryScanState
+import org.meshtastic.feature.discovery.DiscoveryViewModel
+import org.meshtastic.feature.discovery.ui.component.DwellProgressIndicator
+import org.meshtastic.feature.discovery.ui.component.PresetPickerCard
+
+private val CONTENT_PADDING = 16.dp
+private val SECTION_SPACING = 16.dp
+
+private val DWELL_OPTIONS = listOf(1, 5, 15, 30, 45, 60, 90, 120, 180)
+
+/** Main scan screen for the Local Mesh Discovery feature. */
+@Suppress("LongMethod")
+@OptIn(ExperimentalMaterial3Api::class)
+@Composable
+fun DiscoveryScanScreen(
+    viewModel: DiscoveryViewModel,
+    onNavigateUp: () -> Unit,
+    onNavigateToSummary: (sessionId: Long) -> Unit,
+    onNavigateToHistory: () -> Unit,
+    modifier: Modifier = Modifier,
+) {
+    val scanState by viewModel.scanState.collectAsStateWithLifecycle()
+    val selectedPresets by viewModel.selectedPresets.collectAsStateWithLifecycle()
+    val dwellMinutes by viewModel.dwellDurationMinutes.collectAsStateWithLifecycle()
+    val isConnected by viewModel.isConnected.collectAsStateWithLifecycle()
+    val usesDefaultKey by viewModel.usesDefaultKey.collectAsStateWithLifecycle()
+    val is24GhzBlocked by viewModel.is24GhzBlocked.collectAsStateWithLifecycle()
+    val isLora24Region by viewModel.isLora24Region.collectAsStateWithLifecycle()
+    val currentSession by viewModel.currentSession.collectAsStateWithLifecycle()
+    val homePreset by viewModel.homePreset.collectAsStateWithLifecycle()
+
+    var keepScreenAwake by rememberSaveable { mutableStateOf(true) }
+    val isScanning = scanState !is DiscoveryScanState.Idle
+
+    // Keep screen awake while a scan is in progress
+    KeepScreenOn(isScanning && keepScreenAwake)
+
+    // Navigate to summary when scan completes
+    LaunchedEffect(scanState, onNavigateToSummary) {
+        if (scanState is DiscoveryScanState.Complete) {
+            currentSession?.id?.let { sessionId ->
+                viewModel.reset()
+                onNavigateToSummary(sessionId)
+            }
+        }
+    }
+
+    Scaffold(
+        modifier = modifier,
+        topBar = {
+            CenterAlignedTopAppBar(
+                title = { Text(stringResource(Res.string.discovery_local_mesh)) },
+                navigationIcon = {
+                    IconButton(onClick = onNavigateUp) {
+                        Icon(
+                            imageVector = MeshtasticIcons.ArrowBack,
+                            contentDescription = stringResource(Res.string.back),
+                        )
+                    }
+                },
+                actions = {
+                    IconButton(onClick = onNavigateToHistory) {
+                        Icon(
+                            imageVector = MeshtasticIcons.History,
+                            contentDescription = stringResource(Res.string.discovery_scan_history),
+                        )
+                    }
+                },
+            )
+        },
+        bottomBar = {
+            androidx.compose.material3.Surface(
+                modifier = Modifier.fillMaxWidth(),
+                color = MaterialTheme.colorScheme.surface,
+                tonalElevation = 8.dp,
+                shadowElevation = 8.dp,
+            ) {
+                androidx.compose.foundation.layout.Box(
+                    modifier = Modifier.padding(horizontal = CONTENT_PADDING, vertical = 16.dp),
+                ) {
+                    ScanButton(
+                        scanState = scanState,
+                        isConnected = isConnected,
+                        hasPresetsSelected = selectedPresets.isNotEmpty(),
+                        usesDefaultKey = usesDefaultKey,
+                        is24GhzUnsupported = isLora24Region && is24GhzBlocked,
+                        onStart = viewModel::startScan,
+                        onStop = viewModel::stopScan,
+                    )
+                }
+            }
+        },
+    ) { padding ->
+        LazyColumn(
+            contentPadding = padding,
+            verticalArrangement = Arrangement.spacedBy(SECTION_SPACING),
+            modifier = Modifier.fillMaxSize().padding(horizontal = CONTENT_PADDING).padding(top = SECTION_SPACING),
+        ) {
+            // Connection warning
+            if (!isConnected) {
+                item(key = "connection_warning") { ConnectionWarningCard() }
+            }
+
+            if (!isScanning) {
+                // Preset picker
+                item(key = "preset_picker") {
+                    PresetPickerCard(
+                        selectedPresets = selectedPresets,
+                        homePreset = homePreset,
+                        onTogglePreset = viewModel::togglePreset,
+                        enabled = true,
+                    )
+                }
+
+                // Dwell time picker
+                item(key = "dwell_picker") {
+                    DwellTimePicker(
+                        selectedMinutes = dwellMinutes,
+                        onMinuteSelect = viewModel::setDwellDuration,
+                        enabled = true,
+                    )
+                }
+
+                // Keep awake toggle
+                item(key = "keep_awake_toggle") {
+                    KeepAwakeToggleCard(keepAwake = keepScreenAwake, onToggle = { keepScreenAwake = it })
+                }
+            }
+
+            // Scan progress section
+            if (isScanning) {
+                item(key = "scan_progress") { ScanProgressSection(scanState = scanState) }
+            }
+
+            // Bottom spacer
+            item { Spacer(modifier = Modifier.height(SECTION_SPACING)) }
+        }
+    }
+}
+
+@Composable
+private fun KeepAwakeToggleCard(keepAwake: Boolean, onToggle: (Boolean) -> Unit, modifier: Modifier = Modifier) {
+    ElevatedCard(modifier = modifier.fillMaxWidth()) {
+        SwitchPreference(
+            title = stringResource(Res.string.discovery_keep_screen_awake),
+            summary = stringResource(Res.string.discovery_keep_screen_awake_description),
+            checked = keepAwake,
+            enabled = true,
+            onCheckedChange = onToggle,
+        )
+    }
+}
+
+@Composable
+private fun ConnectionWarningCard(modifier: Modifier = Modifier) {
+    val warningDescription = stringResource(Res.string.discovery_connection_warning)
+    ElevatedCard(
+        modifier =
+        modifier.fillMaxWidth().semantics(mergeDescendants = true) {
+            contentDescription = warningDescription
+            liveRegion = LiveRegionMode.Polite
+        },
+    ) {
+        Row(
+            verticalAlignment = Alignment.CenterVertically,
+            horizontalArrangement = Arrangement.spacedBy(12.dp),
+            modifier = Modifier.padding(CONTENT_PADDING),
+        ) {
+            Icon(
+                imageVector = MeshtasticIcons.Warning,
+                contentDescription = null,
+                tint = MaterialTheme.colorScheme.error,
+            )
+            Column {
+                Text(
+                    text = stringResource(Res.string.discovery_not_connected),
+                    style = MaterialTheme.typography.titleSmall,
+                    color = MaterialTheme.colorScheme.error,
+                )
+                Text(
+                    text = stringResource(Res.string.discovery_not_connected_description),
+                    style = MaterialTheme.typography.bodySmall,
+                    color = MaterialTheme.colorScheme.onSurfaceVariant,
+                )
+            }
+        }
+    }
+}
+
+@OptIn(ExperimentalMaterial3Api::class)
+@Composable
+private fun DwellTimePicker(
+    selectedMinutes: Int,
+    onMinuteSelect: (Int) -> Unit,
+    enabled: Boolean,
+    modifier: Modifier = Modifier,
+) {
+    var expanded by remember { mutableStateOf(false) }
+    ElevatedCard(modifier = modifier.fillMaxWidth()) {
+        Column(modifier = Modifier.padding(CONTENT_PADDING)) {
+            Text(
+                text = stringResource(Res.string.discovery_dwell_time),
+                style = MaterialTheme.typography.titleMedium,
+                modifier = Modifier.semantics { heading() },
+            )
+            Text(
+                text = stringResource(Res.string.discovery_dwell_time_description),
+                style = MaterialTheme.typography.bodySmall,
+                color = MaterialTheme.colorScheme.onSurfaceVariant,
+                modifier = Modifier.padding(bottom = 8.dp),
+            )
+            ExposedDropdownMenuBox(expanded = expanded, onExpandedChange = { if (enabled) expanded = it }) {
+                OutlinedTextField(
+                    value = "$selectedMinutes min",
+                    onValueChange = {},
+                    readOnly = true,
+                    enabled = enabled,
+                    trailingIcon = { ExposedDropdownMenuDefaults.TrailingIcon(expanded = expanded) },
+                    modifier = Modifier.fillMaxWidth().menuAnchor(MenuAnchorType.PrimaryNotEditable),
+                )
+                ExposedDropdownMenu(expanded = expanded, onDismissRequest = { expanded = false }) {
+                    DWELL_OPTIONS.forEach { minutes ->
+                        DropdownMenuItem(
+                            text = { Text("$minutes min") },
+                            onClick = {
+                                onMinuteSelect(minutes)
+                                expanded = false
+                            },
+                        )
+                    }
+                }
+            }
+        }
+    }
+}
+
+@Composable
+private fun ScanButton(
+    scanState: DiscoveryScanState,
+    isConnected: Boolean,
+    hasPresetsSelected: Boolean,
+    usesDefaultKey: Boolean,
+    is24GhzUnsupported: Boolean,
+    onStart: () -> Unit,
+    onStop: () -> Unit,
+    modifier: Modifier = Modifier,
+) {
+    val isScanning = scanState !is DiscoveryScanState.Idle
+    if (isScanning) {
+        OutlinedButton(
+            onClick = onStop,
+            colors = ButtonDefaults.outlinedButtonColors(contentColor = MaterialTheme.colorScheme.error),
+            modifier = modifier.fillMaxWidth(),
+        ) {
+            Icon(imageVector = MeshtasticIcons.Close, contentDescription = null)
+            Text(stringResource(Res.string.discovery_stop_scan), modifier = Modifier.padding(start = 8.dp))
+        }
+    } else {
+        val isEnabled = isConnected && hasPresetsSelected && !usesDefaultKey && !is24GhzUnsupported
+        val disabledReason =
+            when {
+                !isConnected -> stringResource(Res.string.discovery_start_scan_reason_not_connected)
+                usesDefaultKey -> stringResource(Res.string.discovery_start_scan_reason_default_key)
+                is24GhzUnsupported -> stringResource(Res.string.discovery_start_scan_reason_24ghz_unsupported)
+                !hasPresetsSelected -> stringResource(Res.string.discovery_start_scan_reason_no_presets)
+                else -> ""
+            }
+        val disabledDescription = stringResource(Res.string.discovery_start_scan_disabled, disabledReason)
+        val buttonModifier =
+            if (!isEnabled) {
+                modifier.fillMaxWidth().semantics { contentDescription = disabledDescription }
+            } else {
+                modifier.fillMaxWidth()
+            }
+        Button(onClick = onStart, enabled = isEnabled, modifier = buttonModifier) {
+            Icon(imageVector = MeshtasticIcons.PlayArrow, contentDescription = null)
+            Text(stringResource(Res.string.discovery_start_scan), modifier = Modifier.padding(start = 8.dp))
+        }
+    }
+}
+
+@Suppress("LongMethod")
+@Composable
+private fun ScanProgressSection(scanState: DiscoveryScanState, modifier: Modifier = Modifier) {
+    ElevatedCard(modifier = modifier.fillMaxWidth()) {
+        Column(
+            verticalArrangement = Arrangement.spacedBy(12.dp),
+            modifier = Modifier.padding(CONTENT_PADDING).semantics { liveRegion = LiveRegionMode.Polite },
+        ) {
+            Text(
+                text = stringResource(Res.string.discovery_scan_progress),
+                style = MaterialTheme.typography.titleMedium,
+                modifier = Modifier.semantics { heading() },
+            )
+            when (scanState) {
+                is DiscoveryScanState.Preparing -> {
+                    Text(
+                        text = stringResource(Res.string.discovery_preparing),
+                        style = MaterialTheme.typography.bodyMedium,
+                    )
+                }
+
+                is DiscoveryScanState.Shifting -> {
+                    Text(
+                        text = stringResource(Res.string.discovery_shifting_to, scanState.presetName),
+                        style = MaterialTheme.typography.bodyMedium,
+                    )
+                }
+
+                is DiscoveryScanState.Reconnecting -> {
+                    Text(
+                        text = stringResource(Res.string.discovery_reconnecting, scanState.presetName),
+                        style = MaterialTheme.typography.bodyMedium,
+                    )
+                }
+
+                is DiscoveryScanState.Dwell -> {
+                    DwellProgressIndicator(
+                        presetName = scanState.presetName,
+                        remainingSeconds = scanState.remainingSeconds,
+                        totalSeconds = scanState.totalSeconds,
+                    )
+                }
+
+                is DiscoveryScanState.Analysis -> {
+                    Text(
+                        text = stringResource(Res.string.discovery_analysing_results),
+                        style = MaterialTheme.typography.bodyMedium,
+                    )
+                }
+
+                is DiscoveryScanState.Restoring -> {
+                    Text(
+                        text = stringResource(Res.string.discovery_restoring_preset),
+                        style = MaterialTheme.typography.bodyMedium,
+                    )
+                }
+
+                is DiscoveryScanState.Cancelling -> {
+                    Text(
+                        text = stringResource(Res.string.discovery_cancelling_scan),
+                        style = MaterialTheme.typography.bodyMedium,
+                    )
+                }
+
+                is DiscoveryScanState.Paused -> {
+                    Text(
+                        text = stringResource(Res.string.discovery_paused, scanState.reason),
+                        style = MaterialTheme.typography.bodyMedium,
+                        color = MaterialTheme.colorScheme.error,
+                    )
+                }
+
+                is DiscoveryScanState.Failed -> {
+                    Text(
+                        text = stringResource(Res.string.discovery_scan_failed, scanState.reason),
+                        style = MaterialTheme.typography.bodyMedium,
+                        color = MaterialTheme.colorScheme.error,
+                    )
+                }
+
+                is DiscoveryScanState.Complete,
+                is DiscoveryScanState.Idle,
+                -> Unit
+            }
+        }
+    }
+}

feature/discovery/src/commonMain/kotlin/org/meshtastic/feature/discovery/ui/DiscoverySummaryScreen.kt

@@ -0,0 +1,321 @@
+/*
+ * Copyright (c) 2026 Meshtastic LLC
+ *
+ * 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/>.
+ */
+@file:Suppress("MagicNumber")
+
+package org.meshtastic.feature.discovery.ui
+
+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.lazy.LazyColumn
+import androidx.compose.foundation.lazy.items
+import androidx.compose.material3.Card
+import androidx.compose.material3.CardDefaults
+import androidx.compose.material3.CircularProgressIndicator
+import androidx.compose.material3.ExperimentalMaterial3Api
+import androidx.compose.material3.Icon
+import androidx.compose.material3.IconButton
+import androidx.compose.material3.MaterialTheme
+import androidx.compose.material3.Scaffold
+import androidx.compose.material3.Text
+import androidx.compose.material3.TopAppBar
+import androidx.compose.runtime.Composable
+import androidx.compose.runtime.LaunchedEffect
+import androidx.compose.runtime.getValue
+import androidx.compose.ui.Alignment
+import androidx.compose.ui.Modifier
+import androidx.compose.ui.text.font.FontWeight
+import androidx.compose.ui.unit.dp
+import androidx.lifecycle.compose.collectAsStateWithLifecycle
+import org.jetbrains.compose.resources.stringResource
+import org.meshtastic.core.common.util.DateFormatter
+import org.meshtastic.core.common.util.NumberFormatter
+import org.meshtastic.core.database.entity.DiscoveredNodeEntity
+import org.meshtastic.core.database.entity.DiscoveryPresetResultEntity
+import org.meshtastic.core.database.entity.DiscoverySessionEntity
+import org.meshtastic.core.resources.Res
+import org.meshtastic.core.resources.back
+import org.meshtastic.core.resources.discovery_export_report
+import org.meshtastic.core.resources.discovery_rerun_analysis
+import org.meshtastic.core.resources.discovery_scan_summary
+import org.meshtastic.core.resources.discovery_stat_analysis
+import org.meshtastic.core.resources.discovery_stat_channel_utilization
+import org.meshtastic.core.resources.discovery_stat_date
+import org.meshtastic.core.resources.discovery_stat_session_overview
+import org.meshtastic.core.resources.discovery_stat_status
+import org.meshtastic.core.resources.discovery_stat_total_dwell_time
+import org.meshtastic.core.resources.discovery_stat_total_unique_nodes
+import org.meshtastic.core.resources.discovery_summary_not_available
+import org.meshtastic.core.resources.discovery_view_map
+import org.meshtastic.core.ui.icon.ArrowBack
+import org.meshtastic.core.ui.icon.Map
+import org.meshtastic.core.ui.icon.MeshtasticIcons
+import org.meshtastic.core.ui.icon.Refresh
+import org.meshtastic.core.ui.icon.Share
+import org.meshtastic.feature.discovery.DiscoverySummaryViewModel
+import org.meshtastic.feature.discovery.export.ExportResult
+import org.meshtastic.feature.discovery.export.rememberExportSaver
+import org.meshtastic.feature.discovery.scan.PresetRanking
+import org.meshtastic.feature.discovery.ui.component.PresetResultCard
+
+@Composable
+fun DiscoverySummaryScreen(
+    viewModel: DiscoverySummaryViewModel,
+    onNavigateUp: () -> Unit,
+    onNavigateToMap: (Long) -> Unit,
+) {
+    val session by viewModel.session.collectAsStateWithLifecycle()
+    val presetResults by viewModel.presetResults.collectAsStateWithLifecycle()
+    val nodesByPreset by viewModel.nodesByPreset.collectAsStateWithLifecycle()
+    val rankings by viewModel.rankings.collectAsStateWithLifecycle()
+    val algorithmicSummary by viewModel.algorithmicSummary.collectAsStateWithLifecycle()
+    val aiSummary by viewModel.aiSummary.collectAsStateWithLifecycle()
+    val presetAiSummaries by viewModel.presetAiSummaries.collectAsStateWithLifecycle()
+    val isGeneratingAi by viewModel.isGeneratingAi.collectAsStateWithLifecycle()
+    val exportResult by viewModel.exportResult.collectAsStateWithLifecycle()
+    val exportSaver = rememberExportSaver()
+
+    LaunchedEffect(exportResult) {
+        when (val result = exportResult) {
+            is ExportResult.Success -> {
+                exportSaver.save(result)
+                viewModel.clearExportResult()
+            }
+
+            is ExportResult.Error -> {
+                // TODO: Show snackbar with error message
+                viewModel.clearExportResult()
+            }
+
+            null -> {
+                /* no-op */
+            }
+        }
+    }
+
+    DiscoverySummaryContent(
+        session = session,
+        presetResults = presetResults,
+        nodesByPreset = nodesByPreset,
+        rankings = rankings,
+        algorithmicSummary = algorithmicSummary,
+        aiSummary = aiSummary,
+        presetAiSummaries = presetAiSummaries,
+        isGeneratingAi = isGeneratingAi,
+        onNavigateUp = onNavigateUp,
+        onNavigateToMap = onNavigateToMap,
+        onExport = viewModel::exportReport,
+        onRerunAnalysis = viewModel::rerunAnalysis,
+    )
+}
+
+@OptIn(ExperimentalMaterial3Api::class)
+@Composable
+@Suppress("LongParameterList", "LongMethod")
+private fun DiscoverySummaryContent(
+    session: DiscoverySessionEntity?,
+    presetResults: List<DiscoveryPresetResultEntity>,
+    nodesByPreset: Map<Long, List<DiscoveredNodeEntity>>,
+    rankings: List<PresetRanking>,
+    algorithmicSummary: String?,
+    aiSummary: String?,
+    presetAiSummaries: Map<Long, String>,
+    isGeneratingAi: Boolean,
+    onNavigateUp: () -> Unit,
+    onNavigateToMap: (Long) -> Unit,
+    onExport: () -> Unit,
+    onRerunAnalysis: () -> Unit,
+) {
+    Scaffold(
+        topBar = {
+            TopAppBar(
+                title = { Text(stringResource(Res.string.discovery_scan_summary)) },
+                navigationIcon = {
+                    IconButton(onClick = onNavigateUp) {
+                        Icon(MeshtasticIcons.ArrowBack, contentDescription = stringResource(Res.string.back))
+                    }
+                },
+                actions = {
+                    if (session != null) {
+                        IconButton(onClick = { onNavigateToMap(session.id) }) {
+                            Icon(
+                                MeshtasticIcons.Map,
+                                contentDescription = stringResource(Res.string.discovery_view_map),
+                            )
+                        }
+                    }
+                    IconButton(onClick = onExport) {
+                        Icon(
+                            MeshtasticIcons.Share,
+                            contentDescription = stringResource(Res.string.discovery_export_report),
+                        )
+                    }
+                },
+            )
+        },
+    ) { padding ->
+        if (session == null) {
+            CircularProgressIndicator(modifier = Modifier.fillMaxSize().padding(padding))
+            return@Scaffold
+        }
+
+        LazyColumn(
+            modifier = Modifier.fillMaxSize().padding(padding).padding(horizontal = 16.dp),
+            verticalArrangement = Arrangement.spacedBy(12.dp),
+        ) {
+            item { Spacer(modifier = Modifier.height(4.dp)) }
+
+            item { SessionOverviewCard(session = session) }
+
+            items(presetResults, key = { it.id }) { result ->
+                val ranking = rankings.find { it.presetResult.id == result.id }
+                PresetResultCard(
+                    result = result,
+                    nodes = nodesByPreset[result.id].orEmpty(),
+                    aiSummary = presetAiSummaries[result.id],
+                    rank = ranking?.rank,
+                    isTied = ranking?.isTied == true,
+                )
+            }
+
+            item {
+                AiSummaryCard(
+                    aiSummary = aiSummary ?: session.aiSummary,
+                    algorithmicSummary = algorithmicSummary,
+                    isGenerating = isGeneratingAi,
+                    onRerunAnalysis = onRerunAnalysis,
+                )
+            }
+
+            item { Spacer(modifier = Modifier.height(16.dp)) }
+        }
+    }
+}
+
+@Composable
+private fun SessionOverviewCard(session: DiscoverySessionEntity) {
+    Card(
+        modifier = Modifier.fillMaxWidth(),
+        colors = CardDefaults.cardColors(containerColor = MaterialTheme.colorScheme.primaryContainer),
+    ) {
+        Column(modifier = Modifier.padding(16.dp)) {
+            Text(
+                text = stringResource(Res.string.discovery_stat_session_overview),
+                style = MaterialTheme.typography.titleMedium,
+                fontWeight = FontWeight.Bold,
+            )
+            Spacer(modifier = Modifier.height(8.dp))
+
+            StatRow(
+                label = stringResource(Res.string.discovery_stat_date),
+                value = DateFormatter.formatDateTime(session.timestamp),
+            )
+            StatRow(
+                label = stringResource(Res.string.discovery_stat_total_unique_nodes),
+                value = session.totalUniqueNodes.toString(),
+            )
+            StatRow(
+                label = stringResource(Res.string.discovery_stat_total_dwell_time),
+                value = formatDuration(session.totalDwellSeconds),
+            )
+            StatRow(
+                label = stringResource(Res.string.discovery_stat_status),
+                value = session.completionStatus.replaceFirstChar { it.uppercase() },
+            )
+            StatRow(
+                label = stringResource(Res.string.discovery_stat_channel_utilization),
+                value = "${NumberFormatter.format(session.avgChannelUtilization, 1)}%",
+            )
+        }
+    }
+}
+
+@Composable
+private fun AiSummaryCard(
+    aiSummary: String?,
+    algorithmicSummary: String?,
+    isGenerating: Boolean,
+    onRerunAnalysis: () -> Unit,
+) {
+    Card(
+        modifier = Modifier.fillMaxWidth(),
+        colors = CardDefaults.cardColors(containerColor = MaterialTheme.colorScheme.tertiaryContainer),
+    ) {
+        Column(modifier = Modifier.padding(16.dp)) {
+            Row(
+                modifier = Modifier.fillMaxWidth(),
+                horizontalArrangement = Arrangement.SpaceBetween,
+                verticalAlignment = Alignment.CenterVertically,
+            ) {
+                Text(
+                    text = stringResource(Res.string.discovery_stat_analysis),
+                    style = MaterialTheme.typography.titleMedium,
+                    fontWeight = FontWeight.Bold,
+                )
+                if (isGenerating) {
+                    CircularProgressIndicator(modifier = Modifier.padding(4.dp), strokeWidth = 2.dp)
+                } else {
+                    IconButton(onClick = onRerunAnalysis) {
+                        Icon(
+                            MeshtasticIcons.Refresh,
+                            contentDescription = stringResource(Res.string.discovery_rerun_analysis),
+                            tint = MaterialTheme.colorScheme.onTertiaryContainer,
+                        )
+                    }
+                }
+            }
+            Spacer(modifier = Modifier.height(8.dp))
+
+            val summaryText =
+                aiSummary ?: algorithmicSummary ?: stringResource(Res.string.discovery_summary_not_available)
+
+            Text(
+                text = summaryText,
+                style = MaterialTheme.typography.bodyMedium,
+                color = MaterialTheme.colorScheme.onTertiaryContainer,
+            )
+        }
+    }
+}
+
+@Composable
+internal fun StatRow(label: String, value: String, modifier: Modifier = Modifier) {
+    Row(
+        modifier = modifier.fillMaxWidth().padding(vertical = 2.dp),
+        horizontalArrangement = Arrangement.SpaceBetween,
+        verticalAlignment = Alignment.CenterVertically,
+    ) {
+        Text(
+            text = label,
+            style = MaterialTheme.typography.bodyMedium,
+            color = MaterialTheme.colorScheme.onSurfaceVariant,
+        )
+        Text(text = value, style = MaterialTheme.typography.bodyMedium, fontWeight = FontWeight.Medium)
+    }
+}
+
+internal fun formatDuration(totalSeconds: Long): String {
+    val minutes = totalSeconds / 60
+    val hours = minutes / 60
+    val remainingMinutes = minutes % 60
+    return if (hours > 0) "${hours}h ${remainingMinutes}m" else "${minutes}m"
+}

feature/discovery/src/commonMain/kotlin/org/meshtastic/feature/discovery/ui/component/DwellProgressIndicator.kt

@@ -0,0 +1,83 @@
+/*
+ * Copyright (c) 2026 Meshtastic LLC
+ *
+ * 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 org.meshtastic.feature.discovery.ui.component
+
+import androidx.compose.foundation.layout.Arrangement
+import androidx.compose.foundation.layout.Column
+import androidx.compose.foundation.layout.fillMaxWidth
+import androidx.compose.foundation.layout.padding
+import androidx.compose.material3.LinearProgressIndicator
+import androidx.compose.material3.MaterialTheme
+import androidx.compose.material3.Text
+import androidx.compose.runtime.Composable
+import androidx.compose.ui.Modifier
+import androidx.compose.ui.semantics.ProgressBarRangeInfo
+import androidx.compose.ui.semantics.clearAndSetSemantics
+import androidx.compose.ui.semantics.contentDescription
+import androidx.compose.ui.semantics.progressBarRangeInfo
+import androidx.compose.ui.semantics.semantics
+import androidx.compose.ui.unit.dp
+import org.jetbrains.compose.resources.stringResource
+import org.meshtastic.core.resources.Res
+import org.meshtastic.core.resources.discovery_dwell_progress
+import org.meshtastic.core.resources.discovery_stat_dwelling_on
+import org.meshtastic.core.resources.discovery_time_remaining
+
+@Suppress("MagicNumber")
+private val CONTENT_PADDING = 8.dp
+private const val SECONDS_PER_MINUTE = 60L
+
+/** Displays dwell progress for a single preset with a countdown timer and linear progress bar. */
+@Composable
+fun DwellProgressIndicator(
+    presetName: String,
+    remainingSeconds: Long,
+    totalSeconds: Long,
+    modifier: Modifier = Modifier,
+) {
+    val progress =
+        if (totalSeconds > 0) {
+            1f - (remainingSeconds.toFloat() / totalSeconds.toFloat())
+        } else {
+            0f
+        }
+    val minutes = remainingSeconds / SECONDS_PER_MINUTE
+    val seconds = remainingSeconds % SECONDS_PER_MINUTE
+    val timeText = "${minutes.toString().padStart(2, '0')}:${seconds.toString().padStart(2, '0')}"
+    val progressDescription = stringResource(Res.string.discovery_dwell_progress, presetName, timeText)
+
+    Column(
+        verticalArrangement = Arrangement.spacedBy(CONTENT_PADDING),
+        modifier =
+        modifier.fillMaxWidth().semantics(mergeDescendants = true) {
+            contentDescription = progressDescription
+            progressBarRangeInfo = ProgressBarRangeInfo(progress, 0f..1f)
+        },
+    ) {
+        Text(
+            text = stringResource(Res.string.discovery_stat_dwelling_on, presetName),
+            style = MaterialTheme.typography.titleSmall,
+        )
+        LinearProgressIndicator(progress = { progress }, modifier = Modifier.fillMaxWidth().clearAndSetSemantics {})
+        Text(
+            text = stringResource(Res.string.discovery_time_remaining, timeText),
+            style = MaterialTheme.typography.bodyMedium,
+            color = MaterialTheme.colorScheme.onSurfaceVariant,
+            modifier = Modifier.padding(top = CONTENT_PADDING / 2),
+        )
+    }
+}

feature/discovery/src/commonMain/kotlin/org/meshtastic/feature/discovery/ui/component/PresetPickerCard.kt

@@ -0,0 +1,127 @@
+/*
+ * Copyright (c) 2026 Meshtastic LLC
+ *
+ * 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 org.meshtastic.feature.discovery.ui.component
+
+import androidx.compose.foundation.layout.Arrangement
+import androidx.compose.foundation.layout.Column
+import androidx.compose.foundation.layout.ExperimentalLayoutApi
+import androidx.compose.foundation.layout.FlowRow
+import androidx.compose.foundation.layout.fillMaxWidth
+import androidx.compose.foundation.layout.padding
+import androidx.compose.foundation.layout.size
+import androidx.compose.material3.ElevatedCard
+import androidx.compose.material3.FilterChip
+import androidx.compose.material3.FilterChipDefaults
+import androidx.compose.material3.Icon
+import androidx.compose.material3.MaterialTheme
+import androidx.compose.material3.Text
+import androidx.compose.runtime.Composable
+import androidx.compose.ui.Modifier
+import androidx.compose.ui.semantics.heading
+import androidx.compose.ui.semantics.semantics
+import androidx.compose.ui.semantics.stateDescription
+import androidx.compose.ui.unit.dp
+import org.jetbrains.compose.resources.stringResource
+import org.meshtastic.core.model.ChannelOption
+import org.meshtastic.core.resources.Res
+import org.meshtastic.core.resources.discovery_lora_presets
+import org.meshtastic.core.resources.discovery_lora_presets_description
+import org.meshtastic.core.resources.discovery_preset_home_label
+import org.meshtastic.core.resources.discovery_stat_selected
+import org.meshtastic.core.resources.discovery_stat_unselected
+import org.meshtastic.core.ui.icon.Check
+import org.meshtastic.core.ui.icon.MeshtasticIcons
+
+@Suppress("MagicNumber")
+private val CHIP_SPACING = 8.dp
+private val CARD_PADDING = 16.dp
+
+/** Formats a [ChannelOption] enum name (e.g. "LONG_FAST") into a human-readable label (e.g. "Long Fast"). */
+internal fun ChannelOption.displayName(): String =
+    name.split("_").joinToString(" ") { word -> word.lowercase().replaceFirstChar { it.uppercase() } }
+
+/** Deprecated modem presets that should not appear in the discovery picker. */
+private val DEPRECATED_PRESETS = setOf(ChannelOption.VERY_LONG_SLOW, ChannelOption.LONG_SLOW)
+
+/** A card containing a [FlowRow] of [FilterChip] items for preset selection. */
+@OptIn(ExperimentalLayoutApi::class)
+@Composable
+fun PresetPickerCard(
+    selectedPresets: Set<ChannelOption>,
+    homePreset: ChannelOption,
+    onTogglePreset: (ChannelOption) -> Unit,
+    enabled: Boolean,
+    modifier: Modifier = Modifier,
+) {
+    ElevatedCard(modifier = modifier.fillMaxWidth()) {
+        Column(modifier = Modifier.padding(CARD_PADDING)) {
+            Text(
+                text = stringResource(Res.string.discovery_lora_presets),
+                style = MaterialTheme.typography.titleMedium,
+                modifier = Modifier.semantics { heading() },
+            )
+            Text(
+                text = stringResource(Res.string.discovery_lora_presets_description),
+                style = MaterialTheme.typography.bodySmall,
+                color = MaterialTheme.colorScheme.onSurfaceVariant,
+                modifier = Modifier.padding(bottom = CHIP_SPACING),
+            )
+            FlowRow(
+                horizontalArrangement = Arrangement.spacedBy(CHIP_SPACING),
+                verticalArrangement = Arrangement.spacedBy(CHIP_SPACING),
+                modifier = Modifier.fillMaxWidth(),
+            ) {
+                ChannelOption.entries
+                    .filter { it !in DEPRECATED_PRESETS }
+                    .forEach { preset ->
+                        val selected = preset in selectedPresets
+                        val isHome = preset == homePreset
+                        val label =
+                            if (isHome) {
+                                stringResource(Res.string.discovery_preset_home_label, preset.displayName())
+                            } else {
+                                preset.displayName()
+                            }
+                        val selectedDesc = stringResource(Res.string.discovery_stat_selected)
+                        val unselectedDesc = stringResource(Res.string.discovery_stat_unselected)
+                        FilterChip(
+                            selected = selected,
+                            onClick = { onTogglePreset(preset) },
+                            label = { Text(label) },
+                            enabled = enabled,
+                            modifier =
+                            Modifier.semantics {
+                                stateDescription = if (selected) selectedDesc else unselectedDesc
+                            },
+                            leadingIcon =
+                            if (selected) {
+                                {
+                                    Icon(
+                                        imageVector = MeshtasticIcons.Check,
+                                        contentDescription = null,
+                                        modifier = Modifier.size(FilterChipDefaults.IconSize),
+                                    )
+                                }
+                            } else {
+                                null
+                            },
+                        )
+                    }
+            }
+        }
+    }
+}

feature/discovery/src/commonMain/kotlin/org/meshtastic/feature/discovery/ui/component/PresetResultCard.kt

@@ -0,0 +1,181 @@
+/*
+ * Copyright (c) 2026 Meshtastic LLC
+ *
+ * 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/>.
+ */
+@file:Suppress("MagicNumber")
+
+package org.meshtastic.feature.discovery.ui.component
+
+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.fillMaxWidth
+import androidx.compose.foundation.layout.height
+import androidx.compose.foundation.layout.padding
+import androidx.compose.material3.Card
+import androidx.compose.material3.HorizontalDivider
+import androidx.compose.material3.MaterialTheme
+import androidx.compose.material3.Text
+import androidx.compose.runtime.Composable
+import androidx.compose.ui.Alignment
+import androidx.compose.ui.Modifier
+import androidx.compose.ui.text.font.FontWeight
+import androidx.compose.ui.unit.dp
+import org.jetbrains.compose.resources.stringResource
+import org.meshtastic.core.common.util.NumberFormatter
+import org.meshtastic.core.database.entity.DiscoveredNodeEntity
+import org.meshtastic.core.database.entity.DiscoveryPresetResultEntity
+import org.meshtastic.core.resources.Res
+import org.meshtastic.core.resources.discovery_stat_avg_airtime_rate
+import org.meshtastic.core.resources.discovery_stat_avg_channel_utilization
+import org.meshtastic.core.resources.discovery_stat_direct
+import org.meshtastic.core.resources.discovery_stat_mesh
+import org.meshtastic.core.resources.discovery_stat_messages
+import org.meshtastic.core.resources.discovery_stat_sensor_pkts
+import org.meshtastic.core.resources.discovery_stat_unique_nodes
+import org.meshtastic.feature.discovery.ui.StatRow
+import org.meshtastic.feature.discovery.ui.formatDuration
+
+@Composable
+fun PresetResultCard(
+    result: DiscoveryPresetResultEntity,
+    @Suppress("UnusedParameter") nodes: List<DiscoveredNodeEntity>,
+    modifier: Modifier = Modifier,
+    aiSummary: String? = null,
+    rank: Int? = null,
+    isTied: Boolean = false,
+) {
+    Card(modifier = modifier.fillMaxWidth()) {
+        Column(modifier = Modifier.padding(16.dp)) {
+            PresetHeader(result = result, rank = rank, isTied = isTied)
+            Spacer(modifier = Modifier.height(12.dp))
+
+            StatsGrid(result = result)
+            Spacer(modifier = Modifier.height(8.dp))
+
+            NodeBreakdown(result = result)
+            Spacer(modifier = Modifier.height(8.dp))
+
+            MessageBreakdown(result = result)
+
+            // Per-preset AI summary
+            val summaryText = aiSummary ?: result.aiSummary
+            if (!summaryText.isNullOrBlank()) {
+                HorizontalDivider(modifier = Modifier.padding(vertical = 8.dp))
+                Text(
+                    text = summaryText,
+                    style = MaterialTheme.typography.bodySmall,
+                    color = MaterialTheme.colorScheme.onSurfaceVariant,
+                )
+            }
+
+            if (result.numPacketsTx > 0) {
+                HorizontalDivider(modifier = Modifier.padding(vertical = 8.dp))
+                RfHealthSection(result = result)
+            }
+        }
+    }
+}
+
+@Composable
+private fun PresetHeader(result: DiscoveryPresetResultEntity, rank: Int?, isTied: Boolean) {
+    Row(
+        modifier = Modifier.fillMaxWidth(),
+        horizontalArrangement = Arrangement.SpaceBetween,
+        verticalAlignment = Alignment.CenterVertically,
+    ) {
+        Row(verticalAlignment = Alignment.CenterVertically, horizontalArrangement = Arrangement.spacedBy(8.dp)) {
+            Text(text = result.presetName, style = MaterialTheme.typography.titleMedium, fontWeight = FontWeight.Bold)
+            if (rank != null) {
+                val rankLabel = if (isTied) "#$rank (tied)" else "#$rank"
+                val rankColor =
+                    if (rank == 1 && !isTied) {
+                        MaterialTheme.colorScheme.primary
+                    } else {
+                        MaterialTheme.colorScheme.onSurfaceVariant
+                    }
+                Text(text = rankLabel, style = MaterialTheme.typography.labelMedium, color = rankColor)
+            }
+        }
+        Text(
+            text = formatDuration(result.dwellDurationSeconds),
+            style = MaterialTheme.typography.bodySmall,
+            color = MaterialTheme.colorScheme.onSurfaceVariant,
+        )
+    }
+}
+
+@Composable
+private fun StatsGrid(result: DiscoveryPresetResultEntity) {
+    Column(verticalArrangement = Arrangement.spacedBy(2.dp)) {
+        StatRow(label = stringResource(Res.string.discovery_stat_unique_nodes), value = result.uniqueNodes.toString())
+        StatRow(
+            label = stringResource(Res.string.discovery_stat_avg_channel_utilization),
+            value = "${NumberFormatter.format(result.avgChannelUtilization, 1)}%",
+        )
+        StatRow(
+            label = stringResource(Res.string.discovery_stat_avg_airtime_rate),
+            value = "${NumberFormatter.format(result.avgAirtimeRate, 1)}%",
+        )
+    }
+}
+
+@Composable
+private fun NodeBreakdown(result: DiscoveryPresetResultEntity) {
+    Row(modifier = Modifier.fillMaxWidth(), horizontalArrangement = Arrangement.spacedBy(16.dp)) {
+        MetricChip(
+            label = stringResource(Res.string.discovery_stat_direct),
+            value = result.directNeighborCount.toString(),
+            modifier = Modifier.weight(1f),
+        )
+        MetricChip(
+            label = stringResource(Res.string.discovery_stat_mesh),
+            value = result.meshNeighborCount.toString(),
+            modifier = Modifier.weight(1f),
+        )
+    }
+}
+
+@Composable
+private fun MessageBreakdown(result: DiscoveryPresetResultEntity) {
+    Row(modifier = Modifier.fillMaxWidth(), horizontalArrangement = Arrangement.spacedBy(16.dp)) {
+        MetricChip(
+            label = stringResource(Res.string.discovery_stat_messages),
+            value = result.messageCount.toString(),
+            modifier = Modifier.weight(1f),
+        )
+        MetricChip(
+            label = stringResource(Res.string.discovery_stat_sensor_pkts),
+            value = result.sensorPacketCount.toString(),
+            modifier = Modifier.weight(1f),
+        )
+    }
+}
+
+@Composable
+private fun MetricChip(label: String, value: String, modifier: Modifier = Modifier) {
+    Column(
+        modifier = modifier.fillMaxWidth().padding(vertical = 4.dp),
+        horizontalAlignment = Alignment.CenterHorizontally,
+    ) {
+        Text(text = value, style = MaterialTheme.typography.titleLarge, fontWeight = FontWeight.Bold)
+        Text(
+            text = label,
+            style = MaterialTheme.typography.bodySmall,
+            color = MaterialTheme.colorScheme.onSurfaceVariant,
+        )
+    }
+}

feature/discovery/src/commonMain/kotlin/org/meshtastic/feature/discovery/ui/component/RfHealthSection.kt

@@ -0,0 +1,81 @@
+/*
+ * Copyright (c) 2026 Meshtastic LLC
+ *
+ * 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/>.
+ */
+@file:Suppress("MagicNumber")
+
+package org.meshtastic.feature.discovery.ui.component
+
+import androidx.compose.foundation.layout.Arrangement
+import androidx.compose.foundation.layout.Column
+import androidx.compose.foundation.layout.Spacer
+import androidx.compose.foundation.layout.height
+import androidx.compose.material3.MaterialTheme
+import androidx.compose.material3.Text
+import androidx.compose.runtime.Composable
+import androidx.compose.ui.Modifier
+import androidx.compose.ui.text.font.FontWeight
+import androidx.compose.ui.unit.dp
+import org.jetbrains.compose.resources.stringResource
+import org.meshtastic.core.common.util.NumberFormatter
+import org.meshtastic.core.database.entity.DiscoveryPresetResultEntity
+import org.meshtastic.core.resources.Res
+import org.meshtastic.core.resources.discovery_stat_bad_packets
+import org.meshtastic.core.resources.discovery_stat_duplicate_packets
+import org.meshtastic.core.resources.discovery_stat_failure_rate
+import org.meshtastic.core.resources.discovery_stat_online_total_nodes
+import org.meshtastic.core.resources.discovery_stat_packets_rx
+import org.meshtastic.core.resources.discovery_stat_packets_tx
+import org.meshtastic.core.resources.discovery_stat_rf_health
+import org.meshtastic.core.resources.discovery_stat_success_rate
+import org.meshtastic.feature.discovery.ui.StatRow
+
+@Composable
+fun RfHealthSection(result: DiscoveryPresetResultEntity, modifier: Modifier = Modifier) {
+    Column(modifier = modifier, verticalArrangement = Arrangement.spacedBy(2.dp)) {
+        Text(
+            text = stringResource(Res.string.discovery_stat_rf_health),
+            style = MaterialTheme.typography.titleSmall,
+            fontWeight = FontWeight.Bold,
+        )
+        Spacer(modifier = Modifier.height(4.dp))
+
+        StatRow(label = stringResource(Res.string.discovery_stat_packets_tx), value = result.numPacketsTx.toString())
+        StatRow(label = stringResource(Res.string.discovery_stat_packets_rx), value = result.numPacketsRx.toString())
+        StatRow(
+            label = stringResource(Res.string.discovery_stat_bad_packets),
+            value = result.numPacketsRxBad.toString(),
+        )
+        StatRow(
+            label = stringResource(Res.string.discovery_stat_duplicate_packets),
+            value = result.numRxDupe.toString(),
+        )
+        StatRow(
+            label = stringResource(Res.string.discovery_stat_success_rate),
+            value = "${NumberFormatter.format(result.packetSuccessRate, 1)}%",
+        )
+        StatRow(
+            label = stringResource(Res.string.discovery_stat_failure_rate),
+            value = "${NumberFormatter.format(result.packetFailureRate, 1)}%",
+        )
+
+        if (result.numOnlineNodes > 0 || result.numTotalNodes > 0) {
+            StatRow(
+                label = stringResource(Res.string.discovery_stat_online_total_nodes),
+                value = "${result.numOnlineNodes} / ${result.numTotalNodes}",
+            )
+        }
+    }
+}

feature/discovery/src/commonTest/kotlin/org/meshtastic/feature/discovery/Check24GhzCapabilityTest.kt

@@ -0,0 +1,131 @@
+/*
+ * Copyright (c) 2026 Meshtastic LLC
+ *
+ * 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 org.meshtastic.feature.discovery
+
+import org.meshtastic.core.model.DeviceHardware
+import org.meshtastic.core.testing.FakeDeviceHardwareRepository
+import org.meshtastic.core.testing.FakeNodeRepository
+import org.meshtastic.feature.discovery.scan.Check24GhzCapability
+import org.meshtastic.feature.discovery.scan.HardwareCapabilityResult
+import kotlin.test.Test
+import kotlin.test.assertIs
+
+class Check24GhzCapabilityTest {
+
+    private val check =
+        Check24GhzCapability(
+            nodeRepository = FakeNodeRepository(),
+            deviceHardwareRepository = FakeDeviceHardwareRepository(),
+        )
+
+    // --- Tag-based detection ---
+
+    @Test
+    fun evaluate_returns_supported_when_tag_contains_sx1280() {
+        val hw = baseHardware(tags = listOf("sx1280", "ble"))
+        assertIs<HardwareCapabilityResult.Supported>(check.evaluate(hw))
+    }
+
+    @Test
+    fun evaluate_returns_supported_when_tag_contains_2_4ghz() {
+        val hw = baseHardware(tags = listOf("2.4ghz"))
+        assertIs<HardwareCapabilityResult.Supported>(check.evaluate(hw))
+    }
+
+    @Test
+    fun evaluate_returns_supported_when_tag_contains_lora24() {
+        val hw = baseHardware(tags = listOf("lora24", "esp32"))
+        assertIs<HardwareCapabilityResult.Supported>(check.evaluate(hw))
+    }
+
+    @Test
+    fun evaluate_returns_unsupported_when_tag_contains_sub_ghz_only() {
+        val hw = baseHardware(tags = listOf("sub-ghz-only"))
+        assertIs<HardwareCapabilityResult.Unsupported>(check.evaluate(hw))
+    }
+
+    @Test
+    fun evaluate_returns_unsupported_when_tag_contains_sx1262() {
+        val hw = baseHardware(tags = listOf("sx1262"))
+        assertIs<HardwareCapabilityResult.Unsupported>(check.evaluate(hw))
+    }
+
+    // --- Pattern-based detection (target / slug) ---
+
+    @Test
+    fun evaluate_returns_supported_when_target_contains_sx1280() {
+        val hw = baseHardware(platformioTarget = "tlora-v2_1-1_6-sx1280")
+        assertIs<HardwareCapabilityResult.Supported>(check.evaluate(hw))
+    }
+
+    @Test
+    fun evaluate_returns_supported_when_slug_contains_2400() {
+        val hw = baseHardware(hwModelSlug = "rak-2400")
+        assertIs<HardwareCapabilityResult.Supported>(check.evaluate(hw))
+    }
+
+    @Test
+    fun evaluate_returns_supported_when_target_contains_lora24() {
+        val hw = baseHardware(platformioTarget = "nano-g2-lora24")
+        assertIs<HardwareCapabilityResult.Supported>(check.evaluate(hw))
+    }
+
+    // --- Fallback to unknown ---
+
+    @Test
+    fun evaluate_returns_unknown_when_no_evidence_available() {
+        val hw = baseHardware(platformioTarget = "heltec-v3", hwModelSlug = "heltec-v3", tags = emptyList())
+        val result = check.evaluate(hw)
+        assertIs<HardwareCapabilityResult.Unknown>(result)
+    }
+
+    @Test
+    fun evaluate_returns_unknown_when_tags_are_null() {
+        val hw = baseHardware(tags = null)
+        val result = check.evaluate(hw)
+        assertIs<HardwareCapabilityResult.Unknown>(result)
+    }
+
+    // --- Edge cases ---
+
+    @Test
+    fun evaluate_tag_matching_is_case_insensitive() {
+        val hw = baseHardware(tags = listOf("SX1280", "BLE"))
+        assertIs<HardwareCapabilityResult.Supported>(check.evaluate(hw))
+    }
+
+    @Test
+    fun evaluate_supported_tag_takes_precedence_when_both_present() {
+        // If hardware has both supported and unsupported tags (unusual), supported wins
+        val hw = baseHardware(tags = listOf("sx1280", "sx1262"))
+        assertIs<HardwareCapabilityResult.Supported>(check.evaluate(hw))
+    }
+
+    private fun baseHardware(
+        platformioTarget: String = "generic-target",
+        hwModelSlug: String = "generic-slug",
+        tags: List<String>? = null,
+    ) = DeviceHardware(
+        activelySupported = true,
+        architecture = "esp32",
+        displayName = "Test Device",
+        hwModel = 42,
+        hwModelSlug = hwModelSlug,
+        platformioTarget = platformioTarget,
+        tags = tags,
+    )
+}

feature/discovery/src/commonTest/kotlin/org/meshtastic/feature/discovery/DiscoveryHistoryBehaviorTest.kt

@@ -0,0 +1,263 @@
+/*
+ * Copyright (c) 2026 Meshtastic LLC
+ *
+ * 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/>.
+ */
+@file:Suppress("MagicNumber")
+
+package org.meshtastic.feature.discovery
+
+import kotlinx.coroutines.flow.Flow
+import kotlinx.coroutines.flow.MutableStateFlow
+import kotlinx.coroutines.flow.first
+import kotlinx.coroutines.flow.flowOf
+import kotlinx.coroutines.flow.update
+import kotlinx.coroutines.test.runTest
+import org.meshtastic.core.database.dao.DiscoveryDao
+import org.meshtastic.core.database.entity.DiscoveredNodeEntity
+import org.meshtastic.core.database.entity.DiscoveryPresetResultEntity
+import org.meshtastic.core.database.entity.DiscoverySessionEntity
+import kotlin.test.Test
+import kotlin.test.assertEquals
+import kotlin.test.assertNotNull
+import kotlin.test.assertNull
+import kotlin.test.assertTrue
+
+/** Tests for session history: sorting, session load by ID, and delete behavior (D042). */
+class DiscoveryHistoryBehaviorTest {
+
+    private val dao = HistoryTestDao()
+
+    // region History sorting
+
+    @Test
+    fun getAllSessions_returnsNewestFirst() = runTest {
+        dao.insertSession(session(timestamp = 1_000L))
+        dao.insertSession(session(timestamp = 3_000L))
+        dao.insertSession(session(timestamp = 2_000L))
+
+        val sessions = dao.getAllSessions().first()
+        assertEquals(3, sessions.size)
+        assertEquals(3_000L, sessions[0].timestamp, "Newest session should be first")
+        assertEquals(2_000L, sessions[1].timestamp)
+        assertEquals(1_000L, sessions[2].timestamp, "Oldest session should be last")
+    }
+
+    @Test
+    fun getAllSessions_emptyListWhenNoSessions() = runTest {
+        val sessions = dao.getAllSessions().first()
+        assertTrue(sessions.isEmpty())
+    }
+
+    @Test
+    fun getAllSessions_singleSession() = runTest {
+        dao.insertSession(session(timestamp = 5_000L))
+        val sessions = dao.getAllSessions().first()
+        assertEquals(1, sessions.size)
+        assertEquals(5_000L, sessions.first().timestamp)
+    }
+
+    // endregion
+
+    // region Session load by ID
+
+    @Test
+    fun sessionLoadById_returnsStoredSession() = runTest {
+        val id = dao.insertSession(session(timestamp = 10_000L, homePreset = "MEDIUM_FAST"))
+        val loaded = dao.getSession(id)
+        assertNotNull(loaded)
+        assertEquals("MEDIUM_FAST", loaded.homePreset)
+        assertEquals(10_000L, loaded.timestamp)
+    }
+
+    @Test
+    fun sessionLoadById_returnsNullForMissing() = runTest {
+        assertNull(dao.getSession(999L), "Should return null for non-existent session")
+    }
+
+    // endregion
+
+    // region Delete behavior
+
+    @Test
+    fun deleteSession_removesFromHistory() = runTest {
+        val id1 = dao.insertSession(session(timestamp = 1L))
+        val id2 = dao.insertSession(session(timestamp = 2L))
+
+        dao.deleteSession(id1)
+
+        val remaining = dao.getAllSessions().first()
+        assertEquals(1, remaining.size)
+        assertEquals(id2, remaining[0].id)
+    }
+
+    @Test
+    fun deleteSession_cascadesPresetResultsAndNodes() = runTest {
+        val sessionId = dao.insertSession(session())
+        val presetId =
+            dao.insertPresetResult(DiscoveryPresetResultEntity(sessionId = sessionId, presetName = "LONG_FAST"))
+        dao.insertDiscoveredNode(DiscoveredNodeEntity(presetResultId = presetId, nodeNum = 100))
+
+        dao.deleteSession(sessionId)
+
+        assertNull(dao.getSession(sessionId))
+        assertTrue(dao.getPresetResults(sessionId).isEmpty(), "Preset results should cascade-delete")
+        assertTrue(dao.getDiscoveredNodes(presetId).isEmpty(), "Discovered nodes should cascade-delete")
+    }
+
+    @Test
+    fun deleteSession_doesNotAffectOtherSessions() = runTest {
+        val id1 = dao.insertSession(session(timestamp = 1L))
+        val id2 = dao.insertSession(session(timestamp = 2L))
+        val preset2 = dao.insertPresetResult(DiscoveryPresetResultEntity(sessionId = id2, presetName = "SHORT_FAST"))
+        dao.insertDiscoveredNode(DiscoveredNodeEntity(presetResultId = preset2, nodeNum = 42))
+
+        dao.deleteSession(id1)
+
+        assertNotNull(dao.getSession(id2), "Other sessions should be unaffected")
+        assertEquals(1, dao.getPresetResults(id2).size)
+        assertEquals(1, dao.getDiscoveredNodes(preset2).size)
+    }
+
+    @Test
+    fun deleteAllSessions_leavesEmptyHistory() = runTest {
+        val id1 = dao.insertSession(session(timestamp = 1L))
+        val id2 = dao.insertSession(session(timestamp = 2L))
+
+        dao.deleteSession(id1)
+        dao.deleteSession(id2)
+
+        assertTrue(dao.getAllSessions().first().isEmpty())
+    }
+
+    // endregion
+
+    // region Helpers
+
+    private fun session(timestamp: Long = 1_000_000L, homePreset: String = "LONG_FAST") = DiscoverySessionEntity(
+        timestamp = timestamp,
+        presetsScanned = "LONG_FAST",
+        homePreset = homePreset,
+        completionStatus = "complete",
+    )
+
+    // endregion
+}
+
+// region In-memory DAO for history tests
+
+private class HistoryTestDao : DiscoveryDao {
+    private var nextSessionId = 1L
+    private var nextPresetResultId = 1L
+    private var nextNodeId = 1L
+
+    private val sessions = mutableMapOf<Long, DiscoverySessionEntity>()
+    private val presetResults = mutableMapOf<Long, DiscoveryPresetResultEntity>()
+    private val discoveredNodes = mutableMapOf<Long, DiscoveredNodeEntity>()
+    private val sessionsFlow = MutableStateFlow<List<DiscoverySessionEntity>>(emptyList())
+
+    private fun refreshSessionsFlow() {
+        sessionsFlow.update { sessions.values.sortedByDescending { it.timestamp } }
+    }
+
+    override suspend fun insertSession(session: DiscoverySessionEntity): Long {
+        val id = nextSessionId++
+        sessions[id] = session.copy(id = id)
+        refreshSessionsFlow()
+        return id
+    }
+
+    override suspend fun updateSession(session: DiscoverySessionEntity) {
+        sessions[session.id] = session
+        refreshSessionsFlow()
+    }
+
+    override fun getAllSessions(): Flow<List<DiscoverySessionEntity>> = sessionsFlow
+
+    override suspend fun getSession(sessionId: Long) = sessions[sessionId]
+
+    override fun getSessionFlow(sessionId: Long): Flow<DiscoverySessionEntity?> = MutableStateFlow(sessions[sessionId])
+
+    override suspend fun deleteSession(sessionId: Long) {
+        sessions.remove(sessionId)
+        val resultIds = presetResults.values.filter { it.sessionId == sessionId }.map { it.id }
+        resultIds.forEach { rid ->
+            discoveredNodes.entries.removeAll { it.value.presetResultId == rid }
+            presetResults.remove(rid)
+        }
+        refreshSessionsFlow()
+    }
+
+    override suspend fun insertPresetResult(result: DiscoveryPresetResultEntity): Long {
+        val id = nextPresetResultId++
+        presetResults[id] = result.copy(id = id)
+        return id
+    }
+
+    override suspend fun updatePresetResult(result: DiscoveryPresetResultEntity) {
+        presetResults[result.id] = result
+    }
+
+    override suspend fun getPresetResults(sessionId: Long) = presetResults.values.filter { it.sessionId == sessionId }
+
+    override fun getPresetResultsFlow(sessionId: Long) =
+        flowOf(presetResults.values.filter { it.sessionId == sessionId })
+
+    override suspend fun insertDiscoveredNode(node: DiscoveredNodeEntity): Long {
+        val id = nextNodeId++
+        discoveredNodes[id] = node.copy(id = id)
+        return id
+    }
+
+    override suspend fun insertDiscoveredNodes(nodes: List<DiscoveredNodeEntity>) {
+        nodes.forEach { insertDiscoveredNode(it) }
+    }
+
+    override suspend fun updateDiscoveredNode(node: DiscoveredNodeEntity) {
+        discoveredNodes[node.id] = node
+    }
+
+    override suspend fun getDiscoveredNodes(presetResultId: Long) =
+        discoveredNodes.values.filter { it.presetResultId == presetResultId }
+
+    override fun getDiscoveredNodesFlow(presetResultId: Long) =
+        flowOf(discoveredNodes.values.filter { it.presetResultId == presetResultId })
+
+    override suspend fun getUniqueNodeNums(sessionId: Long) = presetResults.values
+        .filter { it.sessionId == sessionId }
+        .flatMap { pr -> discoveredNodes.values.filter { it.presetResultId == pr.id } }
+        .map { it.nodeNum }
+        .distinct()
+
+    override suspend fun getUniqueNodeCount(sessionId: Long) = getUniqueNodeNums(sessionId).size
+
+    override suspend fun getMaxDistance(sessionId: Long) = presetResults.values
+        .filter { it.sessionId == sessionId }
+        .flatMap { pr -> discoveredNodes.values.filter { it.presetResultId == pr.id } }
+        .mapNotNull { it.distanceFromUser }
+        .maxOrNull()
+
+    override suspend fun getSessionWithResults(sessionId: Long) = sessions[sessionId]
+
+    override suspend fun markInterruptedSessions() {
+        sessions.keys.toList().forEach { key ->
+            val session = sessions[key]!!
+            if (session.completionStatus == "in_progress") {
+                sessions[key] = session.copy(completionStatus = "interrupted")
+            }
+        }
+    }
+}
+
+// endregion

feature/discovery/src/commonTest/kotlin/org/meshtastic/feature/discovery/DiscoveryMapFilterTest.kt

@@ -0,0 +1,248 @@
+/*
+ * Copyright (c) 2026 Meshtastic LLC
+ *
+ * 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/>.
+ */
+@file:Suppress("MagicNumber")
+
+package org.meshtastic.feature.discovery
+
+import kotlinx.coroutines.flow.Flow
+import kotlinx.coroutines.flow.MutableStateFlow
+import kotlinx.coroutines.flow.flowOf
+import kotlinx.coroutines.test.runTest
+import org.meshtastic.core.database.dao.DiscoveryDao
+import org.meshtastic.core.database.entity.DiscoveredNodeEntity
+import org.meshtastic.core.database.entity.DiscoveryPresetResultEntity
+import org.meshtastic.core.database.entity.DiscoverySessionEntity
+import kotlin.test.Test
+import kotlin.test.assertEquals
+import kotlin.test.assertFalse
+import kotlin.test.assertNull
+import kotlin.test.assertTrue
+
+/**
+ * Tests for the map ViewModel's preset filtering, mapped/unmapped counts, and topology toggle behavior (D028).
+ *
+ * These are logic-level tests that validate the ViewModel's state flows without rendering UI.
+ */
+class DiscoveryMapFilterTest {
+
+    // region Preset filter selection
+
+    @Test
+    fun defaultFilter_isNull_showsAllPresets() {
+        val vm = createViewModel()
+        assertNull(vm.selectedPresetFilter.value, "Default filter should be null (show all)")
+    }
+
+    @Test
+    fun selectPresetFilter_updatesState() {
+        val vm = createViewModel()
+        vm.selectPresetFilter(42L)
+        assertEquals(42L, vm.selectedPresetFilter.value)
+    }
+
+    @Test
+    fun selectPresetFilter_null_resetsToAll() {
+        val vm = createViewModel()
+        vm.selectPresetFilter(42L)
+        vm.selectPresetFilter(null)
+        assertNull(vm.selectedPresetFilter.value)
+    }
+
+    // endregion
+
+    // region Topology toggle
+
+    @Test
+    fun topologyOverlay_defaultOff() {
+        val vm = createViewModel()
+        assertFalse(vm.showTopologyOverlay.value)
+    }
+
+    @Test
+    fun toggleTopologyOverlay_turnsOn() {
+        val vm = createViewModel()
+        vm.toggleTopologyOverlay()
+        assertTrue(vm.showTopologyOverlay.value)
+    }
+
+    @Test
+    fun toggleTopologyOverlay_turnsOff() {
+        val vm = createViewModel()
+        vm.toggleTopologyOverlay()
+        vm.toggleTopologyOverlay()
+        assertFalse(vm.showTopologyOverlay.value)
+    }
+
+    // endregion
+
+    // region Map stats (mapped/unmapped counts)
+
+    @Test
+    fun mapStats_initiallyZero() {
+        val vm = createViewModel()
+        val stats = vm.mapStats.value
+        assertEquals(0, stats.totalNodes)
+        assertEquals(0, stats.mappedNodes)
+        assertEquals(0, stats.unmappedNodes)
+    }
+
+    @Test
+    fun discoveryMapStats_dataClass_equality() {
+        val stats1 = DiscoveryMapStats(totalNodes = 5, mappedNodes = 3, unmappedNodes = 2)
+        val stats2 = DiscoveryMapStats(totalNodes = 5, mappedNodes = 3, unmappedNodes = 2)
+        assertEquals(stats1, stats2)
+    }
+
+    // endregion
+
+    // region Preset results loaded
+
+    @Test
+    fun presetResults_loadedFromDao() = runTest {
+        val dao = MapTestDao()
+        val sessionId = dao.insertSession(testSession())
+        dao.insertPresetResult(DiscoveryPresetResultEntity(sessionId = sessionId, presetName = "LONG_FAST"))
+        dao.insertPresetResult(DiscoveryPresetResultEntity(sessionId = sessionId, presetName = "SHORT_FAST"))
+
+        val vm = DiscoveryMapViewModel(sessionId = sessionId, discoveryDao = dao)
+        // safeLaunch runs in UnconfinedTestDispatcher-like context within the VM
+        // Access the loaded state
+        val results = vm.presetResults.value
+        // The VM loads asynchronously, so results may still be loading.
+        // Verify the DAO has the right data at minimum.
+        val daoResults = dao.getPresetResults(sessionId)
+        assertEquals(2, daoResults.size)
+    }
+
+    // endregion
+
+    // region Helpers
+
+    private fun createViewModel(): DiscoveryMapViewModel {
+        val dao = MapTestDao()
+        return DiscoveryMapViewModel(sessionId = 1L, discoveryDao = dao)
+    }
+
+    private fun testSession() = DiscoverySessionEntity(
+        timestamp = 1_000_000L,
+        presetsScanned = "LONG_FAST",
+        homePreset = "LONG_FAST",
+        completionStatus = "complete",
+    )
+
+    // endregion
+}
+
+// region In-memory DAO for map filter tests
+
+private class MapTestDao : DiscoveryDao {
+    private var nextSessionId = 1L
+    private var nextPresetResultId = 1L
+    private var nextNodeId = 1L
+
+    private val sessions = mutableMapOf<Long, DiscoverySessionEntity>()
+    private val presetResults = mutableMapOf<Long, DiscoveryPresetResultEntity>()
+    private val discoveredNodes = mutableMapOf<Long, DiscoveredNodeEntity>()
+
+    override suspend fun insertSession(session: DiscoverySessionEntity): Long {
+        val id = nextSessionId++
+        sessions[id] = session.copy(id = id)
+        return id
+    }
+
+    override suspend fun updateSession(session: DiscoverySessionEntity) {
+        sessions[session.id] = session
+    }
+
+    override fun getAllSessions(): Flow<List<DiscoverySessionEntity>> =
+        flowOf(sessions.values.sortedByDescending { it.timestamp })
+
+    override suspend fun getSession(sessionId: Long) = sessions[sessionId]
+
+    override fun getSessionFlow(sessionId: Long): Flow<DiscoverySessionEntity?> = MutableStateFlow(sessions[sessionId])
+
+    override suspend fun deleteSession(sessionId: Long) {
+        sessions.remove(sessionId)
+        val resultIds = presetResults.values.filter { it.sessionId == sessionId }.map { it.id }
+        resultIds.forEach { rid ->
+            discoveredNodes.entries.removeAll { it.value.presetResultId == rid }
+            presetResults.remove(rid)
+        }
+    }
+
+    override suspend fun insertPresetResult(result: DiscoveryPresetResultEntity): Long {
+        val id = nextPresetResultId++
+        presetResults[id] = result.copy(id = id)
+        return id
+    }
+
+    override suspend fun updatePresetResult(result: DiscoveryPresetResultEntity) {
+        presetResults[result.id] = result
+    }
+
+    override suspend fun getPresetResults(sessionId: Long) = presetResults.values.filter { it.sessionId == sessionId }
+
+    override fun getPresetResultsFlow(sessionId: Long) =
+        flowOf(presetResults.values.filter { it.sessionId == sessionId })
+
+    override suspend fun insertDiscoveredNode(node: DiscoveredNodeEntity): Long {
+        val id = nextNodeId++
+        discoveredNodes[id] = node.copy(id = id)
+        return id
+    }
+
+    override suspend fun insertDiscoveredNodes(nodes: List<DiscoveredNodeEntity>) {
+        nodes.forEach { insertDiscoveredNode(it) }
+    }
+
+    override suspend fun updateDiscoveredNode(node: DiscoveredNodeEntity) {
+        discoveredNodes[node.id] = node
+    }
+
+    override suspend fun getDiscoveredNodes(presetResultId: Long) =
+        discoveredNodes.values.filter { it.presetResultId == presetResultId }
+
+    override fun getDiscoveredNodesFlow(presetResultId: Long) =
+        flowOf(discoveredNodes.values.filter { it.presetResultId == presetResultId })
+
+    override suspend fun getUniqueNodeNums(sessionId: Long) = presetResults.values
+        .filter { it.sessionId == sessionId }
+        .flatMap { pr -> discoveredNodes.values.filter { it.presetResultId == pr.id } }
+        .map { it.nodeNum }
+        .distinct()
+
+    override suspend fun getUniqueNodeCount(sessionId: Long) = getUniqueNodeNums(sessionId).size
+
+    override suspend fun getMaxDistance(sessionId: Long) = presetResults.values
+        .filter { it.sessionId == sessionId }
+        .flatMap { pr -> discoveredNodes.values.filter { it.presetResultId == pr.id } }
+        .mapNotNull { it.distanceFromUser }
+        .maxOrNull()
+
+    override suspend fun getSessionWithResults(sessionId: Long) = sessions[sessionId]
+
+    override suspend fun markInterruptedSessions() {
+        sessions.keys.toList().forEach { key ->
+            val session = sessions[key]!!
+            if (session.completionStatus == "in_progress") {
+                sessions[key] = session.copy(completionStatus = "interrupted")
+            }
+        }
+    }
+}
+
+// endregion

feature/discovery/src/commonTest/kotlin/org/meshtastic/feature/discovery/DiscoveryPacketCollectionTest.kt

@@ -0,0 +1,427 @@
+/*
+ * Copyright (c) 2026 Meshtastic LLC
+ *
+ * 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/>.
+ */
+@file:Suppress("MagicNumber")
+
+package org.meshtastic.feature.discovery
+
+import kotlinx.coroutines.SupervisorJob
+import kotlinx.coroutines.delay
+import kotlinx.coroutines.flow.Flow
+import kotlinx.coroutines.flow.MutableStateFlow
+import kotlinx.coroutines.flow.flowOf
+import kotlinx.coroutines.test.TestScope
+import kotlinx.coroutines.test.UnconfinedTestDispatcher
+import kotlinx.coroutines.test.runTest
+import okio.ByteString
+import okio.ByteString.Companion.toByteString
+import org.meshtastic.core.common.di.ApplicationCoroutineScope
+import org.meshtastic.core.database.dao.DiscoveryDao
+import org.meshtastic.core.database.entity.DiscoveredNodeEntity
+import org.meshtastic.core.database.entity.DiscoveryPresetResultEntity
+import org.meshtastic.core.database.entity.DiscoverySessionEntity
+import org.meshtastic.core.di.CoroutineDispatchers
+import org.meshtastic.core.model.ChannelOption
+import org.meshtastic.core.model.ConnectionState
+import org.meshtastic.core.model.DataPacket
+import org.meshtastic.core.model.MyNodeInfo
+import org.meshtastic.core.model.NodeAddress
+import org.meshtastic.core.repository.DiscoveryPacketCollector
+import org.meshtastic.core.repository.DiscoveryPacketCollectorRegistry
+import org.meshtastic.core.testing.FakeNodeRepository
+import org.meshtastic.core.testing.FakeRadioConfigRepository
+import org.meshtastic.core.testing.FakeRadioController
+import org.meshtastic.core.testing.FakeServiceRepository
+import org.meshtastic.feature.discovery.ai.DiscoverySummaryAiProvider
+import org.meshtastic.proto.Config
+import org.meshtastic.proto.Data
+import org.meshtastic.proto.LocalConfig
+import org.meshtastic.proto.MeshPacket
+import org.meshtastic.proto.Neighbor
+import org.meshtastic.proto.NeighborInfo
+import org.meshtastic.proto.PortNum
+import org.meshtastic.proto.Position
+import kotlin.test.Test
+import kotlin.test.assertEquals
+import kotlin.test.assertNull
+import kotlin.test.assertTrue
+
+/**
+ * Tests for edge cases in packet collection: duplicate packets, nodes without positions, and neighbor-info-only
+ * sightings (D023).
+ */
+class DiscoveryPacketCollectionTest {
+
+    private val radioController = FakeRadioController()
+    private val serviceRepository = FakeServiceRepository().apply { setConnectionState(ConnectionState.Connected) }
+    private val nodeRepository = FakeNodeRepository()
+    private val radioConfigRepository =
+        FakeRadioConfigRepository().apply {
+            setLocalConfigDirect(
+                LocalConfig(
+                    lora = Config.LoRaConfig(use_preset = true, modem_preset = ChannelOption.LONG_FAST.modemPreset),
+                ),
+            )
+        }
+    private val collectorRegistry = PacketTestCollectorRegistry()
+    private val discoveryDao = InMemoryDiscoveryDao()
+    private val aiProvider = PacketTestAiProvider()
+
+    private fun createEngine(testScope: TestScope): DiscoveryScanEngine {
+        val testDispatcher = UnconfinedTestDispatcher(testScope.testScheduler)
+        val dispatchers = CoroutineDispatchers(io = testDispatcher, main = testDispatcher, default = testDispatcher)
+        val appScope =
+            object : ApplicationCoroutineScope {
+                override val coroutineContext = testDispatcher + SupervisorJob()
+            }
+        return DiscoveryScanEngine(
+            radioController = radioController,
+            serviceRepository = serviceRepository,
+            nodeRepository = nodeRepository,
+            radioConfigRepository = radioConfigRepository,
+            collectorRegistry = collectorRegistry,
+            discoveryDao = discoveryDao,
+            aiProvider = aiProvider,
+            applicationScope = appScope,
+            dispatchers = dispatchers,
+        )
+    }
+
+    private val testPresets = listOf(ChannelOption.LONG_FAST)
+
+    private suspend fun awaitDwell(engine: DiscoveryScanEngine) {
+        while (engine.scanState.value !is DiscoveryScanState.Dwell) {
+            delay(50)
+        }
+    }
+
+    // region Duplicate packets
+
+    @Test
+    fun duplicatePacketsFromSameNodeDeduplicateByNodeNum() = runTest {
+        val engine = createEngine(this)
+        nodeRepository.setMyNodeInfo(createMyNodeInfo())
+        engine.startScan(testPresets, dwellDurationSeconds = 60)
+        awaitDwell(engine)
+
+        // Send two position packets from the same node
+        val meshPacket1 = positionPacket(from = 1111, latI = 377749000, lonI = -1224194000, snr = 5.0f, rssi = -70)
+        val meshPacket2 = positionPacket(from = 1111, latI = 377750000, lonI = -1224195000, snr = 8.0f, rssi = -55)
+        engine.onPacketReceived(meshPacket1, dataPacket(from = 1111))
+        engine.onPacketReceived(meshPacket2, dataPacket(from = 1111))
+
+        engine.stopScan()
+
+        // Only one discovered node for nodeNum=1111
+        val nodes = discoveryDao.discoveredNodes.values.toList()
+        assertEquals(1, nodes.size, "Duplicate packets should map to a single node entry")
+        assertEquals(1111L, nodes[0].nodeNum)
+        // Second packet's SNR/RSSI should overwrite first
+        assertEquals(8.0f, nodes[0].snr, "Later SNR should overwrite")
+        assertEquals(-55, nodes[0].rssi, "Later RSSI should overwrite")
+    }
+
+    @Test
+    fun duplicatePacketsCountMessagesAccumulatively() = runTest {
+        val engine = createEngine(this)
+        nodeRepository.setMyNodeInfo(createMyNodeInfo())
+        engine.startScan(testPresets, dwellDurationSeconds = 60)
+        awaitDwell(engine)
+
+        // Send 3 text messages from same node
+        repeat(3) { engine.onPacketReceived(textMessagePacket(from = 2222), dataPacket(from = 2222)) }
+
+        engine.stopScan()
+
+        val nodes = discoveryDao.discoveredNodes.values.toList()
+        assertEquals(1, nodes.size)
+        assertEquals(3, nodes[0].messageCount, "Message count should accumulate across duplicate packets")
+    }
+
+    // endregion
+
+    // region Nodes without positions
+
+    @Test
+    fun nodeWithoutPositionHasNullLatLon() = runTest {
+        val engine = createEngine(this)
+        nodeRepository.setMyNodeInfo(createMyNodeInfo())
+        engine.startScan(testPresets, dwellDurationSeconds = 60)
+        awaitDwell(engine)
+
+        // Send a text message with no position data
+        engine.onPacketReceived(textMessagePacket(from = 3333), dataPacket(from = 3333))
+
+        engine.stopScan()
+
+        val nodes = discoveryDao.discoveredNodes.values.toList()
+        assertEquals(1, nodes.size)
+        assertNull(nodes[0].latitude, "Node without position should have null latitude")
+        assertNull(nodes[0].longitude, "Node without position should have null longitude")
+        assertNull(nodes[0].distanceFromUser, "Node without position should have null distance")
+    }
+
+    @Test
+    fun nodeWithZeroPositionTreatedAsNoPosition() = runTest {
+        val engine = createEngine(this)
+        nodeRepository.setMyNodeInfo(createMyNodeInfo())
+        engine.startScan(testPresets, dwellDurationSeconds = 60)
+        awaitDwell(engine)
+
+        // Position of 0,0 is treated as invalid/no fix
+        val packet = positionPacket(from = 4444, latI = 0, lonI = 0)
+        engine.onPacketReceived(packet, dataPacket(from = 4444))
+
+        engine.stopScan()
+
+        val nodes = discoveryDao.discoveredNodes.values.toList()
+        assertEquals(1, nodes.size)
+        assertNull(nodes[0].distanceFromUser, "Zero-position node should have null distance")
+    }
+
+    // endregion
+
+    // region Neighbor-info-only sightings
+
+    @Test
+    fun neighborInfoOnlyNodeIsMarkedAsMesh() = runTest {
+        val engine = createEngine(this)
+        nodeRepository.setMyNodeInfo(createMyNodeInfo())
+        engine.startScan(testPresets, dwellDurationSeconds = 60)
+        awaitDwell(engine)
+
+        // Send a neighbor info packet that references node 5555 as a mesh neighbor
+        val niPacket = neighborInfoPacket(from = 9999, neighborNodeIds = listOf(5555))
+        engine.onPacketReceived(niPacket, dataPacket(from = 9999))
+
+        engine.stopScan()
+
+        // Node 5555 should appear as a mesh neighbor even though we never received a direct packet from it
+        val nodes = discoveryDao.discoveredNodes.values.toList()
+        val meshNode = nodes.find { it.nodeNum == 5555L }
+        assertTrue(meshNode != null, "Neighbor-info-only node should be persisted")
+        assertEquals("mesh", meshNode.neighborType, "Neighbor-info-only node should have 'mesh' type")
+    }
+
+    @Test
+    fun neighborInfoDoesNotOverrideDirectType() = runTest {
+        val engine = createEngine(this)
+        nodeRepository.setMyNodeInfo(createMyNodeInfo())
+        engine.startScan(testPresets, dwellDurationSeconds = 60)
+        awaitDwell(engine)
+
+        // First: receive a direct packet from node 6666
+        engine.onPacketReceived(
+            positionPacket(from = 6666, latI = 377749000, lonI = -1224194000, snr = 10f, rssi = -40),
+            dataPacket(from = 6666),
+        )
+
+        // Then: receive neighbor info that also references 6666
+        val niPacket = neighborInfoPacket(from = 8888, neighborNodeIds = listOf(6666))
+        engine.onPacketReceived(niPacket, dataPacket(from = 8888))
+
+        engine.stopScan()
+
+        val nodes = discoveryDao.discoveredNodes.values.toList()
+        val directNode = nodes.find { it.nodeNum == 6666L }
+        assertTrue(directNode != null, "Node should be persisted")
+        assertEquals("direct", directNode.neighborType, "Direct type should not be overridden by neighbor-info")
+        assertEquals(10f, directNode.snr, "SNR from direct packet should be preserved")
+    }
+
+    @Test
+    fun neighborInfoMultipleNeighborsAllRecorded() = runTest {
+        val engine = createEngine(this)
+        nodeRepository.setMyNodeInfo(createMyNodeInfo())
+        engine.startScan(testPresets, dwellDurationSeconds = 60)
+        awaitDwell(engine)
+
+        val niPacket = neighborInfoPacket(from = 7777, neighborNodeIds = listOf(101, 102, 103))
+        engine.onPacketReceived(niPacket, dataPacket(from = 7777))
+
+        engine.stopScan()
+
+        val nodes = discoveryDao.discoveredNodes.values.toList()
+        // Node 7777 (the sender) + 3 mesh neighbors
+        val meshNodes = nodes.filter { it.neighborType == "mesh" }
+        assertEquals(3, meshNodes.size, "All neighbor IDs from NeighborInfo should be recorded")
+        assertTrue(meshNodes.map { it.nodeNum }.containsAll(listOf(101L, 102L, 103L)))
+    }
+
+    // endregion
+
+    // region Helpers
+
+    private fun createMyNodeInfo(nodeNum: Int = 1000) = MyNodeInfo(
+        myNodeNum = nodeNum,
+        hasGPS = true,
+        model = "TestModel",
+        firmwareVersion = "2.0.0",
+        couldUpdate = false,
+        shouldUpdate = false,
+        currentPacketId = 1L,
+        messageTimeoutMsec = 5000,
+        minAppVersion = 1,
+        maxChannels = 8,
+        hasWifi = false,
+        channelUtilization = 0f,
+        airUtilTx = 0f,
+        deviceId = "test-device",
+    )
+
+    private fun positionPacket(from: Int, latI: Int, lonI: Int, snr: Float = 5.5f, rssi: Int = -70): MeshPacket {
+        val posPayload = Position.ADAPTER.encode(Position(latitude_i = latI, longitude_i = lonI)).toByteString()
+        val data = Data(portnum = PortNum.POSITION_APP, payload = posPayload)
+        return MeshPacket(from = from, decoded = data, rx_snr = snr, rx_rssi = rssi)
+    }
+
+    private fun textMessagePacket(from: Int): MeshPacket {
+        val data = Data(portnum = PortNum.TEXT_MESSAGE_APP, payload = "hello".encodeToByteArray().toByteString())
+        return MeshPacket(from = from, decoded = data, rx_snr = 3.0f, rx_rssi = -80)
+    }
+
+    private fun neighborInfoPacket(from: Int, neighborNodeIds: List<Int>): MeshPacket {
+        val neighbors = neighborNodeIds.map { Neighbor(node_id = it) }
+        val ni = NeighborInfo(node_id = from, neighbors = neighbors)
+        val payload = NeighborInfo.ADAPTER.encode(ni).toByteString()
+        val data = Data(portnum = PortNum.NEIGHBORINFO_APP, payload = payload)
+        return MeshPacket(from = from, decoded = data)
+    }
+
+    private fun dataPacket(from: Int) = DataPacket(
+        to = NodeAddress.ID_BROADCAST,
+        bytes = ByteString.EMPTY,
+        dataType = PortNum.POSITION_APP.value,
+        from = "!${from.toString(16)}",
+        hopStart = 3,
+        hopLimit = 3,
+    )
+
+    // endregion
+}
+
+// region Inline test doubles
+
+private class PacketTestCollectorRegistry : DiscoveryPacketCollectorRegistry {
+    override var collector: DiscoveryPacketCollector? = null
+}
+
+private class PacketTestAiProvider : DiscoverySummaryAiProvider {
+    override val isAvailable: Boolean = false
+
+    override suspend fun generateSessionSummary(
+        session: DiscoverySessionEntity,
+        presetResults: List<DiscoveryPresetResultEntity>,
+    ): String? = null
+
+    override suspend fun generatePresetSummary(result: DiscoveryPresetResultEntity): String? = null
+}
+
+private class InMemoryDiscoveryDao : DiscoveryDao {
+    private var nextSessionId = 1L
+    private var nextPresetResultId = 1L
+    private var nextNodeId = 1L
+
+    val sessions = mutableMapOf<Long, DiscoverySessionEntity>()
+    val presetResults = mutableMapOf<Long, DiscoveryPresetResultEntity>()
+    val discoveredNodes = mutableMapOf<Long, DiscoveredNodeEntity>()
+
+    override suspend fun insertSession(session: DiscoverySessionEntity): Long {
+        val id = nextSessionId++
+        sessions[id] = session.copy(id = id)
+        return id
+    }
+
+    override suspend fun updateSession(session: DiscoverySessionEntity) {
+        sessions[session.id] = session
+    }
+
+    override fun getAllSessions(): Flow<List<DiscoverySessionEntity>> =
+        flowOf(sessions.values.sortedByDescending { it.timestamp })
+
+    override suspend fun getSession(sessionId: Long): DiscoverySessionEntity? = sessions[sessionId]
+
+    override fun getSessionFlow(sessionId: Long): Flow<DiscoverySessionEntity?> = MutableStateFlow(sessions[sessionId])
+
+    override suspend fun deleteSession(sessionId: Long) {
+        sessions.remove(sessionId)
+        val resultIds = presetResults.values.filter { it.sessionId == sessionId }.map { it.id }
+        resultIds.forEach { rid ->
+            discoveredNodes.entries.removeAll { it.value.presetResultId == rid }
+            presetResults.remove(rid)
+        }
+    }
+
+    override suspend fun insertPresetResult(result: DiscoveryPresetResultEntity): Long {
+        val id = nextPresetResultId++
+        presetResults[id] = result.copy(id = id)
+        return id
+    }
+
+    override suspend fun updatePresetResult(result: DiscoveryPresetResultEntity) {
+        presetResults[result.id] = result
+    }
+
+    override suspend fun getPresetResults(sessionId: Long) = presetResults.values.filter { it.sessionId == sessionId }
+
+    override fun getPresetResultsFlow(sessionId: Long) =
+        flowOf(presetResults.values.filter { it.sessionId == sessionId })
+
+    override suspend fun insertDiscoveredNode(node: DiscoveredNodeEntity): Long {
+        val id = nextNodeId++
+        discoveredNodes[id] = node.copy(id = id)
+        return id
+    }
+
+    override suspend fun insertDiscoveredNodes(nodes: List<DiscoveredNodeEntity>) {
+        nodes.forEach { insertDiscoveredNode(it) }
+    }
+
+    override suspend fun updateDiscoveredNode(node: DiscoveredNodeEntity) {
+        discoveredNodes[node.id] = node
+    }
+
+    override suspend fun getDiscoveredNodes(presetResultId: Long) =
+        discoveredNodes.values.filter { it.presetResultId == presetResultId }
+
+    override fun getDiscoveredNodesFlow(presetResultId: Long) =
+        flowOf(discoveredNodes.values.filter { it.presetResultId == presetResultId })
+
+    override suspend fun getUniqueNodeNums(sessionId: Long) = presetResults.values
+        .filter { it.sessionId == sessionId }
+        .flatMap { pr -> discoveredNodes.values.filter { it.presetResultId == pr.id } }
+        .map { it.nodeNum }
+        .distinct()
+
+    override suspend fun getUniqueNodeCount(sessionId: Long) = getUniqueNodeNums(sessionId).size
+
+    override suspend fun getMaxDistance(sessionId: Long) = presetResults.values
+        .filter { it.sessionId == sessionId }
+        .flatMap { pr -> discoveredNodes.values.filter { it.presetResultId == pr.id } }
+        .mapNotNull { it.distanceFromUser }
+        .maxOrNull()
+
+    override suspend fun getSessionWithResults(sessionId: Long) = sessions[sessionId]
+
+    override suspend fun markInterruptedSessions() {
+        sessions.keys.toList().forEach { key ->
+            val session = sessions[key]!!
+            if (session.completionStatus == "in_progress") {
+                sessions[key] = session.copy(completionStatus = "interrupted")
+            }
+        }
+    }
+}

feature/discovery/src/commonTest/kotlin/org/meshtastic/feature/discovery/DiscoveryRankingEngineTest.kt

@@ -0,0 +1,398 @@
+/*
+ * Copyright (c) 2026 Meshtastic LLC
+ *
+ * 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/>.
+ */
+@file:Suppress("MagicNumber")
+
+package org.meshtastic.feature.discovery
+
+import org.meshtastic.core.database.entity.DiscoveredNodeEntity
+import org.meshtastic.core.database.entity.DiscoveryPresetResultEntity
+import org.meshtastic.feature.discovery.scan.DiscoveryRankingEngine
+import org.meshtastic.feature.discovery.scan.PresetRankingInput
+import kotlin.test.Test
+import kotlin.test.assertEquals
+import kotlin.test.assertFalse
+import kotlin.test.assertTrue
+
+class DiscoveryRankingEngineTest {
+
+    private val engine = DiscoveryRankingEngine()
+
+    // ---- Helpers ----
+
+    private fun preset(
+        id: Long = 1,
+        sessionId: Long = 100,
+        name: String = "LongFast",
+        uniqueNodes: Int = 0,
+        directNeighborCount: Int = 0,
+        meshNeighborCount: Int = 0,
+        numPacketsRx: Int = 0,
+        numRxDupe: Int = 0,
+        packetFailureRate: Double = 0.0,
+    ) = DiscoveryPresetResultEntity(
+        id = id,
+        sessionId = sessionId,
+        presetName = name,
+        uniqueNodes = uniqueNodes,
+        directNeighborCount = directNeighborCount,
+        meshNeighborCount = meshNeighborCount,
+        numPacketsRx = numPacketsRx,
+        numRxDupe = numRxDupe,
+        packetFailureRate = packetFailureRate,
+    )
+
+    private fun node(
+        presetResultId: Long = 1,
+        nodeNum: Long = 1,
+        snr: Float = 0f,
+        rssi: Int = 0,
+        distanceFromUser: Double? = null,
+    ) = DiscoveredNodeEntity(
+        presetResultId = presetResultId,
+        nodeNum = nodeNum,
+        snr = snr,
+        rssi = rssi,
+        distanceFromUser = distanceFromUser,
+    )
+
+    private fun input(preset: DiscoveryPresetResultEntity, nodes: List<DiscoveredNodeEntity> = emptyList()) =
+        PresetRankingInput(preset, nodes)
+
+    // ---- Tests ----
+
+    @Test
+    fun emptyInputReturnsEmptyOutput() {
+        val result = engine.rank(emptyList())
+        assertTrue(result.isEmpty())
+    }
+
+    @Test
+    fun singlePresetAlwaysRank1NotTied() {
+        val p = preset(uniqueNodes = 5)
+        val result = engine.rank(listOf(input(p)))
+        assertEquals(1, result.size)
+        assertEquals(1, result[0].rank)
+        assertFalse(result[0].isTied)
+        assertEquals(5, result[0].scoreBreakdown.uniqueNodeCount)
+    }
+
+    @Test
+    fun criterion1UniqueNodeCountDecides() {
+        val winner = preset(id = 1, name = "LongFast", uniqueNodes = 10)
+        val loser = preset(id = 2, name = "ShortFast", uniqueNodes = 3)
+        val result = engine.rank(listOf(input(loser), input(winner)))
+
+        assertEquals(2, result.size)
+        assertEquals("LongFast", result[0].presetResult.presetName)
+        assertEquals(1, result[0].rank)
+        assertEquals("ShortFast", result[1].presetResult.presetName)
+        assertEquals(2, result[1].rank)
+        assertFalse(result[0].isTied)
+        assertFalse(result[1].isTied)
+    }
+
+    @Test
+    fun criterion2NeighborDiversityBreaksTie() {
+        val a = preset(id = 1, name = "A", uniqueNodes = 5, directNeighborCount = 3, meshNeighborCount = 4)
+        val b = preset(id = 2, name = "B", uniqueNodes = 5, directNeighborCount = 1, meshNeighborCount = 2)
+        val result = engine.rank(listOf(input(b), input(a)))
+
+        assertEquals("A", result[0].presetResult.presetName, "Higher neighbor diversity wins")
+        assertEquals(7, result[0].scoreBreakdown.neighborDiversity)
+        assertEquals(3, result[1].scoreBreakdown.neighborDiversity)
+    }
+
+    @Test
+    fun criterion3NonDupePacketCountBreaksTie() {
+        val a =
+            preset(
+                id = 1,
+                name = "A",
+                uniqueNodes = 5,
+                directNeighborCount = 3,
+                meshNeighborCount = 2,
+                numPacketsRx = 100,
+                numRxDupe = 10,
+            )
+        val b =
+            preset(
+                id = 2,
+                name = "B",
+                uniqueNodes = 5,
+                directNeighborCount = 3,
+                meshNeighborCount = 2,
+                numPacketsRx = 80,
+                numRxDupe = 5,
+            )
+        val result = engine.rank(listOf(input(b), input(a)))
+
+        assertEquals("A", result[0].presetResult.presetName, "Higher non-dupe packet count wins")
+        assertEquals(90, result[0].scoreBreakdown.nonDupePacketCount)
+        assertEquals(75, result[1].scoreBreakdown.nonDupePacketCount)
+    }
+
+    @Test
+    fun criterion4MedianSnrBreaksTie() {
+        val pA =
+            preset(
+                id = 1,
+                name = "A",
+                uniqueNodes = 5,
+                directNeighborCount = 3,
+                meshNeighborCount = 2,
+                numPacketsRx = 50,
+            )
+        val pB =
+            preset(
+                id = 2,
+                name = "B",
+                uniqueNodes = 5,
+                directNeighborCount = 3,
+                meshNeighborCount = 2,
+                numPacketsRx = 50,
+            )
+        val nodesA =
+            listOf(
+                node(presetResultId = 1, nodeNum = 1, snr = 10f),
+                node(presetResultId = 1, nodeNum = 2, snr = 8f),
+                node(presetResultId = 1, nodeNum = 3, snr = 12f),
+            )
+        val nodesB =
+            listOf(
+                node(presetResultId = 2, nodeNum = 4, snr = 2f),
+                node(presetResultId = 2, nodeNum = 5, snr = 4f),
+                node(presetResultId = 2, nodeNum = 6, snr = 3f),
+            )
+        val result = engine.rank(listOf(input(pB, nodesB), input(pA, nodesA)))
+
+        assertEquals("A", result[0].presetResult.presetName, "Higher median SNR wins")
+        assertEquals(10f, result[0].scoreBreakdown.medianSnr)
+        assertEquals(3f, result[1].scoreBreakdown.medianSnr)
+    }
+
+    @Test
+    fun criterion4MedianRssiBreaksTieOnSnr() {
+        val pA =
+            preset(
+                id = 1,
+                name = "A",
+                uniqueNodes = 5,
+                directNeighborCount = 3,
+                meshNeighborCount = 2,
+                numPacketsRx = 50,
+            )
+        val pB =
+            preset(
+                id = 2,
+                name = "B",
+                uniqueNodes = 5,
+                directNeighborCount = 3,
+                meshNeighborCount = 2,
+                numPacketsRx = 50,
+            )
+        val nodesA =
+            listOf(
+                node(presetResultId = 1, nodeNum = 1, snr = 5f, rssi = -60),
+                node(presetResultId = 1, nodeNum = 2, snr = 5f, rssi = -50),
+                node(presetResultId = 1, nodeNum = 3, snr = 5f, rssi = -55),
+            )
+        val nodesB =
+            listOf(
+                node(presetResultId = 2, nodeNum = 4, snr = 5f, rssi = -90),
+                node(presetResultId = 2, nodeNum = 5, snr = 5f, rssi = -80),
+                node(presetResultId = 2, nodeNum = 6, snr = 5f, rssi = -85),
+            )
+        val result = engine.rank(listOf(input(pB, nodesB), input(pA, nodesA)))
+
+        assertEquals("A", result[0].presetResult.presetName, "Higher median RSSI wins when SNR ties")
+    }
+
+    @Test
+    fun criterion5BestKnownDistanceBreaksTie() {
+        val pA =
+            preset(
+                id = 1,
+                name = "A",
+                uniqueNodes = 5,
+                directNeighborCount = 3,
+                meshNeighborCount = 2,
+                numPacketsRx = 50,
+            )
+        val pB =
+            preset(
+                id = 2,
+                name = "B",
+                uniqueNodes = 5,
+                directNeighborCount = 3,
+                meshNeighborCount = 2,
+                numPacketsRx = 50,
+            )
+        val nodesA =
+            listOf(
+                node(presetResultId = 1, nodeNum = 1, snr = 5f, rssi = -70, distanceFromUser = 5000.0),
+                node(presetResultId = 1, nodeNum = 2, snr = 5f, rssi = -70, distanceFromUser = 3000.0),
+            )
+        val nodesB =
+            listOf(
+                node(presetResultId = 2, nodeNum = 3, snr = 5f, rssi = -70, distanceFromUser = 1000.0),
+                node(presetResultId = 2, nodeNum = 4, snr = 5f, rssi = -70, distanceFromUser = 500.0),
+            )
+        val result = engine.rank(listOf(input(pB, nodesB), input(pA, nodesA)))
+
+        assertEquals("A", result[0].presetResult.presetName, "Greater best-known distance wins")
+        assertEquals(5000.0, result[0].scoreBreakdown.bestKnownDistance)
+        assertEquals(1000.0, result[1].scoreBreakdown.bestKnownDistance)
+    }
+
+    @Test
+    fun criterion6LowestFailurePenaltyBreaksTie() {
+        val pA =
+            preset(
+                id = 1,
+                name = "A",
+                uniqueNodes = 5,
+                directNeighborCount = 3,
+                meshNeighborCount = 2,
+                numPacketsRx = 50,
+                packetFailureRate = 0.05,
+            )
+        val pB =
+            preset(
+                id = 2,
+                name = "B",
+                uniqueNodes = 5,
+                directNeighborCount = 3,
+                meshNeighborCount = 2,
+                numPacketsRx = 50,
+                packetFailureRate = 0.20,
+            )
+        val nodesA = listOf(node(presetResultId = 1, nodeNum = 1, snr = 5f, rssi = -70))
+        val nodesB = listOf(node(presetResultId = 2, nodeNum = 2, snr = 5f, rssi = -70))
+        val result = engine.rank(listOf(input(pB, nodesB), input(pA, nodesA)))
+
+        assertEquals("A", result[0].presetResult.presetName, "Lower failure rate wins")
+        assertEquals(0.05, result[0].scoreBreakdown.failurePenalty)
+    }
+
+    @Test
+    fun allCriteriaTiedMarkedAsTied() {
+        val pA =
+            preset(
+                id = 1,
+                name = "A",
+                uniqueNodes = 5,
+                directNeighborCount = 3,
+                meshNeighborCount = 2,
+                numPacketsRx = 50,
+                packetFailureRate = 0.1,
+            )
+        val pB =
+            preset(
+                id = 2,
+                name = "B",
+                uniqueNodes = 5,
+                directNeighborCount = 3,
+                meshNeighborCount = 2,
+                numPacketsRx = 50,
+                packetFailureRate = 0.1,
+            )
+        val nodesA = listOf(node(presetResultId = 1, nodeNum = 1, snr = 5f, rssi = -70, distanceFromUser = 1000.0))
+        val nodesB = listOf(node(presetResultId = 2, nodeNum = 2, snr = 5f, rssi = -70, distanceFromUser = 1000.0))
+        val result = engine.rank(listOf(input(pA, nodesA), input(pB, nodesB)))
+
+        assertEquals(2, result.size)
+        assertEquals(1, result[0].rank)
+        assertEquals(1, result[1].rank, "Tied presets share the same rank")
+        assertTrue(result[0].isTied)
+        assertTrue(result[1].isTied)
+    }
+
+    @Test
+    fun threePresetsWithOneFailedStillRanked() {
+        val good =
+            preset(
+                id = 1,
+                name = "LongFast",
+                uniqueNodes = 10,
+                directNeighborCount = 5,
+                meshNeighborCount = 3,
+                numPacketsRx = 100,
+                packetFailureRate = 0.02,
+            )
+        val mediocre =
+            preset(
+                id = 2,
+                name = "MedFast",
+                uniqueNodes = 5,
+                directNeighborCount = 2,
+                meshNeighborCount = 1,
+                numPacketsRx = 50,
+                packetFailureRate = 0.10,
+            )
+        val failed =
+            preset(
+                id = 3,
+                name = "ShortFast",
+                uniqueNodes = 0,
+                directNeighborCount = 0,
+                meshNeighborCount = 0,
+                numPacketsRx = 5,
+                packetFailureRate = 0.9,
+            )
+
+        val result = engine.rank(listOf(input(failed), input(mediocre), input(good)))
+
+        assertEquals(3, result.size)
+        assertEquals("LongFast", result[0].presetResult.presetName)
+        assertEquals(1, result[0].rank)
+        assertEquals("MedFast", result[1].presetResult.presetName)
+        assertEquals(2, result[1].rank)
+        assertEquals("ShortFast", result[2].presetResult.presetName)
+        assertEquals(3, result[2].rank)
+        assertFalse(result[0].isTied)
+        assertFalse(result[2].isTied)
+    }
+
+    @Test
+    fun noNodesProducesZeroMediansAndDistance() {
+        val p = preset(uniqueNodes = 3, numPacketsRx = 20)
+        val result = engine.rank(listOf(input(p, emptyList())))
+
+        assertEquals(0f, result[0].scoreBreakdown.medianSnr)
+        assertEquals(0, result[0].scoreBreakdown.medianRssi)
+        assertEquals(0.0, result[0].scoreBreakdown.bestKnownDistance)
+    }
+
+    @Test
+    fun nodesWithoutDistanceYieldZeroBestDistance() {
+        val p = preset(id = 1, uniqueNodes = 2)
+        val nodes =
+            listOf(
+                node(presetResultId = 1, nodeNum = 1, snr = 5f, distanceFromUser = null),
+                node(presetResultId = 1, nodeNum = 2, snr = 3f, distanceFromUser = null),
+            )
+        val result = engine.rank(listOf(input(p, nodes)))
+        assertEquals(0.0, result[0].scoreBreakdown.bestKnownDistance)
+    }
+
+    @Test
+    fun negativeDupeCountClampedToZero() {
+        val p = preset(numPacketsRx = 5, numRxDupe = 10) // more dupes than rx — shouldn't go negative
+        val result = engine.rank(listOf(input(p)))
+        assertEquals(0, result[0].scoreBreakdown.nonDupePacketCount)
+    }
+}

feature/discovery/src/commonTest/kotlin/org/meshtastic/feature/discovery/DiscoveryScanEngineTest.kt

@@ -0,0 +1,538 @@
+/*
+ * Copyright (c) 2026 Meshtastic LLC
+ *
+ * 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/>.
+ */
+@file:Suppress("MagicNumber")
+
+package org.meshtastic.feature.discovery
+
+import kotlinx.coroutines.SupervisorJob
+import kotlinx.coroutines.delay
+import kotlinx.coroutines.flow.Flow
+import kotlinx.coroutines.flow.MutableStateFlow
+import kotlinx.coroutines.flow.flowOf
+import kotlinx.coroutines.test.TestScope
+import kotlinx.coroutines.test.UnconfinedTestDispatcher
+import kotlinx.coroutines.test.runTest
+import okio.ByteString
+import okio.ByteString.Companion.toByteString
+import org.meshtastic.core.common.di.ApplicationCoroutineScope
+import org.meshtastic.core.database.dao.DiscoveryDao
+import org.meshtastic.core.database.entity.DiscoveredNodeEntity
+import org.meshtastic.core.database.entity.DiscoveryPresetResultEntity
+import org.meshtastic.core.database.entity.DiscoverySessionEntity
+import org.meshtastic.core.di.CoroutineDispatchers
+import org.meshtastic.core.model.ChannelOption
+import org.meshtastic.core.model.ConnectionState
+import org.meshtastic.core.model.DataPacket
+import org.meshtastic.core.model.MyNodeInfo
+import org.meshtastic.core.model.Node
+import org.meshtastic.core.model.NodeAddress
+import org.meshtastic.core.repository.DiscoveryPacketCollector
+import org.meshtastic.core.repository.DiscoveryPacketCollectorRegistry
+import org.meshtastic.core.testing.FakeNodeRepository
+import org.meshtastic.core.testing.FakeRadioConfigRepository
+import org.meshtastic.core.testing.FakeRadioController
+import org.meshtastic.core.testing.FakeServiceRepository
+import org.meshtastic.feature.discovery.ai.DiscoverySummaryAiProvider
+import org.meshtastic.proto.Config
+import org.meshtastic.proto.Data
+import org.meshtastic.proto.LocalConfig
+import org.meshtastic.proto.LocalStats
+import org.meshtastic.proto.MeshPacket
+import org.meshtastic.proto.PortNum
+import org.meshtastic.proto.Position
+import org.meshtastic.proto.Telemetry
+import org.meshtastic.proto.User
+import kotlin.test.Test
+import kotlin.test.assertEquals
+import kotlin.test.assertFalse
+import kotlin.test.assertNotNull
+import kotlin.test.assertNull
+import kotlin.test.assertTrue
+
+// region Inline fakes
+
+/** In-memory fake of [DiscoveryDao] for unit tests. */
+private class FakeDiscoveryDao : DiscoveryDao {
+    private var nextSessionId = 1L
+    private var nextPresetResultId = 1L
+    private var nextNodeId = 1L
+
+    val sessions = mutableMapOf<Long, DiscoverySessionEntity>()
+    val presetResults = mutableMapOf<Long, DiscoveryPresetResultEntity>()
+    val discoveredNodes = mutableMapOf<Long, DiscoveredNodeEntity>()
+
+    override suspend fun insertSession(session: DiscoverySessionEntity): Long {
+        val id = nextSessionId++
+        sessions[id] = session.copy(id = id)
+        return id
+    }
+
+    override suspend fun updateSession(session: DiscoverySessionEntity) {
+        sessions[session.id] = session
+    }
+
+    override fun getAllSessions(): Flow<List<DiscoverySessionEntity>> =
+        flowOf(sessions.values.sortedByDescending { it.timestamp })
+
+    override suspend fun getSession(sessionId: Long): DiscoverySessionEntity? = sessions[sessionId]
+
+    override fun getSessionFlow(sessionId: Long): Flow<DiscoverySessionEntity?> = MutableStateFlow(sessions[sessionId])
+
+    override suspend fun deleteSession(sessionId: Long) {
+        sessions.remove(sessionId)
+        val resultIds = presetResults.values.filter { it.sessionId == sessionId }.map { it.id }
+        resultIds.forEach { resultId ->
+            discoveredNodes.entries.removeAll { it.value.presetResultId == resultId }
+            presetResults.remove(resultId)
+        }
+    }
+
+    override suspend fun insertPresetResult(result: DiscoveryPresetResultEntity): Long {
+        val id = nextPresetResultId++
+        presetResults[id] = result.copy(id = id)
+        return id
+    }
+
+    override suspend fun updatePresetResult(result: DiscoveryPresetResultEntity) {
+        presetResults[result.id] = result
+    }
+
+    override suspend fun getPresetResults(sessionId: Long): List<DiscoveryPresetResultEntity> =
+        presetResults.values.filter { it.sessionId == sessionId }
+
+    override fun getPresetResultsFlow(sessionId: Long): Flow<List<DiscoveryPresetResultEntity>> =
+        flowOf(getPresetResultsSynchronous(sessionId))
+
+    private fun getPresetResultsSynchronous(sessionId: Long): List<DiscoveryPresetResultEntity> =
+        presetResults.values.filter { it.sessionId == sessionId }
+
+    override suspend fun insertDiscoveredNode(node: DiscoveredNodeEntity): Long {
+        val id = nextNodeId++
+        discoveredNodes[id] = node.copy(id = id)
+        return id
+    }
+
+    override suspend fun insertDiscoveredNodes(nodes: List<DiscoveredNodeEntity>) {
+        nodes.forEach { insertDiscoveredNode(it) }
+    }
+
+    override suspend fun updateDiscoveredNode(node: DiscoveredNodeEntity) {
+        discoveredNodes[node.id] = node
+    }
+
+    override suspend fun getDiscoveredNodes(presetResultId: Long): List<DiscoveredNodeEntity> =
+        discoveredNodes.values.filter { it.presetResultId == presetResultId }
+
+    override fun getDiscoveredNodesFlow(presetResultId: Long): Flow<List<DiscoveredNodeEntity>> =
+        flowOf(discoveredNodes.values.filter { it.presetResultId == presetResultId })
+
+    override suspend fun getUniqueNodeNums(sessionId: Long): List<Long> = presetResults.values
+        .filter { it.sessionId == sessionId }
+        .flatMap { pr -> discoveredNodes.values.filter { it.presetResultId == pr.id } }
+        .map { it.nodeNum }
+        .distinct()
+
+    override suspend fun getUniqueNodeCount(sessionId: Long): Int = getUniqueNodeNums(sessionId).size
+
+    override suspend fun getMaxDistance(sessionId: Long): Double? = presetResults.values
+        .filter { it.sessionId == sessionId }
+        .flatMap { pr -> discoveredNodes.values.filter { it.presetResultId == pr.id } }
+        .mapNotNull { it.distanceFromUser }
+        .maxOrNull()
+
+    override suspend fun getSessionWithResults(sessionId: Long): DiscoverySessionEntity? = sessions[sessionId]
+
+    override suspend fun markInterruptedSessions() {
+        sessions.keys.toList().forEach { key ->
+            val session = sessions[key]!!
+            if (session.completionStatus == "in_progress") {
+                sessions[key] = session.copy(completionStatus = "interrupted")
+            }
+        }
+    }
+}
+
+/** Simple fake collector registry that tracks registration. */
+private class FakeCollectorRegistry : DiscoveryPacketCollectorRegistry {
+    override var collector: DiscoveryPacketCollector? = null
+}
+
+/** AI provider that is never available (no AI in tests). */
+private class FakeAiProvider : DiscoverySummaryAiProvider {
+    override val isAvailable: Boolean = false
+
+    override suspend fun generateSessionSummary(
+        session: DiscoverySessionEntity,
+        presetResults: List<DiscoveryPresetResultEntity>,
+    ): String? = null
+
+    override suspend fun generatePresetSummary(result: DiscoveryPresetResultEntity): String? = null
+}
+
+// endregion
+
+class DiscoveryScanEngineTest {
+
+    private val radioController = FakeRadioController()
+    private val serviceRepository = FakeServiceRepository().apply { setConnectionState(ConnectionState.Connected) }
+    private val nodeRepository = FakeNodeRepository()
+    private val radioConfigRepository =
+        FakeRadioConfigRepository().apply {
+            setLocalConfigDirect(
+                LocalConfig(
+                    lora = Config.LoRaConfig(use_preset = true, modem_preset = ChannelOption.LONG_FAST.modemPreset),
+                ),
+            )
+        }
+    private val collectorRegistry = FakeCollectorRegistry()
+    private val discoveryDao = FakeDiscoveryDao()
+    private val aiProvider = FakeAiProvider()
+
+    /** Creates a [DiscoveryScanEngine] wired to test dispatchers sharing the given [testScope]'s scheduler. */
+    private fun createEngine(testScope: TestScope): DiscoveryScanEngine {
+        val testDispatcher = UnconfinedTestDispatcher(testScope.testScheduler)
+        val dispatchers = CoroutineDispatchers(io = testDispatcher, main = testDispatcher, default = testDispatcher)
+        val appScope =
+            object : ApplicationCoroutineScope {
+                override val coroutineContext = testDispatcher + SupervisorJob()
+            }
+        return DiscoveryScanEngine(
+            radioController = radioController,
+            serviceRepository = serviceRepository,
+            nodeRepository = nodeRepository,
+            radioConfigRepository = radioConfigRepository,
+            collectorRegistry = collectorRegistry,
+            discoveryDao = discoveryDao,
+            aiProvider = aiProvider,
+            applicationScope = appScope,
+            dispatchers = dispatchers,
+        )
+    }
+
+    private val testPresets = listOf(ChannelOption.LONG_FAST)
+
+    /**
+     * After [DiscoveryScanEngine.startScan], the state is set to [DiscoveryScanState.Shifting] synchronously. This
+     * helper asserts that the engine is active — no real-time wait needed.
+     */
+    private fun assertScanActive(engine: DiscoveryScanEngine) {
+        assertTrue(engine.isActive, "Engine should be active after startScan")
+    }
+
+    /**
+     * Waits briefly for the scan loop (running on test dispatcher) to complete its per-preset initialization
+     * (collection clearing). Call before sending packets to avoid a race where the scan loop's `collectedNodes.clear()`
+     * wipes out test-injected data.
+     */
+    @Suppress("MagicNumber")
+    private suspend fun awaitScanLoopInit() {
+        delay(100)
+    }
+
+    // region Helper factories
+
+    private fun createMyNodeInfo(nodeNum: Int = 1000) = MyNodeInfo(
+        myNodeNum = nodeNum,
+        hasGPS = true,
+        model = "TestModel",
+        firmwareVersion = "2.0.0",
+        couldUpdate = false,
+        shouldUpdate = false,
+        currentPacketId = 1L,
+        messageTimeoutMsec = 5000,
+        minAppVersion = 1,
+        maxChannels = 8,
+        hasWifi = false,
+        channelUtilization = 0f,
+        airUtilTx = 0f,
+        deviceId = "test-device",
+    )
+
+    private fun createNodeWithPosition(num: Int, latI: Int = 0, lonI: Int = 0) = Node(
+        num = num,
+        user = User(id = "!${num.toString(16)}", short_name = "T$num", long_name = "Test Node $num"),
+        position = Position(latitude_i = latI, longitude_i = lonI),
+    )
+
+    private fun createPositionMeshPacket(
+        from: Int,
+        latI: Int,
+        lonI: Int,
+        snr: Float = 5.5f,
+        rssi: Int = -70,
+    ): MeshPacket {
+        val posPayload = Position.ADAPTER.encode(Position(latitude_i = latI, longitude_i = lonI)).toByteString()
+        val data = Data(portnum = PortNum.POSITION_APP, payload = posPayload)
+        return MeshPacket(from = from, decoded = data, rx_snr = snr, rx_rssi = rssi)
+    }
+
+    private fun createTelemetryWithLocalStats(from: Int, localStats: LocalStats): MeshPacket {
+        val telPayload = Telemetry.ADAPTER.encode(Telemetry(local_stats = localStats)).toByteString()
+        val data = Data(portnum = PortNum.TELEMETRY_APP, payload = telPayload)
+        return MeshPacket(from = from, decoded = data)
+    }
+
+    private fun createDataPacket(from: Int): DataPacket = DataPacket(
+        to = NodeAddress.ID_BROADCAST,
+        bytes = ByteString.EMPTY,
+        dataType = PortNum.POSITION_APP.value,
+        from = "!${from.toString(16)}",
+        hopStart = 3,
+        hopLimit = 3,
+    )
+
+    // endregion
+
+    @Test
+    fun startScanCreatesSessionAndRegistersCollector() = runTest {
+        val engine = createEngine(this)
+        engine.startScan(testPresets, dwellDurationSeconds = 10)
+
+        // Session should be persisted (happens synchronously inside startScan)
+        assertEquals(1, discoveryDao.sessions.size)
+        val session = discoveryDao.sessions.values.first()
+        assertEquals("in_progress", session.completionStatus)
+        assertEquals("LONG_FAST", session.presetsScanned)
+        assertEquals("LONG_FAST", session.homePreset)
+
+        // Collector should be registered (synchronous inside startScan)
+        assertNotNull(collectorRegistry.collector)
+        assertTrue(collectorRegistry.collector === engine)
+
+        // currentSession should be populated
+        val currentSession = engine.currentSession.value
+        assertNotNull(currentSession)
+        assertEquals(session.id, currentSession.id)
+
+        // Wait for scan loop to start then clean up
+        assertScanActive(engine)
+        engine.stopScan()
+    }
+
+    @Test
+    fun stopScanPersistsResultsAndTransitionsToIdle() = runTest {
+        val engine = createEngine(this)
+        engine.startScan(testPresets, dwellDurationSeconds = 60)
+        assertScanActive(engine)
+
+        // Verify scan is active
+        assertTrue(engine.isActive)
+
+        engine.stopScan()
+
+        // State should be Complete(Cancelled)
+        assertTrue(engine.scanState.value is DiscoveryScanState.Complete)
+        val completeState = engine.scanState.value as DiscoveryScanState.Complete
+        assertEquals(DiscoveryScanState.CompletionOutcome.Cancelled, completeState.outcome)
+        assertFalse(engine.isActive)
+
+        // Collector should be unregistered
+        assertNull(collectorRegistry.collector)
+
+        // Session should be finalized with "stopped" status
+        val session = discoveryDao.sessions.values.first()
+        assertEquals("stopped", session.completionStatus)
+    }
+
+    @Test
+    fun completeScanCreatesSessionWithInProgressStatus() = runTest {
+        val engine = createEngine(this)
+        engine.startScan(testPresets, dwellDurationSeconds = 5)
+
+        // Immediately after startScan, the session should exist with "in_progress"
+        val session = discoveryDao.sessions.values.first()
+        assertEquals("in_progress", session.completionStatus)
+
+        // Wait for the scan loop to start, then verify active
+        assertScanActive(engine)
+        assertTrue(engine.isActive)
+
+        engine.stopScan()
+    }
+
+    @Test
+    fun emptyPresetDwellPersistsZeroResultEntry() = runTest {
+        val engine = createEngine(this)
+        engine.startScan(testPresets, dwellDurationSeconds = 10)
+        assertScanActive(engine)
+
+        // Stop without receiving any packets — forces persistCurrentDwellResults
+        engine.stopScan()
+
+        // Should have a preset result with zero unique nodes
+        val presetResults = discoveryDao.presetResults.values.toList()
+        assertTrue(presetResults.isNotEmpty(), "Expected at least one preset result")
+
+        val result = presetResults.first()
+        assertEquals("LONG_FAST", result.presetName)
+        assertEquals(0, result.uniqueNodes)
+        assertEquals(0, result.messageCount)
+
+        // No discovered nodes
+        assertTrue(discoveryDao.discoveredNodes.isEmpty())
+    }
+
+    @Test
+    fun packetCollectionPopulatesNodeData() = runTest {
+        val engine = createEngine(this)
+        val myNodeNum = 1000
+        nodeRepository.setMyNodeInfo(createMyNodeInfo(myNodeNum))
+        nodeRepository.setNodes(listOf(createNodeWithPosition(num = myNodeNum, latI = 377749000, lonI = -1224194000)))
+
+        engine.startScan(testPresets, dwellDurationSeconds = 60)
+        assertScanActive(engine)
+
+        // Wait for Dwell state
+        while (engine.scanState.value !is DiscoveryScanState.Dwell) {
+            delay(100)
+        }
+
+        // Simulate receiving a position packet
+        val meshPacket =
+            createPositionMeshPacket(from = 12345, latI = 377749300, lonI = -1224194200, snr = 5.5f, rssi = -70)
+        val dataPacket = createDataPacket(from = 12345)
+
+        engine.onPacketReceived(meshPacket, dataPacket)
+
+        // Stop scan to persist results
+        engine.stopScan()
+
+        // Should have one discovered node with lat/lon
+        val nodes = discoveryDao.discoveredNodes.values.toList()
+        assertEquals(1, nodes.size)
+
+        val node = nodes.first()
+        assertEquals(12345L, node.nodeNum)
+        assertNotNull(node.latitude, "Node should have latitude")
+        assertNotNull(node.longitude, "Node should have longitude")
+        // latitude_i = 377749300 → 37.77493
+        assertTrue(node.latitude!! > 37.7 && node.latitude!! < 37.8, "Latitude should be ~37.77")
+        // longitude_i = -1224194200 → -122.41942
+        assertTrue(node.longitude!! < -122.4 && node.longitude!! > -122.5, "Longitude should be ~-122.42")
+        assertEquals(5.5f, node.snr)
+        assertEquals(-70, node.rssi)
+    }
+
+    @Test
+    fun telemetryWithLocalStatsPopulatesRfHealth() = runTest {
+        val engine = createEngine(this)
+        nodeRepository.setMyNodeInfo(createMyNodeInfo())
+
+        engine.startScan(testPresets, dwellDurationSeconds = 60)
+        assertScanActive(engine)
+
+        // Wait for Dwell state and ensure sessionId is set
+        while (engine.scanState.value !is DiscoveryScanState.Dwell || engine.currentSession.value == null) {
+            delay(100)
+        }
+
+        // Send a telemetry packet with local_stats
+        val localStats =
+            LocalStats(
+                num_packets_tx = 100,
+                num_packets_rx = 200,
+                num_packets_rx_bad = 5,
+                num_rx_dupe = 10,
+                num_tx_relay = 15,
+                num_tx_relay_canceled = 2,
+                num_online_nodes = 3,
+                num_total_nodes = 10,
+                uptime_seconds = 3600,
+            )
+        val meshPacket = createTelemetryWithLocalStats(from = 12345, localStats = localStats)
+        val dataPacket = createDataPacket(from = 12345)
+
+        engine.onPacketReceived(meshPacket, dataPacket)
+
+        // Stop to persist
+        engine.stopScan()
+
+        // The preset result should have RF health fields from local_stats
+        val presetResults = discoveryDao.presetResults.values.toList()
+        assertTrue(presetResults.isNotEmpty(), "Expected a preset result")
+
+        val result = presetResults.first()
+        assertEquals(100, result.numPacketsTx, "numPacketsTx should be 100")
+        assertEquals(200, result.numPacketsRx, "numPacketsRx should be 200")
+        assertEquals(5, result.numPacketsRxBad, "numPacketsRxBad should be 5")
+        assertEquals(10, result.numRxDupe, "numRxDupe should be 10")
+        assertEquals(15, result.numTxRelay, "numTxRelay should be 15")
+        assertEquals(2, result.numTxRelayCanceled, "numTxRelayCanceled should be 2")
+        assertEquals(3, result.numOnlineNodes, "numOnlineNodes should be 3")
+        assertEquals(10, result.numTotalNodes, "numTotalNodes should be 10")
+        assertEquals(3600, result.uptimeSeconds, "uptimeSeconds should be 3600")
+
+        // Packet success/failure rates should be computed
+        // success = (200 - 5) / 200 * 100 = 97.5
+        // failure = 5 / 200 * 100 = 2.5
+        assertTrue(result.packetSuccessRate > 97.0, "Success rate should be ~97.5%")
+        assertTrue(result.packetFailureRate > 2.0, "Failure rate should be ~2.5%")
+    }
+
+    @Test
+    fun userPositionCapturedAtScanStart() = runTest {
+        val engine = createEngine(this)
+        val myNodeNum = 1000
+        nodeRepository.setMyNodeInfo(createMyNodeInfo(myNodeNum))
+        nodeRepository.setNodes(listOf(createNodeWithPosition(num = myNodeNum, latI = 377749300, lonI = -1224194200)))
+
+        engine.startScan(testPresets, dwellDurationSeconds = 10)
+
+        val session = discoveryDao.sessions.values.first()
+        // User position should be captured from the own node
+        // latitude_i = 377749300 → 37.77493
+        assertTrue(session.userLatitude > 37.7 && session.userLatitude < 37.8, "User lat should be ~37.77")
+        assertTrue(session.userLongitude < -122.4 && session.userLongitude > -122.5, "User lon should be ~-122.42")
+
+        engine.stopScan()
+    }
+
+    @Test
+    fun distanceFromUserCalculatedForDiscoveredNodes() = runTest {
+        val engine = createEngine(this)
+        val myNodeNum = 1000
+        nodeRepository.setMyNodeInfo(createMyNodeInfo(myNodeNum))
+        // User at San Francisco (37.7749, -122.4194)
+        nodeRepository.setNodes(listOf(createNodeWithPosition(num = myNodeNum, latI = 377749000, lonI = -1224194000)))
+
+        engine.startScan(testPresets, dwellDurationSeconds = 60)
+        assertScanActive(engine)
+
+        // Wait for Dwell state
+        while (engine.scanState.value !is DiscoveryScanState.Dwell) {
+            delay(100)
+        }
+
+        // Discovered node at Oakland (37.8044, -122.2712) — roughly 15 km away
+        val meshPacket = createPositionMeshPacket(from = 54321, latI = 378044000, lonI = -1222712000)
+        val dataPacket = createDataPacket(from = 54321)
+
+        engine.onPacketReceived(meshPacket, dataPacket)
+        engine.stopScan()
+
+        val nodes = discoveryDao.discoveredNodes.values.toList()
+        assertEquals(1, nodes.size)
+
+        val node = nodes.first()
+        assertNotNull(node.distanceFromUser, "Distance from user should be computed")
+        // SF to Oakland is roughly 13–17 km
+        assertTrue(
+            node.distanceFromUser!! > 10_000 && node.distanceFromUser!! < 25_000,
+            "Distance should be between 10km and 25km, was ${node.distanceFromUser}m",
+        )
+    }
+}

feature/discovery/src/commonTest/kotlin/org/meshtastic/feature/discovery/DiscoverySummaryAiProviderTest.kt

@@ -0,0 +1,167 @@
+/*
+ * Copyright (c) 2026 Meshtastic LLC
+ *
+ * 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/>.
+ */
+@file:Suppress("MagicNumber")
+
+package org.meshtastic.feature.discovery
+
+import kotlinx.coroutines.test.runTest
+import org.meshtastic.core.database.entity.DiscoveryPresetResultEntity
+import org.meshtastic.core.database.entity.DiscoverySessionEntity
+import org.meshtastic.feature.discovery.ai.DiscoverySummaryAiProvider
+import kotlin.test.Test
+import kotlin.test.assertEquals
+import kotlin.test.assertNotNull
+import kotlin.test.assertNull
+import kotlin.test.assertTrue
+
+class DiscoverySummaryAiProviderTest {
+
+    private val testSession =
+        DiscoverySessionEntity(
+            id = 1L,
+            timestamp = 1_000_000L,
+            presetsScanned = "LONG_FAST",
+            homePreset = "LONG_FAST",
+            totalUniqueNodes = 5,
+            completionStatus = "complete",
+        )
+
+    private val testPresetResult =
+        DiscoveryPresetResultEntity(
+            id = 1L,
+            sessionId = 1L,
+            presetName = "LONG_FAST",
+            dwellDurationSeconds = 30L,
+            uniqueNodes = 3,
+            directNeighborCount = 2,
+            meshNeighborCount = 1,
+            messageCount = 5,
+            sensorPacketCount = 2,
+        )
+
+    // --- Supported case: provider available and returns results ---
+
+    @Test
+    fun supported_provider_returns_session_summary() = runTest {
+        val provider = AvailableAiProvider(sessionResult = "AI recommends LONG_FAST")
+        assertTrue(provider.isAvailable)
+        val result = provider.generateSessionSummary(testSession, listOf(testPresetResult))
+        assertEquals("AI recommends LONG_FAST", result)
+    }
+
+    @Test
+    fun supported_provider_returns_preset_summary() = runTest {
+        val provider = AvailableAiProvider(presetResult = "LONG_FAST: Good range, low congestion")
+        assertTrue(provider.isAvailable)
+        val result = provider.generatePresetSummary(testPresetResult)
+        assertEquals("LONG_FAST: Good range, low congestion", result)
+    }
+
+    // --- Unsupported case: provider not available ---
+
+    @Test
+    fun unsupported_provider_reports_not_available() {
+        val provider = UnavailableAiProvider()
+        assertTrue(!provider.isAvailable)
+    }
+
+    @Test
+    fun unsupported_provider_returns_null_for_session_summary() = runTest {
+        val provider = UnavailableAiProvider()
+        val result = provider.generateSessionSummary(testSession, listOf(testPresetResult))
+        assertNull(result)
+    }
+
+    @Test
+    fun unsupported_provider_returns_null_for_preset_summary() = runTest {
+        val provider = UnavailableAiProvider()
+        val result = provider.generatePresetSummary(testPresetResult)
+        assertNull(result)
+    }
+
+    // --- Failure case: provider throws or returns null ---
+
+    @Test
+    fun failing_provider_returns_null_on_session_error() = runTest {
+        val provider = FailingAiProvider()
+        assertTrue(provider.isAvailable) // Provider thinks it's available but fails
+        val result = provider.generateSessionSummary(testSession, listOf(testPresetResult))
+        assertNull(result)
+    }
+
+    @Test
+    fun failing_provider_returns_null_on_preset_error() = runTest {
+        val provider = FailingAiProvider()
+        val result = provider.generatePresetSummary(testPresetResult)
+        assertNull(result)
+    }
+
+    // --- Algorithmic fallback always works ---
+
+    @Test
+    fun algorithmic_generator_produces_non_null_summary() {
+        val generator = DiscoverySummaryGenerator()
+        val summary = generator.generateSessionSummary(testSession, listOf(testPresetResult))
+        assertNotNull(summary)
+        assertTrue(summary.contains("LONG_FAST"))
+    }
+
+    @Test
+    fun algorithmic_generator_handles_empty_presets() {
+        val generator = DiscoverySummaryGenerator()
+        val summary = generator.generateSessionSummary(testSession, emptyList())
+        assertEquals("No presets were scanned during this session.", summary)
+    }
+}
+
+// --- Test doubles ---
+
+private class AvailableAiProvider(
+    private val sessionResult: String? = "AI summary",
+    private val presetResult: String? = "Preset summary",
+) : DiscoverySummaryAiProvider {
+    override val isAvailable: Boolean = true
+
+    override suspend fun generateSessionSummary(
+        session: DiscoverySessionEntity,
+        presetResults: List<DiscoveryPresetResultEntity>,
+    ): String? = sessionResult
+
+    override suspend fun generatePresetSummary(result: DiscoveryPresetResultEntity): String? = presetResult
+}
+
+private class UnavailableAiProvider : DiscoverySummaryAiProvider {
+    override val isAvailable: Boolean = false
+
+    override suspend fun generateSessionSummary(
+        session: DiscoverySessionEntity,
+        presetResults: List<DiscoveryPresetResultEntity>,
+    ): String? = null
+
+    override suspend fun generatePresetSummary(result: DiscoveryPresetResultEntity): String? = null
+}
+
+private class FailingAiProvider : DiscoverySummaryAiProvider {
+    override val isAvailable: Boolean = true
+
+    override suspend fun generateSessionSummary(
+        session: DiscoverySessionEntity,
+        presetResults: List<DiscoveryPresetResultEntity>,
+    ): String? = null // Simulates internal failure returning null
+
+    override suspend fun generatePresetSummary(result: DiscoveryPresetResultEntity): String? = null
+}

feature/discovery/src/commonTest/kotlin/org/meshtastic/feature/discovery/DiscoverySummaryGeneratorTest.kt

@@ -0,0 +1,324 @@
+/*
+ * Copyright (c) 2026 Meshtastic LLC
+ *
+ * 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/>.
+ */
+@file:Suppress("MagicNumber")
+
+package org.meshtastic.feature.discovery
+
+import org.meshtastic.core.database.entity.DiscoveryPresetResultEntity
+import org.meshtastic.core.database.entity.DiscoverySessionEntity
+import kotlin.test.Test
+import kotlin.test.assertContains
+import kotlin.test.assertEquals
+import kotlin.test.assertFalse
+import kotlin.test.assertTrue
+
+class DiscoverySummaryGeneratorTest {
+
+    private val generator = DiscoverySummaryGenerator()
+
+    // ---- Helpers ----
+
+    private fun session(
+        id: Long = 1,
+        totalUniqueNodes: Int = 10,
+        completionStatus: String = "complete",
+        avgChannelUtilization: Double = 0.0,
+    ) = DiscoverySessionEntity(
+        id = id,
+        timestamp = 1_000_000L,
+        presetsScanned = "LongFast,ShortFast",
+        homePreset = "LongFast",
+        totalUniqueNodes = totalUniqueNodes,
+        avgChannelUtilization = avgChannelUtilization,
+        completionStatus = completionStatus,
+    )
+
+    private fun preset(
+        id: Long = 1,
+        sessionId: Long = 1,
+        name: String = "LongFast",
+        uniqueNodes: Int = 5,
+        directNeighborCount: Int = 3,
+        meshNeighborCount: Int = 2,
+        messageCount: Int = 10,
+        sensorPacketCount: Int = 5,
+        avgChannelUtilization: Double = 15.0,
+        avgAirtimeRate: Double = 3.0,
+        packetSuccessRate: Double = 0.95,
+        packetFailureRate: Double = 0.05,
+    ) = DiscoveryPresetResultEntity(
+        id = id,
+        sessionId = sessionId,
+        presetName = name,
+        uniqueNodes = uniqueNodes,
+        directNeighborCount = directNeighborCount,
+        meshNeighborCount = meshNeighborCount,
+        messageCount = messageCount,
+        sensorPacketCount = sensorPacketCount,
+        avgChannelUtilization = avgChannelUtilization,
+        avgAirtimeRate = avgAirtimeRate,
+        packetSuccessRate = packetSuccessRate,
+        packetFailureRate = packetFailureRate,
+    )
+
+    // ---- generateSessionSummary ----
+
+    @Test
+    fun emptyPresetsReturnsNoPresetsMessage() {
+        val result = generator.generateSessionSummary(session(), emptyList())
+        assertEquals("No presets were scanned during this session.", result)
+    }
+
+    @Test
+    fun singlePresetSessionMentionsPresetName() {
+        val p = preset(name = "LongFast", uniqueNodes = 7)
+        val result = generator.generateSessionSummary(session(), listOf(p))
+        assertContains(result, "LongFast")
+        assertContains(result, "7")
+    }
+
+    @Test
+    fun singlePresetSessionIncludesChannelUtilization() {
+        val p = preset(name = "LongFast", avgChannelUtilization = 12.5)
+        val result = generator.generateSessionSummary(session(), listOf(p))
+        assertContains(result, "12.5%")
+    }
+
+    @Test
+    fun multiPresetSessionRanksByNodeCount() {
+        val winner = preset(id = 1, name = "LongFast", uniqueNodes = 12, avgChannelUtilization = 20.0)
+        val loser = preset(id = 2, name = "ShortFast", uniqueNodes = 4, avgChannelUtilization = 10.0)
+        val result = generator.generateSessionSummary(session(), listOf(loser, winner))
+        assertContains(result, "LongFast")
+        assertContains(result, "most nodes")
+    }
+
+    @Test
+    fun multiPresetSessionMentionsAlternativePresets() {
+        val winner = preset(id = 1, name = "LongFast", uniqueNodes = 12, avgChannelUtilization = 20.0)
+        val loser = preset(id = 2, name = "ShortFast", uniqueNodes = 4, avgChannelUtilization = 10.0)
+        val result = generator.generateSessionSummary(session(), listOf(loser, winner))
+        assertContains(result, "ShortFast")
+        assertContains(result, "4 node")
+    }
+
+    @Test
+    fun highCongestionGeneratesWarning() {
+        val congested = preset(name = "LongFast", avgChannelUtilization = 35.0)
+        val result = generator.generateSessionSummary(session(), listOf(congested))
+        assertContains(result, "congestion")
+        assertContains(result, "LongFast")
+    }
+
+    @Test
+    fun lowCongestionNoWarning() {
+        val clear = preset(name = "LongFast", avgChannelUtilization = 10.0)
+        val result = generator.generateSessionSummary(session(), listOf(clear))
+        assertFalse(result.contains("congestion"), "Should not mention congestion at 10%")
+    }
+
+    @Test
+    fun chatDominatedTrafficNoted() {
+        val chatHeavy = preset(name = "LongFast", messageCount = 100, sensorPacketCount = 5)
+        val result = generator.generateSessionSummary(session(), listOf(chatHeavy))
+        assertContains(result, "chat-dominated")
+    }
+
+    @Test
+    fun sensorDominatedTrafficNoted() {
+        val sensorHeavy = preset(name = "LongFast", messageCount = 2, sensorPacketCount = 50)
+        val result = generator.generateSessionSummary(session(), listOf(sensorHeavy))
+        assertContains(result, "sensor-dominated")
+    }
+
+    @Test
+    fun lowTrafficCountsNoMixNote() {
+        val lowTraffic = preset(name = "LongFast", messageCount = 3, sensorPacketCount = 1)
+        val result = generator.generateSessionSummary(session(), listOf(lowTraffic))
+        assertFalse(result.contains("dominated"), "Should not classify traffic mix below threshold")
+    }
+
+    @Test
+    fun equalTrafficMixNoNote() {
+        val balanced = preset(name = "LongFast", messageCount = 0, sensorPacketCount = 0)
+        val result = generator.generateSessionSummary(session(), listOf(balanced))
+        assertFalse(result.contains("dominated"), "Should not mention traffic mix when counts are zero")
+    }
+
+    @Test
+    fun completedSessionRecommendationSaysCompleted() {
+        val p = preset(name = "LongFast")
+        val result = generator.generateSessionSummary(session(completionStatus = "complete"), listOf(p))
+        assertContains(result, "completed")
+        assertContains(result, "Recommendation")
+    }
+
+    @Test
+    fun stoppedSessionRecommendationSaysPartial() {
+        val p = preset(name = "LongFast")
+        val result = generator.generateSessionSummary(session(completionStatus = "stopped"), listOf(p))
+        assertContains(result, "partially completed")
+    }
+
+    @Test
+    fun recommendationIncludesBestPresetName() {
+        val winner = preset(id = 1, name = "MediumSlow", uniqueNodes = 15, avgChannelUtilization = 5.0)
+        val loser = preset(id = 2, name = "LongFast", uniqueNodes = 3, avgChannelUtilization = 5.0)
+        val result = generator.generateSessionSummary(session(), listOf(loser, winner))
+        assertContains(result, "Recommendation: Use MediumSlow")
+    }
+
+    // ---- generatePresetSummary ----
+
+    @Test
+    fun presetSummaryIncludesPresetName() {
+        val result = generator.generatePresetSummary(preset(name = "LongFast"))
+        assertTrue(result.startsWith("LongFast"))
+    }
+
+    @Test
+    fun presetSummaryIncludesNodeCounts() {
+        val p = preset(uniqueNodes = 8, directNeighborCount = 5, meshNeighborCount = 3)
+        val result = generator.generatePresetSummary(p)
+        assertContains(result, "8 nodes")
+        assertContains(result, "5 direct")
+        assertContains(result, "3 mesh")
+    }
+
+    @Test
+    fun presetSummaryIncludesChannelUtilization() {
+        val p = preset(avgChannelUtilization = 42.7)
+        val result = generator.generatePresetSummary(p)
+        assertContains(result, "42.7%")
+        assertContains(result, "channel utilization")
+    }
+
+    @Test
+    fun presetSummaryHighCongestionMarked() {
+        val p = preset(avgChannelUtilization = 30.0)
+        val result = generator.generatePresetSummary(p)
+        assertContains(result, "congested")
+    }
+
+    @Test
+    fun presetSummaryLowCongestionNotMarked() {
+        val p = preset(avgChannelUtilization = 20.0)
+        val result = generator.generatePresetSummary(p)
+        assertFalse(result.contains("congested"))
+    }
+
+    @Test
+    fun presetSummaryChatDominated() {
+        val p = preset(messageCount = 50, sensorPacketCount = 5)
+        val result = generator.generatePresetSummary(p)
+        assertContains(result, "chat-dominated")
+    }
+
+    @Test
+    fun presetSummarySensorDominated() {
+        val p = preset(messageCount = 2, sensorPacketCount = 40)
+        val result = generator.generatePresetSummary(p)
+        assertContains(result, "sensor-dominated")
+    }
+
+    @Test
+    fun presetSummaryKnownPresetIncludesDataRate() {
+        val p = preset(name = "Long Fast")
+        val result = generator.generatePresetSummary(p)
+        // "Long Fast" matches LoRaPresetReference key and should include data rate
+        assertTrue(result.contains("kbps") || result.contains("bps"), "Should include data rate for known preset")
+    }
+
+    // ---- buildSessionPrompt ----
+
+    @Test
+    fun sessionPromptContainsInstructions() {
+        val p = preset(name = "LongFast", uniqueNodes = 5)
+        val result = generator.buildSessionPrompt(session(), listOf(p))
+        assertContains(result, "Analyze this Meshtastic mesh radio discovery scan")
+        assertContains(result, "recommend the best modem preset")
+        assertContains(result, "concise")
+    }
+
+    @Test
+    fun sessionPromptContainsSessionMetadata() {
+        val s = session(totalUniqueNodes = 15, completionStatus = "complete")
+        val p = preset(name = "LongFast")
+        val result = generator.buildSessionPrompt(s, listOf(p))
+        assertContains(result, "15 unique nodes")
+        assertContains(result, "complete")
+    }
+
+    @Test
+    fun sessionPromptContainsPresetData() {
+        val p = preset(name = "ShortFast", uniqueNodes = 8, messageCount = 20, sensorPacketCount = 3)
+        val result = generator.buildSessionPrompt(session(), listOf(p))
+        assertContains(result, "ShortFast")
+        assertContains(result, "Nodes: 8")
+        assertContains(result, "Messages: 20")
+    }
+
+    @Test
+    fun sessionPromptContainsChannelUtilization() {
+        val p = preset(name = "LongFast", avgChannelUtilization = 33.5, avgAirtimeRate = 5.2)
+        val result = generator.buildSessionPrompt(session(), listOf(p))
+        assertContains(result, "33.5")
+        assertContains(result, "5.2")
+    }
+
+    @Test
+    fun sessionPromptContainsCongestionGuidance() {
+        val p = preset(name = "LongFast")
+        val result = generator.buildSessionPrompt(session(), listOf(p))
+        assertContains(result, "Channel util >25% indicates congestion")
+    }
+
+    // ---- buildPresetPrompt ----
+
+    @Test
+    fun presetPromptContainsPresetName() {
+        val p = preset(name = "MediumFast")
+        val result = generator.buildPresetPrompt(p)
+        assertContains(result, "MediumFast")
+        assertContains(result, "summarize")
+    }
+
+    @Test
+    fun presetPromptContainsMetrics() {
+        val p =
+            preset(
+                name = "LongFast",
+                uniqueNodes = 6,
+                directNeighborCount = 4,
+                meshNeighborCount = 2,
+                avgChannelUtilization = 18.0,
+            )
+        val result = generator.buildPresetPrompt(p)
+        assertContains(result, "Nodes: 6")
+        assertContains(result, "Direct: 4")
+        assertContains(result, "Mesh: 2")
+        assertContains(result, "18.0")
+    }
+
+    @Test
+    fun presetPromptContainsGuidanceContext() {
+        val p = preset(name = "LongFast")
+        val result = generator.buildPresetPrompt(p)
+        assertContains(result, "traffic pattern")
+        assertContains(result, "node density")
+    }
+}

feature/discovery/src/iosMain/kotlin/org/meshtastic/feature/discovery/export/ExportSaver.ios.kt

@@ -0,0 +1,25 @@
+/*
+ * Copyright (c) 2026 Meshtastic LLC
+ *
+ * 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 org.meshtastic.feature.discovery.export
+
+import androidx.compose.runtime.Composable
+import co.touchlab.kermit.Logger
+
+@Composable
+actual fun rememberExportSaver(): ExportSaverLauncher = ExportSaverLauncher { result ->
+    Logger.w { "Export save not yet implemented on iOS: ${result.fileName}" }
+}

feature/discovery/src/jvmMain/kotlin/org/meshtastic/feature/discovery/ai/AlgorithmicSummaryProvider.kt

@@ -0,0 +1,37 @@
+/*
+ * Copyright (c) 2026 Meshtastic LLC
+ *
+ * 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 org.meshtastic.feature.discovery.ai
+
+import org.koin.core.annotation.Single
+import org.meshtastic.core.database.entity.DiscoveryPresetResultEntity
+import org.meshtastic.core.database.entity.DiscoverySessionEntity
+import org.meshtastic.feature.discovery.DiscoverySummaryGenerator
+
+/** JVM/Desktop fallback that delegates to the algorithmic [DiscoverySummaryGenerator]. */
+@Single(binds = [DiscoverySummaryAiProvider::class])
+class AlgorithmicSummaryProvider(private val generator: DiscoverySummaryGenerator) : DiscoverySummaryAiProvider {
+
+    override val isAvailable: Boolean = true
+
+    override suspend fun generateSessionSummary(
+        session: DiscoverySessionEntity,
+        presetResults: List<DiscoveryPresetResultEntity>,
+    ): String = generator.generateSessionSummary(session, presetResults)
+
+    override suspend fun generatePresetSummary(result: DiscoveryPresetResultEntity): String =
+        generator.generatePresetSummary(result)
+}

feature/discovery/src/jvmMain/kotlin/org/meshtastic/feature/discovery/export/ExportSaver.jvm.kt

@@ -0,0 +1,53 @@
+/*
+ * Copyright (c) 2026 Meshtastic LLC
+ *
+ * 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 org.meshtastic.feature.discovery.export
+
+import androidx.compose.runtime.Composable
+import androidx.compose.runtime.rememberCoroutineScope
+import co.touchlab.kermit.Logger
+import kotlinx.coroutines.Dispatchers
+import kotlinx.coroutines.launch
+import kotlinx.coroutines.withContext
+import java.io.File
+import javax.swing.JFileChooser
+import javax.swing.filechooser.FileNameExtensionFilter
+
+@Composable
+actual fun rememberExportSaver(): ExportSaverLauncher {
+    val scope = rememberCoroutineScope()
+    return ExportSaverLauncher { result ->
+        scope.launch {
+            withContext(Dispatchers.IO) {
+                @Suppress("TooGenericExceptionCaught")
+                try {
+                    val chooser =
+                        JFileChooser().apply {
+                            dialogTitle = "Save Discovery Report"
+                            selectedFile = File(result.fileName)
+                            val ext = result.fileName.substringAfterLast('.', "txt")
+                            fileFilter = FileNameExtensionFilter("${ext.uppercase()} files", ext)
+                        }
+                    if (chooser.showSaveDialog(null) == JFileChooser.APPROVE_OPTION) {
+                        chooser.selectedFile.writeBytes(result.content)
+                    }
+                } catch (e: Exception) {
+                    Logger.e(throwable = e) { "Failed to save export file on desktop" }
+                }
+            }
+        }
+    }
+}

feature/discovery/src/jvmMain/kotlin/org/meshtastic/feature/discovery/export/TextDiscoveryExporter.kt

@@ -0,0 +1,76 @@
+/*
+ * Copyright (c) 2026 Meshtastic LLC
+ *
+ * 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 org.meshtastic.feature.discovery.export
+
+import org.koin.core.annotation.Single
+
+private const val SEPARATOR_LENGTH = 60
+
+@Single
+class TextDiscoveryExporter : DiscoveryExporter {
+
+    @Suppress("TooGenericExceptionCaught")
+    override suspend fun export(data: DiscoveryExportData): ExportResult = try {
+        val text = renderText(data)
+        val fileName = DiscoveryReportFormatter.generateFileName(data.session, "txt")
+        ExportResult.Success(content = text.encodeToByteArray(), mimeType = "text/plain", fileName = fileName)
+    } catch (e: Exception) {
+        ExportResult.Error("Text export failed: ${e.message}")
+    }
+
+    private fun renderText(data: DiscoveryExportData): String = buildString {
+        appendLine("MESHTASTIC DISCOVERY REPORT")
+        appendLine("=".repeat(SEPARATOR_LENGTH))
+        appendLine()
+
+        appendLine("SESSION OVERVIEW")
+        appendLine("-".repeat(SEPARATOR_LENGTH))
+        for ((label, value) in DiscoveryReportFormatter.formatSessionOverviewLines(data.session)) {
+            appendLine("  $label: $value")
+        }
+        appendLine()
+
+        for (result in data.presetResults) {
+            appendLine("PRESET: ${result.presetName}")
+            appendLine("-".repeat(SEPARATOR_LENGTH))
+            for ((label, value) in DiscoveryReportFormatter.formatPresetLines(result)) {
+                appendLine("  $label: $value")
+            }
+
+            val nodes = data.nodesByPreset[result.id].orEmpty()
+            if (nodes.isNotEmpty()) {
+                appendLine()
+                appendLine("  Discovered Nodes (${nodes.size}):")
+                for (node in nodes) {
+                    appendLine("    ${DiscoveryReportFormatter.formatNodeLine(node)}")
+                }
+            }
+            appendLine()
+        }
+
+        val summary = data.session.aiSummary
+        if (!summary.isNullOrBlank()) {
+            appendLine("AI ANALYSIS")
+            appendLine("-".repeat(SEPARATOR_LENGTH))
+            appendLine(summary)
+            appendLine()
+        }
+
+        appendLine("=".repeat(SEPARATOR_LENGTH))
+        appendLine("Generated by Meshtastic")
+    }
+}

feature/settings/src/androidMain/kotlin/org/meshtastic/feature/settings/SettingsScreen.kt

@@ -42,6 +42,7 @@ import org.koin.core.qualifier.named
 import org.meshtastic.core.common.util.nowMillis
 import org.meshtastic.core.common.util.toDate
 import org.meshtastic.core.common.util.toInstant
+import org.meshtastic.core.navigation.DiscoveryRoute
 import org.meshtastic.core.navigation.Route
 import org.meshtastic.core.navigation.SettingsRoute
 import org.meshtastic.core.navigation.WifiProvisionRoute
@@ -50,6 +51,7 @@ import org.meshtastic.core.resources.app_functions_settings
 import org.meshtastic.core.resources.app_functions_settings_summary
 import org.meshtastic.core.resources.bottom_nav_settings
 import org.meshtastic.core.resources.device_links
+import org.meshtastic.core.resources.discovery_local_mesh
 import org.meshtastic.core.resources.export_configuration
 import org.meshtastic.core.resources.filter_settings
 import org.meshtastic.core.resources.help_and_documentation
@@ -66,6 +68,7 @@ import org.meshtastic.core.ui.icon.FilterList
 import org.meshtastic.core.ui.icon.HelpOutline
 import org.meshtastic.core.ui.icon.List
 import org.meshtastic.core.ui.icon.MeshtasticIcons
+import org.meshtastic.core.ui.icon.PermScanWifi
 import org.meshtastic.core.ui.icon.SettingsRemote
 import org.meshtastic.core.ui.icon.Wifi
 import org.meshtastic.feature.settings.component.AppInfoSection
@@ -259,6 +262,15 @@ fun SettingsScreen(
                     }
                 }
 
+                ExpressiveSection(title = stringResource(Res.string.discovery_local_mesh)) {
+                    ListItem(
+                        text = stringResource(Res.string.discovery_local_mesh),
+                        leadingIcon = MeshtasticIcons.PermScanWifi,
+                    ) {
+                        onNavigate(DiscoveryRoute.DiscoveryGraph)
+                    }
+                }
+
                 ExpressiveSection(title = stringResource(Res.string.wifi_devices)) {
                     ListItem(text = stringResource(Res.string.wifi_devices), leadingIcon = MeshtasticIcons.Wifi) {
                         onNavigate(WifiProvisionRoute.WifiProvision())

feature/settings/src/jvmMain/kotlin/org/meshtastic/feature/settings/DesktopSettingsScreen.kt

@@ -38,6 +38,7 @@ import kotlinx.coroutines.delay
 import kotlinx.coroutines.launch
 import org.jetbrains.compose.resources.stringResource
 import org.meshtastic.core.database.DatabaseConstants
+import org.meshtastic.core.navigation.DiscoveryRoute
 import org.meshtastic.core.navigation.Route
 import org.meshtastic.core.navigation.SettingsRoute
 import org.meshtastic.core.navigation.WifiProvisionRoute
@@ -49,6 +50,7 @@ import org.meshtastic.core.resources.bottom_nav_settings
 import org.meshtastic.core.resources.device_db_cache_limit
 import org.meshtastic.core.resources.device_db_cache_limit_summary
 import org.meshtastic.core.resources.device_links
+import org.meshtastic.core.resources.discovery_local_mesh
 import org.meshtastic.core.resources.help_and_documentation
 import org.meshtastic.core.resources.info
 import org.meshtastic.core.resources.modules_already_unlocked
@@ -71,6 +73,7 @@ import org.meshtastic.core.ui.icon.Language
 import org.meshtastic.core.ui.icon.List
 import org.meshtastic.core.ui.icon.Memory
 import org.meshtastic.core.ui.icon.MeshtasticIcons
+import org.meshtastic.core.ui.icon.PermScanWifi
 import org.meshtastic.core.ui.icon.Wifi
 import org.meshtastic.core.ui.util.rememberShowToastResource
 import org.meshtastic.feature.settings.component.ExpressiveSection
@@ -215,6 +218,15 @@ fun DesktopSettingsScreen(
                     }
                 }
 
+                ExpressiveSection(title = stringResource(Res.string.discovery_local_mesh)) {
+                    ListItem(
+                        text = stringResource(Res.string.discovery_local_mesh),
+                        leadingIcon = MeshtasticIcons.PermScanWifi,
+                    ) {
+                        onNavigate(DiscoveryRoute.DiscoveryGraph)
+                    }
+                }
+
                 ExpressiveSection(title = stringResource(Res.string.device_links)) {
                     ListItem(text = stringResource(Res.string.device_links), leadingIcon = MeshtasticIcons.Device) {
                         onNavigate(SettingsRoute.DeviceLinks)