test: cover the Focus-gate staleness on the playback path

The Focus/DND gate added for #5650 reads a cached snapshot that only
refreshes after deciding, so the first sound after the user enables a
Focus still punches through — the canonical repro for the bug the gate
exists to fix (and the first play after a Focus ends stays wrongly
silent for one notification).

Drive the real playback entry point in tests: playSelectedSound gains an
injectable assertion-store URL and a main-queue completion reporting
whether the sound was allowed to play (production callers pass nothing).
The gate still consults the stale cache here, so the two first-play
assertions fail.

Per the repo's two-commit regression policy: this commit is the red half.

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

Author: austinywang

Sources/TerminalNotificationStore.swift

@@ -334,7 +334,9 @@ enum NotificationSoundSettings {
     /// (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() -> Bool {
+    static func isActiveFocusSuppressionCached(
+        assertionsFileURL: URL = defaultAssertionsFileURL
+    ) -> Bool {
         dndSuppressionLock.lock()
         let snapshot = cachedDndSuppression ?? false
         let needsRefresh = !dndRefreshInFlight
@@ -343,7 +345,7 @@ enum NotificationSoundSettings {
 
         if needsRefresh {
             dndAssertionQueue.async {
-                let suppressed = isSuppressedByActiveFocus()
+                let suppressed = isSuppressedByActiveFocus(assertionsFileURL: assertionsFileURL)
                 dndSuppressionLock.lock()
                 cachedDndSuppression = suppressed
                 dndRefreshInFlight = false
@@ -353,11 +355,25 @@ enum NotificationSoundSettings {
         return snapshot
     }
 
-    static func playSelectedSound(defaults: UserDefaults = .standard) {
+    /// Plays the user-selected notification sound unless an active macOS
+    /// Focus / Do Not Disturb mode should silence it.
+    ///
+    /// `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.
+    static func playSelectedSound(
+        defaults: UserDefaults = .standard,
+        assertionsFileURL: URL = defaultAssertionsFileURL,
+        completion: ((_ didPlay: Bool) -> Void)? = nil
+    ) {
         // Honor macOS Focus / Do Not Disturb for the out-of-band fallback sound.
-        if isActiveFocusSuppressionCached() { return }
+        if isActiveFocusSuppressionCached(assertionsFileURL: assertionsFileURL) {
+            completion?(false)
+            return
+        }
         let value = defaults.string(forKey: key) ?? defaultValue
         playSound(value: value, defaults: defaults)
+        completion?(true)
     }
 
     static func previewSound(value: String, defaults: UserDefaults = .standard) {

cmuxTests/NotificationSoundSettingsTests.swift

@@ -69,4 +69,81 @@ import Testing
             .appendingPathComponent("Assertions.json", isDirectory: false)
         #expect(!NotificationSoundSettings.isSuppressedByActiveFocus(assertionsFileURL: missing))
     }
+
+    // The canonical repro for the Focus bug is: the user enables a Focus, and
+    // the next notification must already be silent. A cached Focus snapshot
+    // that refreshes only after deciding lets exactly that first sound punch
+    // through, so these tests drive the real playback entry point and assert
+    // on the per-play decision, not on the pure predicate.
+
+    @Test func firstPlayAfterFocusActivationIsSuppressed() async throws {
+        let fixture = try ActiveFocusFixture()
+        defer { fixture.cleanUp() }
+
+        try fixture.writeAssertions(#"{"data":[{"storeAssertionRecords":[{"a":1}]}]}"#)
+        #expect(await fixture.playOutcome() == false)
+    }
+
+    @Test func firstPlayAfterFocusEndsIsAudible() async throws {
+        let fixture = try ActiveFocusFixture()
+        defer { fixture.cleanUp() }
+
+        try fixture.writeAssertions(#"{"data":[{"storeAssertionRecords":[{"a":1}]}]}"#)
+        #expect(await fixture.playOutcome() == false)
+
+        // The Focus ended: the very next play must be audible again.
+        try fixture.writeAssertions(#"{"data":[{"storeAssertionRecords":[]}]}"#)
+        #expect(await fixture.playOutcome() == true)
+    }
+
+    @Test func playbackFailsOpenWhenAssertionStoreIsMissing() async throws {
+        let fixture = try ActiveFocusFixture(createAssertionsFile: false)
+        defer { fixture.cleanUp() }
+
+        #expect(await fixture.playOutcome() == true)
+    }
+}
+
+/// Drives `playSelectedSound` against a scratch assertion store and scratch
+/// defaults whose selected sound is "none", so the decision is observable
+/// without audible output.
+private struct ActiveFocusFixture {
+    let directory: URL
+    let assertionsFileURL: URL
+    let defaults: UserDefaults
+    private let suiteName: String
+
+    init(createAssertionsFile: Bool = true) throws {
+        let fileManager = FileManager.default
+        directory = fileManager.temporaryDirectory
+            .appendingPathComponent("cmux-dnd-play-\(UUID().uuidString)", isDirectory: true)
+        try fileManager.createDirectory(at: directory, withIntermediateDirectories: true)
+        assertionsFileURL = directory.appendingPathComponent("Assertions.json", isDirectory: false)
+        if createAssertionsFile {
+            try Data(#"{"data":[]}"#.utf8).write(to: assertionsFileURL)
+        }
+        suiteName = "cmux-tests-notification-sound-\(UUID().uuidString)"
+        defaults = try #require(UserDefaults(suiteName: suiteName))
+        defaults.set("none", forKey: NotificationSoundSettings.key)
+    }
+
+    func writeAssertions(_ json: String) throws {
+        try Data(json.utf8).write(to: assertionsFileURL)
+    }
+
+    func playOutcome() async -> Bool {
+        await withCheckedContinuation { continuation in
+            NotificationSoundSettings.playSelectedSound(
+                defaults: defaults,
+                assertionsFileURL: assertionsFileURL
+            ) { didPlay in
+                continuation.resume(returning: didPlay)
+            }
+        }
+    }
+
+    func cleanUp() {
+        defaults.removePersistentDomain(forName: suiteName)
+        try? FileManager.default.removeItem(at: directory)
+    }
 }