Add Spotify integration with toggleable music source

- Add OAuth 2.0 PKCE authentication for Spotify Web API
- Create SpotifyNowPlayingMonitor for polling current track
- Add Settings tab with music source toggle (Apple Music/Spotify)
- Store tokens securely in Keychain
- Display current track on Glass as NOW_PLAYING card

🤖 Generated with [Claude Code](https://claude.com/claude-code)

Co-Authored-By: Claude Opus 4.5 <noreply@anthropic.com>

IrisCompanion/iris/Spotify/SpotifyNowPlayingMonitor.swift

@@ -0,0 +1,145 @@
+//
+//  SpotifyNowPlayingMonitor.swift
+//  iris
+//
+//  Polling monitor for Spotify currently playing track.
+//
+
+import Foundation
+import os
+
+@available(iOS 16.0, *)
+struct SpotifyNowPlaying: Equatable, Sendable {
+    let itemId: String
+    let title: String
+    let artist: String?
+    let album: String?
+    let isPlaying: Bool
+
+    func asFeedItem(baseGeneratedAt: Int, now: Int) -> FeedItem {
+        let desiredLifetimeSec = 30
+        let ttl = max(1, (now - baseGeneratedAt) + desiredLifetimeSec)
+
+        let subtitleParts = [artist, album]
+            .compactMap { $0?.trimmingCharacters(in: .whitespacesAndNewlines) }
+            .filter { !$0.isEmpty }
+        let subtitle = subtitleParts.isEmpty ? "Spotify" : subtitleParts.joined(separator: " • ")
+
+        return FeedItem(
+            id: "spotify:now:\(itemId)",
+            type: .nowPlaying,
+            title: title.truncated(maxLength: TextConstraints.titleMax),
+            subtitle: subtitle.truncated(maxLength: TextConstraints.subtitleMax),
+            priority: isPlaying ? 0.35 : 0.2,
+            ttlSec: ttl,
+            condition: nil,
+            startsAt: nil,
+            bucket: .fyi,
+            actions: ["DISMISS"]
+        )
+    }
+}
+
+@available(iOS 16.0, *)
+@MainActor
+final class SpotifyNowPlayingMonitor {
+    struct Update: Sendable {
+        let isConnected: Bool
+        let snapshot: SpotifyNowPlaying?
+    }
+
+    var onUpdate: ((Update) -> Void)? = nil
+
+    private let authManager: SpotifyAuthManager
+    private let apiClient: SpotifyAPIClient
+    private let logger = Logger(subsystem: Bundle.main.bundleIdentifier ?? "iris", category: "SpotifyNowPlaying")
+
+    private var pollTimer: DispatchSourceTimer?
+    private var isRunning = false
+    private var lastSnapshot: SpotifyNowPlaying? = nil
+
+    init(authManager: SpotifyAuthManager) {
+        self.authManager = authManager
+        self.apiClient = SpotifyAPIClient(authManager: authManager)
+    }
+
+    func start() {
+        guard !isRunning else { return }
+        isRunning = true
+        logger.info("Spotify monitor started")
+        startPolling()
+
+        Task { @MainActor in
+            await refresh(reason: "start")
+        }
+    }
+
+    func stop() {
+        guard isRunning else { return }
+        isRunning = false
+        logger.info("Spotify monitor stopped")
+
+        pollTimer?.cancel()
+        pollTimer = nil
+    }
+
+    private func startPolling() {
+        guard pollTimer == nil else { return }
+        let timer = DispatchSource.makeTimerSource(queue: .main)
+        timer.schedule(deadline: .now() + 4, repeating: 4)
+        timer.setEventHandler { [weak self] in
+            guard let self else { return }
+            Task { @MainActor in
+                await self.refresh(reason: "poll")
+            }
+        }
+        timer.resume()
+        pollTimer = timer
+    }
+
+    private func refresh(reason: String) async {
+        guard authManager.isConnected else {
+            if lastSnapshot != nil {
+                lastSnapshot = nil
+                onUpdate?(Update(isConnected: false, snapshot: nil))
+            }
+            return
+        }
+
+        do {
+            let playback = try await apiClient.getCurrentPlayback()
+
+            guard let track = playback?.item, playback?.isPlaying == true else {
+                if lastSnapshot != nil {
+                    lastSnapshot = nil
+                    onUpdate?(Update(isConnected: true, snapshot: nil))
+                }
+                return
+            }
+
+            let artistName = track.artists.first?.name
+            let snapshot = SpotifyNowPlaying(
+                itemId: track.id,
+                title: track.name,
+                artist: artistName,
+                album: track.album.name,
+                isPlaying: playback?.isPlaying ?? false
+            )
+
+            guard snapshot != lastSnapshot else { return }
+            lastSnapshot = snapshot
+            onUpdate?(Update(isConnected: true, snapshot: snapshot))
+            logger.debug("Spotify now playing: \(snapshot.title)")
+
+        } catch SpotifyAPIClient.SpotifyAPIError.notAuthenticated {
+            if lastSnapshot != nil {
+                lastSnapshot = nil
+                onUpdate?(Update(isConnected: false, snapshot: nil))
+            }
+        } catch SpotifyAPIClient.SpotifyAPIError.rateLimited {
+            logger.warning("Spotify rate limited, skipping this poll")
+        } catch {
+            logger.error("Spotify fetch error: \(error.localizedDescription)")
+        }
+    }
+}