@@ -62,7 +62,14 @@
             <action android:name="android.intent.action.MAIN" />
             <category android:name="android.intent.category.LAUNCHER" />
         </intent>
+        <!-- Every MG4Control channel: the offline and unstable builds carry a suffixed
+             application id and are the same app. Declaring only the stable id made
+             MG4Control invisible on a car that had it, and the profile actions vanished
+             from the rule editor with it. -->
         <package android:name="com.mg4.control" />
+        <package android:name="com.mg4.control.offline" />
+        <package android:name="com.mg4.control.unstable" />
+        <package android:name="com.mg4.control.offline.unstable" />
         <!-- API 30+: without this the TTS engine is invisible and the "speak" action
              would report "no speech engine" on a car that has one installed. -->
         <intent>
@@ -76,6 +83,13 @@
             <action android:name="android.intent.action.VIEW" />
             <data android:scheme="google.navigation" />
         </intent>
+        <!-- The head unit's own map apps. They publish no geo: filter, so the intent
+             declarations above never see them and "Open map" resolved to nothing. Names
+             taken from the vendor launcher and its navigation widget. -->
+        <package android:name="com.saicmotor.navigation" />
+        <package android:name="com.telenav.app.arp" />
+        <package android:name="com.nng.igo.primong" />
+        <package android:name="com.mmi.navimaps_auto" />
     </queries>
 
     <application
 
