@@ -4,6 +4,17 @@ All notable changes to CallShield will be documented in this file.
 
 ## Unreleased
 
+- SMS checks catch reply bait: a first text from a phone number you've never
+  texted or heard from that fishes for an answer without a link. "Hi mum,
+  this is my new number, my phone broke" is caught in English, Spanish, German,
+  Dutch, Portuguese, Italian, French and a few more, and so are "Is this
+  Sarah?" and "sorry, wrong number". On its own it blocks only in aggressive
+  mode, since a real kid with a new phone writes the same words. Someone
+  else's parent ("this is Maya's mom, here's my new number") doesn't count.
+- The SMS regression test runs 5,000 real smishing reports from the IMC 2025
+  dataset (CC BY 4.0) and reports recall for each language. Content rules
+  catch 13% of them, up from 10% before reply bait, and 35% of the wrong
+  number and "hi mum" scams, up from 4.5%.
 - The report Worker runs the current code. It had been serving a build from
   March, so reports carried no reporter identity and the trending lists and
   spam domains couldn't count independent reporters. It now records a daily
 
@@ -336,8 +336,15 @@ class SmsContentAnalyzer
          * multi-MB string is a real ReDoS risk on the 5-second screening
          * deadline — at this length the message is almost certainly spam
          * anyway, so we sample the first 16 KB and stop.
+         *
+         * [firstContact] says it's the first text from a phone number the user
+         * has never texted or heard from, the only place a friendly opener with
+         * no link is suspicious (see [SmsReplyBait]).
          */
-        fun analyze(body: String): SmsAnalysisResult {
+        fun analyze(
+            body: String,
+            firstContact: Boolean = false,
+        ): SmsAnalysisResult {
             var score = 0
             val reasons = mutableListOf<String>()
 
@@ -429,6 +436,11 @@ class SmsContentAnalyzer
                 reasons.add("short_msg_with_url")
             }
 
+            if (firstContact && SmsReplyBait.matches(ruleText, urls, visibleText.length)) {
+                score += REPLY_BAIT_SCORE
+                reasons.add("reply_bait")
+            }
+
             return SmsAnalysisResult(score.coerceAtMost(100), reasons)
         }
 
@@ -437,6 +449,11 @@ class SmsContentAnalyzer
 
             internal const val MAX_ANALYSIS_LENGTH = 16_384
             internal const val MAX_REPORT_DOMAINS = 10
+
+            // On its own, reply bait clears aggressive mode's bar (25) but not
+            // the default one (50): a real child with a new phone writes the
+            // same words, so it takes a second signal to block by default.
+            internal const val REPLY_BAIT_SCORE = 30
             private const val MAX_VERIFICATION_BODY_LENGTH = 1_024
             private const val MIN_REPORT_DOMAIN_LENGTH = 5
             private const val MAX_REPORT_DOMAIN_LENGTH = 253
@@ -539,7 +556,10 @@ class SmsContentAnalyzer
                 return normalized.takeIf { isValid }
             }
 
-            fun analyze(body: String): SmsAnalysisResult = shared.analyze(body)
+            fun analyze(
+                body: String,
+                firstContact: Boolean = false,
+            ): SmsAnalysisResult = shared.analyze(body, firstContact)
 
             fun extractReportableIndicators(body: String): SmsReportIndicators = shared.extractReportableIndicators(body)
 
 
@@ -60,6 +60,41 @@ class SmsContextChecker
             }
         }
 
