@@ -41,7 +41,9 @@ All notable changes to CallShield will be documented in this file.
   with under half the list's numbers isn't applied in the background, because
   a broken export looks just like a list that cleaned itself up. The list
   keeps its last good copy and says why on its row, which also shows when it
-  last updated.
+  last updated. A list that fails to refresh says what went wrong: the
+  server's HTTP status, the size or row limit, a download that isn't a list,
+  or a certificate that couldn't be verified.
 
 ### Live caller lookup
 
@@ -52,8 +54,12 @@ All notable changes to CallShield will be documented in this file.
   WhoCalledMe as clean on every enriched call.
 - SkipCalls, the one that still works, is now read correctly. It reports spam in
   an `is_spam` field the app never looked for, so every number it flagged showed
-  as clean. A flagged number now shows as flagged, with the category SkipCalls
-  gives (scam, for example).
+  as clean. A flagged number now shows as flagged, and its detail page shows
+  the category SkipCalls gives (scam, for example). SkipCalls never gives a
+  count, so the app no longer shows a made-up "1 report".
+- When SkipCalls can't answer, the caller ID overlay keeps CallShield's own
+  warning and says no source gave a definitive result. It used to switch to a
+  green "Looks Safe".
 - A lookup answer that doesn't look like a lookup result now reads as
   "unavailable", not "clean". The overlay no longer has a caller-name line,
   because nothing free provides one any more, and a spam hit no longer shows as
 
@@ -453,15 +453,16 @@ For a locally suspicious call, CallShield can show a real-time overlay when the
 │ LIKELY SPAM                      │
 │ (212) 555-1234                   │
 │ New York, NY                     │
