Fix Yahoo Finance API: switch from v7 quote to v8 chart endpoint

The v7 /quote endpoint returns 401 Unauthorized as it now requires
cookie-based authentication. The v8 /chart endpoint works without auth.

- Switch to v8/finance/chart/{symbol} endpoint
- Fetch each symbol individually (chart API limitation)
- Update response parsing for chart JSON structure
- Calculate price change from regularMarketPrice - chartPreviousClose

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

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

IrisCompanion/iris/ContentView.swift

@@ -9,6 +9,7 @@ import SwiftUI
 
 struct ContentView: View {
     @EnvironmentObject private var orchestrator: ContextOrchestrator
+    @StateObject private var stockSettings = StockSettingsStore()
 
     var body: some View {
         TabView {
@@ -16,6 +17,14 @@ struct ContentView: View {
                 .tabItem { Label("BLE", systemImage: "dot.radiowaves.left.and.right") }
             OrchestratorView()
                 .tabItem { Label("Orchestrator", systemImage: "bolt.horizontal.circle") }
+            TodosView()
+                .tabItem { Label("Todos", systemImage: "checklist") }
+            NavigationStack {
+                StockSettingsView(store: stockSettings)
+            }
+            .tabItem { Label("Stocks", systemImage: "chart.line.uptrend.xyaxis") }
+            SettingsView()
+                .tabItem { Label("Settings", systemImage: "gearshape") }
         }
         .onAppear { orchestrator.start() }
     }
@@ -25,10 +34,12 @@ struct ContentView_Previews: PreviewProvider {
     static var previews: some View {
         if #available(iOS 16.0, *) {
             let ble = BlePeripheralManager()
-            let orchestrator = ContextOrchestrator(ble: ble)
+            let spotifyAuth = SpotifyAuthManager()
+            let orchestrator = ContextOrchestrator(ble: ble, spotifyAuth: spotifyAuth)
             ContentView()
                 .environmentObject(ble)
                 .environmentObject(orchestrator)
+                .environmentObject(spotifyAuth)
         } else {
             ContentView()
         }

IrisCompanion/iris/DataSources/StockDataSource.swift

@@ -0,0 +1,177 @@
+//
+//  StockDataSource.swift
+//  iris
+//
+
+import Foundation
+
+struct StockDataSourceConfig: Sendable {
+    var maxSymbols: Int = 5
+    var cacheValiditySec: Int = 300
+    var ttlSec: Int = 600
+
+    init() {}
+}
+
+final class StockDataSource {
+    struct StockQuote: Sendable, Equatable {
+        let symbol: String
+        let shortName: String
+        let price: Double
+        let change: Double
+        let changePercent: Double
+        let marketState: String
+    }
+
+    struct StockData: Sendable, Equatable {
+        let quotes: [StockQuote]
+    }
+
+    struct Snapshot: Sendable {
+        let data: StockData
+        let diagnostics: [String: String]
+    }
+
+    enum StockError: Error, LocalizedError, Sendable {
+        case noSymbolsConfigured
+        case networkFailed(message: String, diagnostics: [String: String])
+        case rateLimited(diagnostics: [String: String])
+        case invalidResponse(diagnostics: [String: String])
+
+        var errorDescription: String? {
+            switch self {
+            case .noSymbolsConfigured:
+                return "No symbols configured"
+            case .networkFailed(let message, _):
+                return message
+            case .rateLimited:
+                return "Rate limited by Yahoo Finance"
+            case .invalidResponse:
+                return "Invalid response from Yahoo Finance"
+            }
+        }
+    }
+
+    private let config: StockDataSourceConfig
+    private var cache: (timestamp: Int, data: StockData)?
+
+    init(config: StockDataSourceConfig = .init()) {
+        self.config = config
+    }
+
+    func dataWithDiagnostics(symbols: [String], now: Int) async throws -> Snapshot {
+        var diagnostics: [String: String] = [
+            "now": String(now),
+            "symbols_requested": symbols.joined(separator: ","),
+            "max_symbols": String(config.maxSymbols),
+        ]
+
+        guard !symbols.isEmpty else {
+            diagnostics["result"] = "no_symbols"
+            return Snapshot(data: StockData(quotes: []), diagnostics: diagnostics)
+        }
+
+        let limitedSymbols = Array(symbols.prefix(config.maxSymbols))
+        diagnostics["symbols_queried"] = limitedSymbols.joined(separator: ",")
+
+        if let cache = cache, now - cache.timestamp < config.cacheValiditySec {
+            diagnostics["source"] = "cache"
+            diagnostics["cache_age_sec"] = String(now - cache.timestamp)
+            return Snapshot(data: cache.data, diagnostics: diagnostics)
+        }
+
+        // Fetch each symbol using v8 chart API (supports one symbol per request)
+        var quotes: [StockQuote] = []
+        var fetchErrors: [String] = []
+
+        for symbol in limitedSymbols {
+            do {
+                if let quote = try await fetchQuote(symbol: symbol) {
+                    quotes.append(quote)
+                }
+            } catch {
+                fetchErrors.append("\(symbol): \(error.localizedDescription)")
+            }
+        }
+
+        diagnostics["source"] = "network"
+        diagnostics["quotes_returned"] = String(quotes.count)
+        if !fetchErrors.isEmpty {
+            diagnostics["fetch_errors"] = fetchErrors.joined(separator: "; ")
+        }
+
+        let stockData = StockData(quotes: quotes)
+        cache = (timestamp: now, data: stockData)
+
+        return Snapshot(data: stockData, diagnostics: diagnostics)
+    }
+
+    private func fetchQuote(symbol: String) async throws -> StockQuote? {
+        guard let encodedSymbol = symbol.addingPercentEncoding(withAllowedCharacters: .urlQueryAllowed),
+              let url = URL(string: "https://query1.finance.yahoo.com/v8/finance/chart/\(encodedSymbol)?interval=1d&range=1d") else {
+            return nil
+        }
+
+        var request = URLRequest(url: url)
+        request.setValue("Mozilla/5.0 (iPhone; CPU iPhone OS 17_0 like Mac OS X)", forHTTPHeaderField: "User-Agent")
+        request.setValue("application/json", forHTTPHeaderField: "Accept")
+
+        let (data, response) = try await URLSession.shared.data(for: request)
+
+        if let httpResponse = response as? HTTPURLResponse {
+            guard (200..<300).contains(httpResponse.statusCode) else {
+                throw StockError.networkFailed(message: "HTTP \(httpResponse.statusCode)", diagnostics: [:])
+            }
+        }
+
+        let chartResponse = try JSONDecoder().decode(YahooChartResponse.self, from: data)
+
+        guard let result = chartResponse.chart.result?.first,
+              let meta = result.meta,
+              let price = meta.regularMarketPrice else {
+            return nil
+        }
+
+        let previousClose = meta.chartPreviousClose ?? meta.previousClose ?? price
+        let change = price - previousClose
+        let changePercent = previousClose > 0 ? (change / previousClose) * 100 : 0
+
+        return StockQuote(
+            symbol: meta.symbol ?? symbol,
+            shortName: meta.shortName ?? meta.symbol ?? symbol,
+            price: price,
+            change: change,
+            changePercent: changePercent,
+            marketState: meta.marketState ?? "CLOSED"
+        )
+    }
+}
+
+// MARK: - Yahoo Finance v8 Chart API Response Models
+
+private struct YahooChartResponse: Codable {
+    let chart: Chart
+
+    struct Chart: Codable {
+        let result: [ChartResult]?
+        let error: ChartError?
+    }
+
+    struct ChartResult: Codable {
+        let meta: ChartMeta?
+    }
+
+    struct ChartMeta: Codable {
+        let symbol: String?
+        let shortName: String?
+        let regularMarketPrice: Double?
+        let chartPreviousClose: Double?
+        let previousClose: Double?
+        let marketState: String?
+    }
+
+    struct ChartError: Codable {
+        let code: String?
+        let description: String?
+    }
+}

IrisCompanion/iris/Info.plist

@@ -2,6 +2,17 @@
 <!DOCTYPE plist PUBLIC "-//Apple//DTD PLIST 1.0//EN" "http://www.apple.com/DTDs/PropertyList-1.0.dtd">
 <plist version="1.0">
 <dict>
+	<key>CFBundleURLTypes</key>
+	<array>
+		<dict>
+			<key>CFBundleURLName</key>
+			<string>sh.nym.iris.spotify-auth</string>
+			<key>CFBundleURLSchemes</key>
+			<array>
+				<string>iris-spotify-auth</string>
+			</array>
+		</dict>
+	</array>
 	<key>MKDirectionsApplicationSupportedModes</key>
 	<array/>
 	<key>NSCalendarsFullAccessUsageDescription</key>

IrisCompanion/iris/Models/HeuristicRanker.swift

@@ -90,6 +90,7 @@ final class HeuristicRanker {
         case .transit: return 0.75
         case .poiNearby: return 0.6
         case .info: return 0.4
+        case .stock: return 0.3
         case .nowPlaying: return 0.25
         case .currentWeather: return 0.0
         case .allQuiet: return 0.0

IrisCompanion/iris/Models/StockSettingsStore.swift

@@ -0,0 +1,48 @@
+//
+//  StockSettingsStore.swift
+//  iris
+//
+
+import Foundation
+import Combine
+
+@MainActor
+final class StockSettingsStore: ObservableObject {
+    nonisolated static let userDefaultsKey = "iris.stock.symbols"
+
+    @Published private(set) var symbols: [String] = []
+
+    private let maxSymbols = 5
+
+    init() {
+        loadSymbols()
+    }
+
+    private func loadSymbols() {
+        symbols = UserDefaults.standard.stringArray(forKey: Self.userDefaultsKey) ?? []
+    }
+
+    func saveSymbols(_ newSymbols: [String]) {
+        let cleaned = newSymbols
+            .map { $0.uppercased().trimmingCharacters(in: .whitespacesAndNewlines) }
+            .filter { !$0.isEmpty }
+            .prefix(maxSymbols)
+        symbols = Array(cleaned)
+        UserDefaults.standard.set(symbols, forKey: Self.userDefaultsKey)
+    }
+
+    @discardableResult
+    func addSymbol(_ symbol: String) -> Bool {
+        guard symbols.count < maxSymbols else { return false }
+        let cleaned = symbol.uppercased().trimmingCharacters(in: .whitespacesAndNewlines)
+        guard !cleaned.isEmpty, !symbols.contains(cleaned) else { return false }
+        symbols.append(cleaned)
+        UserDefaults.standard.set(symbols, forKey: Self.userDefaultsKey)
+        return true
+    }
+
+    func removeSymbol(_ symbol: String) {
+        symbols.removeAll { $0 == symbol.uppercased() }
+        UserDefaults.standard.set(symbols, forKey: Self.userDefaultsKey)
+    }
+}

IrisCompanion/iris/Models/TodoItem.swift

@@ -0,0 +1,31 @@
+//
+//  TodoItem.swift
+//  iris
+//
+//  Created by Codex.
+//
+
+import Foundation
+
+struct TodoItem: Identifiable, Codable, Equatable {
+    let id: UUID
+    var title: String
+    var isCompleted: Bool
+    var createdAt: Date
+    var updatedAt: Date
+    var completedAt: Date?
+
+    init(id: UUID = UUID(),
+         title: String,
+         isCompleted: Bool = false,
+         createdAt: Date = Date(),
+         updatedAt: Date = Date(),
+         completedAt: Date? = nil) {
+        self.id = id
+        self.title = title
+        self.isCompleted = isCompleted
+        self.createdAt = createdAt
+        self.updatedAt = updatedAt
+        self.completedAt = completedAt
+    }
+}

IrisCompanion/iris/Models/TodoStore.swift

@@ -0,0 +1,116 @@
+//
+//  TodoStore.swift
+//  iris
+//
+//  Created by Codex.
+//
+
+import Foundation
+
+final class TodoStore {
+    private struct Persisted: Codable {
+        var schema: Int?
+        var items: [TodoItem]
+    }
+
+    private let queue = DispatchQueue(label: "iris.todostore.queue")
+    private let fileURL: URL
+    private var items: [TodoItem]
+
+    init(filename: String = "todos_v1.json") {
+        self.fileURL = Self.defaultFileURL(filename: filename)
+        let persisted = Self.load(from: fileURL)
+        self.items = persisted?.items ?? []
+    }
+
+    func snapshot() -> [TodoItem] {
+        queue.sync { items }
+    }
+
+    @discardableResult
+    func add(title: String, now: Date = Date()) -> TodoItem {
+        queue.sync {
+            let item = TodoItem(title: title, createdAt: now, updatedAt: now)
+            items.append(item)
+            save()
+            return item
+        }
+    }
+
+    @discardableResult
+    func updateTitle(id: UUID, title: String, now: Date = Date()) -> TodoItem? {
+        queue.sync {
+            guard let index = items.firstIndex(where: { $0.id == id }) else { return nil }
+            var item = items[index]
+            item.title = title
+            item.updatedAt = now
+            items[index] = item
+            save()
+            return item
+        }
+    }
+
+    @discardableResult
+    func setCompleted(id: UUID, completed: Bool, now: Date = Date()) -> TodoItem? {
+        queue.sync {
+            guard let index = items.firstIndex(where: { $0.id == id }) else { return nil }
+            var item = items[index]
+            item.isCompleted = completed
+            item.updatedAt = now
+            item.completedAt = completed ? now : nil
+            items[index] = item
+            save()
+            return item
+        }
+    }
+
+    func delete(id: UUID) {
+        queue.sync {
+            items.removeAll { $0.id == id }
+            save()
+        }
+    }
+
+    private func save() {
+        let persisted = Persisted(schema: 1, items: items)
+        Self.save(persisted, to: fileURL)
+    }
+
+    private static func defaultFileURL(filename: String) -> URL {
+        let fm = FileManager.default
+        let base = fm.urls(for: .applicationSupportDirectory, in: .userDomainMask).first ?? fm.temporaryDirectory
+        let bundle = Bundle.main.bundleIdentifier ?? "iris"
+        return base
+            .appendingPathComponent(bundle, isDirectory: true)
+            .appendingPathComponent(filename, isDirectory: false)
+    }
+
+    private static func load(from url: URL) -> Persisted? {
+        guard let data = try? Data(contentsOf: url) else { return nil }
+        return try? makeDecoder().decode(Persisted.self, from: data)
+    }
+
+    private static func save(_ persisted: Persisted, to url: URL) {
+        do {
+            let fm = FileManager.default
+            try fm.createDirectory(at: url.deletingLastPathComponent(), withIntermediateDirectories: true)
+            let data = try makeEncoder().encode(persisted)
+            try data.write(to: url, options: [.atomic])
+        } catch {
+            // Best-effort persistence.
+        }
+    }
+
+    private static func makeEncoder() -> JSONEncoder {
+        let encoder = JSONEncoder()
+        encoder.outputFormatting = [.prettyPrinted, .withoutEscapingSlashes]
+        encoder.dateEncodingStrategy = .iso8601
+        return encoder
+    }
+
+    private static func makeDecoder() -> JSONDecoder {
+        let decoder = JSONDecoder()
+        decoder.dateDecodingStrategy = .iso8601
+        return decoder
+    }
+}

IrisCompanion/iris/Models/Winner.swift

@@ -16,5 +16,6 @@ enum FeedItemType: String, Codable, CaseIterable {
     case nowPlaying = "NOW_PLAYING"
     case currentWeather = "CURRENT_WEATHER"
     case calendarEvent = "CALENDAR_EVENT"
+    case stock = "STOCK"
     case allQuiet = "ALL_QUIET"
 }

IrisCompanion/iris/Orchestrator/ContextOrchestrator.swift

@@ -26,6 +26,15 @@ final class ContextOrchestrator: NSObject, ObservableObject {
     @Published private(set) var lastFetchFailed: Bool = false
     @Published private(set) var musicAuthorization: MusicAuthorization.Status = .notDetermined
     @Published private(set) var nowPlaying: NowPlayingSnapshot? = nil
+    @Published private(set) var spotifyNowPlaying: SpotifyNowPlaying? = nil
+    @Published var musicSource: MusicSource = .appleMusic {
+        didSet {
+            if oldValue != musicSource {
+                switchMusicMonitor()
+                UserDefaults.standard.set(musicSource.rawValue, forKey: "music_source")
+            }
+        }
+    }
 
     private let logger = Logger(subsystem: Bundle.main.bundleIdentifier ?? "iris", category: "ContextOrchestrator")
 
@@ -33,11 +42,14 @@ final class ContextOrchestrator: NSObject, ObservableObject {
     private let weatherDataSource = WeatherDataSource()
     private let calendarDataSource = CalendarDataSource()
     private let poiDataSource = POIDataSource()
+    private let stockDataSource = StockDataSource()
     private let ranker: HeuristicRanker
     private let store: FeedStore
     private let server: LocalServer
     private let ble: BlePeripheralManager
     private let nowPlayingMonitor = NowPlayingMonitor()
+    private let spotifyMonitor: SpotifyNowPlayingMonitor
+    private let spotifyAuth: SpotifyAuthManager
 
     private var lastRecomputeLocation: CLLocation? = nil
     private var lastRecomputeAccuracy: CLLocationAccuracy? = nil
@@ -46,11 +58,20 @@ final class ContextOrchestrator: NSObject, ObservableObject {
 
     init(store: FeedStore = FeedStore(),
          server: LocalServer = LocalServer(),
-         ble: BlePeripheralManager) {
+         ble: BlePeripheralManager,
+         spotifyAuth: SpotifyAuthManager) {
         self.store = store
         self.server = server
         self.ble = ble
+        self.spotifyAuth = spotifyAuth
+        self.spotifyMonitor = SpotifyNowPlayingMonitor(authManager: spotifyAuth)
         self.ranker = HeuristicRanker(lastShownAt: { id in store.lastShownAt(feedItemId: id) })
+
+        if let savedSource = UserDefaults.standard.string(forKey: "music_source"),
+           let source = MusicSource(rawValue: savedSource) {
+            self.musicSource = source
+        }
+
         super.init()
 
         locationManager.delegate = self
@@ -73,13 +94,21 @@ final class ContextOrchestrator: NSObject, ObservableObject {
 
         nowPlayingMonitor.onUpdate = { [weak self] update in
             Task { @MainActor in
-                guard let self else { return }
+                guard let self, self.musicSource == .appleMusic else { return }
                 self.musicAuthorization = update.authorization
                 self.nowPlaying = update.snapshot
                 self.pushLatestFeedToBle()
             }
         }
 
+        spotifyMonitor.onUpdate = { [weak self] update in
+            Task { @MainActor in
+                guard let self, self.musicSource == .spotify else { return }
+                self.spotifyNowPlaying = update.snapshot
+                self.pushLatestFeedToBle()
+            }
+        }
+
         let feed = store.getFeed()
         lastFeed = feed
     }
@@ -88,7 +117,7 @@ final class ContextOrchestrator: NSObject, ObservableObject {
         authorization = locationManager.authorizationStatus
         logger.info("start auth=\(String(describing: self.authorization), privacy: .public)")
         server.start()
-        nowPlayingMonitor.start()
+        startMusicMonitor()
         requestPermissionsIfNeeded()
         locationManager.startUpdatingLocation()
     }
@@ -96,6 +125,27 @@ final class ContextOrchestrator: NSObject, ObservableObject {
     func stop() {
         locationManager.stopUpdatingLocation()
         nowPlayingMonitor.stop()
+        spotifyMonitor.stop()
+    }
+
+    private func startMusicMonitor() {
+        switch musicSource {
+        case .appleMusic:
+            nowPlayingMonitor.start()
+        case .spotify:
+            spotifyMonitor.start()
+        }
+    }
+
+    private func switchMusicMonitor() {
+        nowPlayingMonitor.stop()
+        spotifyMonitor.stop()
+        nowPlaying = nil
+        spotifyNowPlaying = nil
+
+        startMusicMonitor()
+        pushLatestFeedToBle()
+        logger.info("Switched music source to \(self.musicSource.rawValue)")
     }
 
     func recomputeNow(reason: String = "manual") {
@@ -204,10 +254,15 @@ final class ContextOrchestrator: NSObject, ObservableObject {
         async let poiResult = withTimeoutResult(seconds: 6) {
             try await self.poiDataSource.data(for: location, now: nowEpoch)
         }
+        let stockSymbols = UserDefaults.standard.stringArray(forKey: StockSettingsStore.userDefaultsKey) ?? []
+        async let stockResult = withTimeoutResult(seconds: 6) {
+            try await self.stockDataSource.dataWithDiagnostics(symbols: stockSymbols, now: nowEpoch)
+        }
 
         let wxRes = await weatherResult
         let calRes = await calendarResult
         let poiRes = await poiResult
+        let stockRes = await stockResult
 
         func calendarTTL(endAt: Int, now: Int) -> Int {
             let ttl = endAt - now
@@ -223,6 +278,7 @@ final class ContextOrchestrator: NSObject, ObservableObject {
         var rightNowCandidates: [HeuristicRanker.Ranked] = []
         var calendarItems: [FeedItem] = []
         var poiItems: [FeedItem] = []
+        var stockItems: [FeedItem] = []
         var weatherNowItem: FeedItem? = nil
         var fetchFailed = false
         var wxDiagnostics: [String: String] = [:]
@@ -385,13 +441,26 @@ final class ContextOrchestrator: NSObject, ObservableObject {
             }
         }
 
+        switch stockRes {
+        case .success(let snapshot):
+            for quote in snapshot.data.quotes.prefix(3) {
+                let item = stockQuoteToFeedItem(quote: quote, now: nowEpoch)
+                stockItems.append(item)
+            }
+            if !snapshot.data.quotes.isEmpty {
+                logger.info("stock quotes fetched count=\(snapshot.data.quotes.count)")
+            }
+        case .failure(let error):
+            logger.warning("stock fetch failed: \(String(describing: error), privacy: .public)")
+        }
+
         let elapsedMs = Int(Date().timeIntervalSince(start) * 1000)
         lastPipelineElapsedMs = elapsedMs
         lastFetchFailed = fetchFailed
         lastWeatherDiagnostics = wxDiagnostics
         lastCalendarDiagnostics = calDiagnostics
 
-        logger.info("pipeline right_now_candidates=\(rightNowCandidates.count) calendar_items=\(calendarItems.count) poi_items=\(poiItems.count) fetchFailed=\(fetchFailed) elapsed_ms=\(elapsedMs)")
+        logger.info("pipeline right_now_candidates=\(rightNowCandidates.count) calendar_items=\(calendarItems.count) poi_items=\(poiItems.count) stock_items=\(stockItems.count) fetchFailed=\(fetchFailed) elapsed_ms=\(elapsedMs)")
 
         if fetchFailed, rightNowCandidates.isEmpty, calendarItems.isEmpty, weatherNowItem == nil {
             let fallbackFeed = store.getFeed(now: nowEpoch)
@@ -466,6 +535,27 @@ final class ContextOrchestrator: NSObject, ObservableObject {
             fyi.append(weatherNowItem)
         }
 
+        let fyiStocks = stockItems
+            .filter { $0.id != winnerItem.id }
+            .filter { !store.isSuppressed(id: $0.id, type: $0.type, now: nowEpoch) }
+            .prefix(3)
+
+        fyi.append(contentsOf: fyiStocks.map { item in
+            FeedItem(
+                id: item.id,
+                type: item.type,
+                title: item.title.truncated(maxLength: TextConstraints.titleMax),
+                subtitle: item.subtitle.truncated(maxLength: TextConstraints.subtitleMax),
+                priority: min(max(item.priority, 0.0), 1.0),
+                ttlSec: max(1, item.ttlSec),
+                condition: item.condition,
+                startsAt: item.startsAt,
+                poiType: item.poiType,
+                bucket: .fyi,
+                actions: ["DISMISS"]
+            )
+        })
+
         let items = [winnerItem] + fyi
         let feedEnvelope = FeedEnvelope(
             schema: 1,
@@ -507,7 +597,15 @@ final class ContextOrchestrator: NSObject, ObservableObject {
     }
 
     private func feedForGlass(base: FeedEnvelope, now: Int) -> FeedEnvelope {
-        guard let nowPlayingCard = nowPlaying?.asFeedItem(baseGeneratedAt: base.generatedAt, now: now) else {
+        let nowPlayingCard: FeedItem?
+        switch musicSource {
+        case .appleMusic:
+            nowPlayingCard = nowPlaying?.asFeedItem(baseGeneratedAt: base.generatedAt, now: now)
+        case .spotify:
+            nowPlayingCard = spotifyNowPlaying?.asFeedItem(baseGeneratedAt: base.generatedAt, now: now)
+        }
+
+        guard let nowPlayingCard else {
             return base
         }
 
@@ -539,6 +637,34 @@ final class ContextOrchestrator: NSObject, ObservableObject {
         }
         return "\(Int(meters.rounded())) m"
     }
+
+    private func stockQuoteToFeedItem(quote: StockDataSource.StockQuote, now: Int) -> FeedItem {
+        let direction = quote.change >= 0 ? "+" : ""
+        let priceStr: String
+        if quote.price >= 100000 {
+            priceStr = String(format: "%.1fK", quote.price / 1000)
+        } else if quote.price >= 1000 {
+            priceStr = String(format: "%.0f", quote.price)
+        } else {
+            priceStr = String(format: "%.2f", quote.price)
+        }
+        let title = "\(quote.symbol) $\(priceStr)"
+        let subtitle = "\(direction)\(String(format: "%.2f", quote.change)) (\(direction)\(String(format: "%.2f", quote.changePercent))%)"
+
+        return FeedItem(
+            id: "stock:\(quote.symbol):\(now / 300)",
+            type: .stock,
+            title: title.truncated(maxLength: TextConstraints.titleMax),
+            subtitle: subtitle.truncated(maxLength: TextConstraints.subtitleMax),
+            priority: 0.3,
+            ttlSec: 600,
+            condition: nil,
+            startsAt: nil,
+            poiType: nil,
+            bucket: .fyi,
+            actions: ["DISMISS"]
+        )
+    }
 }
 
 extension ContextOrchestrator: CLLocationManagerDelegate {

IrisCompanion/iris/Spotify/KeychainHelper.swift

@@ -0,0 +1,61 @@
+//
+//  KeychainHelper.swift
+//  iris
+//
+//  Secure token storage using iOS Keychain.
+//
+
+import Foundation
+import Security
+
+enum KeychainHelper {
+    private static let service = "sh.nym.iris.spotify"
+
+    static func save(key: String, data: Data) throws {
+        let query: [String: Any] = [
+            kSecClass as String: kSecClassGenericPassword,
+            kSecAttrService as String: service,
+            kSecAttrAccount as String: key
+        ]
+        SecItemDelete(query as CFDictionary)
+
+        let attributes: [String: Any] = [
+            kSecClass as String: kSecClassGenericPassword,
+            kSecAttrService as String: service,
+            kSecAttrAccount as String: key,
+            kSecValueData as String: data,
+            kSecAttrAccessible as String: kSecAttrAccessibleAfterFirstUnlock
+        ]
+        let status = SecItemAdd(attributes as CFDictionary, nil)
+        guard status == errSecSuccess else {
+            throw KeychainError.saveFailed(status)
+        }
+    }
+
+    static func load(key: String) -> Data? {
+        let query: [String: Any] = [
+            kSecClass as String: kSecClassGenericPassword,
+            kSecAttrService as String: service,
+            kSecAttrAccount as String: key,
+            kSecReturnData as String: true,
+            kSecMatchLimit as String: kSecMatchLimitOne
+        ]
+        var result: AnyObject?
+        let status = SecItemCopyMatching(query as CFDictionary, &result)
+        guard status == errSecSuccess else { return nil }
+        return result as? Data
+    }
+
+    static func delete(key: String) {
+        let query: [String: Any] = [
+            kSecClass as String: kSecClassGenericPassword,
+            kSecAttrService as String: service,
+            kSecAttrAccount as String: key
+        ]
+        SecItemDelete(query as CFDictionary)
+    }
+
+    enum KeychainError: Error {
+        case saveFailed(OSStatus)
+    }
+}

IrisCompanion/iris/Spotify/SpotifyAPIClient.swift

@@ -0,0 +1,77 @@
+//
+//  SpotifyAPIClient.swift
+//  iris
+//
+//  Spotify Web API client for fetching currently playing track.
+//
+
+import Foundation
+import os
+
+@available(iOS 16.0, *)
+@MainActor
+final class SpotifyAPIClient {
+    private let authManager: SpotifyAuthManager
+    private let logger = Logger(subsystem: Bundle.main.bundleIdentifier ?? "iris", category: "SpotifyAPI")
+    private let baseUrl = "https://api.spotify.com/v1"
+
+    init(authManager: SpotifyAuthManager) {
+        self.authManager = authManager
+    }
+
+    func getCurrentPlayback() async throws -> SpotifyPlaybackState? {
+        try await getCurrentPlayback(isRetry: false)
+    }
+
+    private func getCurrentPlayback(isRetry: Bool) async throws -> SpotifyPlaybackState? {
+        let refreshed = await authManager.refreshTokenIfNeeded()
+        guard refreshed else {
+            throw SpotifyAPIError.notAuthenticated
+        }
+
+        guard let token = authManager.accessToken else {
+            throw SpotifyAPIError.notAuthenticated
+        }
+
+        var request = URLRequest(url: URL(string: "\(baseUrl)/me/player/currently-playing")!)
+        request.httpMethod = "GET"
+        request.setValue("Bearer \(token)", forHTTPHeaderField: "Authorization")
+
+        let (data, response) = try await URLSession.shared.data(for: request)
+
+        guard let httpResponse = response as? HTTPURLResponse else {
+            throw SpotifyAPIError.invalidResponse
+        }
+
+        switch httpResponse.statusCode {
+        case 200:
+            return try JSONDecoder().decode(SpotifyPlaybackState.self, from: data)
+        case 204:
+            return nil
+        case 401:
+            guard !isRetry else {
+                throw SpotifyAPIError.tokenExpired
+            }
+            let refreshed = await authManager.refreshTokenIfNeeded()
+            if refreshed {
+                return try await getCurrentPlayback(isRetry: true)
+            }
+            throw SpotifyAPIError.tokenExpired
+        case 429:
+            let retryAfter = httpResponse.value(forHTTPHeaderField: "Retry-After")
+            logger.warning("Rate limited, retry after: \(retryAfter ?? "unknown")")
+            throw SpotifyAPIError.rateLimited
+        default:
+            logger.error("API error: \(httpResponse.statusCode)")
+            throw SpotifyAPIError.apiError(httpResponse.statusCode)
+        }
+    }
+
+    enum SpotifyAPIError: Error {
+        case notAuthenticated
+        case tokenExpired
+        case invalidResponse
+        case rateLimited
+        case apiError(Int)
+    }
+}

IrisCompanion/iris/Spotify/SpotifyAuthManager.swift

@@ -0,0 +1,276 @@
+//
+//  SpotifyAuthManager.swift
+//  iris
+//
+//  OAuth 2.0 PKCE authentication for Spotify Web API.
+//
+
+import AuthenticationServices
+import CommonCrypto
+import Foundation
+import os
+
+enum SpotifyConfig {
+    static let redirectUri = "iris-spotify-auth://callback"
+    static let scopes = "user-read-playback-state user-read-currently-playing"
+    static let authUrl = "https://accounts.spotify.com/authorize"
+    static let tokenUrl = "https://accounts.spotify.com/api/token"
+}
+
+@available(iOS 16.0, *)
+@MainActor
+final class SpotifyAuthManager: NSObject, ObservableObject {
+    @Published private(set) var isConnected: Bool = false
+    @Published private(set) var isAuthenticating: Bool = false
+    @Published private(set) var error: String? = nil
+    @Published private(set) var clientId: String = ""
+
+    private let logger = Logger(subsystem: Bundle.main.bundleIdentifier ?? "iris", category: "SpotifyAuth")
+    private let tokensKey = "spotify_tokens"
+    private let clientIdKey = "spotify_client_id"
+    private var codeVerifier: String? = nil
+    private var authSession: ASWebAuthenticationSession? = nil
+
+    var isConfigured: Bool {
+        !clientId.isEmpty
+    }
+
+    override init() {
+        super.init()
+        clientId = UserDefaults.standard.string(forKey: clientIdKey) ?? ""
+        loadTokens()
+    }
+
+    func setClientId(_ id: String) {
+        let trimmed = id.trimmingCharacters(in: .whitespacesAndNewlines)
+        clientId = trimmed
+        UserDefaults.standard.set(trimmed, forKey: clientIdKey)
+        logger.info("Spotify Client ID updated")
+    }
+
+    var accessToken: String? {
+        loadStoredTokens()?.accessToken
+    }
+
+    func startAuth() {
+        guard !isAuthenticating else { return }
+        isAuthenticating = true
+        error = nil
+
+        let verifier = generateCodeVerifier()
+        codeVerifier = verifier
+        let challenge = generateCodeChallenge(verifier: verifier)
+
+        var components = URLComponents(string: SpotifyConfig.authUrl)!
+        components.queryItems = [
+            URLQueryItem(name: "client_id", value: clientId),
+            URLQueryItem(name: "response_type", value: "code"),
+            URLQueryItem(name: "redirect_uri", value: SpotifyConfig.redirectUri),
+            URLQueryItem(name: "scope", value: SpotifyConfig.scopes),
+            URLQueryItem(name: "code_challenge_method", value: "S256"),
+            URLQueryItem(name: "code_challenge", value: challenge)
+        ]
+
+        guard let authUrl = components.url else {
+            error = "Failed to build auth URL"
+            isAuthenticating = false
+            return
+        }
+
+        let session = ASWebAuthenticationSession(
+            url: authUrl,
+            callbackURLScheme: "iris-spotify-auth"
+        ) { [weak self] callbackUrl, authError in
+            Task { @MainActor in
+                self?.handleAuthCallback(callbackUrl: callbackUrl, error: authError)
+            }
+        }
+        session.presentationContextProvider = self
+        session.prefersEphemeralWebBrowserSession = false
+        authSession = session
+
+        if !session.start() {
+            error = "Failed to start auth session"
+            isAuthenticating = false
+        }
+    }
+
+    func handleCallback(url: URL) {
+        guard let components = URLComponents(url: url, resolvingAgainstBaseURL: false),
+              let code = components.queryItems?.first(where: { $0.name == "code" })?.value else {
+            error = "Invalid callback URL"
+            isAuthenticating = false
+            return
+        }
+
+        Task {
+            await exchangeCodeForTokens(code: code)
+        }
+    }
+
+    func disconnect() {
+        KeychainHelper.delete(key: tokensKey)
+        isConnected = false
+        logger.info("Disconnected from Spotify")
+    }
+
+    func refreshTokenIfNeeded() async -> Bool {
+        guard let tokens = loadStoredTokens() else { return false }
+
+        if !tokens.expiresWithinMinutes {
+            return true
+        }
+
+        return await refreshToken(refreshToken: tokens.refreshToken)
+    }
+
+    private func handleAuthCallback(callbackUrl: URL?, error authError: Error?) {
+        isAuthenticating = false
+        authSession = nil
+
+        if let authError = authError as? ASWebAuthenticationSessionError,
+           authError.code == .canceledLogin {
+            logger.info("User cancelled Spotify login")
+            return
+        }
+
+        if let authError {
+            error = authError.localizedDescription
+            return
+        }
+
+        guard let callbackUrl else {
+            error = "No callback URL received"
+            return
+        }
+
+        handleCallback(url: callbackUrl)
+    }
+
+    private func exchangeCodeForTokens(code: String) async {
+        guard let verifier = codeVerifier else {
+            error = "Missing code verifier"
+            isAuthenticating = false
+            return
+        }
+
+        let body = [
+            "grant_type": "authorization_code",
+            "code": code,
+            "redirect_uri": SpotifyConfig.redirectUri,
+            "client_id": clientId,
+            "code_verifier": verifier
+        ]
+
+        do {
+            let tokenResponse = try await postTokenRequest(body: body)
+            let tokens = SpotifyTokens(
+                accessToken: tokenResponse.accessToken,
+                refreshToken: tokenResponse.refreshToken ?? "",
+                expiresAt: Date().addingTimeInterval(TimeInterval(tokenResponse.expiresIn))
+            )
+            try saveTokens(tokens)
+            isConnected = true
+            logger.info("Successfully authenticated with Spotify")
+        } catch {
+            self.error = "Token exchange failed: \(error.localizedDescription)"
+            logger.error("Token exchange failed: \(error.localizedDescription)")
+        }
+
+        codeVerifier = nil
+        isAuthenticating = false
+    }
+
+    private func refreshToken(refreshToken: String) async -> Bool {
+        let body = [
+            "grant_type": "refresh_token",
+            "refresh_token": refreshToken,
+            "client_id": clientId
+        ]
+
+        do {
+            let tokenResponse = try await postTokenRequest(body: body)
+            let newRefreshToken = tokenResponse.refreshToken ?? refreshToken
+            let tokens = SpotifyTokens(
+                accessToken: tokenResponse.accessToken,
+                refreshToken: newRefreshToken,
+                expiresAt: Date().addingTimeInterval(TimeInterval(tokenResponse.expiresIn))
+            )
+            try saveTokens(tokens)
+            logger.info("Refreshed Spotify token")
+            return true
+        } catch {
+            logger.error("Token refresh failed: \(error.localizedDescription)")
+            return false
+        }
+    }
+
+    private func postTokenRequest(body: [String: String]) async throws -> SpotifyTokenResponse {
+        var request = URLRequest(url: URL(string: SpotifyConfig.tokenUrl)!)
+        request.httpMethod = "POST"
+        request.setValue("application/x-www-form-urlencoded", forHTTPHeaderField: "Content-Type")
+
+        let bodyString = body.map { "\($0.key)=\($0.value.addingPercentEncoding(withAllowedCharacters: .urlQueryAllowed) ?? $0.value)" }
+            .joined(separator: "&")
+        request.httpBody = bodyString.data(using: .utf8)
+
+        let (data, response) = try await URLSession.shared.data(for: request)
+
+        guard let httpResponse = response as? HTTPURLResponse,
+              httpResponse.statusCode == 200 else {
+            let statusCode = (response as? HTTPURLResponse)?.statusCode ?? -1
+            throw SpotifyAuthError.tokenRequestFailed(statusCode)
+        }
+
+        return try JSONDecoder().decode(SpotifyTokenResponse.self, from: data)
+    }
+
+    private func loadTokens() {
+        isConnected = loadStoredTokens() != nil
+    }
+
+    private func loadStoredTokens() -> SpotifyTokens? {
+        guard let data = KeychainHelper.load(key: tokensKey) else { return nil }
+        return try? JSONDecoder().decode(SpotifyTokens.self, from: data)
+    }
+
+    private func saveTokens(_ tokens: SpotifyTokens) throws {
+        let data = try JSONEncoder().encode(tokens)
+        try KeychainHelper.save(key: tokensKey, data: data)
+    }
+
+    private func generateCodeVerifier() -> String {
+        var bytes = [UInt8](repeating: 0, count: 32)
+        _ = SecRandomCopyBytes(kSecRandomDefault, bytes.count, &bytes)
+        return Data(bytes).base64URLEncodedString()
+    }
+
+    private func generateCodeChallenge(verifier: String) -> String {
+        guard let data = verifier.data(using: .utf8) else { return "" }
+        var hash = [UInt8](repeating: 0, count: Int(CC_SHA256_DIGEST_LENGTH))
+        data.withUnsafeBytes { buffer in
+            _ = CC_SHA256(buffer.baseAddress, CC_LONG(data.count), &hash)
+        }
+        return Data(hash).base64URLEncodedString()
+    }
+
+    enum SpotifyAuthError: Error {
+        case tokenRequestFailed(Int)
+    }
+}
+
+@available(iOS 16.0, *)
+extension SpotifyAuthManager: ASWebAuthenticationPresentationContextProviding {
+    nonisolated func presentationAnchor(for session: ASWebAuthenticationSession) -> ASPresentationAnchor {
+        ASPresentationAnchor()
+    }
+}
+
+extension Data {
+    func base64URLEncodedString() -> String {
+        base64EncodedString()
+            .replacingOccurrences(of: "+", with: "-")
+            .replacingOccurrences(of: "/", with: "_")
+            .replacingOccurrences(of: "=", with: "")
+    }
+}

IrisCompanion/iris/Spotify/SpotifyModels.swift

@@ -0,0 +1,91 @@
+//
+//  SpotifyModels.swift
+//  iris
+//
+//  Codable models for Spotify Web API responses.
+//
+
+import Foundation
+
+struct SpotifyTokens: Codable {
+    let accessToken: String
+    let refreshToken: String
+    let expiresAt: Date
+
+    enum CodingKeys: String, CodingKey {
+        case accessToken = "access_token"
+        case refreshToken = "refresh_token"
+        case expiresAt = "expires_at"
+    }
+
+    var isExpired: Bool {
+        Date() >= expiresAt
+    }
+
+    var expiresWithinMinutes: Bool {
+        Date().addingTimeInterval(5 * 60) >= expiresAt
+    }
+}
+
+struct SpotifyTokenResponse: Codable {
+    let accessToken: String
+    let tokenType: String
+    let expiresIn: Int
+    let refreshToken: String?
+    let scope: String?
+
+    enum CodingKeys: String, CodingKey {
+        case accessToken = "access_token"
+        case tokenType = "token_type"
+        case expiresIn = "expires_in"
+        case refreshToken = "refresh_token"
+        case scope
+    }
+}
+
+struct SpotifyPlaybackState: Codable {
+    let isPlaying: Bool
+    let progressMs: Int?
+    let item: SpotifyTrack?
+
+    enum CodingKeys: String, CodingKey {
+        case isPlaying = "is_playing"
+        case progressMs = "progress_ms"
+        case item
+    }
+}
+
+struct SpotifyTrack: Codable {
+    let id: String
+    let name: String
+    let artists: [SpotifyArtist]
+    let album: SpotifyAlbum
+    let durationMs: Int
+
+    enum CodingKeys: String, CodingKey {
+        case id, name, artists, album
+        case durationMs = "duration_ms"
+    }
+}
+
+struct SpotifyArtist: Codable {
+    let id: String
+    let name: String
+}
+
+struct SpotifyAlbum: Codable {
+    let id: String
+    let name: String
+}
+
+enum MusicSource: String, CaseIterable, Codable {
+    case appleMusic = "apple_music"
+    case spotify = "spotify"
+
+    var displayName: String {
+        switch self {
+        case .appleMusic: return "Apple Music"
+        case .spotify: return "Spotify"
+        }
+    }
+}

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)")
+        }
+    }
+}

IrisCompanion/iris/ViewModels/TodosViewModel.swift

@@ -0,0 +1,73 @@
+//
+//  TodosViewModel.swift
+//  iris
+//
+//  Created by Codex.
+//
+
+import Foundation
+
+@MainActor
+final class TodosViewModel: ObservableObject {
+    @Published private(set) var todos: [TodoItem] = []
+    @Published var newTitle: String = ""
+
+    private let store: TodoStore
+
+    init(store: TodoStore = TodoStore()) {
+        self.store = store
+        refresh()
+    }
+
+    func refresh() {
+        todos = sortedItems(store.snapshot())
+    }
+
+    func addTodo() {
+        let trimmed = normalizedTitle(newTitle)
+        guard !trimmed.isEmpty else { return }
+        store.add(title: trimmed)
+        newTitle = ""
+        refresh()
+    }
+
+    func deleteTodo(id: UUID) {
+        store.delete(id: id)
+        refresh()
+    }
+
+    func toggleCompleted(id: UUID) {
+        guard let current = todos.first(where: { $0.id == id }) else { return }
+        store.setCompleted(id: id, completed: !current.isCompleted)
+        refresh()
+    }
+
+    func updateTitle(id: UUID, title: String) {
+        let trimmed = normalizedTitle(title)
+        guard !trimmed.isEmpty else { return }
+        store.updateTitle(id: id, title: trimmed)
+        refresh()
+    }
+
+    private func normalizedTitle(_ raw: String) -> String {
+        raw.trimmingCharacters(in: .whitespacesAndNewlines)
+    }
+
+    private func sortedItems(_ items: [TodoItem]) -> [TodoItem] {
+        items.sorted { lhs, rhs in
+            if lhs.isCompleted != rhs.isCompleted {
+                return !lhs.isCompleted
+            }
+            if lhs.isCompleted {
+                let lhsDate = lhs.completedAt ?? lhs.updatedAt
+                let rhsDate = rhs.completedAt ?? rhs.updatedAt
+                if lhsDate != rhsDate {
+                    return lhsDate > rhsDate
+                }
+            } else if lhs.createdAt != rhs.createdAt {
+                return lhs.createdAt > rhs.createdAt
+            }
+            return lhs.id.uuidString < rhs.id.uuidString
+        }
+    }
+}

IrisCompanion/iris/Views/SettingsView.swift

@@ -0,0 +1,177 @@
+//
+//  SettingsView.swift
+//  iris
+//
+//  Settings UI for music source selection and Spotify connection.
+//
+
+import MusicKit
+import SwiftUI
+
+@available(iOS 16.0, *)
+struct SettingsView: View {
+    @EnvironmentObject private var orchestrator: ContextOrchestrator
+    @EnvironmentObject private var spotifyAuth: SpotifyAuthManager
+    @State private var isConfigExpanded: Bool = false
+    @State private var clientIdInput: String = ""
+
+    var body: some View {
+        NavigationStack {
+            List {
+                Section("Music Source") {
+                    Picker("Source", selection: Binding(
+                        get: { orchestrator.musicSource },
+                        set: { newValue in
+                            if newValue == .spotify && !spotifyAuth.isConnected {
+                                return
+                            }
+                            orchestrator.musicSource = newValue
+                        }
+                    )) {
+                        ForEach(MusicSource.allCases, id: \.self) { source in
+                            Text(source.displayName).tag(source)
+                        }
+                    }
+                    .pickerStyle(.segmented)
+
+                    if !spotifyAuth.isConnected {
+                        Text("Connect Spotify below to enable it as a source")
+                            .font(.caption)
+                            .foregroundStyle(.secondary)
+                    }
+                }
+
+                Section {
+                    DisclosureGroup("Configuration", isExpanded: $isConfigExpanded) {
+                        TextField("Client ID", text: $clientIdInput)
+                            .textInputAutocapitalization(.never)
+                            .autocorrectionDisabled()
+                            .font(.system(.body, design: .monospaced))
+
+                        Text("Get your Client ID from developer.spotify.com/dashboard")
+                            .font(.caption)
+                            .foregroundStyle(.secondary)
+
+                        Button("Save") {
+                            spotifyAuth.setClientId(clientIdInput)
+                            isConfigExpanded = false
+                        }
+                        .disabled(clientIdInput.trimmingCharacters(in: .whitespaces).isEmpty)
+                    }
+                    .onAppear {
+                        clientIdInput = spotifyAuth.clientId
+                    }
+
+                    if spotifyAuth.isConnected {
+                        HStack {
+                            Label("Connected", systemImage: "checkmark.circle.fill")
+                                .foregroundColor(.green)
+                            Spacer()
+                        }
+                        Button("Disconnect", role: .destructive) {
+                            spotifyAuth.disconnect()
+                            if orchestrator.musicSource == .spotify {
+                                orchestrator.musicSource = .appleMusic
+                            }
+                        }
+                    } else if spotifyAuth.isConfigured {
+                        Button {
+                            spotifyAuth.startAuth()
+                        } label: {
+                            HStack {
+                                Label("Connect to Spotify", systemImage: "link")
+                                Spacer()
+                                if spotifyAuth.isAuthenticating {
+                                    ProgressView()
+                                }
+                            }
+                        }
+                        .disabled(spotifyAuth.isAuthenticating)
+                    } else {
+                        Text("Enter your Client ID above to connect")
+                            .font(.callout)
+                            .foregroundStyle(.secondary)
+                    }
+
+                    if let error = spotifyAuth.error {
+                        Text(error)
+                            .font(.caption)
+                            .foregroundColor(.red)
+                    }
+                } header: {
+                    Text("Spotify")
+                } footer: {
+                    if !spotifyAuth.isConnected && spotifyAuth.isConfigured {
+                        Text("Connect your Spotify account to display current track on Glass.")
+                    }
+                }
+
+                Section {
+                    HStack {
+                        Text("Authorization")
+                        Spacer()
+                        Text(authStatusText(orchestrator.musicAuthorization))
+                            .foregroundStyle(.secondary)
+                    }
+                } header: {
+                    Text("Apple Music")
+                }
+
+                Section {
+                    if let nowPlayingInfo = currentNowPlaying {
+                        VStack(alignment: .leading, spacing: 4) {
+                            Text(nowPlayingInfo.title)
+                                .font(.headline)
+                            if let artist = nowPlayingInfo.artist {
+                                Text(artist)
+                                    .font(.subheadline)
+                                    .foregroundStyle(.secondary)
+                            }
+                        }
+                    } else {
+                        Text("Nothing playing")
+                            .foregroundStyle(.secondary)
+                    }
+                } header: {
+                    Text("Now Playing")
+                } footer: {
+                    Text("Source: \(orchestrator.musicSource.displayName)")
+                }
+            }
+            .navigationTitle("Settings")
+        }
+    }
+
+    private var currentNowPlaying: (title: String, artist: String?)? {
+        switch orchestrator.musicSource {
+        case .appleMusic:
+            guard let np = orchestrator.nowPlaying else { return nil }
+            return (np.title, np.artist)
+        case .spotify:
+            guard let np = orchestrator.spotifyNowPlaying else { return nil }
+            return (np.title, np.artist)
+        }
+    }
+
+    private func authStatusText(_ status: MusicAuthorization.Status) -> String {
+        switch status {
+        case .notDetermined: return "Not Determined"
+        case .denied: return "Denied"
+        case .restricted: return "Restricted"
+        case .authorized: return "Authorized"
+        @unknown default: return "Unknown"
+        }
+    }
+}
+
+@available(iOS 16.0, *)
+struct SettingsView_Previews: PreviewProvider {
+    static var previews: some View {
+        let ble = BlePeripheralManager()
+        let spotifyAuth = SpotifyAuthManager()
+        let orchestrator = ContextOrchestrator(ble: ble, spotifyAuth: spotifyAuth)
+        SettingsView()
+            .environmentObject(orchestrator)
+            .environmentObject(spotifyAuth)
+    }
+}

IrisCompanion/iris/Views/StockSettingsView.swift

@@ -0,0 +1,104 @@
+//
+//  StockSettingsView.swift
+//  iris
+//
+
+import SwiftUI
+
+struct StockSettingsView: View {
+    @ObservedObject var store: StockSettingsStore
+    @State private var newSymbol: String = ""
+    @State private var showError: Bool = false
+    @State private var errorMessage: String = ""
+
+    var body: some View {
+        Form {
+            Section {
+                ForEach(store.symbols, id: \.self) { symbol in
+                    HStack {
+                        Text(symbol)
+                            .font(.body.monospaced())
+                        Spacer()
+                        Button(role: .destructive) {
+                            store.removeSymbol(symbol)
+                        } label: {
+                            Image(systemName: "trash")
+                                .foregroundStyle(.red)
+                        }
+                        .buttonStyle(.plain)
+                    }
+                }
+                .onDelete { indexSet in
+                    for index in indexSet {
+                        store.removeSymbol(store.symbols[index])
+                    }
+                }
+
+                if store.symbols.count < 5 {
+                    HStack {
+                        TextField("Symbol (e.g. AAPL)", text: $newSymbol)
+                            .textInputAutocapitalization(.characters)
+                            .autocorrectionDisabled()
+                            .font(.body.monospaced())
+                        Button("Add") {
+                            addSymbol()
+                        }
+                        .disabled(newSymbol.trimmingCharacters(in: .whitespacesAndNewlines).isEmpty)
+                    }
+                }
+            } header: {
+                Text("Stock Symbols")
+            } footer: {
+                Text("Enter up to 5 stock symbols. Cards appear in the FYI section.")
+            }
+
+            Section {
+                VStack(alignment: .leading, spacing: 8) {
+                    Text("Examples:")
+                        .font(.subheadline.bold())
+                    Text("AAPL - Apple Inc.")
+                    Text("GOOGL - Alphabet Inc.")
+                    Text("^GSPC - S&P 500 Index")
+                    Text("^DJI - Dow Jones")
+                    Text("^IXIC - NASDAQ Composite")
+                }
+                .font(.caption)
+                .foregroundStyle(.secondary)
+            }
+        }
+        .navigationTitle("Stocks")
+        .alert("Error", isPresented: $showError) {
+            Button("OK") {}
+        } message: {
+            Text(errorMessage)
+        }
+    }
+
+    private func addSymbol() {
+        let cleaned = newSymbol.trimmingCharacters(in: .whitespacesAndNewlines).uppercased()
+        guard !cleaned.isEmpty else { return }
+
+        if store.symbols.contains(cleaned) {
+            errorMessage = "Symbol '\(cleaned)' already exists."
+            showError = true
+            return
+        }
+
+        if store.symbols.count >= 5 {
+            errorMessage = "Maximum of 5 symbols allowed."
+            showError = true
+            return
+        }
+
+        store.addSymbol(cleaned)
+        newSymbol = ""
+    }
+}
+
+struct StockSettingsView_Previews: PreviewProvider {
+    static var previews: some View {
+        NavigationStack {
+            StockSettingsView(store: StockSettingsStore())
+        }
+    }
+}

IrisCompanion/iris/Views/TodosView.swift

@@ -0,0 +1,195 @@
+//
+//  TodosView.swift
+//  iris
+//
+//  Created by Codex.
+//
+
+import SwiftUI
+
+struct TodosView: View {
+    @StateObject private var model = TodosViewModel()
+    @State private var isDoneExpanded = false
+    @State private var lastDoneCount = 0
+
+    private var openTodos: [TodoItem] {
+        model.todos.filter { !$0.isCompleted }
+    }
+
+    private var doneTodos: [TodoItem] {
+        model.todos.filter { $0.isCompleted }
+    }
+
+    var body: some View {
+        NavigationStack {
+            List {
+                Section("Add") {
+                    HStack(spacing: 12) {
+                        TextField("Add a todo", text: $model.newTitle)
+                            .textInputAutocapitalization(.sentences)
+                            .disableAutocorrection(false)
+                            .submitLabel(.done)
+                            .onSubmit { model.addTodo() }
+
+                        Button {
+                            model.addTodo()
+                        } label: {
+                            Image(systemName: "plus.circle.fill")
+                                .font(.title3)
+                        }
+                        .buttonStyle(.plain)
+                        .disabled(model.newTitle.trimmingCharacters(in: .whitespacesAndNewlines).isEmpty)
+                        .accessibilityLabel("Add todo")
+                    }
+                }
+
+                Section("Todos") {
+                    if openTodos.isEmpty {
+                        Text("No open todos")
+                            .foregroundStyle(.secondary)
+                    } else {
+                        ForEach(openTodos) { item in
+                            TodoRow(
+                                item: item,
+                                onToggle: { model.toggleCompleted(id: item.id) },
+                                onDelete: { model.deleteTodo(id: item.id) },
+                                onUpdateTitle: { model.updateTitle(id: item.id, title: $0) }
+                            )
+                        }
+                    }
+                }
+
+                Section {
+                    if isDoneExpanded {
+                        if doneTodos.isEmpty {
+                            Text("No completed todos")
+                                .foregroundStyle(.secondary)
+                        } else {
+                            ForEach(doneTodos) { item in
+                                TodoRow(
+                                    item: item,
+                                    onToggle: { model.toggleCompleted(id: item.id) },
+                                    onDelete: { model.deleteTodo(id: item.id) },
+                                    onUpdateTitle: { model.updateTitle(id: item.id, title: $0) }
+                                )
+                            }
+                        }
+                    }
+                } header: {
+                    Button {
+                        withAnimation(.easeInOut(duration: 0.15)) {
+                            isDoneExpanded.toggle()
+                        }
+                    } label: {
+                        HStack(spacing: 8) {
+                            Text("Done")
+                            Spacer()
+                            if doneTodos.count > 0 {
+                                Text("\(doneTodos.count)")
+                                    .foregroundStyle(.secondary)
+                            }
+                            Image(systemName: isDoneExpanded ? "chevron.down" : "chevron.right")
+                                .foregroundStyle(.secondary)
+                                .font(.caption)
+                        }
+                    }
+                    .buttonStyle(.plain)
+                }
+            }
+            .navigationTitle("Todos")
+            .onAppear {
+                lastDoneCount = doneTodos.count
+                if lastDoneCount == 0 {
+                    isDoneExpanded = false
+                }
+            }
+            .onChange(of: doneTodos.count) { newCount in
+                if lastDoneCount == 0, newCount > 0, !isDoneExpanded {
+                    withAnimation(.easeInOut(duration: 0.15)) {
+                        isDoneExpanded = true
+                    }
+                } else if newCount == 0, isDoneExpanded {
+                    withAnimation(.easeInOut(duration: 0.15)) {
+                        isDoneExpanded = false
+                    }
+                }
+                lastDoneCount = newCount
+            }
+        }
+    }
+}
+
+private struct TodoRow: View {
+    let item: TodoItem
+    let onToggle: () -> Void
+    let onDelete: () -> Void
+    let onUpdateTitle: (String) -> Void
+
+    @State private var draftTitle: String
+    @FocusState private var isFocused: Bool
+
+    init(item: TodoItem,
+         onToggle: @escaping () -> Void,
+         onDelete: @escaping () -> Void,
+         onUpdateTitle: @escaping (String) -> Void) {
+        self.item = item
+        self.onToggle = onToggle
+        self.onDelete = onDelete
+        self.onUpdateTitle = onUpdateTitle
+        _draftTitle = State(initialValue: item.title)
+    }
+
+    var body: some View {
+        HStack(spacing: 12) {
+            Button(action: onToggle) {
+                Image(systemName: item.isCompleted ? "checkmark.circle.fill" : "circle")
+                    .foregroundStyle(item.isCompleted ? .secondary : .primary)
+            }
+            .buttonStyle(.plain)
+            .accessibilityLabel(item.isCompleted ? "Mark incomplete" : "Mark complete")
+
+            TextField("Todo", text: $draftTitle)
+                .focused($isFocused)
+                .submitLabel(.done)
+                .onSubmit { commitTitleIfNeeded() }
+                .onChange(of: isFocused) { focused in
+                    if !focused {
+                        commitTitleIfNeeded()
+                    }
+                }
+                .onChange(of: item.title) { newValue in
+                    if !isFocused {
+                        draftTitle = newValue
+                    }
+                }
+                .foregroundStyle(item.isCompleted ? .secondary : .primary)
+                .opacity(item.isCompleted ? 0.7 : 1.0)
+        }
+        .onDisappear {
+            if isFocused {
+                commitTitleIfNeeded()
+            }
+        }
+        .swipeActions(edge: .trailing, allowsFullSwipe: true) {
+            Button(role: .destructive, action: onDelete) {
+                Label("Delete", systemImage: "trash")
+            }
+        }
+    }
+
+    private func commitTitleIfNeeded() {
+        let trimmed = draftTitle.trimmingCharacters(in: .whitespacesAndNewlines)
+        guard !trimmed.isEmpty else {
+            draftTitle = item.title
+            return
+        }
+        guard trimmed != item.title else { return }
+        onUpdateTitle(trimmed)
+    }
+}
+
+struct TodosView_Previews: PreviewProvider {
+    static var previews: some View {
+        TodosView()
+    }
+}

IrisCompanion/iris/irisApp.swift

@@ -12,12 +12,15 @@ struct irisApp: App {
     @Environment(\.scenePhase) private var scenePhase
     @StateObject private var ble: BlePeripheralManager
     @StateObject private var orchestrator: ContextOrchestrator
+    @StateObject private var spotifyAuth: SpotifyAuthManager
 
     init() {
         let bleManager = BlePeripheralManager()
         bleManager.start()
+        let spotify = SpotifyAuthManager()
         _ble = StateObject(wrappedValue: bleManager)
-        _orchestrator = StateObject(wrappedValue: ContextOrchestrator(ble: bleManager))
+        _spotifyAuth = StateObject(wrappedValue: spotify)
+        _orchestrator = StateObject(wrappedValue: ContextOrchestrator(ble: bleManager, spotifyAuth: spotify))
     }
 
     var body: some Scene {
@@ -25,6 +28,12 @@ struct irisApp: App {
             ContentView()
                 .environmentObject(ble)
                 .environmentObject(orchestrator)
+                .environmentObject(spotifyAuth)
+                .onOpenURL { url in
+                    if url.scheme == "iris-spotify-auth" {
+                        spotifyAuth.handleCallback(url: url)
+                    }
+                }
                 .onChange(of: scenePhase) { phase in
                     if phase == .active || phase == .background {
                         ble.start()