fix: read Focus state fresh for every fallback sound

Replace the stale cached Focus snapshot with a fresh assertion-store
read per play. The read still happens on the background utility queue
(no disk I/O on the @mainactor callers); playback hops back to the main
queue afterwards. An out-of-band sound a few milliseconds later is
imperceptible, but a stale snapshot is not: it let the first sound after
the user enables a Focus punch through, which is the canonical repro of
the bug this gate exists to fix.

This deletes the cache, its lock, and the in-flight flag outright -
notification sounds are cooldown-throttled, so per-play reads need no
caching layer.

This is the green half: the staleness tests from the previous commit now
pass.

Co-Authored-By: Claude Fable 5 <noreply@anthropic.com>

Author: austinywang

Sources/TerminalNotificationStore.swift

@@ -57,10 +57,6 @@ enum NotificationSoundSettings {
         label: "com.cmuxterm.notification-dnd-assertion",
         qos: .utility
     )
-    private static let dndSuppressionLock = NSLock()
-    // nil until the first background read completes. Fail-open treats nil as "not suppressed".
-    private static var cachedDndSuppression: Bool?
-    private static var dndRefreshInFlight = false
     private static let notificationSoundSupportedExtensions: Set<String> = [
         "aif",
         "aiff",
@@ -327,37 +323,17 @@ enum NotificationSoundSettings {
         }
     }
 
-    /// Cheap, main-actor-safe snapshot of the live Focus/DND state.
-    ///
-    /// Reads a process-local cached `Bool` (no disk I/O) and schedules a
-    /// background refresh for the next call. The first call returns `false`
-    /// (fail-open) and warms the cache off-main, so the `@MainActor` playback
-    /// path never reads `Assertions.json` synchronously. Slightly stale by
-    /// design, which is acceptable for an out-of-band fallback sound.
-    static func isActiveFocusSuppressionCached(
-        assertionsFileURL: URL = defaultAssertionsFileURL
-    ) -> Bool {
-        dndSuppressionLock.lock()
-        let snapshot = cachedDndSuppression ?? false
-        let needsRefresh = !dndRefreshInFlight
-        if needsRefresh { dndRefreshInFlight = true }
-        dndSuppressionLock.unlock()
-
-        if needsRefresh {
-            dndAssertionQueue.async {
-                let suppressed = isSuppressedByActiveFocus(assertionsFileURL: assertionsFileURL)
-                dndSuppressionLock.lock()
-                cachedDndSuppression = suppressed
-                dndRefreshInFlight = false
-                dndSuppressionLock.unlock()
-            }
-        }
-        return snapshot
-    }
-
     /// Plays the user-selected notification sound unless an active macOS
     /// Focus / Do Not Disturb mode should silence it.
     ///
+    /// The Focus check reads the assertion store, which is disk I/O, so it
+    /// runs on the background assertion queue and playback hops back to the
+    /// main queue. The state is read fresh for every play: a cached snapshot
+    /// would let the first sound after the user enables a Focus punch
+    /// through, which is the exact bug this gate exists to fix. Notification
+    /// sounds are low-frequency (cooldown-throttled), so one small file read
+    /// per play on a utility queue is cheap.
+    ///
     /// `completion` runs on the main queue with whether the sound was allowed
     /// to play. It exists so tests can observe the gate decision; production
     /// callers pass nothing.
@@ -366,14 +342,16 @@ enum NotificationSoundSettings {
         assertionsFileURL: URL = defaultAssertionsFileURL,
         completion: ((_ didPlay: Bool) -> Void)? = nil
     ) {
-        // Honor macOS Focus / Do Not Disturb for the out-of-band fallback sound.
-        if isActiveFocusSuppressionCached(assertionsFileURL: assertionsFileURL) {
-            completion?(false)
-            return
+        dndAssertionQueue.async {
+            let suppressed = isSuppressedByActiveFocus(assertionsFileURL: assertionsFileURL)
+            DispatchQueue.main.async {
+                if !suppressed {
+                    let value = defaults.string(forKey: key) ?? defaultValue
+                    playSound(value: value, defaults: defaults)
+                }
+                completion?(!suppressed)
+            }
         }
-        let value = defaults.string(forKey: key) ?? defaultValue
-        playSound(value: value, defaults: defaults)
-        completion?(true)
     }
 
     static func previewSound(value: String, defaults: UserDefaults = .standard) {