@@ -12,7 +12,23 @@ package com.mg4.tasker.bridge
  */
 object BridgeContract {
 
-    const val MG4CONTROL_PACKAGE = "com.mg4.control"
+    /**
+     * Every application id MG4Control ships under, most "official" first.
+     *
+     * The suffixes come from MG4Control's own flavors — `.offline` for the build with no
+     * network code, `.unstable` for pre-releases — and they install side by side. Looking
+     * only for the stable id reported "MG4Control not installed" on a car that had it, which
+     * removed the profile actions and the profile picker from the rule editor entirely.
+     *
+     * The service class name does not carry the suffix: only the application id does.
+     */
+    val MG4CONTROL_PACKAGES = listOf(
+        "com.mg4.control",
+        "com.mg4.control.offline",
+        "com.mg4.control.unstable",
+        "com.mg4.control.offline.unstable"
+    )
+
     const val BRIDGE_SERVICE     = "com.mg4.control.api.ProfileControlService"
     const val PERMISSION_BRIDGE  = "com.mg4.control.permission.CONTROL_PROFILES"
 
 
@@ -18,6 +18,7 @@ import com.mg4.tasker.util.BtDevices
 import com.mg4.tasker.util.CarLocation
 import com.mg4.tasker.util.Notifier
 import com.mg4.tasker.util.SpeechEngines
+import com.mg4.tasker.vehicle.BtOnboard
 import com.mg4.tasker.vehicle.BtTracker
 import com.mg4.tasker.vehicle.DeferredWrites
 import com.mg4.tasker.vehicle.VendorServices
@@ -115,9 +116,15 @@ object DiagnosticProbe {
         // right after boot is also what gets them connected for the next rule cycle.
         VendorServices.connect(appContext)
         val fix = CarLocation.lastKnown(appContext)
+        // The two Bluetooth sets are read here for the same reason as the rest of the
+        // snapshot: left out, they arrived null and the diagnostic reported the "on board"
+        // and "hands-free" conditions as blocked on every car, including the ones where a
+        // rule using them evaluates perfectly well.
         val snapshot = VehicleReader.read(
             btMacs = BtTracker.snapshot(appContext),
             btAvailable = BtDevices.isAvailable(appContext),
+            btOnboardMacs = BtOnboard.onboard(appContext),
+            btHandsFreeMacs = BtDevices.activeHandsFree(appContext),
             fix = fix
         )
 
@@ -141,17 +148,33 @@ object DiagnosticProbe {
             navigationApp = hasNavigationApp(appContext),
         )
 
+        val conditions = Diagnostics.conditions(snapshot, gen)
+        val actions = Diagnostics.actions(caps, gen)
+        // The editor reads this back, so what the Diagnostic tab calls blocked is no longer
+        // offered in the pickers. Only the verdicts that describe the car are kept — see
+        // Diagnostics.Reason.describesTheCar.
+        SupportStore.saveDiagnostic(
+            appContext,
+            conditions = structurallyBlocked(conditions),
+            actions = structurallyBlocked(actions),
+        )
+
         return Report(
             at = System.currentTimeMillis(),
             firmwareGen = genName,
             appVersion = "${com.mg4.tasker.BuildConfig.VERSION_NAME} (${com.mg4.tasker.BuildConfig.VERSION_CODE})",
             capabilities = caps,
             environment = environment(appContext, caps, gen?.name, engines, snapshot, fix),
-            conditions = Diagnostics.conditions(snapshot, gen),
-            actions = Diagnostics.actions(caps, gen),
+            conditions = conditions,
+            actions = actions,
         )
     }
 
+    private fun structurallyBlocked(entries: List<Diagnostics.Entry>): Set<String> =
+        entries.filter { it.status == Diagnostics.Status.BLOCKED && it.reason.describesTheCar }
+            .map { it.name }
+            .toSet()
+
     private fun environment(
         context: Context,
         caps: Diagnostics.Capabilities,
@@ -237,13 +260,13 @@ object DiagnosticProbe {
     }
 
     /** Whether any activity answers a `geo:` intent — what NAVIGATE_TO needs to exist. */
-    private fun hasNavigationApp(context: Context): Boolean {
-        val intent = android.content.Intent(
-            android.content.Intent.ACTION_VIEW,
-            android.net.Uri.parse("geo:0,0?q=test")
-        )
-        return intent.resolveActivity(context.packageManager) != null
-    }
+    /**
+     * A `geo:` resolver is not the question — the MG4's map app has no such filter, and this
+     * reported "no navigation app" on a car whose home screen shows one. Asks [MapApps],
+     * which is also what actually opens it.
+     */
+    private fun hasNavigationApp(context: Context): Boolean =
+        com.mg4.tasker.util.MapApps.isAvailable(context)
 
     private fun gateVerdict(): String =
         when (VehicleWriteGate.decideNow()) {
 
@@ -84,8 +84,38 @@ object Diagnostics {
         NOT_DRIVEN_YET,
         /** The platform would not say which phone the head unit made hands-free. */
         NO_HANDSFREE_INFO,
+        ;
+
+        /**
+         * True when this verdict describes **the car**, not the moment it was taken.
+         *
+         * The rule editor hides entries the last diagnostic blocked for one of these
+         * ([com.mg4.tasker.store.SupportStore]) — a diagnostic that says "this head unit has
+         * no radio service" and an action picker that keeps offering "tune radio" cannot both
+         * be right, and the picker was the one lying.
+         *
+         * Everything else is deliberately absent. A gate refusal, a Bluetooth radio switched
+         * off, a missing location fix, a vehicle layer still starting: all of those change
+         * within one drive, and a rule the user could not even write because the car happened
+         * to be moving during a diagnostic would be a far worse bug than the one being fixed.
+         *
+         * [NOTIFICATIONS_OFF] is left out for the same reason from the other side: it is a
+         * permission the user flips in Settings, and the entry must be there when they come
+         * back from flipping it.
+         */
+        val describesTheCar: Boolean
+            get() = this in STRUCTURAL
     }
 
+    private val STRUCTURAL = setOf(
+        Reason.UNSUPPORTED_FIRMWARE,
+        Reason.NO_VENDOR_SERVICE,
+        Reason.NO_NAVIGATION_APP,
+        Reason.NO_TTS_ENGINE,
+        Reason.NO_MG4CONTROL,
+        Reason.NOT_READABLE
+    )
+
     /**
      * One catalogue entry's verdict.
      *
@@ -140,6 +170,14 @@ object Diagnostics {
         ConditionType.entries.map { type ->
             val outcome = ConditionEvaluator.evaluate(probeOf(type), snapshot)
             val hidden = !FirmwareSupport.isSupported(type, gen)
+            // A steering-wheel button has no resting value: the snapshot carries one only
+            // while the press is being dispatched. Probing it at rest therefore always found
+            // nothing, and the report accused the car of not reporting a signal it reports
+            // perfectly well — a false verdict the rule editor now acts on by hiding the
+            // entry. There is nothing to read here, and nothing wrong.
+            if (type == ConditionType.PHYSICAL_BUTTON) {
+                return@map Entry(type.name, Status.OK, Reason.NONE, hidden = hidden)
+            }
             if (outcome == ConditionOutcome.UNAVAILABLE) {
                 Entry(
                     name = type.name,
@@ -229,7 +267,7 @@ object Diagnostics {
 
         // These run entirely inside MG4Tasker. Their configured value can still be invalid,
         // but availability of the vehicle layer is irrelevant to whether the action exists.
-        ActionType.WEBHOOK_GET, ActionType.WEBHOOK_POST, ActionType.DELAY -> Reason.NONE
+        ActionType.WEBHOOK, ActionType.DELAY -> Reason.NONE
 
         // Everything else is a direct MG4Hardware write.
         else -> if (!caps.vehicleLayerReady) Reason.LAYER_NOT_READY else gateReason(type, caps)
 
@@ -16,6 +16,7 @@ import com.mg4.hardware.PhysicalButtonEventDecoder
 import com.mg4.hardware.VehicleWriteGate
 import com.mg4.tasker.model.RuleTrigger
 import com.mg4.tasker.store.AppState
+import com.mg4.tasker.util.BtDevices
 import com.mg4.tasker.util.Notifier
 import com.mg4.tasker.vehicle.BtOnboard
 import com.mg4.tasker.vehicle.BtTracker
@@ -123,16 +124,29 @@ class TaskerVehicleService : Service() {
         AppState.applyWriteThreshold(this)
         onboardThread.start()
         onboardHandler = Handler(onboardThread.looper)
+        // The Bluetooth profile proxies answer on a callback, so the first question asked of
+        // them cannot be answered. Asked for here, they are ready long before the first rule
+        // cycle — which is the cycle that decides whose phone is on board.
+        BtDevices.warmUp(applicationContext)
         registerBtReceiver()
         registerHardkeyReceiver()
         registerIgnitionListener()
         // START_STICKY means this service can be recreated mid-drive. Waiting for the next
         // IGNITION_ON would then leave the whole drive unsampled, and every "phone on board"
         // rule unevaluable until the car had been switched off and on again.
-        if (MG4Hardware.getCurrentIgnitionState() == MG4Hardware.CarIgnitionItem.RUN) {
+        // IgnitionState, not CarIgnitionItem: getCurrentIgnitionState() answers on the AAOS
+        // scale, where 2 means OFF — the very value CarIgnitionItem calls RUN. The mistake
+        // was invisible while the property was unreadable on SWI68 and the comparison could
+        // only ever be false; now that the reader falls back to Katman5, it would have
+        // started sampling on a car that had just been switched off.
+        if (MG4Hardware.getCurrentIgnitionState() == MG4Hardware.IgnitionState.ON) {
             startOnboardSampling()
         }
-        warnIfMG4ControlPresent()
+        // No "MG4Control is also installed" notification here any more. It fired on every
+        // service start on the cars where the two apps are meant to run together, and it said
+        // less than the rule editor already does: the profile actions carry the coexistence
+        // warning at the moment it matters, when one is picked.
+        logMG4ControlPresence()
         isRunning = true
     }
 
@@ -259,10 +273,9 @@ class TaskerVehicleService : Service() {
         )
     }
 
-    private fun warnIfMG4ControlPresent() {
-        if (ProfileBridge.isMG4ControlInstalled(this)) {
-            AppLogger.w(TAG, "MG4Control is installed — both apps can write the vehicle")
-            Notifier.showRuleMessage(this, getString(com.mg4.tasker.R.string.warn_mg4control_present))
-        }
+    /** Kept in the log — the exported debug report still has to say which apps share the car. */
+    private fun logMG4ControlPresence() {
+        val pkg = ProfileBridge.installedPackage(this) ?: return
+        AppLogger.i(TAG, "MG4Control present ($pkg) — both apps can write the vehicle")
     }
 }
@@ -23,6 +23,8 @@ object SupportStore {
     private const val KEY_TIME       = "checked_at"
     private const val KEY_CONDITIONS = "supported_conditions"
     private const val KEY_ACTIONS    = "supported_actions"
+    private const val KEY_DIAG_CONDITIONS = "diagnostic_blocked_conditions"
+    private const val KEY_DIAG_ACTIONS    = "diagnostic_blocked_actions"
 
     /** No record yet, or the record predates the current app version (annotations may have moved). */
     fun needsCheck(context: Context): Boolean {
@@ -48,6 +50,33 @@ object SupportStore {
     fun supportedActions(context: Context): Set<String>? =
         stored(context, KEY_ACTIONS)?.let { known(it, ActionType.entries.map { e -> e.name }) }
 
+    /**
+     * Records what the last diagnostic run found permanently blocked on this car.
+     *
+     * The firmware matrix above is a static table; this is the car answering for itself —
+     * which vendor services actually bound, whether a map app exists, whether the head unit
+     * reports a signal at all. The rule editor subtracts both, so an entry the Diagnostic tab
+     * reports as blocked is no longer offered two screens away.
+     *
+     * Overwritten on every run, so re-running the diagnostic after installing a map app or
+     * granting a permission is what brings the entries back.
+     */
+    fun saveDiagnostic(context: Context, conditions: Set<String>, actions: Set<String>) {
+        prefs(context).edit()
+            .putStringSet(KEY_DIAG_CONDITIONS, conditions)
+            .putStringSet(KEY_DIAG_ACTIONS, actions)
+            .apply()
+    }
+
+    /** ConditionType names the last diagnostic found blocked for a reason that will not change. */
+    fun diagnosticBlockedConditions(context: Context): Set<String> =
+        stored(context, KEY_DIAG_CONDITIONS)?.let { known(it, ConditionType.entries.map { e -> e.name }) }
+            ?: emptySet()
+
+    fun diagnosticBlockedActions(context: Context): Set<String> =
+        stored(context, KEY_DIAG_ACTIONS)?.let { known(it, ActionType.entries.map { e -> e.name }) }
+            ?: emptySet()
+
     private fun stored(context: Context, key: String): Set<String>? =
         prefs(context).takeIf { it.contains(key) }?.getStringSet(key, emptySet())?.toSet()
 
 
@@ -19,6 +19,8 @@ import com.mg4.hardware.FirmwareGen
 import com.mg4.hardware.FirmwareSupport
 import com.mg4.tasker.store.SupportStore
 import com.mg4.tasker.util.BtDevices
+import com.mg4.tasker.util.EmulatorDetector
+import com.mg4.tasker.util.MapApps
 import com.mg4.tasker.util.SpeechEngines
 import com.mg4.tasker.vehicle.ProfileBridge
 import java.util.Locale
@@ -46,12 +48,19 @@ object CatalogPicker {
 
     fun pickCondition(context: Context, firmware: FirmwareGen?, onPick: (ConditionType) -> Unit) {
         val allowed = SupportStore.supportedConditions(context)
+        val diagnosticBlocked = SupportStore.diagnosticBlockedConditions(context)
+        // No emulator image has a paired device, a diagnostic history, or vendor services —
+        // on the head unit those gaps mean "would never work", on an emulator they just mean
+        // "nobody ran the prerequisite step yet". Skip them so every entry stays pickable to
+        // debug, whichever hardware read behind it ends up failing on its own.
+        val debug = EmulatorDetector.isEmulator()
         // Nothing paired means the device picker would be empty, and the rule would carry a
         // blank MAC that can never match. Same reasoning as the profile action below.
         val hasPairedDevice = BtDevices.bonded(context).isNotEmpty()
         val groups = ConditionType.byGroup().mapNotNull { (group, types) ->
             val supported = types
-                .filter { hasPairedDevice || it.spec.kind != ValueKind.BT_DEVICE }
+                .filter { debug || hasPairedDevice || it.spec.kind != ValueKind.BT_DEVICE }
+                .filter { debug || it.name !in diagnosticBlocked }
                 .filter { type ->
                     allow(allowed, type.name) { FirmwareSupport.isSupported(type, firmware) }
                 }
@@ -68,21 +77,25 @@ object CatalogPicker {
 
     fun pickAction(context: Context, firmware: FirmwareGen?, onPick: (ActionType) -> Unit) {
         val allowed = SupportStore.supportedActions(context)
+        val diagnosticBlocked = SupportStore.diagnosticBlockedActions(context)
+        // See pickCondition: an emulator fails every local prerequisite by construction, so
+        // none of them should hide an entry there.
+        val debug = EmulatorDetector.isEmulator()
         // The profile actions are the ones that cannot work without MG4Control. Offering them
         // with an empty profile list only produces a rule that fails at ignition.
         val hasProfiles = ProfileBridge.isMG4ControlInstalled(context)
         val visible = ActionType.entries.filterNot { it in CatalogVisibility.hiddenActions }
         val grouped = visible.groupBy { type ->
             when (type) {
                 ActionType.APPLY_PROFILE, ActionType.SHOW_PROFILE_PICKER,
-                ActionType.WEBHOOK_GET, ActionType.WEBHOOK_POST -> IntegrationGroup
+                ActionType.WEBHOOK -> IntegrationGroup
                 else -> type.group
             }
         }
         val groups = grouped.mapNotNull { (group, types) ->
             val supported = types
-                .filter { hasProfiles || it.group != ActionGroup.PROFILE }
-                .filter { runnableHere(context, it) }
+                .filter { debug || hasProfiles || it.group != ActionGroup.PROFILE }
+                .filter { type -> debug || runnableHere(context, type) ?: (type.name !in diagnosticBlocked) }
                 .filter { type -> allow(allowed, type.name) { FirmwareSupport.isSupported(type, firmware) } }
             if (supported.isEmpty()) return@mapNotNull null
             Group(
@@ -117,20 +130,27 @@ object CatalogPicker {
         allowed?.contains(name) ?: live()
 
     /**
-     * The local actions depend on the head unit, not on the firmware matrix, so the matrix
-     * cannot filter them.
+     * Answers "can this head unit do it" for the actions that can be checked **now**, or null
+     * when only the last diagnostic run can say.
+     *
+     * These depend on the head unit rather than on the firmware matrix, so the matrix cannot
+     * filter them; and they are cheap local queries — a package lookup, no vehicle read,
+     * nothing that blocks — so they are asked live rather than read back from a stored
+     * diagnostic. That matters when the answer changes: installing a speech engine or a map
+     * app brings its action back to the picker immediately, without a second diagnostic.
      *
      * Speech was the visible case: the Diagnostic tab reported "no speech engine" while the
      * editor kept offering the action, and picking it produced a rule that could only ever
-     * fail. Both now ask [SpeechEngines] the same question — a package query, no vehicle
-     * read, nothing that blocks.
+     * fail. Both now ask [SpeechEngines] the same question.
      *
-     * The message action is not filtered: it shows on screen whatever the notification
+     * The message action is deliberately absent: it shows on screen whatever the notification
      * channel is doing, so it always has a way to reach the driver.
      */
-    private fun runnableHere(context: Context, type: ActionType): Boolean = when (type) {
+    private fun runnableHere(context: Context, type: ActionType): Boolean? = when (type) {
         ActionType.SPEAK_TEXT -> SpeechEngines.any(context)
-        else -> true
+        ActionType.NAVIGATE_TO -> MapApps.isAvailable(context)
+        ActionType.SHOW_NOTIFICATION -> true
+        else -> null
     }
 
     private class Group(val label: String, val entries: List<Entry>)