fix: prevent stale companion controls after teardown

app/src/main/java/com/papi/nova/Game.kt

@@ -52,6 +52,7 @@ import com.papi.nova.ui.StreamContainer
 import com.google.android.material.bottomsheet.BottomSheetDialog
 import com.papi.nova.utils.Dialog
 import com.papi.nova.utils.DeviceUtils
+import com.papi.nova.utils.CompanionControlLifecyclePolicy
 import com.papi.nova.utils.ExternalDisplayControlPresentation
 import com.papi.nova.utils.GameDisplayLaunchTrampolineActivity
 import com.papi.nova.utils.MouseModeOption
@@ -458,7 +459,14 @@ listenForExternalDisplayRemoval()
 }
 
 fun showCompanionControls() {
-runOnUiThread { launchCompanionControlsIfAvailable() }
+runOnUiThread {
+if (!CompanionControlLifecyclePolicy.canShow(isStreamActive, isFinishing(), isDestroyed)) {
+LimeLog.info("Nova: Skipping companion controls for inactive Game lifecycle active=$isStreamActive finishing=${isFinishing()} destroyed=$isDestroyed")
+closeCompanionControls()
+return@runOnUiThread
+}
+launchCompanionControlsIfAvailable()
+}
 }
 
 @SuppressLint("InlinedApi")
@@ -4442,6 +4450,7 @@ if (connecting || connected)
 connected = false
 connecting = connected
 isStreamActive = false
+closeCompanionControls()
 stopPolarisLiveSessionStatusRefresh()
 runtimeTasks.cancel("NovaBitrateAdjust")
  // Send AI session report before dismissing HUD

app/src/main/java/com/papi/nova/utils/CompanionControlLifecyclePolicy.kt

@@ -0,0 +1,10 @@
+package com.papi.nova.utils
+
+internal object CompanionControlLifecyclePolicy {
+    @JvmStatic
+    fun canShow(
+        streamActive: Boolean,
+        gameFinishing: Boolean,
+        gameDestroyed: Boolean
+    ): Boolean = streamActive && !gameFinishing && !gameDestroyed
+}

app/src/test/java/com/papi/nova/utils/CompanionControlLifecyclePolicyTest.kt

@@ -0,0 +1,27 @@
+package com.papi.nova.utils
+
+import org.junit.Assert.assertFalse
+import org.junit.Assert.assertTrue
+import org.junit.Test
+
+class CompanionControlLifecyclePolicyTest {
+    @Test
+    fun activeLiveGameCanShowCompanionControls() {
+        assertTrue(CompanionControlLifecyclePolicy.canShow(true, false, false))
+    }
+
+    @Test
+    fun inactiveStreamCannotShowCompanionControls() {
+        assertFalse(CompanionControlLifecyclePolicy.canShow(false, false, false))
+    }
+
+    @Test
+    fun finishingGameCannotShowCompanionControls() {
+        assertFalse(CompanionControlLifecyclePolicy.canShow(true, true, false))
+    }
+
+    @Test
+    fun destroyedGameCannotShowCompanionControls() {
+        assertFalse(CompanionControlLifecyclePolicy.canShow(true, false, true))
+    }
+}

app/src/test/java/com/papi/nova/utils/NovaExternalDisplayRoutingSourceGuardTest.kt

@@ -338,6 +338,47 @@ class NovaExternalDisplayRoutingSourceGuardTest {
         )
     }
 
+    @Test
+    fun stoppedStreamDismissesCompanionControlsBeforeBackgroundCleanup() {
+        val source = File("src/main/java/com/papi/nova/Game.kt").readText()
+        val stopConnection =
+            source.substringAfter("private fun stopConnection()")
+                .substringBefore("override fun stageFailed(")
+        val streamInactive = stopConnection.indexOf("isStreamActive = false")
+        val controlsClosed = stopConnection.indexOf("closeCompanionControls()", streamInactive)
+        val backgroundCleanup = stopConnection.indexOf("launchRuntimeIo(\"NovaSessionReport\")")
+
+        assertTrue("stopConnection must mark the stream inactive", streamInactive >= 0)
+        assertTrue("stopConnection must dismiss companion controls after marking the stream inactive", controlsClosed > streamInactive)
+        assertTrue("companion controls must close before asynchronous teardown work", controlsClosed in 0 until backgroundCleanup)
+    }
+
+    @Test
+    fun companionReopenChecksLiveGameLifecycleAtExecutionTime() {
+        val source = File("src/main/java/com/papi/nova/Game.kt").readText()
+        val showControls =
+            source.substringAfter("fun showCompanionControls() {")
+                .substringBefore("@SuppressLint(\"InlinedApi\")")
+        val uiDispatch = showControls.indexOf("runOnUiThread {")
+        val lifecycleDecision = showControls.indexOf("CompanionControlLifecyclePolicy.canShow(")
+        val deniedClose = showControls.indexOf("closeCompanionControls()")
+        val deniedReturn = showControls.indexOf("return@runOnUiThread")
+        val presentationLaunch = showControls.indexOf("launchCompanionControlsIfAvailable()")
+
+        assertTrue("showCompanionControls must dispatch before reading lifecycle state", uiDispatch >= 0)
+        assertTrue("lifecycle state must be checked inside the UI-thread callback", lifecycleDecision > uiDispatch)
+        assertTrue("denied reopen must close stale controls", deniedClose > lifecycleDecision)
+        assertTrue("denied reopen must return before presentation launch", deniedReturn > deniedClose)
+        assertTrue("presentation launch must follow the lifecycle gate", presentationLaunch > deniedReturn)
+        val compactShowControls = showControls.replace(Regex("\\s+"), " ")
+        assertTrue(
+            "The execution-time lifecycle decision must receive the live Game state, not constants",
+            compactShowControls.contains(
+                "CompanionControlLifecyclePolicy.canShow(isStreamActive, isFinishing(), isDestroyed)"
+            )
+        )
+    }
+
     @Test
     fun newlyAddedDisplayReopensCompanionControlsUsingTheNewLogicalDisplayId() {
         val game = File("src/main/java/com/papi/nova/Game.kt").readText()