Fix iOS push alerts opt-out toggle

Packages/iOS/CmuxMobileShellUI/Sources/CmuxMobileShellUI/Debug/MobilePushReadinessPreviewView.swift

@@ -12,6 +12,7 @@ import SwiftUI
 struct MobilePushReadinessPreviewView: View {
     private let fixture: Fixture
     private let rejectsMacMutations: Bool
+    private let delaysPhoneMutation: Bool
 
     @State private var phoneEnabled: Bool
     @State private var authorization: MobilePushAuthorization
@@ -22,6 +23,7 @@ struct MobilePushReadinessPreviewView: View {
         let fixture = Fixture(rawValue: state) ?? .healthy
         self.fixture = fixture
         self.rejectsMacMutations = environment["CMUX_UITEST_PUSH_MUTATION_FAILURE"] == "1"
+        self.delaysPhoneMutation = environment["CMUX_UITEST_PUSH_PHONE_MUTATION_DELAY"] == "1"
         self._phoneEnabled = State(initialValue: fixture.registration.isEnabled)
         self._authorization = State(initialValue: fixture.authorization)
         self._registration = State(initialValue: fixture.registration)
@@ -69,6 +71,9 @@ struct MobilePushReadinessPreviewView: View {
 
     @MainActor
     private func setPhoneEnabled(_ enabled: Bool) async -> Bool {
+        if delaysPhoneMutation {
+            try? await Task.sleep(for: .milliseconds(500))
+        }
         phoneEnabled = enabled
         registration = enabled
             ? Self.registered

Packages/iOS/CmuxMobileShellUI/Sources/CmuxMobileShellUI/MobilePushSettingsContent.swift

@@ -75,15 +75,11 @@ struct MobilePushSettingsContent: View {
         Group {
             statusRow
 
-            Toggle(
-                L10n.string(
-                    "mobile.notifications.phoneEnabled",
-                    defaultValue: "Allow Push Alerts on This iPhone"
-                ),
-                isOn: phoneEnabledBinding
+            MobilePushToggle(
+                isEnabled: $phoneEnabled,
+                isUpdating: $isMutatingPhone,
+                onChange: onPhoneEnabledChange
             )
-            .accessibilityIdentifier("MobileSettingsNotifications")
-            .disabled(isMutatingPhone)
 
             if let repair = readiness.repair,
                Self.shouldPresentRepair(repair, canConnectMac: canConnectMac),
@@ -248,25 +244,6 @@ struct MobilePushSettingsContent: View {
         .accessibilityIdentifier("MobileSettingsPushReadinessStatus")
     }
 
-    private var phoneEnabledBinding: Binding<Bool> {
-        Binding(
-            get: { phoneEnabled },
-            set: { requested in
-                guard !isMutatingPhone else { return }
-                let confirmed = phoneEnabled
-                phoneEnabled = requested
-                isMutatingPhone = true
-                Task {
-                    let succeeded = await onPhoneEnabledChange(requested)
-                    if !succeeded {
-                        phoneEnabled = confirmed
-                    }
-                    isMutatingPhone = false
-                }
-            }
-        )
-    }
-
     private var macForwardingBinding: Binding<Bool> {
         Binding(
             get: { macForwardingEnabled },

Packages/iOS/CmuxMobileShellUI/Sources/CmuxMobileShellUI/MobilePushToggle.swift

@@ -0,0 +1,44 @@
+#if os(iOS)
+import CmuxMobileSupport
+import SwiftUI
+
+/// The phone push preference is persisted asynchronously, so update the
+/// control optimistically and roll it back only when the mutation fails.
+/// Keeping this binding shared prevents release and diagnostic settings from
+/// drifting into different interaction behavior.
+struct MobilePushToggle: View {
+    @Binding var isEnabled: Bool
+    @Binding var isUpdating: Bool
+    let onChange: @MainActor (Bool) async -> Bool
+
+    var body: some View {
+        Toggle(
+            L10n.string(
+                "mobile.notifications.phoneEnabled",
+                defaultValue: "Allow Push Alerts on This iPhone"
+            ),
+            isOn: binding
+        )
+        .accessibilityIdentifier("MobileSettingsNotifications")
+        .disabled(isUpdating)
+    }
+
+    private var binding: Binding<Bool> {
+        Binding(
+            get: { isEnabled },
+            set: { requested in
+                guard !isUpdating else { return }
+                let previous = isEnabled
+                isEnabled = requested
+                isUpdating = true
+                Task { @MainActor in
+                    defer { isUpdating = false }
+                    if !(await onChange(requested)) {
+                        isEnabled = previous
+                    }
+                }
+            }
+        )
+    }
+}
+#endif

Packages/iOS/CmuxMobileShellUI/Sources/CmuxMobileShellUI/MobileSettingsView.swift

@@ -46,6 +46,7 @@ struct MobileSettingsView: View {
     /// `isEnabled` as a non-observable `UserDefaults` read, so reading it
     /// directly in `body` would not re-render when it flips.
     @State private var notificationsEnabled = false
+    @State private var notificationsToggleUpdating = false
 #if DEBUG
     @State private var debugReplyScheduled: Bool?
 #endif
@@ -428,21 +429,11 @@ struct MobileSettingsView: View {
                         .foregroundStyle(.secondary)
                     }
 #else
-                    Toggle(
-                        L10n.string(
-                            "mobile.notifications.phoneEnabled",
-                            defaultValue: "Allow Push Alerts on This iPhone"
-                        ),
-                        isOn: Binding(
-                            get: { notificationsEnabled },
-                            set: { enabled in
-                                Task { @MainActor in
-                                    notificationsEnabled = await updatePhonePushEnabled(enabled)
-                                }
-                            }
-                        )
+                    MobilePushToggle(
+                        isEnabled: $notificationsEnabled,
+                        isUpdating: $notificationsToggleUpdating,
+                        onChange: updatePhonePushEnabled
                     )
-                    .accessibilityIdentifier("MobileSettingsNotifications")
 #endif
                 }
 

ios/cmuxUITests/PushReadinessUITests.swift

@@ -115,6 +115,30 @@ final class PushReadinessUITests: XCTestCase {
         waitForValue(forwarding, "0")
     }
 
+    @MainActor
+    func testPhonePushToggleTurnsOffWhileMutationIsPending() {
+        let app = launchPreview(
+            "healthy",
+            extraEnvironment: ["CMUX_UITEST_PUSH_PHONE_MUTATION_DELAY": "1"]
+        )
+        defer { app.terminate() }
+
+        let phone = app.switches["MobileSettingsNotifications"]
+        XCTAssertTrue(phone.waitForExistence(timeout: 8))
+        XCTAssertEqual(phone.value as? String, "1")
+
+        tapSwitch(phone)
+
+        XCTAssertEqual(
+            phone.value as? String,
+            "0",
+            "The toggle must reflect the requested opt-out before the async cleanup finishes"
+        )
+        XCTAssertFalse(phone.isEnabled)
+        waitForEnabled(phone)
+        XCTAssertEqual(phone.value as? String, "0")
+    }
+
     @MainActor
     func testFailedMacMutationRollsBackAndStaysVisible() {
         let app = launchPreview(