fix: retain NotificationService in SwiftUI view body

NotificationService was stored as @State in KasetApp but never
referenced in the view body. After the WindowGroup → Window change
in v0.7.0 (#97), SwiftUI stopped retaining the unused @State,
causing the observation task to be cancelled on dealloc.

Fix: reference notificationService in the body so SwiftUI tracks it.
Add NotificationServiceTests with 8 tests for observation lifecycle,
track change detection, and deduplication.

Author: sozercan

App/KasetApp.swift

@@ -98,6 +98,9 @@ struct KasetApp: App {
 
     var body: some Scene {
         Window("Kaset", id: "main") {
+            // Keep NotificationService alive by referencing it in the view body
+            let _ = self.notificationService
+
             // Skip UI during unit tests to prevent window spam
             if UITestConfig.isRunningUnitTests, !UITestConfig.isUITestMode {
                 Color.clear

Core/Services/Notification/NotificationService.swift

@@ -12,7 +12,9 @@ final class NotificationService {
     /// nonisolated(unsafe) required for deinit access; Swift 6.2 warning is expected.
     nonisolated(unsafe) private var observationTask: Task<Void, Never>?
     // swiftformat:enable modifierOrder
-    private var lastNotifiedTrackId: String?
+    /// Tracks the last notified track to prevent duplicate notifications.
+    /// Internal for testing.
+    private(set) var lastNotifiedTrackId: String?
 
     init(playerService: PlayerService, settingsManager: SettingsManager = .shared) {
         self.playerService = playerService
@@ -93,6 +95,14 @@ final class NotificationService {
         }
     }
 
+    /// Whether the observation loop is actively running.
+    var isObserving: Bool {
+        if let task = self.observationTask {
+            return !task.isCancelled
+        }
+        return false
+    }
+
     func stopObserving() {
         self.observationTask?.cancel()
         self.observationTask = nil

Tests/KasetTests/NotificationServiceTests.swift

@@ -0,0 +1,109 @@
+import Foundation
+import Testing
+@testable import Kaset
+
+/// Tests for NotificationService track-change observation.
+@Suite("NotificationService", .serialized, .tags(.service))
+@MainActor
+struct NotificationServiceTests {
+    var playerService: PlayerService
+    var notificationService: NotificationService
+
+    init() {
+        self.playerService = PlayerService()
+        self.notificationService = NotificationService(playerService: self.playerService)
+    }
+
+    // MARK: - Observation Lifecycle
+
+    @Test("observation task is active after init")
+    func observationActiveAfterInit() {
+        #expect(self.notificationService.isObserving)
+    }
+
+    @Test("stopObserving cancels observation task")
+    func stopObservingCancelsTask() {
+        self.notificationService.stopObserving()
+        #expect(!self.notificationService.isObserving)
+    }
+
+    // MARK: - Track Change Detection
+
+    @Test("detects track change and updates lastNotifiedTrackId")
+    func detectsTrackChange() async {
+        self.playerService.currentTrack = TestFixtures.makeSong(id: "song-1", title: "First Song")
+
+        // Wait for polling cycle (500ms) + margin
+        try? await Task.sleep(for: .milliseconds(700))
+
+        #expect(self.notificationService.lastNotifiedTrackId == "song-1")
+    }
+
+    @Test("detects multiple track changes")
+    func detectsMultipleTrackChanges() async {
+        self.playerService.currentTrack = TestFixtures.makeSong(id: "song-1", title: "First Song")
+        try? await Task.sleep(for: .milliseconds(700))
+        #expect(self.notificationService.lastNotifiedTrackId == "song-1")
+
+        self.playerService.currentTrack = TestFixtures.makeSong(id: "song-2", title: "Second Song")
+        try? await Task.sleep(for: .milliseconds(700))
+        #expect(self.notificationService.lastNotifiedTrackId == "song-2")
+    }
+
+    @Test("does not notify for same track twice")
+    func doesNotNotifyForSameTrackTwice() async {
+        self.playerService.currentTrack = TestFixtures.makeSong(id: "song-1", title: "First Song")
+        try? await Task.sleep(for: .milliseconds(700))
+        #expect(self.notificationService.lastNotifiedTrackId == "song-1")
+
+        // Set a different track, then back to the same one
+        self.playerService.currentTrack = TestFixtures.makeSong(id: "song-2", title: "Second Song")
+        try? await Task.sleep(for: .milliseconds(700))
+
+        // The lastNotifiedTrackId should now be song-2, meaning song-1 wasn't skipped
+        #expect(self.notificationService.lastNotifiedTrackId == "song-2")
+    }
+
+    @Test("skips tracks with Loading... title")
+    func skipsLoadingTracks() async {
+        self.playerService.currentTrack = TestFixtures.makeSong(id: "loading-track", title: "Loading...")
+        try? await Task.sleep(for: .milliseconds(700))
+
+        #expect(self.notificationService.lastNotifiedTrackId == nil)
+    }
+
+    @Test("notifies after Loading... resolves to real title")
+    func notifiesAfterLoadingResolves() async {
+        // First set loading placeholder
+        self.playerService.currentTrack = TestFixtures.makeSong(id: "song-1", title: "Loading...")
+        try? await Task.sleep(for: .milliseconds(700))
+        #expect(self.notificationService.lastNotifiedTrackId == nil)
+
+        // Now resolve to real track (same id, different title)
+        self.playerService.currentTrack = TestFixtures.makeSong(id: "song-1", title: "Real Song")
+        try? await Task.sleep(for: .milliseconds(700))
+        #expect(self.notificationService.lastNotifiedTrackId == "song-1")
+    }
+
+    @Test("no notification when track is nil")
+    func noNotificationWhenTrackIsNil() async {
+        self.playerService.currentTrack = nil
+        try? await Task.sleep(for: .milliseconds(700))
+
+        #expect(self.notificationService.lastNotifiedTrackId == nil)
+    }
+
+    // MARK: - Service Retention
+
+    @Test("service remains active after multiple polling cycles")
+    func serviceRemainsActiveAfterPolling() async {
+        // Verify the observation task survives multiple cycles
+        try? await Task.sleep(for: .seconds(2))
+        #expect(self.notificationService.isObserving)
+
+        // And still detects changes
+        self.playerService.currentTrack = TestFixtures.makeSong(id: "late-song", title: "Late Song")
+        try? await Task.sleep(for: .milliseconds(700))
+        #expect(self.notificationService.lastNotifiedTrackId == "late-song")
+    }
+}