fix(android): treat saved contacts as saved peers for notifications

When "Received Message" is disabled but "Message from Saved Peer" is
enabled, no notification was posted for messages from saved peers saved
via "Save to Contacts" (Chats long-press, Messaging star), QR import,
or manual entry.

MessageCollector resolved the saved-peer flag exclusively from the
legacy announces.isFavorite column, but only the announce-stream star
path sets that column. The other save paths write to the contacts
table via ContactRepository and never touch the flag, so isFavorite
reached NotificationHelper as false and the general-toggle-off gate
silently dropped the notification.

Resolve saved-peer status from both signals: the legacy announce
favorite flag OR membership in the active identity's contacts table.
Lookup failures keep the existing fail-safe default.

Regression test: MessageCollectorTest covers a contacts-table-only
saved peer (announce isFavorite = false, hasContact = true) and
asserts notifyMessageReceived is called with isFavorite = true.

Author: torlando-tech

app/src/main/java/network/columba/app/service/MessageCollector.kt

@@ -143,13 +143,7 @@ class MessageCollector
                                 }
                             }
 
-                            val isFavorite =
-                                try {
-                                    announceRepository.getAnnounce(sourceHash)?.isFavorite ?: false
-                                } catch (e: Exception) {
-                                    Log.w(TAG, "Could not check if peer is favorite", e)
-                                    false
-                                }
+                            val isFavorite = isSavedPeer(sourceHash)
 
                             // Only notify if the message hasn't been read yet
                             // This prevents duplicate notifications after service restart
@@ -274,13 +268,7 @@ class MessageCollector
                             Log.d(TAG, "Message saved to database for peer ${sourceHash.take(16)} (hasPublicKey=${publicKey != null})")
 
                             // Check if sender is a saved peer (favorite)
-                            val isFavorite =
-                                try {
-                                    announceRepository.getAnnounce(sourceHash)?.isFavorite ?: false
-                                } catch (e: Exception) {
-                                    Log.w(TAG, "Could not check if peer is favorite", e)
-                                    false
-                                }
+                            val isFavorite = isSavedPeer(sourceHash)
 
                             // Show notification for received message
                             try {
@@ -458,6 +446,39 @@ class MessageCollector
             return PeerNameResolver.formatHashAsFallback(peerHash)
         }
 
+        /**
+         * Determine whether [sourceHash] is a "saved peer" for notification purposes.
+         *
+         * A peer is considered saved if it is either:
+         *  - flagged as a favorite on its announce row (legacy "Save Peer" via the
+         *    announce stream star), OR
+         *  - present in the active identity's contacts table (written by the
+         *    "Save to Contacts" flows in Chats/Messaging, QR import, manual entry,
+         *    and propagation-node relay setup, which do not touch the announce flag).
+         *
+         * Both signals must be checked: the contacts table is the source of truth for
+         * "saved" as the user experiences it, and the legacy flag is kept so peers saved
+         * before the contacts table existed continue to notify. Either signal being true
+         * is sufficient.
+         */
+        private suspend fun isSavedPeer(sourceHash: String): Boolean {
+            val favoriteFlag =
+                try {
+                    announceRepository.getAnnounce(sourceHash)?.isFavorite ?: false
+                } catch (e: Exception) {
+                    Log.w(TAG, "Could not check if peer is favorite", e)
+                    false
+                }
+            if (favoriteFlag) return true
+
+            return try {
+                contactRepository.hasContact(sourceHash)
+            } catch (e: Exception) {
+                Log.w(TAG, "Could not check if peer is a saved contact", e)
+                false
+            }
+        }
+
         /**
          * Get peer name with fallback - uses PeerNameResolver for consistent lookup across the app
          */

app/src/test/java/network/columba/app/service/MessageCollectorTest.kt

@@ -370,6 +370,51 @@ class MessageCollectorTest {
             }
         }
 
+    @Test
+    fun `processMessage treats saved contact without favorite announce as favorite`() =
+        runBlocking {
+            // Given: A message from a peer saved via "Save to Contacts" (Chats/Messaging
+            // screens). Those flows write to the contacts table and never touch the
+            // legacy announce isFavorite flag, so the announce row reports
+            // isFavorite = false even though the peer IS a saved contact.
+            val testMessage =
+                ReceivedMessage(
+                    messageHash = "contact_msg",
+                    content = "Message from saved contact",
+                    sourceHash = testSourceHash,
+                    destinationHash = testDestHash,
+                    timestamp = System.currentTimeMillis(),
+                    fieldsJson = null,
+                    publicKey = null,
+                )
+
+            // Announce row exists but is NOT favorited (Save to Contacts never sets it)
+            coEvery { announceRepository.getAnnounce(testSourceHashHex) } returns
+                mockk {
+                    every { isFavorite } returns false
+                }
+            // But the peer IS in the contacts table
+            coEvery { contactRepository.hasContact(testSourceHashHex) } returns true
+
+            // When: Start collecting and emit
+            val startResult = runCatching { messageCollector.startCollecting() }
+            assertTrue("startCollecting should complete without throwing", startResult.isSuccess)
+            kotlinx.coroutines.delay(50)
+            messageFlow.emit(testMessage)
+            kotlinx.coroutines.delay(200)
+
+            // Then: Notification should be posted with isFavorite = true, so that
+            // "Message from Saved Peer" (with "Received Message" off) still fires.
+            coVerify(timeout = 2000) {
+                notificationHelper.notifyMessageReceived(
+                    destinationHash = testSourceHashHex,
+                    peerName = any(),
+                    messagePreview = any(),
+                    isFavorite = true,
+                )
+            }
+        }
+
     @Test
     fun `processMessage handles announce lookup failure gracefully for notifications`() =
         runBlocking {