Fix scheduled explosion cleanup getting stuck (#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. -->
### Prevent scheduled explosion cleanup from getting stuck by adding per-conversation expiration tasks and immediate cancellation in `ScheduledExplosionManager`
Add `_expirationTasks` with locking, schedule per-conversation expiration via `ScheduledExplosionManager.scheduleExpirationTask`, post `.conversationExpired` on expiry or immediately if past, and cancel all tasks in `deinit` and `cancelNotifications(for:)`. Include tests for expiry posting and rescan behavior.

#### 📍Where to Start
Start with `handleScheduledExplosion` in [ScheduledExplosionManager.swift](https://github.com/xmtplabs/convos-ios/pull/475/files#diff-02b035d174d75b0dde80ebc879a4bc253710f806fa9c6aae3f49b2f1a798abcb), then review `scheduleExpirationTask` and `cancelAllTasks`.

<!-- Macroscope's review summary starts here -->

<sup><a href="https://app.macroscope.com">Macroscope</a> summarized 106ede7.</sup>
<!-- Macroscope's review summary ends here -->

<!-- Macroscope's pull request summary ends here -->

Author: lourou

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

@@ -6,15 +6,16 @@ public protocol ScheduledExplosionManagerProtocol {}
 
 /// @unchecked Sendable: Protocol dependencies (DatabaseReader, AppLifecycle)
 /// are all Sendable. The `observers` array is only modified during init and deinit.
-/// The `schedulingTasks` dictionary is protected by `taskLock` to prevent data races
-/// from concurrent notification callbacks.
+/// The `schedulingTasks` and `expirationTasks` dictionaries are 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-"
@@ -37,6 +38,7 @@ final class ScheduledExplosionManager: ScheduledExplosionManagerProtocol, @unche
     deinit {
         Log.warning("ScheduledExplosionManager deinit - removing observers")
         observers.forEach { NotificationCenter.default.removeObserver($0) }
+        cancelAllTasks()
     }
 
     private func setupObservers() {
@@ -83,6 +85,8 @@ final class ScheduledExplosionManager: ScheduledExplosionManagerProtocol, @unche
             self.removeSchedulingTask(for: conversationId)
         }
         taskLock.unlock()
+
+        scheduleExpirationTask(conversationId: conversationId, expiresAt: expiresAt)
     }
 
     private nonisolated func removeSchedulingTask(for conversationId: String) {
@@ -91,6 +95,43 @@ 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()
         defer { taskLock.unlock() }
@@ -141,6 +182,10 @@ 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)")
@@ -241,16 +286,29 @@ final class ScheduledExplosionManager: ScheduledExplosionManagerProtocol, @unche
             if let name, !name.isEmpty {
                 return name
             }
+        } catch is CancellationError {
+            return "Untitled"
         } catch {
             Log.error("Failed to fetch conversation name: \(error)")
         }
         return "Untitled"
     }
 
+    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)"

ConvosCore/Tests/ConvosCoreTests/ScheduledExplosionManagerTests.swift

@@ -167,6 +167,68 @@ struct ScheduledExplosionManagerTests {
         #expect(removedIds.contains("explosion-\(conversationId)"))
     }
 
+    @Test("Posts conversationExpired at expiresAt after scheduling")
+    func testPostsConversationExpiredAtExpiry() async throws {
+        let fixtures = ScheduledExplosionTestFixtures()
+        let expiresAt = Date().addingTimeInterval(1.0)
+
+        let capture = NotificationCapture()
+        capture.startCapturing(.conversationExpired)
+        defer { capture.stopCapturing() }
+
+        let conversationId = fixtures.conversationId
+
+        await MainActor.run {
+            NotificationCenter.default.post(
+                name: .conversationScheduledExplosion,
+                object: nil,
+                userInfo: [
+                    "conversationId": conversationId,
+                    "expiresAt": expiresAt
+                ]
+            )
+        }
+
+        try await waitUntil(timeout: .seconds(3)) {
+            capture.hasNotification(.conversationExpired)
+        }
+
+        let notifications = capture.notifications(named: .conversationExpired)
+        let matched = notifications.contains {
+            ($0.userInfo?["conversationId"] as? String) == conversationId
+        }
+        #expect(matched, "Should post conversationExpired for scheduled conversation")
+    }
+
+    @Test("App active rescan schedules deterministic expiry cleanup")
+    func testRescanSchedulesExpiryCleanup() async throws {
+        let fixtures = ScheduledExplosionTestFixtures()
+        let expiresAt = Date().addingTimeInterval(1.0)
+        try await fixtures.setupConversation(expiresAt: expiresAt)
+
+        let capture = NotificationCapture()
+        capture.startCapturing(.conversationExpired)
+        defer { capture.stopCapturing() }
+
+        let activeNotification = fixtures.appLifecycle.didBecomeActiveNotification
+        let conversationId = fixtures.conversationId
+
+        await MainActor.run {
+            NotificationCenter.default.post(name: activeNotification, object: nil)
+        }
+
+        try await waitUntil(timeout: .seconds(3)) {
+            capture.notifications(named: .conversationExpired).contains {
+                ($0.userInfo?["conversationId"] as? String) == conversationId
+            }
+        }
+
+        let matched = capture.notifications(named: .conversationExpired).contains {
+            ($0.userInfo?["conversationId"] as? String) == conversationId
+        }
+        #expect(matched, "Should post conversationExpired after app-active rescan when expiresAt is reached")
+    }
+
     @Test("Notification content has correct format")
     func testNotificationContentFormat() async throws {
         let fixtures = ScheduledExplosionTestFixtures()