@@ -48,6 +48,7 @@ All notable changes to CallShield will be documented in this file.
 - Database v57 adds the FCC complaints published through 2026-10-29 and FTC's through 2026-10-28, for 51,379 numbers, and refreshes the 652 French telemarketing ranges. The community watch list now carries 7 numbers that several people reported.
 - The Simplified Chinese translation now covers nearly every screen, with 311 more strings and every plural, from aixtin (#42). Only the two newest strings still show in English.
 - The Android post-call screen has a Call back button (#43). It opens your dialer with the number filled in, so a call that dropped is one tap from a redial and CallShield still needs no permission to place calls.
+- Spam on the post-call screen now records the block and the report itself, and the home screen widget redraws itself when your lists change. Both used to hand the job to the app's own receiver with a broadcast, which Android 17 QPR2 no longer delivers once the app has left the screen, so the block could have been lost.
 
 ## v1.12.0 (2026-10-09)
 
 
@@ -12,7 +12,7 @@
 <p align="center">
   <a href="https://github.com/SysAdminDoc/CallShield/releases/latest"><img src="https://img.shields.io/github/v/release/SysAdminDoc/CallShield?style=flat-square&color=a6e3a1" alt="Release"></a>
   <img src="https://img.shields.io/badge/Spam%20Numbers-51%2C379-f38ba8?style=flat-square" alt="51,379 Numbers">
-  <img src="https://img.shields.io/badge/JVM%20unit%20tests-2021-94e2d5?style=flat-square" alt="2021 JVM unit tests">
+  <img src="https://img.shields.io/badge/JVM%20unit%20tests-2026-94e2d5?style=flat-square" alt="2026 JVM unit tests">
   <img src="https://img.shields.io/badge/Android-10%2B-89b4fa?style=flat-square" alt="Android 10+">
   <img src="https://img.shields.io/badge/License-MIT-cba6f7?style=flat-square" alt="MIT License">
   <img src="https://img.shields.io/badge/API%20Keys-None-fab387?style=flat-square" alt="No required API keys">
@@ -592,12 +592,12 @@ RELEASE_KEY_PASSWORD=...
 ## Testing
 
 ```bash
-./gradlew testDebugUnitTest   # 2021 tests
+./gradlew testDebugUnitTest   # 2026 tests
 ./gradlew connectedDebugAndroidTest -Pandroid.testInstrumentationRunnerArguments.class=com.sysadmindoc.callshield.platform.TargetSdkBehaviorSmokeTest
 ./gradlew verifyPipelineTests # Cloudflare Worker (node) + data-pipeline and translation checks (python)
 ```
 
-The suite is **2021 total JVM unit tests**, run with Robolectric wherever a screen, a service or the database is involved.
+The suite is **2026 total JVM unit tests**, run with Robolectric wherever a screen, a service or the database is involved.
 
 Two GitHub workflows run without building the app. **Validation** runs the Worker and
 pipeline suites on every push except report-only ones (`run-pipeline-tests.ps1 -CorrectnessOnly`),
@@ -634,7 +634,7 @@ language in [issue #7](https://github.com/SysAdminDoc/CallShield/issues/7).
 | Community API | Cloudflare Workers |
 | URL Safety | Local spam-domain data, with optional PhishTank and OpenPhish |
 | Verification | Local Gradle, lint, and release-artifact checks |
-| Tests | 2021 JVM unit tests (JUnit) |
+| Tests | 2026 JVM unit tests (JUnit) |
 | Strings | 1792 string resources and 49 plural groups (translation-ready) |
 | Accessibility | 100+ content descriptions, 48dp touch targets |
 | Min SDK | 29 (Android 10) |
 
@@ -29,12 +29,7 @@ class SpamActionReceiver : BroadcastReceiver() {
             when (intent.action) {
                 ACTION_FEEDBACK_SPAM -> {
                     val number = intent.getStringExtra(EXTRA_FEEDBACK_NUMBER) ?: return
-                    notificationManager.cancel(NotificationHelper.feedbackNotificationId(number))
-                    Toast.makeText(appContext, appContext.getString(R.string.feedback_blocked), Toast.LENGTH_SHORT).show()
-                    suspend {
-                        repo.blockNumber(number, "spam", appContext.getString(R.string.desc_blocked_from_after_call_feedback))
-                        CommunityContributor.contribute(appContext, repo.normalizeNumber(number), "spam")
-                    }
+                    spamFeedback(appContext, number)
                 }
 
                 ACTION_FEEDBACK_NOT_SPAM -> {
@@ -109,29 +104,11 @@ class SpamActionReceiver : BroadcastReceiver() {
                 }
             } ?: return
 
-        // Previously this created a fresh CoroutineScope(SupervisorJob+IO) per
-        // broadcast, which was never cancelled and leaked a Job on every
-        // action. Reuse the process-wide appScope — the work must outlive
-        // onReceive anyway (goAsync covers the broadcast lifetime, not the
-        // suspend body).
+        // The work must outlive onReceive (goAsync covers the broadcast
+        // lifetime, not the suspend body), so it runs on the process-wide
+        // appScope rather than a scope created and leaked per broadcast.
         val pendingResult = goAsync()
-        CallShieldApp.appScope.launch {
-            try {
-                work.invoke()
-            } catch (e: Exception) {
-                // The confirmation toast already fired for responsiveness; a
-                // failed DB write must not stay silent (and an uncaught throw
-                // here would take down the process via appScope).
-                Log.w("SpamActionReceiver", "Notification action failed", e)
-                withContext(Dispatchers.Main) {
-                    Toast
-                        .makeText(appContext, appContext.getString(R.string.notification_action_failed), Toast.LENGTH_SHORT)
-                        .show()
-                }
-            } finally {
-                pendingResult.finish()
-            }
-        }
+        launchAction(appContext, work) { pendingResult.finish() }
     }
 
     /** "Not spam" on a blocked-call alert: let the number ring for a day, and tell the community when its data was wrong. */
@@ -184,5 +161,66 @@ class SpamActionReceiver : BroadcastReceiver() {
         const val ACTION_FEEDBACK_SPAM = "com.sysadmindoc.callshield.FEEDBACK_SPAM"
         const val ACTION_FEEDBACK_NOT_SPAM = "com.sysadmindoc.callshield.FEEDBACK_NOT_SPAM"
         const val EXTRA_FEEDBACK_NUMBER = "number"
+        private const val TAG = "SpamActionReceiver"
+
+        /**
+         * The after-call "Spam" feedback: cancels the prompt and confirms at
+         * once, and returns the block plus the community report to run off
+         * the main thread. Shared with the post-call screen, which calls it
+         * directly instead of broadcasting to this receiver: Android 17 QPR2
+         * no longer lets a broadcast an app sends to itself raise the
+         * sender's priority, and that screen finishes right after the tap.
+         * Call on the main thread, which the toast needs.
+         */
+        fun spamFeedback(
+            appContext: Context,
+            number: String,
+        ): suspend () -> Unit {
+            val notificationManager = appContext.getSystemService(Context.NOTIFICATION_SERVICE) as NotificationManager
+            notificationManager.cancel(NotificationHelper.feedbackNotificationId(number))
+            Toast.makeText(appContext, appContext.getString(R.string.feedback_blocked), Toast.LENGTH_SHORT).show()
+            val repo = SpamRepository.getInstance(appContext)
+            return {
+                repo.blockNumber(number, "spam", appContext.getString(R.string.desc_blocked_from_after_call_feedback))
+                CommunityContributor.contribute(appContext, repo.normalizeNumber(number), "spam")
+            }
+        }
+
+        /**
+         * Runs [work] now and ignores what it returns. The confirmation toast
+         * already fired for responsiveness, so a failed write is logged and
+         * shown rather than left silent, and never thrown into the caller's
+         * scope.
+         */
+        suspend fun runAction(
+            appContext: Context,
+            work: suspend () -> Any?,
+        ) {
+            try {
+                work()
+            } catch (e: Exception) {
+                Log.w(TAG, "Notification action failed", e)
+                withContext(Dispatchers.Main) {
+                    Toast
+                        .makeText(appContext, appContext.getString(R.string.notification_action_failed), Toast.LENGTH_SHORT)
+                        .show()
+                }
+            }
+        }
+
+        /** [runAction] on the process scope, then [onDone] whether it succeeded or not. */
+        fun launchAction(
+            appContext: Context,
+            work: suspend () -> Any?,
+            onDone: () -> Unit,
+        ) {
+            CallShieldApp.appScope.launch {
+                try {
+                    runAction(appContext, work)
+                } finally {
+                    onDone()
+                }
+            }
+        }
     }
 }
@@ -149,11 +149,15 @@ class PostCallActivity : AppCompatActivity() {
                         .blockNumber(number, "spam", app.getString(R.string.desc_blocked_post_call_local))
                 }.onFailure { Log.w(TAG, "Local post-call block failed", it) }
             } else {
-                app.sendBroadcast(
-                    Intent(app, SpamActionReceiver::class.java)
-                        .setAction(SpamActionReceiver.ACTION_FEEDBACK_SPAM)
-                        .putExtra(SpamActionReceiver.EXTRA_FEEDBACK_NUMBER, number),
-                )
+                // A direct call, not a broadcast to SpamActionReceiver: Android 17
+                // QPR2 no longer lets a broadcast an app sends to itself raise the
+                // sender's priority, and this screen finishes right after the tap.
+                // The prompt and toast go inside runAction too, so a failure there
+                // is shown instead of thrown into appScope after the screen closed.
+                SpamActionReceiver.runAction(app) {
+                    val work = withContext(Dispatchers.Main) { SpamActionReceiver.spamFeedback(app, number) }
+                    work()
+                }
             }
         }
         finishAndRemoveTask()
 
@@ -14,6 +14,7 @@ import com.sysadmindoc.callshield.data.SpamRepository
 import com.sysadmindoc.callshield.data.local.AppDatabase
 import com.sysadmindoc.callshield.ui.MainActivity
 import com.sysadmindoc.callshield.util.relativeTimeSpan
+import kotlinx.coroutines.Job
 import kotlinx.coroutines.flow.first
 import kotlinx.coroutines.launch
 import java.text.NumberFormat
@@ -36,19 +37,23 @@ class CallShieldWidget : AppWidgetProvider() {
         // Without this the process drops to cached priority as soon as
         // onUpdate returns and can be killed mid-query, leaving the widget on
         // layout placeholders until the next 30-minute cycle.
-        val pendingResult = goAsync()
-        val appContext = context.applicationContext
+        // Null when onUpdate is called directly rather than from a delivered
+        // broadcast (Robolectric's widget host does that).
+        val pendingResult: PendingResult? = goAsync()
+        render(context.applicationContext, appWidgetIds).invokeOnCompletion { pendingResult?.finish() }
+    }
+
+    /** Loads the counts and pushes every widget in [appWidgetIds]; the job ends once the last one is updated. */
+    private fun render(
+        appContext: Context,
+        appWidgetIds: IntArray,
+    ): Job =
         CallShieldApp.appScope.launch {
-            try {
-                val manager = AppWidgetManager.getInstance(appContext)
-                for (id in appWidgetIds) {
-                    updateWidget(appContext, manager, id)
-                }
-            } finally {
-                pendingResult.finish()
+            val manager = AppWidgetManager.getInstance(appContext)
+            for (id in appWidgetIds) {
+                updateWidget(appContext, manager, id)
             }
         }
-    }
 
     private suspend fun updateWidget(
         appContext: Context,
@@ -163,17 +168,21 @@ class CallShieldWidget : AppWidgetProvider() {
     }
 
     companion object {
-        fun refreshAll(context: Context) {
-            val intent =
-                Intent(context, CallShieldWidget::class.java).apply {
-                    action = AppWidgetManager.ACTION_APPWIDGET_UPDATE
-                }
+        /**
+         * Re-renders every placed widget directly and returns the job doing
+         * it, or null when none is placed. This used to broadcast
+         * ACTION_APPWIDGET_UPDATE to this provider; Android 17 QPR2 no longer
+         * lets a broadcast an app sends to itself raise the sender's
+         * priority, and most refreshes come from background syncs.
+         */
+        fun refreshAll(context: Context): Job? {
+            val appContext = context.applicationContext
             val ids =
                 AppWidgetManager
-                    .getInstance(context)
-                    .getAppWidgetIds(ComponentName(context, CallShieldWidget::class.java))
-            intent.putExtra(AppWidgetManager.EXTRA_APPWIDGET_IDS, ids)
-            context.sendBroadcast(intent)
+                    .getInstance(appContext)
+                    .getAppWidgetIds(ComponentName(appContext, CallShieldWidget::class.java))
+            if (ids.isEmpty()) return null
+            return CallShieldWidget().render(appContext, ids)
         }
     }
 
 
@@ -0,0 +1,29 @@
+package com.sysadmindoc.callshield.service
+
+import org.junit.Assert.assertEquals
+import org.junit.Test
+import java.io.File
+
+/**
+ * Android 17 QPR2 stops a broadcast an app sends to itself from raising the
+ * sender's priority and drops it when the process dies first, so the app
+ * never hands its own work to a receiver by broadcast: the post-call screen
+ * calls [SpamActionReceiver.spamFeedback] and the widget renders itself.
+ * The notification actions still reach [SpamActionReceiver], but those
+ * broadcasts come from the system through a PendingIntent, not from this
+ * process. A broadcast meant for another app would need its own entry here.
+ */
+class NoSelfBroadcastTest {
+    @Test
+    fun `no source sends a broadcast`() {
+        val senders =
+            File("src/main/java")
+                .walk()
+                .filter { it.extension == "kt" }
+                .filter { Regex("""\bsend(Ordered)?Broadcast(AsUser)?\(""").containsMatchIn(it.readText()) }
+                .map { it.name }
+                .toList()
+
+        assertEquals(emptyList<String>(), senders)
+    }
+}
@@ -1,22 +1,32 @@
 package com.sysadmindoc.callshield.service
 
+import android.app.Application
 import android.app.NotificationChannel
 import android.app.NotificationManager
 import android.content.Context
 import android.content.Intent
+import android.os.Looper
 import androidx.test.core.app.ApplicationProvider
+import com.sysadmindoc.callshield.R
 import com.sysadmindoc.callshield.data.CommunityContributor
 import com.sysadmindoc.callshield.data.CommunityContributor.ContributeOutcome
 import com.sysadmindoc.callshield.data.CommunityContributor.ContributeResult
+import com.sysadmindoc.callshield.data.CommunityReport
+import com.sysadmindoc.callshield.data.SpamRepository
+import kotlinx.coroutines.runBlocking
 import org.junit.After
+import org.junit.Assert.assertEquals
 import org.junit.Assert.assertFalse
+import org.junit.Assert.assertNull
 import org.junit.Assert.assertTrue
 import org.junit.Before
 import org.junit.Test
 import org.junit.runner.RunWith
 import org.robolectric.RobolectricTestRunner
 import org.robolectric.Shadows.shadowOf
 import org.robolectric.annotation.Config
+import org.robolectric.shadows.ShadowToast
+import kotlin.concurrent.thread
 
 /**
  * Robolectric coverage for [SpamActionReceiver] — drives the real
@@ -81,6 +91,65 @@ class SpamActionReceiverRobolectricTest {
         )
     }
 
+    /**
+     * The post-call screen calls this directly instead of broadcasting
+     * FEEDBACK_SPAM to the receiver, so the prompt must go at once, nothing
+     * may be broadcast, and the returned work must block and report.
+     *
+     * The other tests here leave their receiver work running on the app
+     * scope, and it reports through the same fake transport, so only this
+     * number's reports are compared. It uses the shared repository like
+     * those tests do, so their late writes never land on a fixture that is
+     * being closed.
+     */
+    @Test
+    fun `spam feedback shared with the post-call screen blocks and reports without a broadcast`() {
+        val number = "+15553330002"
+        val id = postFeedbackNotification(number)
+        val sent = mutableListOf<CommunityReport>()
+        CommunityContributor.transport = { report ->
+            synchronized(sent) { sent += report }
+            ContributeResult(true, "faked in test", ContributeOutcome.REPORTED_SPAM)
+        }
+
+        val work = SpamActionReceiver.spamFeedback(context, number)
+
+        assertFalse("the after-call prompt goes at once", shadowOf(nm).getNotification(id) != null)
+        assertTrue("nothing is broadcast", shadowOf(context as Application).broadcastIntents.isEmpty())
+        runBlocking { work() }
+        val repository = SpamRepository.getInstance(context)
+        assertEquals("user_blocklist", runBlocking { repository.isSpam(number) }.matchSource)
+        val ours = synchronized(sent) { sent.filter { it.number == number } }
+        assertEquals(listOf(number to "spam"), ours.map { it.number to it.type })
+    }
+
+    /** The post-call screen has already closed when this runs, so a failed write must show the toast and throw nothing. */
+    @Test
+    fun `a failed action shows the failure toast instead of throwing`() {
+        ShadowToast.reset()
+        var escaped: Throwable? = null
+        // Off the main thread, since runAction posts its toast to it.
+        val worker =
+            thread {
+                try {
+                    runBlocking { SpamActionReceiver.runAction(context) { error("disk full") } }
+                } catch (e: Throwable) {
+                    escaped = e
+                }
+            }
+        val deadline = System.currentTimeMillis() + 5_000
+        while (worker.isAlive && System.currentTimeMillis() < deadline) {
+            shadowOf(Looper.getMainLooper()).idle()
+            Thread.sleep(20)
+        }
+        worker.join(1_000)
+        shadowOf(Looper.getMainLooper()).idle()
+
+        assertFalse("runAction finished", worker.isAlive)
+        assertNull("nothing escaped runAction", escaped)
+        assertEquals(context.getString(R.string.notification_action_failed), ShadowToast.getTextOfLatestToast())
+    }
+
     @Test
     fun `FEEDBACK_NOT_SPAM cancels the same feedback notification`() {
         val number = "+15559876543"