-│ Spam Score: 50%                  │
-│ ⚠ SkipCalls: Flagged as scam     │
+│ Spam Score: 50% (Flagged)        │
+│ ⚠ SkipCalls: Flagged             │
 │ All sources checked              │
 │ [Search] [Block] [Dismiss]       │
 │ 🔈 Play SIT Tone (anti-dialer)  │
 └──────────────────────────────────┘
 ```
 
-- Shows instantly with the area code, then updates when SkipCalls answers
+- Shows instantly with the area code, then updates when SkipCalls answers. SkipCalls gives a verdict and a category but no report count. The number's detail page shows the category
+- If SkipCalls can't answer, the overlay keeps CallShield's own warning and says no source returned a definitive result
 - **SIT Tone**. ITU-T E.180 three-tone sequence tricks autodialers into removing your number
 - Color-coded: green (safe) → yellow → orange → red (spam)
 
@@ -812,7 +813,7 @@ language in [issue #7](https://github.com/SysAdminDoc/CallShield/issues/7).
 | URL Safety | Local spam-domain data; optional URLhaus (abuse.ch) |
 | Verification | Local Gradle, lint, and release-artifact checks |
 | Tests | 1100 JVM unit tests (JUnit) |
-| Strings | 1416 string resources and 33 plural groups (translation-ready) |
+| Strings | 1422 string resources and 33 plural groups (translation-ready) |
 | Accessibility | 100+ content descriptions, 48dp touch targets |
 | Min SDK | 29 (Android 10) |
 | Target SDK | 36 |
 
@@ -57,7 +57,10 @@ internal object ExternalBlocklistParser {
 
     private const val EXPIRES_HEADER_LINES = 50
     private val expiresLine = Regex("""^expires\s*:\s*(.+)$""", RegexOption.IGNORE_CASE)
-    private val expiresValue = Regex("""^(\d{1,5})(?!\d)\s*([a-z]*)""", RegexOption.IGNORE_CASE)
+
+    // A decimal such as "1.5 hours" is refused rather than read as "1", which
+    // with no unit after it would mean days.
+    private val expiresValue = Regex("""^(\d{1,5})(?![\d.])\s*([a-z]*)""", RegexOption.IGNORE_CASE)
 
     fun parse(
         rawUrl: String,
@@ -128,7 +131,9 @@ internal object ExternalBlocklistParser {
             if (format == "json") {
                 jsonExpires(body)
             } else {
+                // A byte-order mark survives trim() and would hide a first-line header.
                 body
+                    .removePrefix("\uFEFF")
                     .lineSequence()
                     .map { it.trim() }
                     .filter { it.isNotEmpty() }
 
@@ -1,11 +1,14 @@
 package com.sysadmindoc.callshield.data.remote
 
+import com.sysadmindoc.callshield.data.ExternalBlocklistFailureReason
 import com.sysadmindoc.callshield.data.ExternalBlocklistParser
+import com.sysadmindoc.callshield.data.ExternalBlocklistValidationException
 import kotlinx.coroutines.Dispatchers
 import kotlinx.coroutines.withContext
 import okhttp3.HttpUrl
 import okhttp3.HttpUrl.Companion.toHttpUrl
 import okhttp3.Request
+import java.io.IOException
 import java.util.concurrent.TimeUnit
 
 interface ExternalBlocklistDataSource {
@@ -54,33 +57,50 @@ class OkHttpExternalBlocklistDataSource : ExternalBlocklistDataSource {
                         return@use null
                     }
                     if (!response.isSuccessful) {
-                        error("HTTP ${response.code}")
-                    }
-                    when (val body = response.body?.readUtf8Bounded(ExternalBlocklistParser.MAX_SUBSCRIPTION_BYTES)) {
-                        is BoundedResponseBody.Text -> {
-                            body.value
-                        }
-
-                        BoundedResponseBody.Empty -> {
-                            error("External blocklist returned an empty body")
-                        }
-
-                        is BoundedResponseBody.Oversized -> {
-                            error("External blocklist exceeded ${body.maxBytes} byte cap")
-                        }
-
-                        BoundedResponseBody.Unreadable,
-                        null,
-                        -> {
-                            error("External blocklist response could not be read")
-                        }
+                        throw ExternalBlocklistHttpException(response.code)
                     }
+                    externalBlocklistBodyText(response.body.readUtf8Bounded(ExternalBlocklistParser.MAX_SUBSCRIPTION_BYTES))
                 }
             if (bodyText != null) return bodyText
         }
     }
 }
 
+/** The list server answered with an error status; kept apart so the row can say which. */
+internal class ExternalBlocklistHttpException(
+    val code: Int,
+) : IOException("HTTP $code")
+
+/**
+ * A body that arrived but holds nothing is an empty list, the same answer the
+ * parser gives for a list with no numbers, so a background refresh holds the
+ * last good copy instead of recording a failure.
+ */
+internal fun externalBlocklistBodyText(body: BoundedResponseBody): String =
+    when (body) {
+        is BoundedResponseBody.Text -> {
+            body.value
+        }
+
+        BoundedResponseBody.Empty -> {
+            throw ExternalBlocklistValidationException(
+                ExternalBlocklistFailureReason.EMPTY,
+                "External blocklist returned an empty body",
+            )
+        }
+
+        is BoundedResponseBody.Oversized -> {
+            throw ExternalBlocklistValidationException(
+                ExternalBlocklistFailureReason.OVERSIZE,
+                "External blocklist exceeded ${body.maxBytes} byte cap",
+            )
+        }
+
+        BoundedResponseBody.Unreadable -> {
+            throw IOException("External blocklist response could not be read")
+        }
+    }
+
 internal fun validatedExternalBlocklistRedirect(
     originalUrl: HttpUrl,
     currentUrl: HttpUrl,
 
@@ -29,10 +29,12 @@ internal fun parseSkipCallsBody(body: String): ExternalLookup.SourceResult {
             ?.get(1)
             ?.trim()
             ?.takeUnless { it.isEmpty() || it.equals("unknown", ignoreCase = true) }
+    // SkipCalls gives a verdict and a category, never a count. Reporting one
+    // report would put a made-up "1 report" on the overlay and detail page.
     return ExternalLookup.SourceResult(
         source = "SkipCalls",
         isSpam = true,
-        reports = 1,
+        reports = 0,
         detail = if (description != null) "Flagged as $description" else "Flagged as spam",
         status = RemoteLookupStatus.FOUND,
     )
 
@@ -24,6 +24,7 @@ import com.sysadmindoc.callshield.data.model.SpamPrefixJson
 import com.sysadmindoc.callshield.data.model.SpamShardDescriptor
 import com.sysadmindoc.callshield.data.model.SpamShardManifest
 import com.sysadmindoc.callshield.data.remote.ExternalBlocklistDataSource
+import com.sysadmindoc.callshield.data.remote.ExternalBlocklistHttpException
 import com.sysadmindoc.callshield.data.remote.GitHubDataSource
 import com.sysadmindoc.callshield.data.remote.GitHubFeedValidationException
 import com.sysadmindoc.callshield.data.remote.HttpClient
@@ -287,13 +288,23 @@ class SyncRepository(
      * list's size is not applied: the last good rows stay and the list is
      * flagged, the way a collapsed database or hot-feed publish is refused.
      */
+    @Suppress("TooGenericExceptionCaught")
     suspend fun refreshDueExternalBlocklists(now: Long = System.currentTimeMillis()): List<ExternalBlocklistRefreshOutcome> =
         withContext(Dispatchers.IO) {
             syncMutex.withLock {
                 settingsRepository
                     .readExternalBlocklistSubscriptions()
                     .filter { ExternalBlocklistRefreshPolicy.isDue(it, now) }
-                    .map { refreshExternalBlocklist(it, now) }
+                    .map { subscription ->
+                        // A storage error on one list must not skip every list after it.
+                        try {
+                            refreshExternalBlocklist(subscription, now)
+                        } catch (e: CancellationException) {
+                            throw e
+                        } catch (e: Exception) {
+                            failExternalBlocklist(subscription, now, e)
+                        }
+                    }
             }
         }
 
@@ -722,17 +733,57 @@ class SyncRepository(
         return ExternalBlocklistRefreshOutcome.HELD
     }
 
+    @Suppress("TooGenericExceptionCaught")
     private suspend fun failExternalBlocklist(
         subscription: ExternalBlocklistSubscription,
         now: Long,
         error: Exception,
     ): ExternalBlocklistRefreshOutcome {
         // The cause can embed the list's full URL, so it goes to the log only.
         android.util.Log.w("SyncRepository", "External blocklist refresh failed", error)
-        recordExternalBlocklistAttempt(subscription.id, now, context.getString(R.string.external_blocklist_refresh_failed))
+        try {
+            recordExternalBlocklistAttempt(subscription.id, now, externalBlocklistFailureText(error))
+        } catch (e: CancellationException) {
+            throw e
+        } catch (e: Exception) {
+            android.util.Log.w("SyncRepository", "Could not record the failed refresh", e)
+        }
         return ExternalBlocklistRefreshOutcome.FAILED
     }
 
+    /**
+     * What went wrong, without the URL. A list that moved (HTTP 404) or grew past
+     * the caps reads differently on its row from one that was briefly unreachable.
+     */
+    private fun externalBlocklistFailureText(error: Exception): String {
+        val reason = (error as? ExternalBlocklistValidationException)?.reason
+        return when {
+            error is ExternalBlocklistHttpException -> {
+                context.getString(R.string.external_blocklist_refresh_http, error.code)
+            }
+
+            reason == ExternalBlocklistFailureReason.OVERSIZE -> {
+                context.getString(R.string.external_blocklist_refresh_too_large)
+            }
+
+            reason == ExternalBlocklistFailureReason.ROW_LIMIT -> {
+                context.getString(R.string.external_blocklist_refresh_too_many_rows)
+            }
+
+            reason != null -> {
+                context.getString(R.string.external_blocklist_refresh_unreadable)
+            }
+
+            HttpClient.isCertificateTrustFailure(error) -> {
+                context.getString(R.string.external_blocklist_refresh_certificate)
+            }
+
+            else -> {
+                context.getString(R.string.external_blocklist_refresh_failed)
+            }
+        }
+    }
+
     private suspend fun recordExternalBlocklistAttempt(
         id: String,
         now: Long,