@mentra/bluetooth-sdk 3.2.1-beta.319 → 3.2.1-beta.355

package/android/src/main/java/com/mentra/bluetoothsdk/DeviceManager.kt

@@ -13,6 +13,7 @@ import androidx.core.content.ContextCompat
 import com.mentra.bluetoothsdk.controllers.ControllerManager
 import com.mentra.bluetoothsdk.controllers.R1
 import com.mentra.bluetoothsdk.services.ForegroundService
+import com.mentra.bluetoothsdk.services.G2ConnectionRecovery
 import com.mentra.bluetoothsdk.services.PhoneMic
 import com.mentra.bluetoothsdk.sgcs.Ar99
 import com.mentra.bluetoothsdk.sgcs.G1
@@ -45,12 +46,15 @@ import java.util.concurrent.Executors
 import java.util.concurrent.TimeUnit
 import kotlin.jvm.JvmStatic
 
-class DeviceManager {
+class DeviceManager internal constructor(initializeHardware: Boolean) {
+    constructor() : this(initializeHardware = true)
     companion object {
 
         @Volatile
         private var _instance: DeviceManager? = null
 
+        internal fun isInitialized(): Boolean = _instance != null
+
         @JvmStatic
         fun getInstance(): DeviceManager {
             return _instance
@@ -59,6 +63,10 @@ class DeviceManager {
     }
 
     // MARK: - Unique (Android)
+    private val connectionRecovery = G2ConnectionRecovery(Bridge.getContext())
+    private val recoveryLock = Any()
+    private var recoverG2Connection = false
+    private var recoveryListenerId: String? = null
     private var serviceStarted = false
     private val mainHandler = Handler(Looper.getMainLooper())
     private val executor: ExecutorService = Executors.newSingleThreadExecutor()
@@ -79,7 +87,8 @@ class DeviceManager {
     // MARK: - End Unique
 
     // MARK: - Properties
-    var sgc: SGCManager? = null
+    // Read by the welcome executor as well as device lifecycle handlers.
+    @Volatile var sgc: SGCManager? = null
     var controller: ControllerManager? = null
 
     // settings:
@@ -283,7 +292,22 @@ class DeviceManager {
 
     init {
         Bridge.log("DeviceManager: init()")
+        recoveryListenerId = DeviceStore.store.addListener { category, changes ->
+            if (category == "bluetooth" && changes.keys.any { it in G2ConnectionRecovery.keys }) {
+                synchronized(recoveryLock) {
+                    if (recoverG2Connection) {
+                        connectionRecovery.save(DeviceStore.store.getCategory("bluetooth"))
+                    }
+                }
+            }
+        }
         initializeViewStates()
+        if (initializeHardware) initializeHardwareServices()
+    }
+
+    // Keep host routing usable without starting audio codecs, receivers or services.
+    // The public constructor always initializes the hardware environment.
+    private fun initializeHardwareServices() {
         startForegroundService()
         // setupPermissionMonitoring()
         setupBluetoothStateMonitoring()
@@ -1497,6 +1521,10 @@ class DeviceManager {
         Bridge.log("MAN: handleDeviceReady() ${sgc?.type}")
         resetMicHealth()
         defaultWearable = sgc?.type ?: ""
+        synchronized(recoveryLock) {
+            recoverG2Connection = defaultWearable == DeviceTypes.G2
+            connectionRecovery.save(DeviceStore.store.getCategory("bluetooth"))
+        }
         searching = false
 
         syncSystemTimeOnceForConnection(readyKey)
@@ -1518,13 +1546,18 @@ class DeviceManager {
             2000
         )
 
-        // Show welcome message on first connect for all display glasses
+        // A full-canvas device can opt out so this temporary message does not
+        // erase the host's connected-edge scene replay.
         if (shouldSendBootingMessage) {
             shouldSendBootingMessage = false
-            executor.execute {
-                sgc?.sendTextWall("// MentraOS Connected")
-                Thread.sleep(3000)
-                sgc?.clearDisplay()
+            val device = sgc
+            if (device?.showConnectionConfirmation == true) {
+                executor.execute {
+                    if (sgc !== device) return@execute
+                    device.sendTextWall("// MentraOS Connected")
+                    Thread.sleep(3000)
+                    if (sgc === device) device.clearDisplay()
+                }
             }
         }
 
@@ -1677,7 +1710,7 @@ class DeviceManager {
         dashboardSceneCleanupPending = false
         val elementIds = pendingDashboardSceneElementIds.toList()
         pendingDashboardSceneElementIds.clear()
-        if (elementIds.isNotEmpty()) {
+        if (elementIds.isNotEmpty() && sgc?.sceneHandoffRequiresClear == true) {
             sgc?.clearSceneElements(elementIds)
         }
     }
@@ -1714,7 +1747,7 @@ class DeviceManager {
             sceneStates[stateIndex] = null
             if (stateIndex == 1 && dashboardSceneCleanupPending) {
                 pendingDashboardSceneElementIds.addAll(prevFrame.elements.map { it.id })
-            } else if (layoutType != "clear_view") {
+            } else if (layoutType != "clear_view" && shouldClearSceneHandoff(stateIndex)) {
                 sgc?.clearSceneElements(prevFrame.elements.map { it.id })
             }
         }
@@ -1781,7 +1814,7 @@ class DeviceManager {
             val prevLegacyType = viewStates[stateIndex].layoutType
             val cleanupDeferred = stateIndex == 1 && dashboardSceneCleanupPending
             if (
-                !cleanupDeferred &&
+                !cleanupDeferred && shouldClearSceneHandoff(stateIndex) &&
                     prevLegacyType.isNotEmpty() &&
                     prevLegacyType != "clear_view" &&
                     prevLegacyType != "scene"
@@ -1797,7 +1830,7 @@ class DeviceManager {
             // blank.
             if (stateIndex == 1 && dashboardSceneCleanupPending) {
                 pendingDashboardSceneElementIds.addAll(prevFrame.elements.map { it.id })
-            } else {
+            } else if (shouldClearSceneHandoff(stateIndex)) {
                 sgc?.clearSceneElements(prevFrame.elements.map { it.id })
             }
             frame = frame.copy(replay = true, elements = frame.elements.map { it.copy(change = "created") })
@@ -1816,6 +1849,15 @@ class DeviceManager {
         }
     }
 
+    // Hidden-view updates only change their replay slot. They must never clear
+    // the visible view, and full-frame adapters need no separate handoff sweep.
+    private fun shouldClearSceneHandoff(stateIndex: Int): Boolean {
+        val visibleIndex = if (headUp && contextualDashboard) 1 else 0
+        val device = sgc ?: return false
+        return stateIndex == visibleIndex && !screenDisabled && device.fullyBooted &&
+            !device.type.contains(DeviceTypes.SIMULATED) && device.sceneHandoffRequiresClear
+    }
+
     /** Guarded scene dispatch — mirrors sendCurrentState's send conditions. */
     private fun dispatchSceneFrame(stateIndex: Int, frame: SceneFrame) {
         if (screenDisabled) return
@@ -2389,8 +2431,15 @@ class DeviceManager {
     }
 
     fun disconnect(clearPendingIdentity: Boolean = true) {
+        synchronized(recoveryLock) {
+            recoverG2Connection = false
+            connectionRecovery.clear()
+        }
         sgc?.clearDisplay()
-        sgc?.disconnect()
+        // NIMO owns a background canvas encoder and this path discards its instance.
+        // A link-level reconnect keeps the instance (and encoder) through disconnect().
+        val device = sgc
+        if (device is Nimo) device.cleanup() else device?.disconnect()
         sgc = null // Clear the SGC reference after disconnect
         resetSystemTimeSync()
         resetMicHealth()
@@ -2440,6 +2489,10 @@ class DeviceManager {
     }
 
     fun forget() {
+        synchronized(recoveryLock) {
+            recoverG2Connection = false
+            connectionRecovery.clear()
+        }
         Bridge.log("MAN: Forgetting smart glasses")
 
         val live = sgc as? MentraLive
@@ -2554,6 +2607,8 @@ class DeviceManager {
 
     // MARK: Cleanup
     fun cleanup() {
+        recoveryListenerId?.let { DeviceStore.store.removeListener(it) }
+        recoveryListenerId = null
         stopBluetoothStateMonitoring()
 
         micReinitRunnable?.let { mainHandler.removeCallbacks(it) }

package/android/src/main/java/com/mentra/bluetoothsdk/DeviceStore.kt

@@ -142,6 +142,7 @@ object DeviceStore {
         store.set("bluetooth", "gallery_mode", true)
         store.set("bluetooth", "voice_activity_detection_enabled", BluetoothSdkDefaults.VOICE_ACTIVITY_DETECTION_ENABLED)
         store.set("bluetooth", "loudness_gate_enabled", BluetoothSdkDefaults.LOUDNESS_GATE_ENABLED)
+        store.set("bluetooth", "auto_power_off_enabled", BluetoothSdkDefaults.AUTO_POWER_OFF_ENABLED)
         store.set("bluetooth", "screen_disabled", false)
         store.set("bluetooth", "button_photo_size", "max")
         store.set("bluetooth", "button_max_recording_time", 10)
@@ -219,14 +220,30 @@ object DeviceStore {
             }
 
             // BLUETOOTH:
+            "bluetooth" to "contextual_dashboard" -> {
+                if (value is Boolean) {
+                    CoroutineScope(Dispatchers.Main.immediate).launch {
+                        // The setting changes the selected view even without a new head event.
+                        // Re-read state on Main and retain the manager's readiness/display guards.
+                        if (store.get("glasses", "headUp") == true) {
+                            DeviceManager.getInstance().sendCurrentState()
+                        }
+                    }
+                }
+            }
             "bluetooth" to "brightness" -> {
                 val b = (value as? Number)?.toInt()  ?: 50
                 val auto = (store.get("bluetooth", "auto_brightness") as? Boolean) ?: true
                 CoroutineScope(Dispatchers.Main).launch {
-                    DeviceManager.getInstance().sgc?.setBrightness(b, auto)
-                    DeviceManager.getInstance().sgc?.sendTextWall("Set brightness to $b%")
-                    delay(800) // 0.8 seconds
-                    DeviceManager.getInstance().sgc?.clearDisplay()
+                    val device = DeviceManager.getInstance().sgc ?: return@launch
+                    device.setBrightness(b, auto)
+                    if (device.showBrightnessConfirmation) {
+                        device.sendTextWall("Set brightness to $b%")
+                        delay(800) // 0.8 seconds
+                        if (DeviceManager.getInstance().sgc === device) {
+                            device.clearDisplay()
+                        }
+                    }
                 }
             }
             "bluetooth" to "auto_brightness" -> {
@@ -234,16 +251,17 @@ object DeviceStore {
                 val auto = (value as? Boolean) ?: true
                 val autoBrightnessChanged = (oldValue as? Boolean) != auto
                 CoroutineScope(Dispatchers.Main).launch {
-                    DeviceManager.getInstance().sgc?.setBrightness(b, auto)
-                    if (autoBrightnessChanged) {
-                        DeviceManager.getInstance()
-                                .sgc
-                                ?.sendTextWall(
-                                        if (auto) "Enabled auto brightness"
-                                        else "Disabled auto brightness"
-                                )
+                    val device = DeviceManager.getInstance().sgc ?: return@launch
+                    device.setBrightness(b, auto)
+                    if (autoBrightnessChanged && device.showBrightnessConfirmation) {
+                        device.sendTextWall(
+                                if (auto) "Enabled auto brightness"
+                                else "Disabled auto brightness"
+                        )
                         delay(800) // 0.8 seconds
-                        DeviceManager.getInstance().sgc?.clearDisplay()
+                        if (DeviceManager.getInstance().sgc === device) {
+                            device.clearDisplay()
+                        }
                     }
                 }
             }
@@ -291,6 +309,12 @@ object DeviceStore {
             "bluetooth" to "loudness_gate_enabled" -> {
                 DeviceManager.getInstance().sgc?.sendLoudnessGateSetting()
             }
+            "bluetooth" to "auto_power_off_enabled" -> {
+                Bridge.log(
+                        "DeviceStore: auto_power_off_enabled changed to $value — sending cs_swit type 11"
+                )
+                DeviceManager.getInstance().sgc?.sendAutoPowerOffSetting()
+            }
             // Deliberately has no seeded default above: the key starts absent so
             // that a session where the engine has not authorized tuning can only
             // ever send a reset.

package/android/src/main/java/com/mentra/bluetoothsdk/GeneratedChangelogCatalog.kt

@@ -3,7 +3,7 @@ package com.mentra.bluetoothsdk
 /** Generated from /changelogs. Do not edit directly. */
 internal val GENERATED_RELEASE_CHANGELOGS: List<ReleaseChangelog> =
     listOf(
-        ReleaseChangelog(version = "3.2.1", markdown = "This release is under active development. User-facing changes will be documented as they land."),
+        ReleaseChangelog(version = "3.2.1", markdown = "This release is under active development. User-facing changes will be documented as they land.\n\n- Mentra Miniapp SDK: `session.stream.preview({source: \"call\"})` and the `<StreamPreview>` component (from `@mentra/miniapp/react`) show the live video of a call your miniapp owns inside its UI. Requires the `CAMERA` permission; the lease survives the UI closing and ends with `handle.stop()` or the meeting. See [Stream preview](https://docs.mentraglass.com/app-devs/core-concepts/stream-preview)."),
         ReleaseChangelog(version = "3.2.0", markdown = "This release is under active development. User-facing changes will be documented as they land.\n\n- Breaking Bluetooth SDK change: `forgetWifiNetwork(ssid)` now returns `WifiForgetResult` instead of `WifiStatusChangeEvent`. Migrate status-only consumers to the semantic `outcome`; the requested network remains `ssid`, while optional post-command connectivity is reported by `connected`, `currentSsid`, and `localIp`."),
         ReleaseChangelog(version = "3.1.1", markdown = "- Improved Google login on iOS.\n- Pairing no longer requires phone microphone access."),
         ReleaseChangelog(version = "3.1.0", markdown = "**Mentra App and glasses**\n\n- Improved glasses pairing and reconnection, including on iPad.\n- Improved Android background reliability for captions and miniapps.\n- Added Xingyi AR99 support.\n- More reliable photo and video capture, with improved shutter sounds and privacy-light timing. Taking photos no longer interrupts your running miniapp.\n- Added video thumbnails and smoother gallery browsing.\n- Easier Mentra Live updates through your phone, with clearer progress and better recovery from interruptions.\n\n**Miniapp updates**\n\n- **Mentra AI:** Control whether photos are included with questions. Improved visual answers and connected-app follow-ups.\n- **Captions:** Added offline transcription settings and top/bottom positioning on supported displays.\n- **Translation:** Restored all 60 languages.\n- **Mentra Maps:** Clearer directions on G1/G2, less display flickering, and improved Android offline routing.\n- **Livestreamer:** More video-quality controls and custom streaming options, plus improved startup and sharing.\n- **Merge:** Tap to expand an insight; swipe down or back to dismiss it.\n- **Mentra Notes:** Smoother back navigation.\n- **Recorder:** Fixed audio sharing."),

package/android/src/main/java/com/mentra/bluetoothsdk/GeneratedReleaseMetadata.kt

@@ -3,9 +3,9 @@ package com.mentra.bluetoothsdk
 /** Generated by release CI. Do not edit in a release checkout. */
 internal object GeneratedReleaseMetadata {
     const val FAMILY_BASE_VERSION: String = "3.2.1"
-    const val RELEASE_IDENTITY: String = "3.2.1-beta.319"
-    const val RELEASE_SET_ID: String = "mentra-3.2.1-beta.319"
-    const val SOURCE_COMMIT: String = "551a7fef692b763630ae7708e247fe17b75571ab"
-    const val OTA_MANIFEST_URL: String = "https://artifactscdn.mentraglass.com/Mentra-Community/MentraOS/releases/mentra-builds-v3.2.1/mentra-live-ota-3.2.1-beta.319.json"
-    const val OTA_MANIFEST_SHA256: String = "b604978c7ff60b68fe50bceaee8bc89219ec028bdc1d3872c0ec7aae846bd0ec"
+    const val RELEASE_IDENTITY: String = "3.2.1-beta.355"
+    const val RELEASE_SET_ID: String = "mentra-3.2.1-beta.355"
+    const val SOURCE_COMMIT: String = "e8566f5d4cab141cf4d1f93009527b5b136805c8"
+    const val OTA_MANIFEST_URL: String = "https://artifactscdn.mentraglass.com/Mentra-Community/MentraOS/releases/mentra-builds-v3.2.1/mentra-live-ota-3.2.1-beta.355.json"
+    const val OTA_MANIFEST_SHA256: String = "1a21430c982331457a73d65285d0b08f5a93b2a64d2ea004b8331ee9645a3453"
 }

package/android/src/main/java/com/mentra/bluetoothsdk/MentraBluetoothSdk.kt

@@ -651,6 +651,10 @@ class MentraBluetoothSdk private constructor(
         DeviceStore.apply(ObservableStore.BLUETOOTH_CATEGORY, "loudness_gate_enabled", enabled)
     }
 
+    fun setAutoPowerOffEnabled(enabled: Boolean) {
+        DeviceStore.apply(ObservableStore.BLUETOOTH_CATEGORY, "auto_power_off_enabled", enabled)
+    }
+
     @Deprecated(
         message =
             "Sticky action-button photo presets are deprecated. Prefer per-request " +

package/android/src/main/java/com/mentra/bluetoothsdk/VersionInfoResponseAccumulator.kt

@@ -6,13 +6,14 @@ internal sealed interface VersionInfoAccumulatorOutcome {
     data class Complete(val result: VersionInfoResult) : VersionInfoAccumulatorOutcome
 }
 
-/** One request, explicit modern completion, or the deployed legacy chunk-3 terminal boundary. */
+/** One request, explicit modern completion, or the legacy firmware's terminal chunk. */
 internal class VersionInfoResponseAccumulator(private val expectedRequestId: String) {
     private val values = mutableMapOf<String, Any>()
     private val chunks = mutableMapOf<Int, Map<String, Any>>()
     private var count: Int? = null
     private var sid: String? = null
     private var legacyStarted = false
+    private var legacyTwoChunkResponse = false
     private var completed = false
 
     fun accept(event: Map<String, Any>): VersionInfoAccumulatorOutcome {
@@ -41,10 +42,20 @@ internal class VersionInfoResponseAccumulator(private val expectedRequestId: Str
         if (count != null) return VersionInfoAccumulatorOutcome.Ignored
         when (event[RESPONSE_CHUNK_KEY] as? String ?: "version_info") {
             "version_info" -> { values.clear(); merge(event); return finish() }
-            "version_info_1" -> { values.clear(); legacyStarted = true; merge(event) }
+            "version_info_1" -> {
+                values.clear()
+                legacyStarted = true
+                legacyTwoChunkResponse = event["buildNumber"] == "27"
+                merge(event)
+            }
             "version_info_2" -> {
                 if (!legacyStarted) return VersionInfoAccumulatorOutcome.Ignored
+                // Factory ASG27 sends only chunks 1 and 2. Its second chunk carries the
+                // OTA URL and legacy firmware version; ASG31+ moves firmware to chunk 3.
                 merge(event)
+                if (legacyTwoChunkResponse && values["buildNumber"] == "27" &&
+                    !(event["otaVersionUrl"] as? String).isNullOrBlank()
+                ) return finish()
             }
             "version_info_3" -> {
                 if (!legacyStarted) return VersionInfoAccumulatorOutcome.Ignored

package/android/src/main/java/com/mentra/bluetoothsdk/services/Foreground.kt

@@ -13,6 +13,8 @@ import android.os.IBinder
 import androidx.core.app.NotificationCompat
 import androidx.core.content.ContextCompat
 import com.mentra.bluetoothsdk.Bridge
+import com.mentra.bluetoothsdk.DeviceManager
+import com.mentra.bluetoothsdk.DeviceStore
 import com.mentra.bluetoothsdk.debug.BleTraceLogger
 
 class ForegroundService : Service() {
@@ -107,9 +109,40 @@ class ForegroundService : Service() {
         }
         // Re-check permissions in case they changed
         startForegroundWithAutoDetectedType()
+        // A null intent is Android restarting START_STICKY after process death.
+        // Do not wait for an Activity/Expo module to restore the native BLE owner.
+        if (intent == null && !DeviceManager.isInitialized()) {
+            val settings = G2ConnectionRecovery(this).read()
+            if (settings != null && !startHostRuntimeRecovery()) {
+                Bridge.initialize(applicationContext)
+                settings.forEach { (key, value) -> DeviceStore.set("bluetooth", key, value) }
+                Bridge.log("ForegroundService: restoring G2 connection after process restart")
+                try {
+                    DeviceManager.getInstance().connectDefault()
+                } catch (error: Exception) {
+                    Bridge.log("ForegroundService: G2 recovery failed: ${error.message}")
+                }
+            }
+        }
         return START_STICKY
     }
 
+    private fun startHostRuntimeRecovery(): Boolean {
+        // Keep the standalone SDK free of React dependencies. The Mentra App
+        // opts in with a private headless service declared by its host module.
+        val serviceName = packageManager.getApplicationInfo(packageName, PackageManager.GET_META_DATA)
+                .metaData?.getString("com.mentra.bluetoothsdk.RUNTIME_RECOVERY_SERVICE")
+                ?: return false
+        return try {
+            if (startService(Intent().setClassName(packageName, serviceName)) == null) return false
+            Bridge.log("ForegroundService: requested host JavaScript runtime recovery")
+            true
+        } catch (error: Exception) {
+            Bridge.log("ForegroundService: host runtime recovery could not start: ${error.message}")
+            false
+        }
+    }
+
     private fun startForegroundWithAutoDetectedType() {
         startForegroundWithType(detectServiceType())
     }

package/android/src/main/java/com/mentra/bluetoothsdk/services/G2ConnectionRecovery.kt

@@ -0,0 +1,47 @@
+package com.mentra.bluetoothsdk.services
+
+import android.content.Context
+import com.mentra.bluetoothsdk.utils.DeviceTypes
+import org.json.JSONObject
+
+/** Native recovery of the last active G2 link when Android restarts our sticky service. */
+internal class G2ConnectionRecovery(context: Context) {
+    private val preferences = context.getSharedPreferences("g2_connection_recovery", Context.MODE_PRIVATE)
+
+    companion object {
+        // Deliberately exclude transient connection flags, mic intent, tokens and pending pairing.
+        internal val keys = setOf(
+            "default_wearable", "device_name", "device_address", "project_name",
+            "brightness", "auto_brightness", "dashboard_height", "dashboard_depth",
+            "head_up_angle", "use_native_dashboard", "twelve_hour_time", "metric_system",
+            "screen_disabled", "power_saving_mode", "lc3_frame_size",
+        )
+    }
+
+    fun save(settings: Map<String, Any>) {
+        if (settings["default_wearable"] != DeviceTypes.G2 ||
+            (settings["device_name"] as? String).isNullOrBlank()) {
+            clear()
+            return
+        }
+        val snapshot = settings.filterKeys { it in keys }
+        preferences.edit().putString("snapshot", JSONObject(snapshot).toString()).apply()
+    }
+
+    fun clear() {
+        preferences.edit().remove("snapshot").apply()
+    }
+
+    fun read(): Map<String, Any>? {
+        val raw = preferences.getString("snapshot", null) ?: return null
+        return try {
+            val json = JSONObject(raw)
+            if (json.optString("default_wearable") != DeviceTypes.G2 ||
+                json.optString("device_name").isBlank()) return null
+            keys.filter { json.has(it) && !json.isNull(it) }.associateWith { json.get(it) }
+        } catch (_: Exception) {
+            clear()
+            null
+        }
+    }
+}

package/android/src/main/java/com/mentra/bluetoothsdk/sgcs/G2.kt

@@ -1,5 +1,6 @@
 package com.mentra.bluetoothsdk.sgcs
 
+import com.mentra.bluetoothsdk.utils.G2Text
 import com.mentra.bluetoothsdk.PhotoRequest
 import android.bluetooth.BluetoothAdapter
 import android.bluetooth.BluetoothGatt
@@ -1664,8 +1665,15 @@ class G2 : SGCManager() {
         if (char == null || gatt == null) return
         char.value = packet
         char.writeType = BluetoothGattCharacteristic.WRITE_TYPE_NO_RESPONSE
-        val ok = gatt.writeCharacteristic(char)
-        bgcapNoteWriteResult(ok) // BGCAP
+        // A rejected write never entered Android's queue. Retry on this dedicated
+        // BLE worker before later commands (especially a page replacement) overtake it.
+        var ok = false
+        for (attempt in 0 until 5) {
+            ok = gatt.writeCharacteristic(char)
+            bgcapNoteWriteResult(ok)
+            if (ok) break
+            if (attempt < 4) Thread.sleep(BLE_PACKET_GAP_MS)
+        }
         if (leg != null) {
             Bridge.log("G2/FILE: write $leg ${packet.size}B -> ${if (ok) "queued" else "DROPPED (stack busy)"}")
         }
@@ -2190,7 +2198,7 @@ class G2 : SGCManager() {
         val rBorderColor = borderColor ?: defaultTextBorderColor
         val rBorderRadius = borderRadius ?: defaultTextBorderRadius
         val rPaddingLength = paddingLength ?: defaultTextPaddingLength
-        val content = if (text.isEmpty()) " " else text
+        val content = G2Text.containerContent(text)
 
         // Pure state mutation: update the container's content and schedule its sends; the reconcile
         // loop does the actual updateText writes. Reuse an existing container if the rect matches
@@ -2257,6 +2265,12 @@ class G2 : SGCManager() {
     }
 
     override fun clearDisplay() {
+        // Expo invokes this on its worker queue; all container mutations must
+        // share Main with reconcileDisplay and scene updates.
+        if (Looper.myLooper() != Looper.getMainLooper()) {
+            mainHandler.post { clearDisplay() }
+            return
+        }
         Bridge.log("G2: clearDisplay()")
         // Clear the text in place — do NOT shut down + rebuild the EvenHub page. Tearing the page
         // down (rebuildPage) kills audio streaming AND triggers a firmware systemExit /
@@ -2266,9 +2280,22 @@ class G2 : SGCManager() {
         // several seconds (incident 8164175a). Just blank the text + clear images; the reconcile
         // loop pushes the blanked text on a live page, and a dead page is only resurrected for
         // meaningful (non-blank) content, so a clear can't churn it back up.
-        for (i in textContainers.indices) {
-            textContainers[i].content = "\n"
-            textContainers[i].pendingSends = 1 + EVEN_HUB_RESEND_COUNT
+        for (container in textContainers) {
+            // Erase the firmware's existing text BEFORE forgetting its container.
+            // A queued reconcile cannot do this after the positioned container is removed.
+            // Cover the previous byte range, rather than replacing only its first character.
+            val blank = " ".repeat(maxOf(1, container.content.toByteArray(Charsets.UTF_8).size))
+            container.content = blank
+            container.pendingSends = 1 + EVEN_HUB_RESEND_COUNT
+            if (pageCreated) {
+                val erase = EvenHubProto.updateTextMessage(
+                    containerID = container.id,
+                    contentOffset = 0,
+                    contentLength = blank.length,
+                    content = blank
+                )
+                repeat(1 + EVEN_HUB_RESEND_COUNT) { sendEvenHubCommand(erase) }
+            }
         }
         for (i in imageContainers.indices) {
             // The firmware still shows this container's image; emptying bmpData locally never reaches
@@ -2296,8 +2323,13 @@ class G2 : SGCManager() {
             textContainers.removeAll { it.id in huskIds }
             sceneTextByElement.entries.removeAll { it.value in huskIds }
             sceneImageByElement.clear()
-            Bridge.log("G2: clearDisplay() — purging ${huskIds.size} positioned husk container(s), one rebuild")
-            displayScope.launch { coalescedPageRebuild() }
+            // Replace the live page now, while still on Main. A shutdown followed by
+            // reconcile cannot clear this case: reconcile intentionally skips blank pages,
+            // leaving the firmware's old positioned text visible until new speech arrives.
+            // Queue the blank replacement before any following miniapp frame, without
+            // tearing down the page (or its microphone session).
+            Bridge.log("G2: clearDisplay() — replacing page after removing ${huskIds.size} positioned container(s)")
+            if (pageCreated) createPageWithContainers()
         }
     }
 
@@ -2344,6 +2376,15 @@ class G2 : SGCManager() {
                     return false
                 }
 
+        if (Looper.myLooper() != Looper.getMainLooper()) {
+            mainHandler.post { applyBitmap(rx, ry, rw, rh, bmpData) }
+            return true
+        }
+        return applyBitmap(rx, ry, rw, rh, bmpData)
+    }
+
+    // Called only on Main, including the inline scene-frame path.
+    private fun applyBitmap(rx: Int, ry: Int, rw: Int, rh: Int, bmpData: ByteArray): Boolean {
         // Pure state mutation: update the target container's bytes and mark it dirty. The reconcile
         // loop is the sole sender, so two displayBitmap calls can never overlap a sendImageData and
         // clobber the single-slot image ACK — no lock needed. Reuse an existing container if the rect
@@ -2538,7 +2579,7 @@ class G2 : SGCManager() {
         @Suppress("NAME_SHADOWING")
         val height = minOf(maxOf(height, minTextContainerHeight), 288 - y)
         run {
-            val content = if (text.isEmpty()) " " else text
+            val content = G2Text.containerContent(text)
             val existingId = sceneTextByElement[elementId]
             if (existingId != null) {
                 val idx = textContainers.indexOfFirst { it.id == existingId }
@@ -2999,15 +3040,15 @@ class G2 : SGCManager() {
                 }
                 // Only settle the flag if it's still empty — a displayBitmap during the await would
                 // have set new bytes, so leave it dirty for the next pass to send the real image.
-                val jj = imageContainers.indexOfFirst { it.id == container.id }
+                val jj = imageContainers.indexOfFirst { it === container }
                 if (jj >= 0 && imageContainers[jj].bmpData.isEmpty()) {
                     imageContainers[jj].dirty = false
                 }
                 continue
             }
             sendImageData(container.id, container.name, sentBytes)
-            // Re-find by id: the list may have shifted (eviction) during the await.
-            val j = imageContainers.indexOfFirst { it.id == container.id }
+            // Re-find by identity: eviction can reuse this ID during the await.
+            val j = imageContainers.indexOfFirst { it === container }
             if (j >= 0 && imageContainers[j].bmpData.contentEquals(sentBytes)) {
                 imageContainers[j].dirty = false
             }
@@ -3677,8 +3718,17 @@ class G2 : SGCManager() {
         rightAuthenticated = false
         startupPageCreated = false
         pageCreated = false
-        imageContainers.clear()
-        textContainers.clear()
+        // Keep GATT teardown synchronous for manager replacement, but never
+        // remove containers underneath Main's reconcile/scene iteration.
+        if (Looper.myLooper() == Looper.getMainLooper()) {
+            imageContainers.clear()
+            textContainers.clear()
+        } else {
+            mainHandler.post {
+                imageContainers.clear()
+                textContainers.clear()
+            }
+        }
         dashboardShowing = 0
         dashboardOpening = false
         heartbeatCounter = 0