反spam: 堵住五个静默绕过 + 新增签到探针层

这五个问题都是在同源的私有 bot 上、用真实群流量测出来的，公开版同样存在
(探针那层是公开版从来就没有的功能)。都属同一类：消息走到某条路径后，
反spam 静默地根本没跑。

1. @提及/回复bot 绕过 —— 该分支回复完就 return，位置在整条反spam 之前。
spam bot 只要回复一下 bot 自己发的欢迎语就完全免检，而且 bot 还会用 AI
回它一句(等于帮它顶帖)。改为：先过反spam，判定干净了才在函数末尾回答。
新增 sender_ctx 提示提问本身不算违规，避免把正常提问的人误判封号。
管理员仍照常得到回答(公开版对管理员是提前 return，不能顺手跳过回答)。

2. 编辑消息绕过 —— 先发一句无害的、再编辑成广告。两因叠加：allowed_updates
没订阅 edited_message(Telegram 根本不推) + handler 只取 update.message
(编辑事件里是 None)。改为订阅 + 取 message or edited_message；编辑只重判
不重答；私聊 handler 与 CommandHandler 显式加 UpdateType.MESSAGE，否则
编辑一次就重复回答/重复执行命令一次。

3. 判定解析 fail-open —— 非 spam/yes 开头一律当干净，模型多说两个字
(根据以上判断，yes)或被 max_tokens=8 截断在前言里就是免死金牌。
改三态 True/False/None，None 退回词库兜底并记录原始输出；max_tokens 8→32。

4. 新增签到探针层(modules/probe.py) —— 对所有非管理员生效，只标记绝不封人，
窗口内累计到阈值才静默删除。词表刻意只收签到打卡这一族：更宽的版本
(哈+/好+的?/收到/顶/纯emoji/纯标点)实测命中中文群短消息的 59%，
会把真人的哈哈👍删掉，比漏拦更糟。window_start 记窗口起点且命中不刷新，
否则每天发一句水消息的人计数只涨不降，被永久静默删。

5. 命令消息绕过 —— 群 handler 带着 ~filters.COMMAND，命令根本不进反spam；
而发给别的 bot 的命令(/start@某bot)我们的 CommandHandler 也不接
(PTB 会校验 @用户名是否等于自己)。两边都不接 = 没有任何 handler 处理它。
影响面不止 /start：/start@某bot 加我微信一天1000 这类带正文的伪命令同样溜过。
去掉该过滤器(CommandHandler 注册在前，自己的命令行为不变)，并把光秃秃的
/start@别的bot 归入探针层(拉流量话术，AI 判不出来)。

验证：py_compile 全过；探针/正则 12/12(含 0 误伤真人短消息、不误伤自己的命令
和别的bot的正常功能调用)；同源修复已在私有 bot 的生产环境跑通并经真实
telegram.Update 对象的 PTB 分发对照测试(10/10)与端到端测试(5/5)。

.env.example

@@ -31,3 +31,7 @@ SPAM_REPEAT_THRESHOLD=3
 SPAM_REPEAT_WINDOW=300
 # Chinese-slang lexicon hard-hit threshold (prefilter). Higher = stricter.
 LEXICON_HARD_THRESHOLD=6
+# Probe ("check-in") filler: silently delete after this many flags. Never bans.
+PROBE_FLAG_DELETE=2
+# Rolling window for those flags (hours); older flags reset the count.
+PROBE_WINDOW_HOURS=24

README.md