+        /**
+         * True when [number] is a full phone number (not a short code) with no
+         * inbox message older than a two-minute grace, so the one arriving is
+         * its first. The grace keeps the arriving message itself from counting
+         * when the SMS app has already stored it. False when the inbox can't
+         * be read, so an unreadable inbox never makes a sender a stranger.
+         */
+        fun isFirstMessageFrom(
+            context: Context,
+            number: String,
+            nowMillis: Long = System.currentTimeMillis(),
+        ): Boolean {
+            val normalized = normalize(number)
+            if (normalized.length < MIN_FIRST_CONTACT_DIGITS) return false
+
+            return try {
+                context.contentResolver
+                    .query(
+                        Telephony.Sms.Inbox.CONTENT_URI,
+                        arrayOf(Telephony.Sms.Inbox.ADDRESS),
+                        "${Telephony.Sms.Inbox.ADDRESS} LIKE ? AND ${Telephony.Sms.Inbox.DATE} < ?",
+                        arrayOf("%${normalized.takeLast(7)}", (nowMillis - FIRST_CONTACT_GRACE_MS).toString()),
+                        null,
+                    )?.use { cursor ->
+                        while (cursor.moveToNext()) {
+                            val address = cursor.getString(0) ?: continue
+                            if (normalize(address) == normalized) return false
+                        }
+                        true
+                    } ?: false
+            } catch (_: Exception) {
+                false
+            }
+        }
+
         /**
          * Strong trust check backed exclusively by prior outbound history.
          * Called from SpamRepository before keyword/content analysis.
@@ -248,6 +283,8 @@ class SmsContextChecker
             private const val MAX_SMS_BURST_ROWS = 500
             private const val SMS_BURST_PHONE_DIGITS = 10
             private const val SMS_BURST_PREFIX_DIGITS = 6
+            private const val MIN_FIRST_CONTACT_DIGITS = 8
+            private const val FIRST_CONTACT_GRACE_MS = 2 * MILLIS_PER_MINUTE
 
             fun hasSentMessageTo(
                 context: Context,
 
@@ -0,0 +1,135 @@
+package com.sysadmindoc.callshield.data
+
+/**
+ * Reply bait: a text that opens a conversation and carries no link, the way
+ * "Hi mum, this is my new number" and "Is this Sarah?" scams wait for an
+ * answer before they ask for money or move the chat to WhatsApp. It only
+ * means something in a stranger's first text, which the caller decides; this
+ * reads the words.
+ *
+ * Measured on the IMC 2025 smishing sample in SmsEvaluationCorpusTest. Most
+ * wrong-number openers ("How are you doing", "Is the house still for sale?")
+ * read exactly like a real first text, so only the unambiguous ones count.
+ * Word edges are \p{L} lookarounds and spaces include \p{Zs}, as in
+ * [SmsContentAnalyzer], because the JVM and Android's ICU disagree on \b.
+ */
+internal object SmsReplyBait {
+    /** A real first text that asks "is this Sarah?" says why it's writing, so the opener counts only when it's short. */
+    private const val MAX_OPENER_LENGTH = 80
+
+    /** How far back from a parent word to look for "Maya's" or "my". */
+    private const val POSSESSIVE_WINDOW = 24
+
+    private const val START = "(?<![\\p{L}\\p{N}])"
+    private const val END = "(?![\\p{L}\\p{N}])"
+    private const val SPACE = "[\\s\\p{Zs}]"
+    private const val APOSTROPHE = "['’]"
+
+    private val chatLinkHosts = setOf("wa.me", "api.whatsapp.com", "chat.whatsapp.com")
+
+    // A parent the text speaks to.
+    private val parent =
+        Regex(
+            "(?iu)$START(?:mum|mom|mam|mama|mamma|mammy|mummy|mommy|dad|daddy|papa|pap|pappa|m[aã]e|mam[aã]e|papai" +
+                "|mam[aá]|pap[aá]|mami|papi|mutti|vati|maman|ayah|bunda)$END|엄마|아빠|妈妈|爸爸|お母さん|お父さん",
+        )
+
+    // "mam" is also ma'am and "pap" is also porridge, so they count with a lost
+    // or new phone but not with a request to use WhatsApp alone.
+    private val ambiguousParents = setOf("mam", "pap")
+
+    // Whose parent: "Maya's mom", "my dad", "la mamá de Lucía", "le papa de Léo".
+    private val possessive =
+        Regex(
+            "(?iu)(?:$APOSTROPHE(?:s)?|s$APOSTROPHE|$START(?:my|your|his|her|their|our|the|a|la|el|lo|los|las|su|sus|mi|mis|tu" +
+                "|der|die|das|dem|den|meine?|deine?|seine?|ihre?|unsere?|het|mijn|jouw|je|zijn|haar|onze" +
+                "|le|les|mon|ma|ton|ta|son|sa|notre|il|gli|mio|mia|tuo|tua|suo|sua" +
+                "|o|os|as|meu|minha|teu|seu|nossa|de|van|von|di|du|des|do|da|della|del))$SPACE*$",
+        )
+
+    // "This is your mum", "It's your son".
+    private val parentSignsOff =
+        Regex(
+            "(?iu)^[^\\p{L}\\p{N}]*(?:(?:hi|hello|hey)[^\\p{L}\\p{N}]+)?(?:this is|it$APOSTROPHE?s|it is)$SPACE+" +
+                "(?:your$SPACE+)?(?:mum|mom|mother|dad|father|son|daughter)$END",
+        )
+
+    // A lost, broken or new phone, in the languages the reports use.
+    private val newPhone =
+        Regex(
+            "(?iu)$START(?:" +
+                "new (?:mobile |phone |cell |cellphone |whatsapp )?(?:number|phone|no\\.?$END|nr\\.?$END)" +
+                "|temporary (?:number|phone)|(?:save|store) (?:this|my|the) (?:new )?number" +
+                "|(?:lost|broke|smashed|dropped|cracked|damaged) my (?:old )?(?:phone|mobile|cell|sim)" +
+                "|my (?:old )?(?:phone|mobile|cell)[^.!?\\n]{0,20}(?:broken|broke|smashed|lost|dead|damaged|cracked|stolen" +
+                "|won$APOSTROPHE?t (?:turn on|work)|doesn$APOSTROPHE?t (?:turn on|work))" +
+                "|friend$APOSTROPHE?s phone|using a spare|water damage" +
+                "|(?:nuevo|otro) n[uú]mero|n[uú]mero (?:nuevo|temporal)" +
+                "|(?:tel[eé]fono|m[oó]vil|celular)[^.!?\\n]{0,15}(?:roto|rompi|ca[ií]d|perd[ií])" +
+                "|neue[sn]? (?:handy)?nummer|nummer gewechselt|nummer (?:ein)?speichern" +
+                "|(?:handy|telefon)[^.!?\\n]{0,15}(?:kaputt|verloren|defekt|gestohlen|zertr)" +
+                "|nieuwe? (?:mobiele |telefoon|gsm |06[- ]?)?(?:nummer|nr$END)|leentoestel" +
+                "|(?:telefoon|mobiel|gsm)[^.!?\\n]{0,15}(?:kapot|kwijt|gevallen|gestolen)" +
+                "|(?:novo|outro) n[uú]mero|n[uú]mero novo" +
+                "|(?:telem[oó]vel|celular|telefone|ecr[aã])[^.!?\\n]{0,15}(?:avariad|partid|quebrad|estragad|perdi)" +
+                "|nuov[oi] numero|(?:telefono|cellulare)[^.!?\\n]{0,15}(?:rott|cadut|pers[oa])" +
+                "|nouveau num[eé]ro|(?:t[eé]l[eé]phone|portable)[^.!?\\n]{0,15}(?:cass[eé]|perdu|tomb[eé])" +
+                "|nomor baru|hp[^.!?\\n]{0,10}rusak" +
+                ")|폰이? ?고장|새 번호|手机坏|换号|新号码|携帯[がを]?壊|新しい番号",
+        )
+
+    private val chatApp = Regex("(?iu)${START}whats ?app")
+
+    private val wrongNumber =
+        Regex(
+            "(?iu)$START(?:wrong (?:number|person)|do you (?:still )?remember me" +
+                "|did(?:n$APOSTROPHE?t| not) you saved? my number|long time no (?:see|talk|chat|speak))$END",
+        )
+
+    // "Hi, is this Sarah?" The name has to be capitalized: "is this the
+    // number for the flyer?" is someone with a reason to write.
+    private val isThisName =
+        Regex(
+            "^[^\\p{L}\\p{N}]*(?:(?iu:hi|hello|hey|good (?:morning|afternoon|evening))[^\\p{L}\\p{N}]+)?" +
+                "(?iu:is this|are you|is that)$SPACE+(?iu:you$SPACE+)?(?:(?iu:mr|mrs|ms|miss|dr)\\.?$SPACE+)?" +
+                "\\p{Lu}\\p{Ll}+(?:${APOSTROPHE}s)?(?:$SPACE+(?iu:number|phone|cell))?$SPACE*\\?",
+        )
+
+    /**
+     * True when [text] fishes for a reply. [urls] are the lowercase links it
+     * carries: any link but a WhatsApp chat link makes it a link scam instead.
+     * [visibleLength] is its length without invisible characters.
+     */
+    fun matches(
+        text: String,
+        urls: List<String>,
+        visibleLength: Int,
+    ): Boolean {
+        if (urls.any { !isChatLink(it) }) return false
+        val parents = parentsAddressed(text)
+        val signsOff = parentSignsOff.containsMatchIn(text)
+        if ((parents.isNotEmpty() || signsOff) && newPhone.containsMatchIn(text)) return true
+        if ((signsOff || parents.any { it !in ambiguousParents }) && chatApp.containsMatchIn(text)) return true
+        return wrongNumber.containsMatchIn(text) || (visibleLength <= MAX_OPENER_LENGTH && isThisName.containsMatchIn(text))
+    }
+
+    /** The parent words [text] speaks to, skipping ones that name someone's parent. */
+    private fun parentsAddressed(text: String): List<String> =
+        parent
+            .findAll(text)
+            .filterNot { match ->
+                val start = match.range.first
+                possessive.containsMatchIn(text.substring((start - POSSESSIVE_WINDOW).coerceAtLeast(0), start))
+            }.map { it.value.lowercase() }
+            .toList()
+
+    private fun isChatLink(url: String): Boolean {
+        val host =
+            url
+                .substringAfter("://")
+                .substringBefore('/')
+                .substringBefore('?')
+                .removePrefix("www.")
+        return host in chatLinkHosts
+    }
+}
@@ -1283,7 +1283,7 @@ internal class SmsContentChecker(
 
     override suspend fun check(ctx: CheckContext): BlockResult? {
         val body = ctx.smsBody ?: return null
-        val result = smsContentAnalyzer.analyze(body)
+        val result = smsContentAnalyzer.analyze(body, firstContact = ctx.smsFirstContact)
         val aggressive = ctx.prefs[SpamRepository.KEY_AGGRESSIVE_MODE] ?: false
         val threshold = if (aggressive) 25 else 50
         return if (result.score >= threshold) {
 
@@ -132,6 +132,12 @@ data class CheckContext(
      * relationship so the later, globally ordered SMS trust rule can decide.
      */
     val smsContextTrusted: Boolean = false,
+    /**
+     * True for a live SMS that is the first text from a full phone number the
+     * user has never texted and has no earlier message from. Only the reply
+     * bait rule in [com.sysadmindoc.callshield.data.SmsContentAnalyzer] reads it.
+     */
+    val smsFirstContact: Boolean = false,
     /** Region-scoped sender-ID/numbering evidence for SMS only. */
     val senderProvenance: SenderProvenance? = null,
     /**
 
@@ -272,6 +272,13 @@ class SpamRepositoryImpl(
         val smsContextTrusted =
             canonicalPhone.isNotBlank() &&
                 checkerDependencies.smsContextChecker.isTrustedSender(context, canonicalPhone)
+        // Reply bait only means something in a stranger's first text. A rescan
+        // finds the old message itself in the inbox, so it applies only live.
+        val smsFirstContact =
+            realtimeCall &&
+                !smsContextTrusted &&
+                canonicalPhone.isNotBlank() &&
+                checkerDependencies.smsContextChecker.isFirstMessageFrom(context, canonicalPhone)
         var trustedAllowSource: String? = null
         var sharedDiagnostics: ScreeningDiagnostics? = null
         if (canonicalPhone.isNotBlank()) {
@@ -311,6 +318,7 @@ class SpamRepositoryImpl(
                 prefs = prefs,
                 trustedAllowSource = trustedAllowSource,
                 smsContextTrusted = smsContextTrusted,
+                smsFirstContact = smsFirstContact,
                 senderProvenance = senderProvenance,
             )
         val pipelineRun = CheckerPipeline.runWithDiagnostics(smsExtensions, ctx)
 
@@ -72,6 +72,7 @@ fun signalLabelRes(signal: String): Int? =
         "special_chars" -> R.string.signal_special_chars
         "short_msg_with_url" -> R.string.signal_short_message_with_link
         "disguised_text" -> R.string.signal_disguised_text
+        "reply_bait" -> R.string.signal_reply_bait
         "spam_domain" -> R.string.signal_spam_domain
         "lookalike_host" -> R.string.signal_lookalike_host
         else -> overlayReasonLabelRes(signal)
 
@@ -377,6 +377,7 @@
     <string name="signal_special_chars">符号过多</string>
     <string name="signal_short_message_with_link">带链接的简短消息</string>
     <string name="signal_disguised_text">链接或品牌名中藏有伪装字符</string>
+    <string name="signal_reply_bait">陌生号码的第一条短信在诱你回复</string>
     <string name="signal_spam_domain">链接指向已知垃圾网站</string>
     <string name="signal_lookalike_host">链接仿冒知名网站</string>
     <string name="signal_list_separator">、</string>