Replace per-conversation expiration timers with single next-expiration timer (#509)

## Summary

Replaces the per-conversation `Task.sleep` timers added in #475 with a proper single-timer architecture in `ExpiredConversationsWorker`.

## Problem

PR #475 added per-conversation `Task.sleep` tasks in `ScheduledExplosionManager` to detect when conversations expire while the app is foregrounded. This approach had several issues:

1. **Wrong responsibility** — `ScheduledExplosionManager` handles local push notifications. Expiration cleanup belongs in `ExpiredConversationsWorker`.
2. **Per-conversation tasks don't scale** — 10 scheduled explosions = 10 sleeping tasks.
3. **Duplicates existing logic** — `ExpiredConversationsWorker` already knows how to query and clean up expired conversations, it just needed a trigger.

## Solution

`ExpiredConversationsWorker` now maintains a **single timer** for the next expiring conversation:

1. After processing expired conversations, queries DB for the soonest future `expiresAt`
2. Schedules one `Task.sleep` for that duration
3. When the timer fires, processes all newly-expired conversations and reschedules

The timer is cancelled and rescheduled whenever:
- A new explosion is scheduled (`.conversationScheduledExplosion`)
- The app becomes active (`didBecomeActive`)
- A conversation expires (`.conversationExpired`)

## Changes

- **`ScheduledExplosionManager`**: Removed all expiration task logic (`_expirationTasks`, `scheduleExpirationTask`, `postConversationExpired`). Now only handles local push notification scheduling.
- **`ExpiredConversationsWorker`**: Added single `nextExpirationTask` timer with `fetchNextExpiration()` DB query. Now also observes `.conversationScheduledExplosion`.
- **Tests**: Moved expiration tests to new `ExpiredConversationsWorkerTests`. All existing `ScheduledExplosionManager` notification tests still pass.

Stacks on #475.

<!-- Macroscope's pull request summary starts here -->
<!-- Macroscope will only edit the content between these invisible markers, and the markers themselves will not be visible in the GitHub rendered markdown. -->
<!-- If you delete either of the start / end markers from your PR's description, Macroscope will append its summary at the bottom of the description. -->
> [!NOTE]
> ### Replace per-conversation expiration timers with a single buffered next-expiration Task in `ExpiredConversationsWorker.scheduleNextExpirationCheck` with a 0.5s wake buffer
> Move expiration timing from `ScheduledExplosionManager` to `ExpiredConversationsWorker`, add `checkAndReschedule` and a single `nextExpirationTask`, and gate progress indicator completion animation via `HoldToConfirmStyleConfig.poofProgressIndicatorOnComplete`.
>
> #### 📍Where to Start
> Start with `ExpiredConversationsWorker.checkAndReschedule` in [ExpiredConversationsWorker.swift](https://github.com/xmtplabs/convos-ios/pull/509/files#diff-0fe27ce7c3c36513ccb0460c6a57e998999c277b68bf21f48fbf24d6b935a616).
>
> <!-- Macroscope's review summary starts here -->
>
> <sup><a href="https://app.macroscope.com">Macroscope</a> summarized 6fd1648.</sup>
> <!-- Macroscope's review summary ends here -->
>
<!-- macroscope-ui-refresh -->
<!-- Macroscope's pull request summary ends here -->

Author: yewreeka

Convos/Shared Views/HoldToConfirmButton.swift

@@ -25,6 +25,7 @@ struct HoldToConfirmStyleConfig {
 
     // Progress indicator
     var showProgressIndicator: Bool = true
+    var poofProgressIndicatorOnComplete: Bool = true
 
     static let `default`: HoldToConfirmStyleConfig = .init()
 }
@@ -65,6 +66,10 @@ struct HoldToConfirmPrimitiveStyle: PrimitiveButtonStyle {
         @State private var didFire: Bool = false
         @State private var frozenProgress: Double = 0
 
+        private var shouldPoof: Bool {
+            config.poofProgressIndicatorOnComplete && didFire
+        }
+
         var body: some View {
             TimelineView(.animation(paused: !isPressing)) { context in
                 let currentProgress: Double = {
@@ -96,6 +101,10 @@ struct HoldToConfirmPrimitiveStyle: PrimitiveButtonStyle {
                                             .fill(config.progressIndicatorColor)
                                             .scaleEffect(currentProgress)
                                     )
+                                    .scaleEffect(shouldPoof ? 2.0 : 1.0)
+                                    .blur(radius: shouldPoof ? 8 : 0)
+                                    .opacity(shouldPoof ? 0 : 1)
+                                    .animation(.easeOut(duration: 0.25), value: shouldPoof)
                                 Spacer()
                             }
                             .padding(config.progressIndicatorPadding)

ConvosCore/Sources/ConvosCore/Storage/Workers/ExpiredConversationsWorker.swift

@@ -3,15 +3,22 @@ import GRDB
 
 public protocol ExpiredConversationsWorkerProtocol {}
 
+/// Monitors conversations with scheduled explosions and triggers cleanup when they expire.
+///
+/// Uses a single timer targeting the next expiring conversation rather than per-conversation
+/// timers. After processing expired conversations, queries the database for the soonest
+/// future expiresAt and schedules one task to wake at that time.
+///
 /// @unchecked Sendable: Protocol dependencies (SessionManager, DatabaseReader, AppLifecycle)
-/// are all Sendable. The `observers` array is marked `nonisolated(unsafe)` and only modified
-/// during init (setupObservers) and deinit. NotificationCenter callbacks use weak self
-/// and dispatch work to async Tasks.
+/// are all Sendable. The `observers` array is only modified during init and deinit.
+/// The `nextExpirationTask` is protected by `taskLock`.
 final class ExpiredConversationsWorker: ExpiredConversationsWorkerProtocol, @unchecked Sendable {
     private let sessionManager: any SessionManagerProtocol
     private let databaseReader: any DatabaseReader
     private let appLifecycle: any AppLifecycleProviding
     nonisolated(unsafe) private var observers: [NSObjectProtocol] = []
+    private let taskLock: NSLock = NSLock()
+    private var nextExpirationTask: Task<Void, Never>?
 
     init(
         databaseReader: any DatabaseReader,
@@ -22,12 +29,13 @@ final class ExpiredConversationsWorker: ExpiredConversationsWorkerProtocol, @unc
         self.sessionManager = sessionManager
         self.appLifecycle = appLifecycle
         setupObservers()
-        checkForExpiredConversations()
+        checkAndReschedule()
     }
 
     deinit {
         Log.warning("ExpiredConversationsWorker deinit - removing observers")
         observers.forEach { NotificationCenter.default.removeObserver($0) }
+        cancelNextExpirationTask()
     }
 
     private func setupObservers() {
@@ -38,7 +46,7 @@ final class ExpiredConversationsWorker: ExpiredConversationsWorkerProtocol, @unc
             object: nil,
             queue: .main
         ) { [weak self] _ in
-            self?.checkForExpiredConversations()
+            self?.checkAndReschedule()
         })
 
         observers.append(center.addObserver(
@@ -50,38 +58,95 @@ final class ExpiredConversationsWorker: ExpiredConversationsWorkerProtocol, @unc
             if let conversationId = notification.userInfo?["conversationId"] as? String {
                 self?.handleExpiredConversation(conversationId: conversationId)
             } else {
-                self?.checkForExpiredConversations()
+                self?.checkAndReschedule()
             }
         })
 
+        observers.append(center.addObserver(
+            forName: .conversationScheduledExplosion,
+            object: nil,
+            queue: .main
+        ) { [weak self] _ in
+            self?.checkAndReschedule()
+        })
+
         observers.append(center.addObserver(
             forName: .explosionNotificationTapped,
             object: nil,
             queue: .main
         ) { [weak self] _ in
-            self?.checkForExpiredConversations()
+            self?.checkAndReschedule()
         })
     }
 
-    private func checkForExpiredConversations() {
+    private func handleExpiredConversation(conversationId: String) {
         Task { [weak self] in
             guard let self else { return }
-            await self.queryAndProcessExpiredConversations()
+            await self.processExpiredConversationById(conversationId)
+            await self.scheduleNextExpirationCheck()
         }
     }
 
-    private func handleExpiredConversation(conversationId: String) {
+    private func checkAndReschedule() {
         Task { [weak self] in
             guard let self else { return }
-            await self.processExpiredConversationById(conversationId)
+            await self.queryAndProcessExpiredConversations()
+            await self.scheduleNextExpirationCheck()
+        }
+    }
+
+    private func scheduleNextExpirationCheck() async {
+        cancelNextExpirationTask()
+
+        do {
+            let nextExpiresAt = try await databaseReader.read { db -> Date? in
+                try db.fetchNextExpiration()
+            }
+
+            guard let nextExpiresAt else { return }
+
+            let interval = nextExpiresAt.timeIntervalSinceNow
+            guard interval > 0 else {
+                await queryAndProcessExpiredConversations()
+                await scheduleNextExpirationCheck()
+                return
+            }
+
+            let bufferedInterval: Double = interval + Constant.expirationBuffer
+            Log.info("ExpiredConversationsWorker: next expiration in \(Int(interval))s (sleeping \(bufferedInterval)s)")
+
+            let task = Task { [weak self] in
+                try? await Task.sleep(for: .seconds(bufferedInterval))
+                guard !Task.isCancelled else { return }
+                self?.checkAndReschedule()
+            }
+
+            replaceNextExpirationTask(task)
+        } catch {
+            Log.error("Failed to query next expiration: \(error)")
         }
     }
 
+    private nonisolated func cancelNextExpirationTask() {
+        taskLock.lock()
+        nextExpirationTask?.cancel()
+        nextExpirationTask = nil
+        taskLock.unlock()
+    }
+
+    private nonisolated func replaceNextExpirationTask(_ task: Task<Void, Never>) {
+        taskLock.lock()
+        nextExpirationTask?.cancel()
+        nextExpirationTask = task
+        taskLock.unlock()
+    }
+
     private func processExpiredConversationById(_ conversationId: String) async {
         do {
             let conversation = try await databaseReader.read { db -> ExpiredConversation? in
-                guard let row = try DBConversation.fetchOne(db, key: conversationId) else {
-                    Log.warning("Conversation not found for expiration: \(conversationId)")
+                guard let row = try DBConversation.fetchOne(db, key: conversationId),
+                      let expiresAt = row.expiresAt,
+                      expiresAt <= Date() else {
                     return nil
                 }
                 return ExpiredConversation(
@@ -104,16 +169,16 @@ final class ExpiredConversationsWorker: ExpiredConversationsWorkerProtocol, @unc
                 try db.fetchExpiredConversations()
             }
             guard !expiredConversations.isEmpty else { return }
-            await processExpiredConversations(expiredConversations)
+            for conversation in expiredConversations {
+                await cleanupExpiredConversation(conversation)
+            }
         } catch {
             Log.error("Failed to query expired conversations: \(error)")
         }
     }
 
-    private func processExpiredConversations(_ conversations: [ExpiredConversation]) async {
-        for conversation in conversations {
-            await cleanupExpiredConversation(conversation)
-        }
+    private enum Constant {
+        static let expirationBuffer: TimeInterval = 0.5
     }
 
     private func cleanupExpiredConversation(_ conversation: ExpiredConversation) async {
@@ -139,7 +204,7 @@ struct ExpiredConversation {
     let inboxId: String
 }
 
-fileprivate extension Database {
+private extension Database {
     func fetchExpiredConversations() throws -> [ExpiredConversation] {
         let rows = try DBConversation
             .filter(DBConversation.Columns.expiresAt != nil)
@@ -154,4 +219,13 @@ fileprivate extension Database {
             )
         }
     }
+
+    func fetchNextExpiration() throws -> Date? {
+        try DBConversation
+            .filter(DBConversation.Columns.expiresAt != nil)
+            .filter(DBConversation.Columns.expiresAt > Date())
+            .order(DBConversation.Columns.expiresAt.asc)
+            .fetchOne(self)?
+            .expiresAt
+    }
 }

ConvosCore/Sources/ConvosCore/Storage/Workers/ScheduledExplosionManager.swift

@@ -6,16 +6,15 @@ public protocol ScheduledExplosionManagerProtocol {}
 
 /// @unchecked Sendable: Protocol dependencies (DatabaseReader, AppLifecycle)
 /// are all Sendable. The `observers` array is only modified during init and deinit.
-/// The `schedulingTasks` and `expirationTasks` dictionaries are protected by `taskLock`
-/// to prevent data races from concurrent notification callbacks.
+/// The `schedulingTasks` dictionary is protected by `taskLock` to prevent data races
+/// from concurrent notification callbacks.
 final class ScheduledExplosionManager: ScheduledExplosionManagerProtocol, @unchecked Sendable {
     private let databaseReader: any DatabaseReader
     private let appLifecycle: any AppLifecycleProviding
     private let notificationCenter: any UserNotificationCenterProtocol
     nonisolated(unsafe) private var observers: [NSObjectProtocol] = []
     private let taskLock: NSLock = NSLock()
     private var _schedulingTasks: [String: Task<Void, Never>] = [:]
-    private var _expirationTasks: [String: Task<Void, Never>] = [:]
 
     private enum Constant {
         static let reminderIdentifierPrefix: String = "explosion-reminder-"
@@ -85,8 +84,6 @@ final class ScheduledExplosionManager: ScheduledExplosionManagerProtocol, @unche
             self.removeSchedulingTask(for: conversationId)
         }
         taskLock.unlock()
-
-        scheduleExpirationTask(conversationId: conversationId, expiresAt: expiresAt)
     }
 
     private nonisolated func removeSchedulingTask(for conversationId: String) {
@@ -95,42 +92,6 @@ final class ScheduledExplosionManager: ScheduledExplosionManagerProtocol, @unche
         taskLock.unlock()
     }
 
-    private nonisolated func removeExpirationTask(for conversationId: String) {
-        taskLock.lock()
-        _expirationTasks[conversationId] = nil
-        taskLock.unlock()
-    }
-
-    private func scheduleExpirationTask(conversationId: String, expiresAt: Date) {
-        taskLock.lock()
-        _expirationTasks[conversationId]?.cancel()
-        _expirationTasks[conversationId] = Task { [weak self] in
-            guard let self else { return }
-
-            let interval = expiresAt.timeIntervalSinceNow
-            guard interval > 0 else {
-                await self.postConversationExpired(conversationId: conversationId)
-                self.removeExpirationTask(for: conversationId)
-                return
-            }
-
-            try? await Task.sleep(for: .seconds(interval))
-            guard !Task.isCancelled else { return }
-
-            await self.postConversationExpired(conversationId: conversationId)
-            self.removeExpirationTask(for: conversationId)
-        }
-        taskLock.unlock()
-    }
-
-    @MainActor
-    private func postConversationExpired(conversationId: String) {
-        NotificationCenter.default.post(
-            name: .conversationExpired,
-            object: nil,
-            userInfo: ["conversationId": conversationId]
-        )
-    }
 
     func hasSchedulingTask(for conversationId: String) -> Bool {
         taskLock.lock()
@@ -182,10 +143,6 @@ final class ScheduledExplosionManager: ScheduledExplosionManagerProtocol, @unche
                     expiresAt: conversation.expiresAt,
                     conversationName: conversation.name
                 )
-                scheduleExpirationTask(
-                    conversationId: conversation.conversationId,
-                    expiresAt: conversation.expiresAt
-                )
             }
         } catch {
             Log.error("Failed to query scheduled explosions: \(error)")
@@ -199,7 +156,6 @@ final class ScheduledExplosionManager: ScheduledExplosionManagerProtocol, @unche
     ) async {
         let reminderDate = expiresAt.addingTimeInterval(-Constant.oneHourInSeconds)
 
-        // Capture interval BEFORE any async operations to avoid time drift
         let reminderInterval = reminderDate.timeIntervalSinceNow
         guard reminderInterval > 0 else {
             Log.info("ScheduledExplosionManager: Skipping reminder for \(conversationId), less than 1 hour away")
@@ -297,18 +253,14 @@ final class ScheduledExplosionManager: ScheduledExplosionManagerProtocol, @unche
     private func cancelAllTasks() {
         taskLock.lock()
         _schedulingTasks.values.forEach { $0.cancel() }
-        _expirationTasks.values.forEach { $0.cancel() }
         _schedulingTasks.removeAll()
-        _expirationTasks.removeAll()
         taskLock.unlock()
     }
 
     private func cancelNotifications(for conversationId: String) {
         taskLock.lock()
         _schedulingTasks[conversationId]?.cancel()
         _schedulingTasks[conversationId] = nil
-        _expirationTasks[conversationId]?.cancel()
-        _expirationTasks[conversationId] = nil
         taskLock.unlock()
         let reminderIdentifier = "\(Constant.reminderIdentifierPrefix)\(conversationId)"
         let explosionIdentifier = "\(Constant.explosionIdentifierPrefix)\(conversationId)"