fix(profiles): prompt before applying display spacing

Clicking Apply on Displays > "Menu Bar Item Spacing" while a profile is active triggered a relaunch wave for menu bar apps, after which `DisplaySettingsManager.applyActiveDisplaySpacing` called `ProfileManager.reapplyActiveProfile()`. The reapplied profile's stored `displayConfigurations` still held the previous offset, so the just-applied spacing was silently reverted, then re-applied by a second relaunch wave once the value flipped back. Reported in #619.

The Apply and inline ↺ reset buttons now route through a single confirmation gate in `DisplaySettingsPane`. When the change targets the active menu bar display, the alert names the relaunch wave; when a profile is active, the alert lets the user pick `Update Active Profile` (saves into the active profile via `updateProfile(scope:.configurationOnly)`) or `Update All Profiles` (writes the spacing into every profile via the new `ProfileManager.updateAllProfilesItemSpacingOffset(displayUUID:offset:)` helper). The profile file(s) are written synchronously before the Combine sink dispatches `applyActiveDisplaySpacing`, so the subsequent `reapplyActiveProfile` loads the new spacing instead of the old one and the value sticks.

Cases without an active profile and a non-active display still apply immediately, preserving the prior fast path. Cancelling the alert snaps the slider back to the saved value. New strings are added to `Localizable.xcstrings` for Crowdin pickup.

`DisplaySettingsManager.loadInitialState` also now adopts externally configured system spacing on first launch. When no per-display configurations exist yet and the user has set `NSStatusItemSpacing` outside Thaw (e.g. via a `defaults write` in Terminal), the manager seeds each connected display's `itemSpacingOffset` from that on-disk value and persists the seed inline. Previously Thaw read its own default offset of 0, computed target = 16, and fired a relaunch wave on every startup that overwrote the user's manual setting. Addresses the recurring restart loops in #602 and #598.

Fixes #598, #602, #619

Signed-off-by: Amir Zarrinkafsh <3339418+nightah@users.noreply.github.com>

Author: nightah

Thaw/Resources/Localizable.xcstrings

@@ -43989,6 +43989,30 @@
           }
         }
       }
+    },
+    "Apply spacing change?" : {
+      "comment" : "Title of the alert shown before applying a menu bar item spacing change.",
+      "localizations" : {}
+    },
+    "Applying this spacing change will briefly relaunch all apps with menu bar items." : {
+      "comment" : "Alert message variant shown when applying a spacing change for the active menu bar display and no profile is active.",
+      "localizations" : {}
+    },
+    "Applying this spacing change will briefly relaunch all apps with menu bar items. Save the new spacing to the active profile \"%@\", or save it to every profile." : {
+      "comment" : "Alert message variant shown when applying a spacing change for the active menu bar display while a profile is active. %@ is the active profile name.",
+      "localizations" : {}
+    },
+    "Save the new spacing to the active profile \"%@\", or save it to every profile." : {
+      "comment" : "Alert message variant shown when applying a spacing change for a non-active display while a profile is active. %@ is the active profile name.",
+      "localizations" : {}
+    },
+    "Update Active Profile" : {
+      "comment" : "Button in the spacing-change confirmation alert that writes the new spacing into the active profile.",
+      "localizations" : {}
+    },
+    "Update All Profiles" : {
+      "comment" : "Button in the spacing-change confirmation alert that writes the new spacing into every profile.",
+      "localizations" : {}
     }
   },
   "version" : "1.1"

Thaw/Settings/Models/DisplaySettingsManager.swift