@@ -114,6 +114,8 @@ Everything is set via environment variables — see [`.env.example`](.env.exampl
 | `AI_AUDIO_MODEL` | `Qwen/Qwen3-Omni-30B-A3B-Instruct` | Voice-message model |
 | `AI_IMAGE_MAX_WIDTH` | `600` | Downscale width before vision calls |
 | `LEXICON_HARD_THRESHOLD` | `6` | Slang pre-filter strictness (higher = stricter) |
+| `PROBE_FLAG_DELETE` | `2` | Check-in filler flags before it starts deleting (never bans) |
+| `PROBE_WINDOW_HOURS` | `24` | Rolling window for those flags |
 
 ---
 
@@ -158,6 +160,7 @@ TelegramGuard/
 │   ├── chat.py            Prompt orchestration (loads .ilang)
 │   ├── prefilter.py       Zero-cost spam pre-filter + triage
 │   ├── lexicon.py         Slang / evasion normalization + scoring
+│   ├── probe.py           Check-in filler detection (mark-only, never bans)
 │   ├── ilang_judge.py     I-Lang decision function
 │   ├── admin.py           Group admin
 │   ├── db.py              Shared SQLite + async lock

README_AR.md

@@ -98,6 +98,8 @@ python bot.py
 | `AI_AUDIO_MODEL` | `Qwen/Qwen3-Omni-30B-A3B-Instruct` | نموذج الرسائل الصوتية |
 | `AI_IMAGE_MAX_WIDTH` | `600` | عرض التصغير قبل استدعاءات الرؤية |
 | `LEXICON_HARD_THRESHOLD` | `6` | صرامة المرشّح الأوّلي للعامية (الأعلى = أكثر صرامة) |
+| `PROBE_FLAG_DELETE` | `2` | عدد علامات رسائل «الحضور» قبل بدء الحذف (لا يحظر أبدًا) |
+| `PROBE_WINDOW_HOURS` | `24` | النافذة المتحركة لتلك العلامات (بالساعات) |
 
 ---
 
@@ -142,6 +144,7 @@ TelegramGuard/
 │   ├── chat.py            Prompt orchestration (loads .ilang)
 │   ├── prefilter.py       Zero-cost spam pre-filter + triage
 │   ├── lexicon.py         Slang / evasion normalization + scoring
+│   ├── probe.py           كشف رسائل «الحضور» (تعليم فقط، بلا حظر)
 │   ├── ilang_judge.py     I-Lang decision function
 │   ├── admin.py           Group admin
 │   ├── db.py              Shared SQLite + async lock

README_CN.md

@@ -98,6 +98,8 @@ python bot.py
 | `AI_AUDIO_MODEL` | `Qwen/Qwen3-Omni-30B-A3B-Instruct` | 语音模型 |
 | `AI_IMAGE_MAX_WIDTH` | `600` | 识图前压缩宽度 |
 | `LEXICON_HARD_THRESHOLD` | `6` | 黑话预过滤严格度(越高越严) |
+| `PROBE_FLAG_DELETE` | `2` | 签到水消息累计多少次后开始静默删除(绝不封号) |
+| `PROBE_WINDOW_HOURS` | `24` | 上述标记的滚动有效窗口(小时) |
 
 ---
 
@@ -142,6 +144,7 @@ TelegramGuard/
 │   ├── chat.py            提示词编排(加载 .ilang)
 │   ├── prefilter.py       零成本垃圾预过滤 + 三路分诊
 │   ├── lexicon.py         黑话/规避归一化 + 打分
+│   ├── probe.py           签到水消息识别(只标记, 绝不封号)
 │   ├── ilang_judge.py     I-Lang 判定函数
 │   ├── admin.py           群管理
 │   ├── db.py              SQLite 共享连接 + 异步锁

README_ES.md

@@ -98,6 +98,8 @@ Todo se configura mediante variables de entorno — consulta [`.env.example`](.e
 | `AI_AUDIO_MODEL` | `Qwen/Qwen3-Omni-30B-A3B-Instruct` | Modelo para mensajes de voz |
 | `AI_IMAGE_MAX_WIDTH` | `600` | Ancho de reducción antes de las llamadas de visión |
 | `LEXICON_HARD_THRESHOLD` | `6` | Rigor del prefiltro de jerga (mayor = más estricto) |
+| `PROBE_FLAG_DELETE` | `2` | Marcas de relleno tipo «presente» antes de borrar (nunca banea) |
+| `PROBE_WINDOW_HOURS` | `24` | Ventana móvil para esas marcas (horas) |
 
 ---
 
@@ -142,6 +144,7 @@ TelegramGuard/
 │   ├── chat.py            Prompt orchestration (loads .ilang)
 │   ├── prefilter.py       Zero-cost spam pre-filter + triage
 │   ├── lexicon.py         Slang / evasion normalization + scoring
+│   ├── probe.py           Detección de relleno tipo «presente» (solo marca, nunca banea)
 │   ├── ilang_judge.py     I-Lang decision function
 │   ├── admin.py           Group admin
 │   ├── db.py              Shared SQLite + async lock

README_FA.md

@@ -98,6 +98,8 @@ python bot.py
 | `AI_AUDIO_MODEL` | `Qwen/Qwen3-Omni-30B-A3B-Instruct` | مدل پیام صوتی |
 | `AI_IMAGE_MAX_WIDTH` | `600` | کاهش عرض تصویر پیش از فراخوانی‌های بینایی |
 | `LEXICON_HARD_THRESHOLD` | `6` | سخت‌گیری پیش‌فیلتر زبان کوچه‌بازاری (بالاتر = سخت‌گیرانه‌تر) |
+| `PROBE_FLAG_DELETE` | `2` | تعداد نشانه‌های پیام «حضور» پیش از حذف خودکار (هرگز مسدود نمی‌کند) |
+| `PROBE_WINDOW_HOURS` | `24` | بازهٔ چرخشی برای این نشانه‌ها (ساعت) |
 
 ---
 
@@ -142,6 +144,7 @@ TelegramGuard/
 │   ├── chat.py            Prompt orchestration (loads .ilang)
 │   ├── prefilter.py       Zero-cost spam pre-filter + triage
 │   ├── lexicon.py         Slang / evasion normalization + scoring
+│   ├── probe.py           تشخیص پیام‌های «حضور» (فقط نشانه‌گذاری، بدون مسدودسازی)
 │   ├── ilang_judge.py     I-Lang decision function
 │   ├── admin.py           Group admin
 │   ├── db.py              Shared SQLite + async lock

README_RU.md

@@ -98,6 +98,8 @@ python bot.py
 | `AI_AUDIO_MODEL` | `Qwen/Qwen3-Omni-30B-A3B-Instruct` | Модель для голосовых сообщений |
 | `AI_IMAGE_MAX_WIDTH` | `600` | Ширина уменьшения изображения перед вызовами зрения |
 | `LEXICON_HARD_THRESHOLD` | `6` | Строгость предфильтра сленга (выше = строже) |
+| `PROBE_FLAG_DELETE` | `2` | Сколько меток «отметился» до начала удаления (никогда не банит) |
+| `PROBE_WINDOW_HOURS` | `24` | Скользящее окно для этих меток (часы) |
 
 ---
 
@@ -142,6 +144,7 @@ TelegramGuard/
 │   ├── chat.py            Prompt orchestration (loads .ilang)
 │   ├── prefilter.py       Zero-cost spam pre-filter + triage
 │   ├── lexicon.py         Slang / evasion normalization + scoring
+│   ├── probe.py           Обнаружение флуда «отметился» (только метки, без банов)
 │   ├── ilang_judge.py     I-Lang decision function
 │   ├── admin.py           Group admin
 │   ├── db.py              Shared SQLite + async lock

bot.py

@@ -24,6 +24,7 @@ from modules.chat import (
 )
 from modules.admin import is_admin, is_bot_admin, register_group
 from modules.prefilter import prefilter
+from modules import probe
 
 logging.basicConfig(
     format="%(asctime)s [%(levelname)s] %(message)s",
@@ -137,8 +138,57 @@ async def cmd_ban(update: Update, context: ContextTypes.DEFAULT_TYPE):
 
 # ==================== Group ====================
 
+async def _answer_mention(msg, context, is_mention, text):
+    """Reply to someone who @mentioned the bot or replied to it.
+
+    Called only once the message is known to be clean (or from an admin) — it
+    used to run at the top of handle_group_message and return, which let any
+    spammer skip the entire anti-spam pipeline just by replying to the bot.
+    """
+    clean = text.replace("@" + context.bot.username, "").strip() if (text and is_mention) else (text.strip() if text else "")
+    g_history = context.chat_data.setdefault("group_history", [])
+    if msg.photo:
+        try:
+            f = await context.bot.get_file(msg.photo[-1].file_id)
+            img_data = bytes(await f.download_as_bytearray())
+            reply = await ai_group_vision(img_data, caption=clean, history=g_history)
+        except Exception:
+            reply = "Couldn't read that image. Try sending another one?"
+    elif msg.video:
+        if msg.video.thumbnail:
+            try:
+                vf = await context.bot.get_file(msg.video.thumbnail.file_id)
+                vimg = bytes(await vf.download_as_bytearray())
+                reply = await ai_group_vision(vimg, caption=clean, history=g_history)
+            except Exception:
+                if clean:
+                    g_history.append({"role": "user", "text": "[video] " + clean})
+                    reply = await ai_group_reply("[video] " + clean, g_history)
+                else:
+                    reply = "Couldn't read the video thumbnail. What's it about?"
+        elif clean:
+            g_history.append({"role": "user", "text": "[video] " + clean})
+            reply = await ai_group_reply("[video] " + clean, g_history)
+        else:
+            reply = "Can't process videos directly. What's it about?"
+    else:
+        g_history.append({"role": "user", "text": clean})
+        reply = await ai_group_reply(clean, g_history)
+    g_history.append({"role": "assistant", "text": reply})
+    if len(g_history) > 20:
+        g_history[:] = g_history[-20:]
+    try:
+        await msg.reply_text(reply)
+    except Exception as e:
+        logger.warning("group @mention reply failed: chat=" + str(msg.chat.id) + " err=" + str(e))
+
+
 async def handle_group_message(update: Update, context: ContextTypes.DEFAULT_TYPE):
-    msg = update.message
+    # Edited messages come in too: this used to read update.message only, which
+    # is None on an edit event, so the handler returned on its first line and
+    # "post something harmless, then edit it into an ad" bypassed everything.
+    is_edited = update.message is None and update.edited_message is not None
+    msg = update.message or update.edited_message
     if not msg:
         return
     chat_id = msg.chat.id
@@ -151,50 +201,22 @@ async def handle_group_message(update: Update, context: ContextTypes.DEFAULT_TYP
 
     tos_ok = await check_tos(chat_id)
 
-    # @mention or reply to bot
+    # @mention or reply to bot — only detected here, answered at the end of the
+    # function once anti-spam has cleared the message.
     is_mention = text and context.bot.username and ("@" + context.bot.username) in text
     is_reply_to_bot = msg.reply_to_message and msg.reply_to_message.from_user and msg.reply_to_message.from_user.id == context.bot.id
     has_media = bool(msg.photo or msg.video or msg.document)
-    if (text or has_media) and (is_mention or is_reply_to_bot):
-        clean = text.replace("@" + context.bot.username, "").strip() if (text and is_mention) else (text.strip() if text else "")
-        if not tos_ok:
-            reply = "I haven't been enabled yet. Ask an admin to tap the Accept & Enable button above."
-        else:
-            g_history = context.chat_data.setdefault("group_history", [])
-            if msg.photo:
-                try:
-                    f = await context.bot.get_file(msg.photo[-1].file_id)
-                    img_data = bytes(await f.download_as_bytearray())
-                    reply = await ai_group_vision(img_data, caption=clean, history=g_history)
-                except Exception:
-                    reply = "Couldn't read that image. Try sending another one?"
-            elif msg.video:
-                if msg.video.thumbnail:
-                    try:
-                        vf = await context.bot.get_file(msg.video.thumbnail.file_id)
-                        vimg = bytes(await vf.download_as_bytearray())
-                        reply = await ai_group_vision(vimg, caption=clean, history=g_history)
-                    except Exception:
-                        if clean:
-                            g_history.append({"role": "user", "text": "[video] " + clean})
-                            reply = await ai_group_reply("[video] " + clean, g_history)
-                        else:
-                            reply = "Couldn't read the video thumbnail. What's it about?"
-                elif clean:
-                    g_history.append({"role": "user", "text": "[video] " + clean})
-                    reply = await ai_group_reply("[video] " + clean, g_history)
-                else:
-                    reply = "Can't process videos directly. What's it about?"
-            else:
-                g_history.append({"role": "user", "text": clean})
-                reply = await ai_group_reply(clean, g_history)
-            g_history.append({"role": "assistant", "text": reply})
-            if len(g_history) > 20:
-                g_history[:] = g_history[-20:]
-        await msg.reply_text(reply)
-        return
+    # An edited message is re-judged for spam but never re-answered, otherwise
+    # the bot replies again every time the user tweaks their message.
+    wants_reply = bool((text or has_media) and (is_mention or is_reply_to_bot) and not is_edited)
 
+    # ToS not accepted: guidance only. Without admin consent we take no action.
     if not tos_ok:
+        if wants_reply:
+            try:
+                await msg.reply_text("I haven't been enabled yet. Ask an admin to tap the Accept & Enable button above.")
+            except Exception as e:
+                logger.warning("group @mention reply failed: chat=" + str(chat_id) + " err=" + str(e))
         return
 
     # Admin check
@@ -213,14 +235,39 @@ async def handle_group_message(update: Update, context: ContextTypes.DEFAULT_TYP
         user_msgs[uid] = []
     content_hash = _hashlib.md5(text.encode()).hexdigest() if text else ""
     now = _time.time()
+    # An edit carries the same message_id: replace the existing entry instead of
+    # appending a second one, so the bulk-delete list holds no duplicates and
+    # editing one message repeatedly doesn't look like flooding.
+    user_msgs[uid] = [e for e in user_msgs[uid] if e[0] != msg.message_id]
     user_msgs[uid].append((msg.message_id, content_hash, now))
     if len(user_msgs[uid]) > 20:
         user_msgs[uid] = user_msgs[uid][-20:]
 
-    # Admin bypass
+    # Admin bypass: no enforcement on admins, but still answer them.
     if is_admin_user:
+        if wants_reply:
+            await _answer_mention(msg, context, is_mention, text)
         return
 
+    # Probe ("check-in") filler: mark only, never ban. Runs before the duplicate
+    # check so repeated check-ins can't escalate into a ban.
+    try:
+        if await probe.check(msg, chat_id, uid, context.bot.username):
+            return
+    except Exception as e:
+        logger.warning("probe check failed: " + str(e))
+
+    # @mention / reply-to-bot now goes through anti-spam as well. Asking the bot
+    # a question is not an offence though — without this hint the judge reads a
+    # question addressed to it as promotion and bans the person for it.
+    sender_ctx = ""
+    if wants_reply:
+        sender_ctx = (
+            "This message is addressed to the bot (a question or a reply to it). "
+            "Asking the bot something is not a violation on its own — only call it "
+            "spam if the content really is advertising, a scam, or contact harvesting."
+        )
+
     # Duplicate message detection
     spam = False
     if content_hash:
@@ -243,30 +290,30 @@ async def handle_group_message(update: Update, context: ContextTypes.DEFAULT_TYP
                 try:
                     f = await context.bot.get_file(msg.photo[-1].file_id)
                     data = bytes(await f.download_as_bytearray())
-                    spam = await ai_judge_group_image(data, text)
+                    spam = await ai_judge_group_image(data, text, sender_context=sender_ctx)
                 except Exception:
                     if text:
-                        spam = await ai_judge_group_message(text)
+                        spam = await ai_judge_group_message(text, sender_context=sender_ctx)
             elif msg.video:
                 if msg.video.thumbnail:
                     try:
                         vf = await context.bot.get_file(msg.video.thumbnail.file_id)
                         vdata = bytes(await vf.download_as_bytearray())
-                        spam = await ai_judge_group_image(vdata, text)
+                        spam = await ai_judge_group_image(vdata, text, sender_context=sender_ctx)
                     except Exception:
                         if text:
-                            spam = await ai_judge_group_message(text)
+                            spam = await ai_judge_group_message(text, sender_context=sender_ctx)
                 elif text:
-                    spam = await ai_judge_group_message(text)
+                    spam = await ai_judge_group_message(text, sender_context=sender_ctx)
                 elif msg.forward_date:
                     spam = True
             elif msg.document or msg.sticker:
                 if text:
-                    spam = await ai_judge_group_message(text)
+                    spam = await ai_judge_group_message(text, sender_context=sender_ctx)
                 elif msg.forward_date:
                     spam = True
             elif text:
-                spam = await ai_judge_group_message(text)
+                spam = await ai_judge_group_message(text, sender_context=sender_ctx)
         # verdict == "clean" → skip AI, let it through
 
     if spam:
@@ -293,6 +340,11 @@ async def handle_group_message(update: Update, context: ContextTypes.DEFAULT_TYP
                     pass
         return
 
+    # Clean message (spam was handled and returned above). Only now do we answer
+    # someone who was talking to the bot.
+    if wants_reply:
+        await _answer_mention(msg, context, is_mention, text)
+
 
 # ==================== Private ====================
 
@@ -445,24 +497,32 @@ def main():
 
     app = Application.builder().token(config.BOT_TOKEN).connect_timeout(30).read_timeout(30).write_timeout(30).pool_timeout(30).build()
 
+    # UpdateType.MESSAGE everywhere below: once edited_message is subscribed to,
+    # every handler sees edit events too. Only the group handler wants them —
+    # anywhere else an edit would run the command or the answer a second time.
     for cmd, fn in [
         ("start", cmd_start), ("help", cmd_help), ("ban", cmd_ban),
     ]:
-        app.add_handler(CommandHandler(cmd, fn))
+        app.add_handler(CommandHandler(cmd, fn, filters=filters.UpdateType.MESSAGE))
 
     app.add_handler(ChatMemberHandler(handle_my_chat_member, ChatMemberHandler.MY_CHAT_MEMBER))
     app.add_handler(CallbackQueryHandler(handle_tos_callback, pattern="^tos_"))
 
-    # Group
+    # Group — deliberately no UpdateType filter: edits must be re-judged here.
+    # Also deliberately no ~filters.COMMAND. A command addressed to a DIFFERENT bot
+    # ("/start@OtherBot buy followers cheap") is refused by our own CommandHandlers —
+    # PTB checks the @username against this bot and returns None on a mismatch — so
+    # excluding commands here left those messages handled by nothing at all.
+    # The CommandHandlers above are registered first, so our own commands still win.
     app.add_handler(MessageHandler(
-        (filters.TEXT | filters.PHOTO | filters.VIDEO | filters.Document.ALL | filters.Sticker.ALL) & filters.ChatType.GROUPS & ~filters.COMMAND,
+        (filters.TEXT | filters.PHOTO | filters.VIDEO | filters.Document.ALL | filters.Sticker.ALL) & filters.ChatType.GROUPS,
         handle_group_message
     ))
 
     # Private
-    app.add_handler(MessageHandler(filters.TEXT & filters.ChatType.PRIVATE & ~filters.COMMAND, handle_private_text))
-    app.add_handler(MessageHandler(filters.PHOTO & filters.ChatType.PRIVATE, handle_private_photo))
-    app.add_handler(MessageHandler(filters.VOICE & filters.ChatType.PRIVATE, handle_private_voice))
+    app.add_handler(MessageHandler(filters.TEXT & filters.ChatType.PRIVATE & ~filters.COMMAND & filters.UpdateType.MESSAGE, handle_private_text))
+    app.add_handler(MessageHandler(filters.PHOTO & filters.ChatType.PRIVATE & filters.UpdateType.MESSAGE, handle_private_photo))
+    app.add_handler(MessageHandler(filters.VOICE & filters.ChatType.PRIVATE & filters.UpdateType.MESSAGE, handle_private_voice))
 
     loop = asyncio.new_event_loop()
     asyncio.set_event_loop(loop)
@@ -481,7 +541,10 @@ def main():
             url_path="webhook",
             webhook_url=webhook_url + "/webhook",
             drop_pending_updates=True,
-            allowed_updates=["message", "callback_query", "my_chat_member"],
+            # edited_message: without subscribing, Telegram never sends edit
+            # events at all and "post something harmless, then edit it into an
+            # ad" walks straight past the anti-spam pipeline.
+            allowed_updates=["message", "edited_message", "callback_query", "my_chat_member"],
         )
     else:
         # Polling mode: run AI test first, then start
@@ -503,7 +566,9 @@ def main():
         logger.info("I-Lang Guard starting (polling mode)")
         app.run_polling(
             drop_pending_updates=True,
-            allowed_updates=["message", "callback_query", "my_chat_member"],
+            # See the webhook branch above — edited_message must be subscribed
+            # to or edits bypass anti-spam entirely.
+            allowed_updates=["message", "edited_message", "callback_query", "my_chat_member"],
             bootstrap_retries=10
         )
 

config.py

@@ -25,5 +25,12 @@ SPAM_REPEAT_WINDOW = int(os.environ.get("SPAM_REPEAT_WINDOW", "300"))
 # Chinese-slang lexicon hard-hit threshold (prefilter Layer 2.5). Higher = stricter.
 LEXICON_HARD_THRESHOLD = int(os.environ.get("LEXICON_HARD_THRESHOLD", "6"))
 
+# Probe ("check-in") detection. Mark-only layer: it never bans, it only starts
+# silently deleting once a member has been flagged this many times...
+PROBE_FLAG_DELETE = int(os.environ.get("PROBE_FLAG_DELETE", "2"))
+# ...within this rolling window (hours). Flags older than the window reset to 1,
+# so a real person posting one such message a day is never permanently silenced.
+PROBE_WINDOW_HOURS = int(os.environ.get("PROBE_WINDOW_HOURS", "24"))
+
 # Admin user ID (auto-detected from first /start)
 ADMIN_USER_ID = None

modules/chat.py

@@ -4,6 +4,7 @@ import random
 import os
 
 from modules import ai_provider
+from modules import lexicon
 import config
 
 logger = logging.getLogger(__name__)
@@ -90,10 +91,34 @@ def _deflect():
 
 
 def _is_spam(raw):
-    """Parse a spam-judge reply. Fixes the old `"spam" in result` substring bug
-    (a wordy 'not spam' would count as spam). Expects the model to answer spam/ok."""
-    s = (raw or "").strip().lower().lstrip("\"'`* ")
-    return s.startswith("spam") or s.startswith("yes")
+    """Parse a spam-judge reply into True / False / None (couldn't parse it).
+
+    Fixes the old `"spam" in result` substring bug (a wordy 'not spam' counted as
+    spam) and the fail-open that replaced it: anything not starting with spam/yes
+    silently meant "clean", so a model that prefixes its answer ("Based on the
+    above, yes") or gets truncated inside that preamble was a free pass.
+    None means unparseable — callers fall back to the lexicon instead of letting
+    the message through.
+    """
+    s = (raw or "").strip().lower().lstrip("\"'`*# 　")
+    if not s:
+        return None
+    if s.startswith(("spam", "yes", "y,", "违规", "是", "有")) or s == "y":
+        return True
+    if s.startswith(("ok", "no", "n,", "not ", "clean", "正常", "否", "不是", "无")) or s == "n":
+        return False
+    return None
+
+
+def _lexicon_fallback(text):
+    """Used when the verdict is unparseable or the API call failed: fall back to
+    a lexicon hard hit rather than silently letting the message through."""
+    try:
+        s, _ = lexicon.score(text or "")
+        return s >= getattr(config, "LEXICON_HARD_THRESHOLD", 6)
+    except Exception as e:
+        logger.warning("lexicon fallback failed: " + str(e))
+        return False
 
 
 async def ai_text(text, history=None, context_info=""):
@@ -137,24 +162,42 @@ async def ai_voice(audio_bytes, mime_type="audio/ogg", history=None, context_inf
         return ("chat", "Didn't catch that. Try again or type it out.")
 
 
-async def ai_judge_group_message(text):
+async def ai_judge_group_message(text, sender_context=""):
     try:
-        prompt = ANTISPAM_TEXT_PROMPT + "\n\nMessage content: " + text[:1000]
-        raw = await ai_provider.generate_text(prompt, max_tokens=8, temperature=0.0)
-        return _is_spam(raw)
-    except Exception:
-        return False
+        prompt = ANTISPAM_TEXT_PROMPT
+        if sender_context:
+            prompt += "\n\nSender context: " + sender_context
+        prompt += "\n\nMessage content: " + text[:1000]
+        # max_tokens 32, not 8: eight tokens is enough to truncate the answer
+        # inside a preamble ("Based on the above,"), which leaves nothing to
+        # parse and drops the judgement down to the lexicon for no reason.
+        raw = await ai_provider.generate_text(prompt, max_tokens=32, temperature=0.0)
+        verdict = _is_spam(raw)
+        if verdict is None:  # unparseable — don't let it through silently
+            logger.warning("spam text verdict unparseable: " + repr((raw or "")[:80]) + " — falling back to lexicon")
+            return _lexicon_fallback(text)
+        return verdict
+    except Exception as e:
+        logger.warning("spam text judge failed, falling back to lexicon: " + str(e))
+        return _lexicon_fallback(text)
 
 
-async def ai_judge_group_image(image_bytes, caption=""):
+async def ai_judge_group_image(image_bytes, caption="", sender_context=""):
     try:
         prompt = ANTISPAM_TEXT_PROMPT + "\n\nJudge this image. Reply ONLY: spam or ok."
+        if sender_context:
+            prompt += "\nSender context: " + sender_context
         if caption:
             prompt += "\nCaption: " + caption[:500]
-        raw = await ai_provider.generate_vision(prompt, image_bytes, max_tokens=8, temperature=0.0)
-        return _is_spam(raw)
-    except Exception:
-        return False
+        raw = await ai_provider.generate_vision(prompt, image_bytes, max_tokens=32, temperature=0.0)
+        verdict = _is_spam(raw)
+        if verdict is None:  # same as above — no silent pass
+            logger.warning("spam image verdict unparseable: " + repr((raw or "")[:80]) + " — falling back to lexicon")
+            return _lexicon_fallback(caption)
+        return verdict
+    except Exception as e:
+        logger.warning("spam image judge failed, falling back to lexicon: " + str(e))
+        return _lexicon_fallback(caption)
 
 
 async def ai_group_vision(image_bytes, caption="", history=None):

modules/database.py

@@ -30,6 +30,13 @@ async def init_db():
                 joined_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP,
                 PRIMARY KEY (chat_id, user_id)
             );
+            CREATE TABLE IF NOT EXISTS probe_flags (
+                chat_id INTEGER,
+                user_id INTEGER,
+                flags INTEGER DEFAULT 0,
+                window_start TIMESTAMP,
+                PRIMARY KEY (chat_id, user_id)
+            );
             CREATE TABLE IF NOT EXISTS tos_consent (
                 chat_id INTEGER PRIMARY KEY,
                 accepted_by INTEGER,

modules/probe.py

@@ -0,0 +1,120 @@
+"""
+Probe ("check-in") detection.
+
+Spam bots warm a group up with harmless filler — 签到 / 打卡 / 冒泡 — to see whether
+anyone is moderating and to build a bit of message history before dropping the
+actual ad. This layer is deliberately the gentlest one in the stack:
+
+  * every non-admin member is subject to it (not just new joiners)
+  * it NEVER bans — the worst it does is silently delete
+  * and it only starts deleting after the same member has been flagged
+    config.PROBE_FLAG_DELETE times inside a rolling PROBE_WINDOW_HOURS window
+
+Everything else keeps going through the lexicon + AI path.
+"""
+
+import logging
+import re
+
+import config
+from modules.db import shared_db
+
+logger = logging.getLogger(__name__)
+
+# Deliberately narrow — only the check-in family of phrases.
+# A wider pattern (哈+ / 好+的? / 收到 / 顶, plus "pure emoji" and "pure punctuation")
+# was measured against real Chinese group chat: it hit 59% of ordinary short
+# messages. Since this layer applies to every member, that means silently
+# deleting real people's "哈哈" and "👍" — worse than missing a probe.
+PROBE_PATTERNS = re.compile(
+    r"^(签到|打卡|报到|新人报道|前来报道|冒泡|水一下|沙发|路过)\s*$"
+)
+
+
+def looks_like_probe(text):
+    """Pure check-in filler. Single-message check, no history involved."""
+    if not text:
+        return False
+    t = text.strip()
+    return len(t) <= 8 and bool(PROBE_PATTERNS.match(t))
+
+
+# A bare "/start@SomeOtherBot" posted in a group is the classic way to drive
+# traffic to another bot — you start a bot in private, not by announcing it in a
+# group. The AI judge cannot flag it (there is nothing to judge but a command),
+# so it belongs here. Only /start: "/menu@ShopBot" is somebody legitimately
+# using another bot in the group and must not be touched.
+FOREIGN_START = re.compile(r"^/start@([A-Za-z0-9_]{4,32})\s*$", re.I)
+
+
+def looks_like_foreign_start(text, my_username=""):
+    """True for a bare /start aimed at a bot that is not us."""
+    if not text:
+        return False
+    m = FOREIGN_START.match(text.strip())
+    if not m:
+        return False
+    return m.group(1).lower() != (my_username or "").lower().lstrip("@")
+
+
+def _window_hours():
+    try:
+        return max(1, int(getattr(config, "PROBE_WINDOW_HOURS", 24)))
+    except (TypeError, ValueError):
+        return 24
+
+
+async def add_flag(chat_id, user_id):
+    """Add one probe flag for this member and return the running count.
+
+    UPSERT, not a bare UPDATE: members have no row until their first probe, and
+    an UPDATE that matches nothing affects 0 rows and keeps returning 0 — the
+    delete threshold would never be reached and this whole layer would be dead.
+
+    window_start records the START of the current window and is NOT refreshed on
+    a hit, so the window genuinely expires. Refreshing it every time would let
+    the count of someone who posts one such message a day ratchet up forever
+    until they are permanently silenced.
+    """
+    window = "-%d hours" % _window_hours()
+    async with shared_db() as db:
+        await db.execute(
+            "INSERT INTO probe_flags (chat_id, user_id, flags, window_start) "
+            "VALUES (?, ?, 1, CURRENT_TIMESTAMP) "
+            "ON CONFLICT(chat_id, user_id) DO UPDATE SET "
+            "flags = CASE WHEN window_start IS NULL OR window_start < datetime('now', ?) "
+            "             THEN 1 ELSE flags + 1 END, "
+            "window_start = CASE WHEN window_start IS NULL OR window_start < datetime('now', ?) "
+            "                    THEN CURRENT_TIMESTAMP ELSE window_start END",
+            (chat_id, user_id, window, window)
+        )
+        await db.commit()
+        cur = await db.execute(
+            "SELECT flags FROM probe_flags WHERE chat_id=? AND user_id=?",
+            (chat_id, user_id)
+        )
+        row = await cur.fetchone()
+        return row[0] if row else 0
+
+
+async def check(msg, chat_id, user_id, my_username=""):
+    """Flag a probe message. Returns True if this message was one (caller stops).
+
+    Judges msg.text only, never captions: a caption hit would delete the photo
+    along with it, which is a visible accident. Admins never reach this — the
+    caller returns for them before calling in.
+    """
+    if not msg.text:
+        return False
+    if not (looks_like_probe(msg.text) or looks_like_foreign_start(msg.text, my_username)):
+        return False
+    flags = await add_flag(chat_id, user_id)
+    logger.info("PROBE flag: user=" + str(user_id) + " chat=" + str(chat_id) +
+                " flags=" + str(flags) + " text=" + msg.text[:20])
+    if flags >= getattr(config, "PROBE_FLAG_DELETE", 2):
+        # Mark-only layer: delete quietly, never ban, never warn.
+        try:
+            await msg.delete()
+        except Exception as e:
+            logger.warning("PROBE delete failed: " + str(e))
+    return True