@mentra/bluetooth-sdk 3.2.0-dev.265 → 3.2.1-beta.312

package/ios/Source/DeviceManager.swift

@@ -50,6 +50,8 @@ struct ViewState {
     private var cancellables = Set<AnyCancellable>()
     #if os(macOS)
     private var audioRouteObserver: MacAudioRouteObserver?
+    #else
+    private var audioRouteObservation: AudioRouteObservation?
     #endif
     var sendStateWorkItem: DispatchWorkItem?
     let sendStateQueue = DispatchQueue(label: "sendStateQueue", qos: .userInitiated)
@@ -366,6 +368,18 @@ struct ViewState {
         Bridge.log("MAN: init()")
         super.init()
 
+        #if !os(macOS)
+        // Pair Audio precedes BLE readiness and microphone capture. Its audio
+        // state must not depend on the lazily created PhoneMic singleton.
+        audioRouteObservation = AudioRouteObservation(names: [
+            AVAudioSession.routeChangeNotification,
+            UIApplication.didBecomeActiveNotification,
+        ]) { [weak self] in
+            self?.refreshAudioDeviceState()
+            self?.updateMicState()
+        }
+        #endif
+
         // Start memory monitoring (logs every 30s to help detect leaks)
         // MemoryMonitor.start()
 
@@ -929,6 +943,16 @@ struct ViewState {
     }
 
     func checkCurrentAudioDevice() {
+        #if os(macOS)
+        refreshAudioDeviceState()
+        #else
+        // DeviceStore calls this when the selected glasses change. Replace any
+        // pending route checks so the new target gets its own settling window.
+        audioRouteObservation?.refresh()
+        #endif
+    }
+
+    private func refreshAudioDeviceState() {
         let audioDevicePattern = getAudioDevicePattern()
         Bridge.log("MAN: checkCurrentAudioDevice: audioDevicePattern: \(audioDevicePattern)")
 
@@ -942,59 +966,13 @@ struct ViewState {
         glassesBluetoothClassicConnected = AudioSessionMonitor.isAudioDeviceConnected(devicePattern: audioDevicePattern)
         otherBtConnected = AudioSessionMonitor.isOtherAudioDeviceConnected(devicePattern: audioDevicePattern)
         #else
-        // check if the device disconnected:
-        let isConnected = AudioSessionMonitor.isAudioDeviceConnected(
-            devicePattern: audioDevicePattern
-        )
-
-        if !isConnected {
-            Bridge.log("MAN: Device '\(deviceName)' disconnected")
-            glassesBluetoothClassicConnected = false
-
-            let isOtherDeviceConnected = AudioSessionMonitor.isOtherAudioDeviceConnected(
-                devicePattern: audioDevicePattern
-            )
-            if isOtherDeviceConnected {
-                Bridge.log("MAN: Other device connected, returning")
-                otherBtConnected = true
-            }
-            return
-        }
-
-        let isPaired = AudioSessionMonitor.isDevicePaired(devicePattern: audioDevicePattern)
-        if isPaired {
-            Bridge.log("MAN: Successfully detected newly paired device '\(audioDevicePattern)'")
-            glassesBluetoothClassicConnected = true
-        } else {
-            glassesBluetoothClassicConnected = false
-        }
+        // A connected HFP input remains eligible even while another output is
+        // selected. Inspect available inputs as well as the active A2DP route.
+        glassesBluetoothClassicConnected = AudioSessionMonitor.isDevicePaired(devicePattern: audioDevicePattern)
+        otherBtConnected = AudioSessionMonitor.isOtherAudioDeviceConnected(devicePattern: audioDevicePattern)
         #endif
     }
 
-    #if !os(macOS)
-    func onRouteChange(
-        reason: AVAudioSession.RouteChangeReason, availableInputs: [AVAudioSessionPortDescription]
-    ) {
-        Bridge.log("MAN: onRouteChange: reason: \(reason)")
-        Bridge.log("MAN: onRouteChange: inputs: \(availableInputs)")
-
-        // check if our deviceName is connected:
-        // (return if deviceName is empty):
-        if deviceName.isEmpty {
-            Bridge.log("MAN: Device name is empty, returning")
-            return
-        }
-
-        // Add small delay to let iOS populate availableInputs
-        DispatchQueue.main.asyncAfter(deadline: .now() + 0.2) { [weak self] in
-            guard let self = self else { return }
-            checkCurrentAudioDevice()
-        }
-
-        updateMicState()
-    }
-    #endif
-
     func onInterruption(began: Bool) {
         Bridge.log("MAN: Interruption: \(began)")
         systemMicUnavailable = began
@@ -1488,6 +1466,26 @@ struct ViewState {
 
     func dbg2() {}
 
+    func queryWearState() {
+        sgc?.queryWearState()
+    }
+
+    func setWearReporting(_ enabled: Bool) {
+        sgc?.setWearReporting(enabled)
+    }
+
+    func setWearTuning(intervalMs: Int, count: Int, majority: Int) {
+        sgc?.setWearTuning(intervalMs: intervalMs, count: count, majority: majority)
+    }
+
+    func requestWearTuning() {
+        sgc?.requestWearTuning()
+    }
+
+    func resetWearTuning() {
+        sgc?.resetWearTuning()
+    }
+
     func startStream(_ message: [String: Any]) {
         var message = message
         Bridge.log("MAN: startStream: \(message)")
@@ -1586,6 +1584,10 @@ struct ViewState {
         return live
     }
 
+    func sendGalleryServerEnabled(requestId: String, enabled: Bool) throws {
+        try liveSgc().sendGalleryServerEnabled(requestId: requestId, enabled: enabled)
+    }
+
     func sendGalleryMode(requestId: String, enabled: Bool) throws {
         try liveSgc().sendGalleryMode(requestId: requestId, active: enabled)
     }

package/ios/Source/DeviceStore.swift

@@ -254,6 +254,12 @@ class DeviceStore {
         case ("bluetooth", "loudness_gate_enabled"):
             DeviceManager.shared.sgc?.sendLoudnessGateSetting()
 
+        // Deliberately has no seeded default: the key starts absent so that a
+        // session where the engine has not authorized tuning can only ever
+        // send a reset.
+        case ("bluetooth", "mic_tuning"):
+            DeviceManager.shared.sgc?.sendMicTuningSetting()
+
         case ("bluetooth", "screen_disabled"):
             if let disabled = value as? Bool {
                 if disabled {

package/ios/Source/GeneratedChangelogCatalog.swift

@@ -2,7 +2,8 @@ import Foundation
 
 /// Generated from /changelogs. Do not edit directly.
 let generatedReleaseChangelogs: [ReleaseChangelog] = [
+    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.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: "Software updates are more reliable, with clearer progress and recovery when the glasses restart.\n\n- MentraOS, Mentra Engine, the Bluetooth SDK, and the glasses client now share one coordinated release version.\n- Mentra Live updates can continue across APK, system, and firmware restarts without asking the user to start the same update again.\n- Bluetooth photo capture and transfer diagnostics are more precise and less disruptive to normal glasses traffic.\n- Bluetooth SDK usage analytics now report the host app's version, build type, and install source (store, TestFlight, sideload, simulator), plus the glasses firmware versions on identification, so store usage can be measured separately from development builds.\n- Bluetooth SDK usage analytics now identify G2 glasses by serial, keep long-lived connections visible across day boundaries, and retry failed uploads instead of dropping them."),
-    ReleaseChangelog(version: "3.1.0", markdown: "Software updates are more reliable, with clearer progress and recovery when the glasses restart.\n\n- MentraOS, Mentra Engine, the Bluetooth SDK, and the glasses client now share one coordinated release version.\n- Mentra Live updates can continue across APK, system, and firmware restarts without asking the user to start the same update again.\n- Bluetooth photo capture and transfer diagnostics are more precise and less disruptive to normal glasses traffic.\n- Bluetooth SDK usage analytics now report the host app's version, build type, and install source (store, TestFlight, sideload, simulator), plus the glasses firmware versions on identification, so store usage can be measured separately from development builds.\n- Bluetooth SDK usage analytics now identify G2 glasses by serial, keep long-lived connections visible across day boundaries, and retry failed uploads instead of dropping them."),
+    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/ios/Source/GeneratedReleaseMetadata.swift

@@ -2,10 +2,10 @@ import Foundation
 
 /// Generated by release CI. Do not edit in a release checkout.
 enum GeneratedReleaseMetadata {
-    static let familyBaseVersion = "3.2.0"
-    static let releaseIdentity = "3.2.0-dev.265"
-    static let releaseSetId = "mentra-3.2.0-dev.265"
-    static let sourceCommit = "e8e1ced74c05705b313769d49dfbf98f8bf5b1d2"
-    static let otaManifestUrl = "https://github.com/Mentra-Community/MentraOS/releases/download/mentra-builds-v3.2.0/mentra-live-ota-3.2.0-dev.265.json"
-    static let otaManifestSha256 = "c75ed12b14a9897db8c89a9bd3baa6bad432aa908e7fc0b0f50af8c7d8b8a9ad"
+    static let familyBaseVersion = "3.2.1"
+    static let releaseIdentity = "3.2.1-beta.312"
+    static let releaseSetId = "mentra-3.2.1-beta.312"
+    static let sourceCommit = "0e549d30e1de230cc9f22e77b80ca1704833cceb"
+    static let otaManifestUrl = "https://artifactscdn.mentraglass.com/Mentra-Community/MentraOS/releases/mentra-builds-v3.2.1/mentra-live-ota-3.2.1-beta.312.json"
+    static let otaManifestSha256 = "c7d7975d15ab271035e7e26431be200d91664cc4c85b761e373ed4bc4026a3ac"
 }

package/ios/Source/MentraBluetoothSDK.swift

@@ -639,6 +639,17 @@ public final class MentraBluetoothSDK {
         DeviceStore.shared.apply(ObservableStore.bluetoothCategory, "screen_disabled", disabled)
     }
 
+    /// Enable or disable persistent, unauthenticated HTTP gallery access on the glasses' Wi-Fi.
+    /// Defaults off and survives glasses restarts. Only enable on a trusted network.
+    /// The ack reports the saved `enabled` state and current `listening`/`url` separately.
+    public func setGalleryServerEnabled(_ enabled: Bool) async throws -> SettingsAckEvent {
+        try await performSettingsCommand(
+            setting: "gallery_server",
+            updateStore: { _ in },
+            send: { requestId in try DeviceManager.shared.sendGalleryServerEnabled(requestId: requestId, enabled: enabled) }
+        )
+    }
+
     public func setGalleryModeEnabled(_ enabled: Bool) async throws -> SettingsAckEvent {
         try await performSettingsCommand(
             setting: "gallery_mode",

package/ios/Source/audio/PcmStreamPlayer.swift

@@ -1,5 +1,6 @@
 import AVFoundation
 import Foundation
+import os
 
 private enum PcmStreamError: LocalizedError {
     case invalidArgument(String)
@@ -25,6 +26,7 @@ private enum PcmStreamError: LocalizedError {
 /// recovery, close, and abort deterministic without blocking Expo's module
 /// queue.
 final class PcmStreamPlayer: @unchecked Sendable {
+    private let logger = Logger(subsystem: "com.mentra.pcm-stream", category: "playback")
     private static let backpressureCeilingMs: Int64 = 2000
     private static let maximumBacklogMs: Int64 = 10000
 
@@ -37,6 +39,7 @@ final class PcmStreamPlayer: @unchecked Sendable {
 
     private var queuedFrames: Int64 = 0
     private var playedFrames: Int64 = 0
+    private var writtenFrames: Int64 = 0
     private var closing = false
     private var aborted = false
     private var finished = false
@@ -107,6 +110,10 @@ final class PcmStreamPlayer: @unchecked Sendable {
                     }
 
                     let buffer = try makeBuffer(data: data, frameCount: frameCount)
+                    if writtenFrames == 0 {
+                        logger.info("PCM_PLAYBACK first_write frames=\(frameCount) sampleRate=\(self.sampleRate) engineRunning=\(self.engine.isRunning)")
+                    }
+                    writtenFrames += Int64(frameCount)
                     queuedFrames += Int64(frameCount)
                     player.scheduleBuffer(
                         buffer,
@@ -157,6 +164,7 @@ final class PcmStreamPlayer: @unchecked Sendable {
         await withCheckedContinuation { continuation in
             stateQueue.async { [self] in
                 if !aborted {
+                    logger.info("PCM_PLAYBACK abort writtenFrames=\(self.writtenFrames) playedFrames=\(self.playedFrames) queuedFrames=\(self.queuedFrames)")
                     aborted = true
                     finished = true
                     player.stop()
@@ -201,6 +209,10 @@ final class PcmStreamPlayer: @unchecked Sendable {
 
     private func didPlay(frameCount: Int) {
         guard !aborted, terminalError == nil else { return }
+        if playedFrames == 0 {
+            let rate = sampleRate
+            logger.info("PCM_PLAYBACK first_played frames=\(frameCount) sampleRate=\(rate)")
+        }
         queuedFrames = max(0, queuedFrames - Int64(frameCount))
         playedFrames += Int64(frameCount)
 

package/ios/Source/events/BluetoothEvents.swift

@@ -206,6 +206,21 @@ public struct SettingsAckEvent: CustomStringConvertible {
         stringValue(values, "errorMessage")
     }
 
+    /// Saved setting value, when included in the acknowledgement.
+    public var enabled: Bool? {
+        boolValue(values, "enabled")
+    }
+
+    /// Whether the persistent gallery server is currently available over station Wi-Fi.
+    public var listening: Bool? {
+        boolValue(values, "listening")
+    }
+
+    /// Current gallery base URL, available only with a running server and station Wi-Fi.
+    public var url: String? {
+        stringValue(values, "url")
+    }
+
     public var description: String {
         "SettingsAckEvent(setting: \(setting), status: \(status))"
     }

package/ios/Source/services/PhoneMic.swift

@@ -359,9 +359,7 @@ class PhoneMic {
         }
 
         Bridge.log("MIC: handleRouteChange: \(reason)")
-        DeviceManager.shared.onRouteChange(
-            reason: reason, availableInputs: audioSession?.availableInputs ?? []
-        )
+        // DeviceManager observes readiness independently of microphone capture.
 
         // // If we're recording and the audio route changed (e.g., AirPods connected/disconnected)
         // if isRecording {

package/ios/Source/sgcs/MentraLive.swift

@@ -1060,6 +1060,10 @@ extension MentraLive: CBCentralManagerDelegate {
             self.readinessCompletedThisBleSession = false
             self.updateConnectionState(ConnTypes.DISCONNECTED)
             self.rgbLedAuthorityClaimed = false
+            // The glasses reset mic and wear tuning on BLE disconnect, so the
+            // next link must be allowed to send them again.
+            self.lastSentMicTuningBody = nil
+            self.wearTuningQueriedThisLink = false
 
             self.stopAllTimers()
             self.closeL2capFileChannel()
@@ -1698,6 +1702,21 @@ class MentraLive: NSObject, SGCManager {
     private var ancsRelayEnableRequested = false
     private var peerWireCapsBinary = false
     private var peerFilePayloadV2 = false
+    /// Firmware understands cs_mictun / cs_micst / cs_micrms. Nothing mic-tuning
+    /// related goes on the wire until this is seen.
+    private var peerMicTuning = false
+    /// Firmware understands cs_weartun / cs_wearst. Wear reporting stays off
+    /// until Super Mode asks for it; this flag only gates those commands.
+    private var peerWearTuning = false
+    /// Tuning generation echoed by the last sr_mictun / sr_micst. An sr_micrms
+    /// measured before that revision describes a config we already replaced.
+    private var micTuningGeneration = 0
+    /// Connect-time dedupe, mirroring Android. Several paths push mic tuning
+    /// when a link comes up and the wire_caps parse re-runs per glasses_ready;
+    /// the glasses only forget tuning on BLE disconnect, so an identical body
+    /// within one link is dropped. Both reset in didDisconnectPeripheral.
+    private var lastSentMicTuningBody: String?
+    private var wearTuningQueriedThisLink = false
     /// Last observed glasses process session id (`sid` in glasses_ready / version_info_1).
     /// The BES keeps the BLE link alive across asg_client restarts, so transport state
     /// cannot signal a restart - a CHANGED (or newly appearing) sid is the restart signal.
@@ -2646,7 +2665,8 @@ class MentraLive: NSObject, SGCManager {
 
     // MARK: - Data Processing
 
-    private func processReceivedData(_ data: Data) {
+    // Internal so native integration tests can replay the actual BLE receive path.
+    func processReceivedData(_ data: Data) {
         guard data.count > 0 else { return }
 
         let bytes = [UInt8](data)
@@ -3427,6 +3447,35 @@ class MentraLive: NSObject, SGCManager {
                 )
             }
 
+        case "sr_mictun", "sr_micst":
+            if let body = k900ParseBody(json["B"]) {
+                handleMicTuningState(body)
+            }
+
+        case "sr_weartun":
+            if let body = k900ParseBody(json["B"]) {
+                handleWearTuningState(json, body)
+            }
+
+        case "sr_wrst":
+            if let body = k900ParseBody(json["B"]) {
+                Bridge.sendWearState(worn: (k900JsonInt(body, "on") ?? 0) != 0)
+            }
+
+        case "sr_micrms":
+            if let body = k900ParseBody(json["B"]) {
+                let generation = k900JsonInt(body, "gen") ?? 0
+                // Measured under a config we have already replaced.
+                if generation >= micTuningGeneration {
+                    Bridge.sendMicRms(
+                        rms: k900JsonInt(body, "rms") ?? 0,
+                        gateOpen: (k900JsonInt(body, "gate") ?? 0) != 0,
+                        speakerElevated: (k900JsonInt(body, "sp") ?? 0) != 0,
+                        generation: generation
+                    )
+                }
+            }
+
         case "sr_shut":
             Bridge.log("K900 shutdown command received - glasses shutting down")
             // Mark as killed to prevent reconnection attempts
@@ -3781,6 +3830,14 @@ class MentraLive: NSObject, SGCManager {
         sendJson(json, wakeUp: true)
     }
 
+    func sendGalleryServerEnabled(requestId: String, enabled: Bool) {
+        sendJson([
+            "type": "set_gallery_server_enabled",
+            "request_id": requestId,
+            "enabled": enabled,
+        ], wakeUp: true)
+    }
+
     func sendGalleryMode() {
         let active = DeviceStore.shared.get("bluetooth", "gallery_mode") as! Bool
         sendGalleryMode(requestId: nil, active: active)
@@ -6049,6 +6106,9 @@ extension MentraLive {
         peerK900Le = false
         peerWireCapsBinary = false
         peerFilePayloadV2 = false
+        peerWearTuning = false
+        peerMicTuning = false
+        micTuningGeneration = 0
         BleJsonCompact.resetSession()
         wireHandshakeSentGeneration = -1
     }
@@ -6118,6 +6178,33 @@ extension MentraLive {
         if caps.keys.contains("file_payload_v2") {
             peerFilePayloadV2 = (caps["file_payload_v2"] as? Bool) == true
         }
+        if caps.keys.contains("wear_tuning"), !peerWearTuning {
+            let supported = (caps["wear_tuning"] as? Bool) == true
+                || ((caps["wear_tuning"] as? NSNumber)?.intValue ?? 0) != 0
+            if supported {
+                peerWearTuning = true
+                Bridge.log("LIVE: wire_caps wear_tuning supported")
+                // Nothing to push: wear reporting starts off on the glasses
+                // and stays off until the tuning screen asks for it. One read
+                // per link: the flag is cleared on every wire epoch, but the
+                // glasses only forget tuning on BLE disconnect.
+                if !wearTuningQueriedThisLink {
+                    wearTuningQueriedThisLink = true
+                    requestWearTuning()
+                }
+            }
+        }
+        if caps.keys.contains("mic_tuning"), !peerMicTuning {
+            let supported = (caps["mic_tuning"] as? Bool) == true
+                || ((caps["mic_tuning"] as? NSNumber)?.intValue ?? 0) != 0
+            if supported {
+                peerMicTuning = true
+                // Caps can land after the on-connect batch already ran, which
+                // would have skipped the tuning send.
+                Bridge.log("LIVE: wire_caps mic_tuning supported")
+                sendMicTuningSetting()
+            }
+        }
     }
 
     private func advertiseFilePayloadCapabilityToBes() {
@@ -6786,6 +6873,165 @@ extension MentraLive {
 
         // Send glasses-side loudness / Barrier gate setting.
         sendLoudnessGateSetting()
+
+        // Send mic tuning. With nothing authorized this sends a reset, which is
+        // what returns a freshly connected pair of glasses to stock behaviour.
+        sendMicTuningSetting()
+    }
+
+    /// Mic tuning field names, matching the BES cs_mictun body.
+    private static let micTuningFields = [
+        "gain", "open", "close", "attack", "hang", "sp_open", "sp_close", "sp_hold",
+    ]
+
+    /// Push the effective mic tuning to the glasses.
+    ///
+    /// The store holds only what the engine has authorized for this process; a
+    /// missing value means "no tuning", which is sent as an explicit reset
+    /// rather than silently skipped. That is what keeps a persisted super-mode
+    /// value from surviving into a session where super mode is off.
+    func sendMicTuningSetting() {
+        guard connectedPeripheral != nil, txCharacteristic != nil else {
+            Bridge.log("LIVE: Cannot send mic tuning - BLE write path not ready")
+            return
+        }
+        if !peerMicTuning {
+            Bridge.log("LIVE: mic_tuning cap not advertised; sending cs_mictun anyway")
+        }
+
+        var body: [String: Any] = [:]
+        if let fields = DeviceStore.shared.get("bluetooth", "mic_tuning") as? [String: Any] {
+            for name in Self.micTuningFields {
+                if let number = fields[name] as? NSNumber {
+                    body[name] = number.intValue
+                }
+            }
+        }
+        if body.isEmpty {
+            body["reset"] = 1
+        }
+
+        // Key order is fixed so equal bodies serialize identically.
+        let serialized = body.keys.sorted().map { "\($0)=\(body[$0]!)" }.joined(separator: ",")
+        if serialized == lastSentMicTuningBody {
+            Bridge.log("LIVE: 🎚️ Mic tuning unchanged this link, not resending: \(serialized)")
+            return
+        }
+
+        Bridge.log("LIVE: 🎚️ Sending mic tuning to glasses: \(body)")
+        sendMicTuningCommand("cs_mictun", body: body)
+        lastSentMicTuningBody = serialized
+    }
+
+    /// Ask the glasses what tuning they are actually running (sr_micst).
+    func requestMicTuningState() {
+        guard connectedPeripheral != nil, txCharacteristic != nil else {
+            Bridge.log("LIVE: Cannot send cs_micst - BLE write path not ready")
+            return
+        }
+        if !peerMicTuning {
+            Bridge.log("LIVE: mic_tuning cap not advertised; sending cs_micst anyway")
+        }
+        sendMicTuningCommand("cs_micst", body: [:])
+    }
+
+    /// Enable or disable the sr_micrms readout.
+    func setMicRmsTelemetry(_ enabled: Bool) {
+        guard connectedPeripheral != nil, txCharacteristic != nil, peerMicTuning else { return }
+        sendMicTuningCommand("cs_micrms", body: ["on": enabled ? 1 : 0])
+    }
+
+    /// Read the current wear state (sr_wrst). Always available.
+    @objc func queryWearState() {
+        sendWearCommandIfReady("cs_wrst", body: [:])
+    }
+
+    /// Turn wear reporting on or off for this session.
+    ///
+    /// Deliberately not the NV-backed cs_swit type 1: the glasses must forget
+    /// this on disconnect, and any later switch write would re-persist a wear
+    /// bit that had been enabled once.
+    @objc func setWearReporting(_ enabled: Bool) {
+        sendWearCommandIfReady("cs_weartun", body: ["enabled": enabled ? 1 : 0])
+    }
+
+    /// Move the debounce vote. Negative means "leave this one alone".
+    @objc func setWearTuning(intervalMs: Int, count: Int, majority: Int) {
+        var body: [String: Any] = [:]
+        if intervalMs >= 0 { body["interval"] = intervalMs }
+        if count >= 0 { body["count"] = count }
+        if majority >= 0 { body["majority"] = majority }
+        guard !body.isEmpty else { return }
+        sendWearCommandIfReady("cs_weartun", body: body)
+    }
+
+    /// Ask what the poll loop is actually running (sr_weartun).
+    @objc func requestWearTuning() {
+        sendWearCommandIfReady("cs_wearst", body: [:])
+    }
+
+    /// Restore firmware defaults and disable reporting. Distinct from sending
+    /// the default vote values, which would leave reporting on.
+    @objc func resetWearTuning() {
+        sendWearCommandIfReady("cs_weartun", body: ["reset": 1])
+    }
+
+    private func sendWearCommandIfReady(_ name: String, body: [String: Any]) {
+        guard connectedPeripheral != nil, txCharacteristic != nil else {
+            Bridge.log("LIVE: Cannot send \(name) - BLE write path not ready")
+            return
+        }
+        if !peerWearTuning && name != "cs_wrst" {
+            Bridge.log("LIVE: wear_tuning cap not advertised; sending \(name) anyway")
+        }
+        sendMicTuningCommand(name, body: body)
+    }
+
+    private func sendMicTuningCommand(_ name: String, body: [String: Any]) {
+        do {
+            let bodyData = try JSONSerialization.data(withJSONObject: body)
+            guard let bodyString = String(data: bodyData, encoding: .utf8) else {
+                Bridge.log("LIVE: Failed to encode \(name) payload")
+                return
+            }
+            let command: [String: Any] = ["C": name, "V": 1, "B": bodyString]
+            if !sendRawK900Command(command, wakeUp: true) {
+                Bridge.log("LIVE: Failed to send \(name)")
+            }
+        } catch {
+            Bridge.log("LIVE: Error encoding \(name) payload: \(error)")
+        }
+    }
+
+    /// Post-clamp tuning the glasses report as in force. Forwarded verbatim so
+    /// the screen can show the applied value next to the requested one.
+    private func handleMicTuningState(_ body: [String: Any]) {
+        var state: [String: Any] = [:]
+        for name in Self.micTuningFields {
+            if let number = body[name] as? NSNumber {
+                state[name] = number.intValue
+            }
+        }
+        let generation = (body["gen"] as? NSNumber)?.intValue ?? 0
+        state["generation"] = generation
+        state["overridden"] = ((body["ovr"] as? NSNumber)?.intValue ?? 0) != 0
+        micTuningGeneration = generation
+        Bridge.sendMicTuningState(state)
+    }
+
+    /// What the wear poll loop is actually running. A rejected patch comes back
+    /// with the unchanged values and a non-zero result code, so the screen can
+    /// show that the request did not take.
+    private func handleWearTuningState(_ json: [String: Any], _ body: [String: Any]) {
+        let state: [String: Any] = [
+            "enabled": (k900JsonInt(body, "enabled") ?? 0) != 0,
+            "interval": k900JsonInt(body, "interval") ?? 0,
+            "count": k900JsonInt(body, "count") ?? 0,
+            "majority": k900JsonInt(body, "majority") ?? 0,
+            "generation": k900JsonInt(body, "gen") ?? 0,
+            "accepted": (k900JsonInt(json, "S") ?? 0) == 0,
+        ]
+        Bridge.sendWearTuningState(state)
     }
 
     func sendVoiceActivityDetectionSetting() {

package/ios/Source/sgcs/SGCManager.swift

@@ -228,6 +228,24 @@ protocol SGCManager {
 
     func sendLoudnessGateSetting()
 
+    // MARK: - Mic tuning (super-mode only)
+
+    func sendMicTuningSetting()
+    func requestMicTuningState()
+    func setMicRmsTelemetry(_ enabled: Bool)
+
+    // MARK: - Wear detection (super-mode only)
+
+    // These are protocol requirements, not extension-only members, on purpose:
+    // DeviceManager holds an `SGCManager?`, and a method that exists only in
+    // the extension is statically dispatched through that reference, so the
+    // no-op below would win over MentraLive's implementation.
+    func queryWearState()
+    func setWearReporting(_ enabled: Bool)
+    func setWearTuning(intervalMs: Int, count: Int, majority: Int)
+    func requestWearTuning()
+    func resetWearTuning()
+
     // MARK: - Version Info
 
     func requestVersionInfo()
@@ -417,6 +435,20 @@ extension SGCManager {
 
     func sendLoudnessGateSetting() {}
 
+    // MARK: - Mic tuning (default no-op — Mentra Live supports this)
+
+    func sendMicTuningSetting() {}
+    func requestMicTuningState() {}
+    func setMicRmsTelemetry(_: Bool) {}
+
+    // MARK: - Wear detection (default no-op — Mentra Live supports this)
+
+    func queryWearState() {}
+    func setWearReporting(_: Bool) {}
+    func setWearTuning(intervalMs _: Int, count _: Int, majority _: Int) {}
+    func requestWearTuning() {}
+    func resetWearTuning() {}
+
     /// Default no-op; Mentra Live and G2 override to handle phone-detected clock skew.
     func sendSetSystemTime(_: Int64) {
         Bridge.log("SGC: sendSetSystemTime not supported")