@@ -46,6 +46,15 @@ final class DisplaySettingsManager: ObservableObject {
     /// Internal access so unit tests in ThawTests can seed and assert it.
     var lastAppliedActiveDisplayUUID: String?
 
+    /// UUID of the display that currently owns the menu bar, or nil if it
+    /// cannot be determined. Exposed for views that need to decide whether
+    /// a spacing change will trigger the relaunch wave (only writes against
+    /// the active display do, because applyActiveDisplaySpacing only reads
+    /// configurationForActiveDisplay()).
+    var activeMenuBarDisplayUUID: String? {
+        Bridging.getActiveMenuBarDisplayUUID()
+    }
+
     /// Performs the initial setup of the manager.
     func performSetup(with appState: AppState) {
         self.appState = appState
@@ -84,7 +93,17 @@ final class DisplaySettingsManager: ObservableObject {
 
     // MARK: - Loading
 
-    /// Loads saved configurations from Defaults.
+    /// Default baseline for NSStatusItemSpacing and NSStatusItemSelectionPadding,
+    /// kept in sync with MenuBarItemSpacingManager.Key.defaultValue. Used to
+    /// translate on-disk system spacing into Thaw's relative offset model.
+    private static let systemSpacingDefault = 16
+
+    /// Loads saved configurations from Defaults. On a truly first launch
+    /// (no persisted per-display configurations) with externally configured
+    /// system spacing, adopts the on-disk value as the seed offset for each
+    /// connected display so Thaw does not overwrite a user's manual
+    /// defaults write NSStatusItemSpacing and trigger a startup relaunch
+    /// wave. See issue #602.
     private func loadInitialState() {
         if let data = Defaults.data(forKey: .displayIceBarConfigurations) {
             do {
@@ -94,6 +113,9 @@ final class DisplaySettingsManager: ObservableObject {
                 diagLog.error("Failed to decode per-display configurations: \(error)")
             }
         }
+        if configurations.isEmpty {
+            seedConfigurationsFromSystemSpacing()
+        }
         if let data = Defaults.data(forKey: .knownDisplays) {
             do {
                 let decoded = try decoder.decode([String: KnownDisplay].self, from: data)
@@ -115,6 +137,62 @@ final class DisplaySettingsManager: ObservableObject {
         }
     }
 
+    /// Reads the current system value for NSStatusItemSpacing from the byHost
+    /// global domain. Returns nil when the key is unset, letting callers
+    /// distinguish "user has explicitly configured spacing" from "macOS
+    /// default applies".
+    private static func currentSystemSpacing() -> Int? {
+        CFPreferencesCopyValue(
+            "NSStatusItemSpacing" as CFString,
+            kCFPreferencesAnyApplication,
+            kCFPreferencesCurrentUser,
+            kCFPreferencesCurrentHost
+        ) as? Int
+    }
+
+    /// When the user has manually set NSStatusItemSpacing outside of Thaw
+    /// (e.g. via a defaults write in Terminal), seed an entry for each
+    /// connected display whose itemSpacingOffset corresponds to that on-disk
+    /// value. Without this, applyActiveDisplaySpacing on first launch reads
+    /// the default offset of 0, computes target = 16, sees on-disk = N, and
+    /// fires a relaunch wave that rewrites the user's manual setting back to
+    /// 16. The seeded entries are written to Defaults inline because the
+    /// persistence sink is not yet wired at loadInitialState time; without
+    /// the explicit save, subsequent launches would re-seed on every start
+    /// instead of remembering the adopted value. The padding key is not
+    /// consulted because Thaw drives both keys from a single offset; users
+    /// whose padding diverges from spacing will see one normalising relaunch
+    /// on first launch but no recurring waves thereafter.
+    private func seedConfigurationsFromSystemSpacing() {
+        guard let onDisk = Self.currentSystemSpacing(),
+              onDisk != Self.systemSpacingDefault
+        else {
+            return
+        }
+        let offset = Double(onDisk - Self.systemSpacingDefault)
+        var seeded = configurations
+        for screen in NSScreen.screens {
+            guard let uuid = Bridging.getDisplayUUIDString(for: screen.displayID) else {
+                continue
+            }
+            if seeded[uuid] != nil { continue }
+            seeded[uuid] = DisplayIceBarConfiguration
+                .defaultConfiguration
+                .withItemSpacingOffset(offset)
+        }
+        guard seeded != configurations else { return }
+        configurations = seeded
+        do {
+            let data = try encoder.encode(seeded)
+            Defaults.set(data, forKey: .displayIceBarConfigurations)
+            diagLog.info(
+                "Seeded itemSpacingOffset=\(offset) from external NSStatusItemSpacing=\(onDisk) for \(seeded.count) display(s)"
+            )
+        } catch {
+            diagLog.error("Failed to persist seeded per-display configurations: \(error)")
+        }
+    }
+
     // MARK: - Persistence
 
     /// Configures Combine sinks to persist configurations on change.

Thaw/Settings/Models/ProfileManager.swift

@@ -667,6 +667,23 @@ final class ProfileManager: ObservableObject {
         try saveProfileAndUpdateManifest(profile)
     }
 
+    /// Writes the given itemSpacingOffset into every profile's stored
+    /// displayConfigurations entry for the specified display UUID. Creates
+    /// a default entry when a profile has no prior configuration for that
+    /// display. Used by the spacing-apply confirmation in DisplaySettingsPane
+    /// so a freshly applied spacing change is not reverted by the next
+    /// profile reapply.
+    func updateAllProfilesItemSpacingOffset(displayUUID: String, offset: Double) throws {
+        let now = Date()
+        for meta in profiles {
+            var profile = try loadProfile(id: meta.id)
+            let base = profile.displayConfigurations[displayUUID] ?? .defaultConfiguration
+            profile.displayConfigurations[displayUUID] = base.withItemSpacingOffset(offset)
+            profile.modifiedAt = now
+            try saveProfileAndUpdateManifest(profile)
+        }
+    }
+
     // MARK: - Profile Hooks
 
     /// Returns the automation config (pre/post hooks) attached to the

Thaw/Settings/SettingsPanes/DisplaySettingsPane.swift

@@ -9,14 +9,31 @@
 import SwiftUI
 
 struct DisplaySettingsPane: View {
+    @EnvironmentObject var appState: AppState
     @ObservedObject var displaySettings: DisplaySettingsManager
 
     @State private var maxSliderLabelWidth: CGFloat = 0
     /// Per-display draft of the spacing slider, keyed by display UUID.
     /// Until the user clicks Apply, dragging the slider only updates this
-    /// dictionary — it does not touch the saved configuration or trigger
+    /// dictionary, it does not touch the saved configuration or trigger
     /// any relaunches.
     @State private var draftSpacing: [String: CGFloat] = [:]
+    /// Pending spacing apply held while the confirmation alert is shown.
+    /// Set by requestSpacingApply when a prompt is required; the alert binds
+    /// to its non-nil state. Nil when no alert is showing.
+    @State private var pendingSpacingApply: PendingSpacingApply?
+    @State private var errorMessage: String?
+    @State private var showingError = false
+
+    /// A spacing apply request awaiting user confirmation.
+    private struct PendingSpacingApply: Equatable {
+        let displayID: String
+        let displayName: String
+        let offset: Double
+        let isActiveDisplay: Bool
+        let activeProfileID: UUID?
+        let activeProfileName: String?
+    }
 
     var body: some View {
         IceForm {
@@ -26,6 +43,21 @@ struct DisplaySettingsPane: View {
                 }
             }
         }
+        .alert(
+            String(localized: "Apply spacing change?"),
+            isPresented: Binding(
+                get: { pendingSpacingApply != nil },
+                set: { if !$0 { pendingSpacingApply = nil } }
+            ),
+            presenting: pendingSpacingApply,
+            actions: { pending in spacingConfirmationButtons(for: pending) },
+            message: { pending in Text(spacingConfirmationMessage(for: pending)) }
+        )
+        .alert("Error", isPresented: $showingError) {
+            Button("OK") { errorMessage = nil }
+        } message: {
+            if let errorMessage { Text(errorMessage) }
+        }
     }
 
     @ViewBuilder
@@ -204,18 +236,13 @@ struct DisplaySettingsPane: View {
         } label: {
             LabeledContent {
                 Button("Apply") {
-                    displaySettings.updateConfiguration(forDisplayUUID: display.id) { config in
-                        config.withItemSpacingOffset(Double(draft))
-                    }
+                    requestSpacingApply(for: display, offset: Double(draft))
                 }
                 .help(Text("Apply the spacing for this display"))
                 .disabled(!canApply)
 
                 Button {
-                    draftSpacing[display.id] = 0
-                    displaySettings.updateConfiguration(forDisplayUUID: display.id) { config in
-                        config.withItemSpacingOffset(0)
-                    }
+                    requestSpacingApply(for: display, offset: 0)
                 } label: {
                     Image(systemName: "arrow.counterclockwise.circle.fill")
                 }
@@ -235,4 +262,124 @@ struct DisplaySettingsPane: View {
             draftSpacing[display.id] = CGFloat(newValue)
         }
     }
+
+    // MARK: - Spacing Apply Confirmation
+
+    /// Routes both the Apply button and the inline reset button through a
+    /// single decision point. When no profile is active and the change is
+    /// for a non-active display, applies immediately (matches prior
+    /// behaviour). Otherwise stages a PendingSpacingApply so the .alert
+    /// can ask the user to choose between updating the active profile,
+    /// updating every profile, or cancelling.
+    private func requestSpacingApply(
+        for display: DisplaySettingsManager.DisplayInfo,
+        offset: Double
+    ) {
+        let activeID = appState.profileManager.activeProfileID
+        let isActiveDisplay = displaySettings.activeMenuBarDisplayUUID == display.id
+
+        if activeID == nil, !isActiveDisplay {
+            commitSpacing(displayID: display.id, offset: offset)
+            return
+        }
+
+        let activeName = activeID.flatMap { id in
+            appState.profileManager.profiles.first(where: { $0.id == id })?.name
+        }
+        pendingSpacingApply = PendingSpacingApply(
+            displayID: display.id,
+            displayName: display.name,
+            offset: offset,
+            isActiveDisplay: isActiveDisplay,
+            activeProfileID: activeID,
+            activeProfileName: activeName
+        )
+    }
+
+    /// Writes the new spacing to displaySettings.configurations. The
+    /// Combine sink in DisplaySettingsManager picks this up and drives the
+    /// relaunch wave on the next main-queue dispatch, so the caller is
+    /// expected to have already written the profile file when persisting
+    /// to a profile is desired.
+    private func commitSpacing(displayID: String, offset: Double) {
+        draftSpacing[displayID] = CGFloat(offset)
+        displaySettings.updateConfiguration(forDisplayUUID: displayID) { config in
+            config.withItemSpacingOffset(offset)
+        }
+    }
+
+    @ViewBuilder
+    private func spacingConfirmationButtons(for pending: PendingSpacingApply) -> some View {
+        if pending.activeProfileID != nil {
+            Button(String(localized: "Update Active Profile"), role: .destructive) {
+                if let id = pending.activeProfileID {
+                    // Save to the profile FIRST so the spacing value is on disk
+                    // before the Combine sink dispatches applyActiveDisplaySpacing,
+                    // which would otherwise trigger reapplyActiveProfile and
+                    // overwrite the new spacing with the profile's old value.
+                    // updateProfile(scope:.configurationOnly) captures live state,
+                    // so we update the in-memory configuration first, then save.
+                    commitSpacing(displayID: pending.displayID, offset: pending.offset)
+                    do {
+                        try appState.profileManager.updateProfile(
+                            id: id,
+                            scope: .configurationOnly,
+                            appState: appState
+                        )
+                    } catch {
+                        errorMessage = error.localizedDescription
+                        showingError = true
+                    }
+                } else {
+                    commitSpacing(displayID: pending.displayID, offset: pending.offset)
+                }
+            }
+            Button(String(localized: "Update All Profiles"), role: .destructive) {
+                commitSpacing(displayID: pending.displayID, offset: pending.offset)
+                do {
+                    try appState.profileManager.updateAllProfilesItemSpacingOffset(
+                        displayUUID: pending.displayID,
+                        offset: pending.offset
+                    )
+                } catch {
+                    errorMessage = error.localizedDescription
+                    showingError = true
+                }
+            }
+            Button(String(localized: "Cancel"), role: .cancel) {
+                draftSpacing[pending.displayID] = CGFloat(
+                    displaySettings.configuration(forUUID: pending.displayID).itemSpacingOffset
+                )
+            }
+        } else {
+            Button(String(localized: "Apply"), role: .destructive) {
+                commitSpacing(displayID: pending.displayID, offset: pending.offset)
+            }
+            Button(String(localized: "Cancel"), role: .cancel) {
+                draftSpacing[pending.displayID] = CGFloat(
+                    displaySettings.configuration(forUUID: pending.displayID).itemSpacingOffset
+                )
+            }
+        }
+    }
+
+    private func spacingConfirmationMessage(for pending: PendingSpacingApply) -> String {
+        let profileName = pending.activeProfileName ?? ""
+        switch (pending.isActiveDisplay, pending.activeProfileID != nil) {
+        case (true, true):
+            return String(
+                format: String(localized: "Applying this spacing change will briefly relaunch all apps with menu bar items. Save the new spacing to the active profile \"%@\", or save it to every profile."),
+                profileName
+            )
+        case (false, true):
+            return String(
+                format: String(localized: "Save the new spacing to the active profile \"%@\", or save it to every profile."),
+                profileName
+            )
+        case (true, false):
+            return String(localized: "Applying this spacing change will briefly relaunch all apps with menu bar items.")
+        case (false, false):
+            return ""
+        }
+    }
 }