反spam: 同步私有姊妹版的入口完整性审计成果

同源的私有 bot 在真实群流量上跑出了这批问题，公开版逐条同样存在。
仍是同一个模式:消息走到某条路径后，反spam 静默地根本没跑。

1. 崩溃: msg.forward_date 在 PTB 22.8 已不存在(Bot API 7.0 换成 forward_origin，
读取直接 AttributeError)。三处在读它 —— bot.py 两处判定链 + prefilter.forward_spam，
于是任何无 caption 的贴纸/文件/GIF 进群就崩，不判定不删除不记录。
而且全仓库零个错误处理器，崩了只在日志留 traceback。已全部改 forward_origin
并注册 add_error_handler。

2. 命令抢占: CommandHandler 注册在群 handler 之前且同在 group 0，PTB 每个 group
只跑第一个匹配的；而 PTB 允许命令携带任意后缀正文 —— /<任意命令> <广告> 被命令
handler 吃掉后静默 return，广告全程无人过问。群 handler 移到 group=-1 先跑，
真正处置(删/封)后 raise ApplicationHandlerStop 掐断。连带:命令消息不再算作
@提问，否则 /start@自己 会被 AI 回一遍、命令再回一遍。

3. 类型覆盖: 过滤器白名单只有 TEXT/PHOTO/VIDEO/Document/Sticker，语音、音频、
圆视频、投票、快拍等匹配不到任何 handler。改为收群里的一切、只排掉入群退群
系统消息。名片不再排除 —— 本仓库没有独立的名片 handler，排掉等于复刻同一个洞。

4. 判定链死分支 + 看不见的文本: 贴纸/无caption文件/GIF 以前只判 caption，
没 caption 就恒判为干净。现在走缩略图识图(image/* 文件直接用本体)，
并新增 _poll_text / _media_meta / _hidden_text 与 judge_text ——
text_link 超链接的真实 URL 存在 entities 里不在 text 里，转发来源频道名、
发送者昵称、via_bot 同理，全都读者可见而判定层以前看不见。
三者都喂给词库、名片检测和 AI，不是只喂其中一层。

5. 处置静默失败: gather(return_exceptions=True) 把权限不足和限流变成返回值而非
异常，"我没权限"的提醒分支因此是永远进不去的死代码，而日志照打成功。
改为分别核对删除与封禁结果，全失败时提醒(每群每小时一次)并记录真实错误。

6. sender_chat 身份: 以某个 chat 的身份发言时 from 里是全局共用的假用户，
真身在 sender_chat。后果是 ban_chat_member 对频道身份永远无效、
每用户消息桶把不相关的发送者混在一起。新增 actor_id 与 _ban_actor()，
外部频道走 ban_chat_sender_chat；正确豁免匿名管理员与关联频道自动转发。

7. 判定截断: 长消息只送前一段给模型，前面塞长文、广告放末尾即可绕过。
改为掐头去尾。

8. 群内公开命令限流: bot 用 reply_text 回复会把触发消息顶到最新，
等于替刷屏者反复顶他自己的广告。非管理员每群 60 秒一次，管理员与私聊不限。

9. 加进频道不再假装启用: 过滤器不含 CHANNEL、也没订阅 channel_post，
结构上永远看不到任何帖子，以前却照样走完 ToS 回一个绿勾。改为说明并退出。

10. 词库: 补伪造货币品类、汉字形近字归一(叚→假 幣→币)、词中分隔符剥离(叚*币)、
以及规避加成 —— 会做规避写法本身就是意图证据。冥币(祭祀用品)不收，
练功券只给 4 分(银行点钞券是合法商品)。

11. /start@别的bot 改为首次即删: 它归在探针层但不该走累计阈值 ——
实测是两个一次性小号各发一次，阈值 2 会让它们一个都逃掉。签到水消息保持
首次免罚(真人可能无意发一次)，宣传别的 bot 不会是无意的。

验证: py_compile 全过; PTB 22.8 真实 Update 对象分发 20/20;
针对本仓库实际代码的端到端 25/25; 词库回归 15/15 且旧样本零漂移;
本次交叉核对 21/21。

.env.example

@@ -35,3 +35,9 @@ LEXICON_HARD_THRESHOLD=6
 PROBE_FLAG_DELETE=2
 # Rolling window for those flags (hours); older flags reset the count.
 PROBE_WINDOW_HOURS=24
+# How much of a long message the judge sees (clipped head + tail, not head only).
+JUDGE_TEXT_LIMIT=1800
+JUDGE_CAPTION_LIMIT=900
+# Cooldown (seconds) on public group commands for non-admins, so the bot cannot
+# be used as a megaphone to bump someone's message. Admins are never limited.
+GROUP_CMD_COOLDOWN=60

README.md

@@ -116,6 +116,9 @@ Everything is set via environment variables — see [`.env.example`](.env.exampl
 | `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 |
+| `JUDGE_TEXT_LIMIT` | `1800` | Chars of a long message the judge sees (head + tail) |
+| `JUDGE_CAPTION_LIMIT` | `900` | Same, for image captions |
+| `GROUP_CMD_COOLDOWN` | `60` | Cooldown (s) on public group commands for non-admins |
 
 ---
 

README_AR.md

@@ -100,6 +100,9 @@ python bot.py
 | `LEXICON_HARD_THRESHOLD` | `6` | صرامة المرشّح الأوّلي للعامية (الأعلى = أكثر صرامة) |
 | `PROBE_FLAG_DELETE` | `2` | عدد علامات رسائل «الحضور» قبل بدء الحذف (لا يحظر أبدًا) |
 | `PROBE_WINDOW_HOURS` | `24` | النافذة المتحركة لتلك العلامات (بالساعات) |
+| `JUDGE_TEXT_LIMIT` | `1800` | عدد أحرف الرسالة الطويلة التي يراها التحليل (البداية + النهاية) |
+| `JUDGE_CAPTION_LIMIT` | `900` | المثل نفسه لتعليقات الصور |
+| `GROUP_CMD_COOLDOWN` | `60` | مهلة (ثانية) لأوامر المجموعة العامة لغير المشرفين |
 
 ---
 

README_CN.md

@@ -100,6 +100,9 @@ python bot.py
 | `LEXICON_HARD_THRESHOLD` | `6` | 黑话预过滤严格度(越高越严) |
 | `PROBE_FLAG_DELETE` | `2` | 签到水消息累计多少次后开始静默删除(绝不封号) |
 | `PROBE_WINDOW_HOURS` | `24` | 上述标记的滚动有效窗口(小时) |
+| `JUDGE_TEXT_LIMIT` | `1800` | 长消息送judge的字数(掐头去尾各一半) |
+| `JUDGE_CAPTION_LIMIT` | `900` | 同上，图片附带文字 |
+| `GROUP_CMD_COOLDOWN` | `60` | 群内公开命令对非管理员的冷却(秒) |
 
 ---
 

README_ES.md

@@ -100,6 +100,9 @@ Todo se configura mediante variables de entorno — consulta [`.env.example`](.e
 | `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) |
+| `JUDGE_TEXT_LIMIT` | `1800` | Caracteres de un mensaje largo que ve el análisis (inicio + final) |
+| `JUDGE_CAPTION_LIMIT` | `900` | Lo mismo, para los pies de foto |
+| `GROUP_CMD_COOLDOWN` | `60` | Espera (s) en comandos públicos de grupo para no administradores |
 
 ---
 

README_FA.md

@@ -100,6 +100,9 @@ python bot.py
 | `LEXICON_HARD_THRESHOLD` | `6` | سخت‌گیری پیش‌فیلتر زبان کوچه‌بازاری (بالاتر = سخت‌گیرانه‌تر) |
 | `PROBE_FLAG_DELETE` | `2` | تعداد نشانه‌های پیام «حضور» پیش از حذف خودکار (هرگز مسدود نمی‌کند) |
 | `PROBE_WINDOW_HOURS` | `24` | بازهٔ چرخشی برای این نشانه‌ها (ساعت) |
+| `JUDGE_TEXT_LIMIT` | `1800` | تعداد نویسه‌های پیام بلند که تحلیل می‌بیند (ابتدا + انتها) |
+| `JUDGE_CAPTION_LIMIT` | `900` | همان مورد برای زیرنویس تصاویر |
+| `GROUP_CMD_COOLDOWN` | `60` | مهلت (ثانیه) برای فرمان‌های عمومی گروه برای غیرمدیران |
 
 ---
 

README_RU.md

@@ -100,6 +100,9 @@ python bot.py
 | `LEXICON_HARD_THRESHOLD` | `6` | Строгость предфильтра сленга (выше = строже) |
 | `PROBE_FLAG_DELETE` | `2` | Сколько меток «отметился» до начала удаления (никогда не банит) |
 | `PROBE_WINDOW_HOURS` | `24` | Скользящее окно для этих меток (часы) |
+| `JUDGE_TEXT_LIMIT` | `1800` | Сколько символов длинного сообщения видит анализатор (начало + конец) |
+| `JUDGE_CAPTION_LIMIT` | `900` | То же для подписей к изображениям |
+| `GROUP_CMD_COOLDOWN` | `60` | Задержка (с) публичных групповых команд для не-админов |
 
 ---
 

bot.py

@@ -12,7 +12,8 @@ sys.path.insert(0, os.path.dirname(os.path.abspath(__file__)))
 from telegram import Update, InlineKeyboardButton, InlineKeyboardMarkup
 from telegram.ext import (
     Application, CommandHandler, MessageHandler,
-    CallbackQueryHandler, ChatMemberHandler, filters, ContextTypes
+    CallbackQueryHandler, ChatMemberHandler, filters, ContextTypes,
+    ApplicationHandlerStop
 )
 import config
 from modules.db import db_exec
@@ -85,6 +86,30 @@ async def _handle_ai_result(intent, reply, msg, user_id, context):
 
 # ==================== Commands ====================
 
+async def _group_cmd_allowed(update, context):
+    """Rate-limit publicly callable commands inside a group.
+
+    The bot answers with reply_text, which bumps the triggering message back to
+    the top of the chat — so anyone can spam /help and have the bot repeatedly
+    bump their own ad for them, and a loop of /start makes it reprint the whole
+    ToS block. One call per chat per GROUP_CMD_COOLDOWN seconds for non-admins;
+    admins and private chats are never limited.
+    """
+    if update.effective_chat.type == "private":
+        return True
+    try:
+        if await is_admin(update, context):
+            return True
+    except Exception:
+        pass
+    key = "cmd_cd_" + str(update.effective_chat.id)
+    last = context.bot_data.get(key, 0)
+    if _time.time() - last < getattr(config, "GROUP_CMD_COOLDOWN", 60):
+        return False
+    context.bot_data[key] = _time.time()
+    return True
+
+
 async def cmd_start(update: Update, context: ContextTypes.DEFAULT_TYPE):
     if not config.ADMIN_USER_ID:
         config.ADMIN_USER_ID = update.effective_user.id
@@ -100,6 +125,10 @@ async def cmd_start(update: Update, context: ContextTypes.DEFAULT_TYPE):
     else:
         chat_id = update.effective_chat.id
         await register_group(chat_id, update.effective_chat.title)
+        # Rate-limited: the ToS text is a large block, and without this anyone
+        # can loop /start to make the bot flood the group with it.
+        if not await _group_cmd_allowed(update, context):
+            return
         if not await check_tos(chat_id):
             keyboard = InlineKeyboardMarkup([
                 [InlineKeyboardButton("Accept & Enable", callback_data="tos_accept_" + str(chat_id))],
@@ -118,6 +147,8 @@ async def cmd_help(update: Update, context: ContextTypes.DEFAULT_TYPE):
             "Anything else → Just chat"
         )
     else:
+        if not await _group_cmd_allowed(update, context):
+            return
         await update.message.reply_text(
             "I work automatically in groups. No config needed.\n\nAdmin commands:\n/ban — Reply to a message to ban the user"
         )
@@ -138,6 +169,125 @@ async def cmd_ban(update: Update, context: ContextTypes.DEFAULT_TYPE):
 
 # ==================== Group ====================
 
+async def _ban_actor(context, chat_id, sender_chat, user_id):
+    """Ban whoever is actually responsible for the message.
+
+    A message posted under a chat's identity carries a globally shared stand-in
+    user in `from` (Channel_Bot / GroupAnonymousBot); ban_chat_member on that id
+    is a permanent no-op, so a spammer wearing a channel identity could post
+    forever. The real identity is in sender_chat and needs ban_chat_sender_chat.
+    """
+    if sender_chat is not None and sender_chat.id != chat_id:
+        return await context.bot.ban_chat_sender_chat(chat_id, sender_chat.id)
+    return await context.bot.ban_chat_member(chat_id, user_id)
+
+
+async def _remind_no_permission(msg, context, chat_id):
+    """Tell admins we found spam but cannot act on it. Once per chat per hour."""
+    last = context.bot_data.get("perm_remind_" + str(chat_id), 0)
+    if _time.time() - last <= 3600:
+        return
+    context.bot_data["perm_remind_" + str(chat_id)] = _time.time()
+    try:
+        await msg.reply_text(
+            "⚠️ Detected spam but I don't have permissions to act.\n\n"
+            "Tap group name → Admins → Add Admin → Find me → Enable Delete Messages and Ban Users → Done"
+        )
+    except Exception:
+        pass
+
+
+def _poll_text(msg):
+    """A poll's visible text: the question plus every option.
+
+    A poll is prime real estate — 300 characters of question and up to 12 options
+    of 100 characters each, all sender-controlled — and none of it appears in
+    msg.text, so it used to be judged by nobody.
+    """
+    p = getattr(msg, "poll", None)
+    if not p:
+        return ""
+    parts = [p.question or ""]
+    for o in (p.options or []):
+        parts.append(getattr(o, "text", "") or "")
+    return " ".join(x for x in parts if x)
+
+
+def _media_meta(msg):
+    """Text a reader can see on a media message but that msg.text/caption lacks.
+
+    Ads live here routinely: the file name spells out a contact handle, the audio
+    title is used as ad space, the sticker set name points at a landing page, a
+    shared contact card is a phone number and a display name and nothing else.
+    """
+    out = []
+    for obj, attrs in (
+        (getattr(msg, "document", None), ("file_name",)),
+        (getattr(msg, "audio", None), ("title", "performer", "file_name")),
+        (getattr(msg, "video", None), ("file_name",)),
+        (getattr(msg, "animation", None), ("file_name",)),
+        (getattr(msg, "sticker", None), ("emoji", "set_name")),
+        (getattr(msg, "venue", None), ("title", "address")),
+        (getattr(msg, "game", None), ("title", "description")),
+        (getattr(msg, "invoice", None), ("title", "description")),
+        # No dedicated contact handler exists, so contact cards come through the
+        # normal pipeline and this is the only text they carry.
+        (getattr(msg, "contact", None), ("first_name", "last_name", "phone_number")),
+    ):
+        if obj is None:
+            continue
+        for a in attrs:
+            v = getattr(obj, a, None)
+            if v:
+                out.append(str(v))
+    return " ".join(out)
+
+
+def _hidden_text(msg, user):
+    """Attack-surface text that readers can see or tap but msg.text does not hold.
+
+    1. The URL behind a hyperlink: a text_link entity keeps its url in entities,
+       never in msg.text. "[hello everyone](spam-link)" reached the judge as two
+       harmless words.
+    2. The forward origin's title: a spammer's own channel name IS the ad, and it
+       is rendered above the message and is tappable.
+    3. The sender's display name: set first_name to an ad and every innocuous
+       message they post is advertising on their behalf.
+    """
+    out = []
+    for e in list(getattr(msg, "entities", None) or []) + list(getattr(msg, "caption_entities", None) or []):
+        u = getattr(e, "url", None)
+        if u:
+            out.append(u)
+        eu = getattr(e, "user", None)  # text_mention: a user rendered as a link
+        if eu is not None:
+            for a in ("first_name", "last_name", "username"):
+                v = getattr(eu, a, None)
+                if v:
+                    out.append(str(v))
+    fo = getattr(msg, "forward_origin", None)
+    if fo is not None:
+        for holder in (getattr(fo, "chat", None), getattr(fo, "sender_chat", None), getattr(fo, "sender_user", None)):
+            if holder is None:
+                continue
+            for a in ("title", "username", "first_name"):
+                v = getattr(holder, a, None)
+                if v:
+                    out.append(str(v))
+        v = getattr(fo, "sender_user_name", None)
+        if v:
+            out.append(str(v))
+    vb = getattr(msg, "via_bot", None)
+    if vb is not None and getattr(vb, "username", None):
+        out.append(str(vb.username))
+    if user is not None:
+        for a in ("first_name", "last_name", "username"):
+            v = getattr(user, a, None)
+            if v:
+                out.append(str(v))
+    return " ".join(out)
+
+
 async def _answer_mention(msg, context, is_mention, text):
     """Reply to someone who @mentioned the bot or replied to it.
 
@@ -196,6 +346,12 @@ async def handle_group_message(update: Update, context: ContextTypes.DEFAULT_TYP
     if not user:
         return
     text = msg.text or msg.caption or ""
+    # The string the judges see = the visible body plus everything a reader can
+    # see or tap that is NOT in text (link targets, forward origin, display name).
+    # Only the judging layers get it; text itself stays untouched because it is
+    # still used for @mention parsing, the probe layer and logging.
+    _hidden = _hidden_text(msg, user)
+    judge_text = (text + " " + _hidden).strip() if _hidden else text
 
     await register_group(chat_id, msg.chat.title)
 
@@ -206,9 +362,17 @@ async def handle_group_message(update: Update, context: ContextTypes.DEFAULT_TYP
     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)
+    # Is this message a command? This handler now runs in group=-1, ahead of the
+    # CommandHandlers, so command messages reach it too. They must be excluded:
+    # "/start@ourbot" contains "@ourbotusername", so the mention check above fires
+    # and the bot would answer it with AI here while cmd_start answers it again
+    # in group 0 — one command, two replies.
+    ents = getattr(msg, "entities", None) or ()
+    is_command = bool(ents) and ents[0].type == "bot_command" and ents[0].offset == 0
     # 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)
+    wants_reply = bool((text or has_media) and (is_mention or is_reply_to_bot)
+                       and not is_edited and not is_command)
 
     # ToS not accepted: guidance only. Without admin consent we take no action.
     if not tos_ok:
@@ -217,20 +381,41 @@ async def handle_group_message(update: Update, context: ContextTypes.DEFAULT_TYP
                 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))
+        # Plain return, never ApplicationHandlerStop: the group-0 CommandHandlers
+        # still have to run, otherwise /start can never be used to accept the ToS
+        # and the bot could never be enabled at all.
         return
 
+    # A message posted under a chat's identity (anonymous admin, channel identity)
+    # gets a globally shared stand-in user in `from` — GroupAnonymousBot
+    # (1087968824) or Channel_Bot (136817688) — with the real identity in
+    # sender_chat. Never reading sender_chat had two consequences:
+    #   1. banning called ban_chat_member on the stand-in id, which does nothing,
+    #      so a channel identity could post ads indefinitely
+    #   2. the per-user message bucket was keyed on that shared id, pooling every
+    #      channel-identity sender together, so a cleanup deleted other people's
+    #      messages
+    sender_chat = getattr(msg, "sender_chat", None)
+    # sender_chat == this group means an admin posting anonymously — an admin.
+    is_anon_admin = sender_chat is not None and sender_chat.id == chat_id
+    # An automatic forward from the linked channel is the owner's own content.
+    is_auto_forward = bool(getattr(msg, "is_automatic_forward", False))
+    # The party held responsible: bookkeeping, judging and banning all key on it.
+    actor_id = sender_chat.id if sender_chat is not None else user.id
+
     # Admin check
-    is_admin_user = False
-    try:
-        member = await context.bot.get_chat_member(chat_id, user.id)
-        if member.status in ("administrator", "creator"):
-            is_admin_user = True
-    except Exception:
-        pass
+    is_admin_user = is_anon_admin or is_auto_forward
+    if not is_admin_user:
+        try:
+            member = await context.bot.get_chat_member(chat_id, user.id)
+            if member.status in ("administrator", "creator"):
+                is_admin_user = True
+        except Exception:
+            pass
 
     # Track recent messages: (msg_id, content_hash, timestamp)
     user_msgs = context.chat_data.setdefault("user_recent_msgs", {})
-    uid = user.id
+    uid = actor_id
     if uid not in user_msgs:
         user_msgs[uid] = []
     content_hash = _hashlib.md5(text.encode()).hexdigest() if text else ""
@@ -251,11 +436,17 @@ async def handle_group_message(update: Update, context: ContextTypes.DEFAULT_TYP
 
     # Probe ("check-in") filler: mark only, never ban. Runs before the duplicate
     # check so repeated check-ins can't escalate into a ban.
+    probe_result = None
     try:
-        if await probe.check(msg, chat_id, uid, context.bot.username):
-            return
+        probe_result = await probe.check(msg, chat_id, uid, context.bot.username)
     except Exception as e:
         logger.warning("probe check failed: " + str(e))
+    # ApplicationHandlerStop is raised outside the try above on purpose — it is
+    # an Exception subclass, so `except Exception` would swallow it.
+    if probe_result == probe.DELETED:
+        raise ApplicationHandlerStop
+    if probe_result:
+        return
 
     # @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
@@ -279,9 +470,12 @@ async def handle_group_message(update: Update, context: ContextTypes.DEFAULT_TYP
             spam = True
             logger.info("REPEAT SPAM: user=" + str(uid) + " chat=" + str(chat_id) + " count=" + str(len(recent_same)))
 
-    # Pre-filter: keyword/regex/forward/new-account (zero API cost)
+    # Pre-filter: keyword/regex/forward/new-account (zero API cost).
+    # judge_text, not text: the keyword, contact and lexicon layers have to see
+    # the hidden text too, otherwise a bare "hello everyone" hyperlinked to a spam
+    # URL passes every one of them.
     if not spam:
-        verdict = prefilter(msg, user, text)
+        verdict = prefilter(msg, user, judge_text)
         if verdict == "spam":
             spam = True
         elif verdict == "ai":
@@ -290,30 +484,77 @@ 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, sender_context=sender_ctx)
+                    spam = await ai_judge_group_image(data, judge_text, sender_context=sender_ctx)
                 except Exception:
-                    if text:
-                        spam = await ai_judge_group_message(text, sender_context=sender_ctx)
+                    if judge_text:
+                        spam = await ai_judge_group_message(judge_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, sender_context=sender_ctx)
+                        spam = await ai_judge_group_image(vdata, judge_text, sender_context=sender_ctx)
                     except Exception:
-                        if text:
-                            spam = await ai_judge_group_message(text, sender_context=sender_ctx)
-                elif 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, sender_context=sender_ctx)
-                elif msg.forward_date:
+                        if judge_text:
+                            spam = await ai_judge_group_message(judge_text, sender_context=sender_ctx)
+                elif judge_text:
+                    spam = await ai_judge_group_message(judge_text, sender_context=sender_ctx)
+                elif msg.forward_origin:
                     spam = True
+            elif msg.document or msg.sticker or msg.animation or msg.video_note:
+                # This branch used to judge the caption and nothing else, falling
+                # back to msg.forward_date — an attribute PTB no longer has, so a
+                # caption-less sticker/document/GIF raised AttributeError right
+                # here and the message was never judged, deleted or logged.
+                # And these ads are usually IN the picture, not in the caption:
+                # the sticker image is the ad, "send as file" dodges the vision
+                # judge, the file name spells out a contact handle.
+                # Now: judge the thumbnail if there is one, otherwise at least
+                # judge the metadata text.
+                thumb = None
+                if msg.sticker:
+                    # A plain .webp sticker can go to the vision judge as-is;
+                    # animated/video stickers only via their thumbnail.
+                    thumb = msg.sticker.thumbnail
+                    if not thumb and not msg.sticker.is_animated and not msg.sticker.is_video:
+                        thumb = msg.sticker
+                elif msg.animation:
+                    thumb = msg.animation.thumbnail
+                elif msg.video_note:
+                    thumb = msg.video_note.thumbnail
+                elif msg.document:
+                    thumb = msg.document.thumbnail
+                    if not thumb and (msg.document.mime_type or "").startswith("image/"):
+                        thumb = msg.document  # an image "sent as a file": judge it directly
+                # Combined, not "judge_text or metadata": judge_text is never
+                # empty (it always carries the sender's display name), so an
+                # `or` would silently discard the file name / sticker set name
+                # on every single message.
+                meta = (judge_text + " " + _media_meta(msg)).strip()
+                judged = False
+                if thumb is not None:
+                    try:
+                        tf = await context.bot.get_file(thumb.file_id)
+                        tdata = bytes(await tf.download_as_bytearray())
+                        spam = await ai_judge_group_image(tdata, meta, sender_context=sender_ctx)
+                        judged = True
+                    except Exception as e:
+                        logger.warning("media thumb judge failed: " + str(e))
+                if not judged:
+                    if meta:
+                        spam = await ai_judge_group_message(meta, sender_context=sender_ctx)
+                    elif msg.forward_origin:
+                        spam = True
+            elif msg.poll:
+                spam = await ai_judge_group_message((_poll_text(msg) + " " + _hidden).strip(), sender_context=sender_ctx)
             elif text:
-                spam = await ai_judge_group_message(text, sender_context=sender_ctx)
+                spam = await ai_judge_group_message(judge_text, sender_context=sender_ctx)
+            else:
+                # Everything else that carries sender-controlled text but no body:
+                # a shared contact card, a venue, an audio track.
+                meta = (_media_meta(msg) + " " + _hidden).strip()
+                if meta:
+                    spam = await ai_judge_group_message(meta, sender_context=sender_ctx)
         # verdict == "clean" → skip AI, let it through
 
     if spam:
@@ -322,23 +563,36 @@ async def handle_group_message(update: Update, context: ContextTypes.DEFAULT_TYP
             for entry in user_msgs.get(uid, []):
                 mid = entry[0] if isinstance(entry, tuple) else entry
                 tasks.append(context.bot.delete_message(chat_id, mid))
-            tasks.append(context.bot.ban_chat_member(chat_id, uid))
+            n_del = len(tasks)
+            tasks.append(_ban_actor(context, chat_id, sender_chat, user.id))
             results = await asyncio.gather(*tasks, return_exceptions=True)
+            # gather(return_exceptions=True) never raises: a permission error
+            # (Forbidden) or a rate limit (RetryAfter) comes back as a VALUE in
+            # results. The old code threw the results away, so a bot without the
+            # rights logged "SPAM nuked" while the ad sat untouched in the group
+            # and the reminder branch below was unreachable dead code.
+            deleted_ok = sum(1 for r in results[:n_del]
+                             if not isinstance(r, Exception) and r is not False)
+            ban_ok = not isinstance(results[n_del], Exception)
+            errs = [r for r in results if isinstance(r, Exception)]
             user_msgs.pop(uid, None)
-            logger.info("SPAM nuked: user=" + str(uid) + " chat=" + str(chat_id) + " tasks=" + str(len(tasks)))
+            if errs and (deleted_ok == 0 or not ban_ok):
+                logger.warning(
+                    "SPAM action PARTIAL/FAILED: user=" + str(uid) + " chat=" + str(chat_id) +
+                    " deleted=" + str(deleted_ok) + "/" + str(n_del) + " ban_ok=" + str(ban_ok) +
+                    " errs=" + str([type(e).__name__ + ":" + str(e)[:60] for e in errs[:3]])
+                )
+                await _remind_no_permission(msg, context, chat_id)
+            else:
+                logger.info("SPAM nuked: user=" + str(uid) + " chat=" + str(chat_id) +
+                            " deleted=" + str(deleted_ok) + "/" + str(n_del) + " (banned)")
         except Exception as e:
             logger.warning("Anti-spam action failed: " + str(e))
-            last_remind = context.bot_data.get("perm_remind_" + str(chat_id), 0)
-            if _time.time() - last_remind > 3600:
-                context.bot_data["perm_remind_" + str(chat_id)] = _time.time()
-                try:
-                    await msg.reply_text(
-                        "\u26a0\ufe0f Detected spam but I don't have permissions to act.\n\n"
-                        "Tap group name → Admins → Add Admin → Find me → Enable Delete Messages and Ban Users → Done"
-                    )
-                except Exception:
-                    pass
-        return
+            await _remind_no_permission(msg, context, chat_id)
+        # The message is gone: stop the chain so the group-0 CommandHandlers do
+        # not reply to a deleted message. A command may carry arbitrary trailing
+        # text, so "/help <ad text>" reaches this handler AND cmd_help.
+        raise ApplicationHandlerStop
 
     # Clean message (spam was handled and returned above). Only now do we answer
     # someone who was talking to the bot.
@@ -406,6 +660,27 @@ async def handle_my_chat_member(update: Update, context: ContextTypes.DEFAULT_TY
     new = result.new_chat_member.status if result.new_chat_member else "left"
 
     if old in ("left", "kicked") and new in ("member", "administrator"):
+        # Channels are not supported: the anti-spam filter is ChatType.GROUPS
+        # (which excludes CHANNEL) and allowed_updates does not subscribe to
+        # channel_post, so structurally we can never see a single post here.
+        # Running the whole ToS flow and answering with a green "enabled" tick
+        # was an empty promise — the owner would think the product works. Say so
+        # and leave instead.
+        if result.chat.type not in ("group", "supergroup"):
+            try:
+                await context.bot.send_message(
+                    chat_id,
+                    "I only support groups and supergroups — not channels. "
+                    "I can't see any content here, so keeping me around wouldn't do "
+                    "anything. Leaving now."
+                )
+            except Exception:
+                pass
+            try:
+                await context.bot.leave_chat(chat_id)
+            except Exception as e:
+                logger.warning("leave non-group chat failed: " + str(e))
+            return
         await delete_tos(chat_id)
         await register_group(chat_id, result.chat.title)
         keyboard = InlineKeyboardMarkup([
@@ -497,6 +772,13 @@ def main():
 
     app = Application.builder().token(config.BOT_TOKEN).connect_timeout(30).read_timeout(30).write_timeout(30).pool_timeout(30).build()
 
+    async def _on_error(update, context):
+        # There was no error handler at all, so an exception inside a handler
+        # left nothing but a traceback in the log: a crash halfway through the
+        # judging chain looked exactly like a clean message.
+        logger.exception("handler error: " + str(context.error))
+    app.add_error_handler(_on_error)
+
     # 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.
@@ -513,11 +795,28 @@ def main():
     # ("/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.
+    #
+    # group=-1, and it has to be. PTB runs only the FIRST matching handler per
+    # group, and CommandHandler accepts arbitrary trailing text (everything after
+    # /help goes into args), so with the CommandHandlers registered first in
+    # group 0 a message like "/help buy followers cheap 加V abc" was swallowed by
+    # cmd_help and never judged at all. Running first fixes that; the handler
+    # raises ApplicationHandlerStop once it has actually deleted something, so
+    # clean messages still fall through to the group-0 command handlers.
+    #
+    # The type whitelist is gone too. TEXT|PHOTO|VIDEO|Document|Sticker meant
+    # audio, voice, video notes, polls, stories, venues, locations and dice
+    # matched no handler anywhere — an mp3 with an ad caption, or a poll whose
+    # question IS the ad, was visible to the whole group and checked by nobody.
+    # Everything in a group is now accepted, minus join/leave/pin system events.
+    # CONTACT is deliberately NOT excluded (unlike the private bot this was
+    # ported from, which has a dedicated contact handler): here nothing else
+    # would pick a shared contact card up, and a contact card is a display name
+    # plus a phone number, which is exactly what a contact-harvesting ad is.
     app.add_handler(MessageHandler(
-        (filters.TEXT | filters.PHOTO | filters.VIDEO | filters.Document.ALL | filters.Sticker.ALL) & filters.ChatType.GROUPS,
+        filters.ChatType.GROUPS & ~filters.StatusUpdate.ALL,
         handle_group_message
-    ))
+    ), group=-1)
 
     # Private
     app.add_handler(MessageHandler(filters.TEXT & filters.ChatType.PRIVATE & ~filters.COMMAND & filters.UpdateType.MESSAGE, handle_private_text))

config.py

@@ -32,5 +32,17 @@ PROBE_FLAG_DELETE = int(os.environ.get("PROBE_FLAG_DELETE", "2"))
 # 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"))
 
+# How much of an over-long message the spam judge sees. The text is clipped
+# head + tail (never head only), so an ad appended to the end of a long paste
+# still lands inside the judged range.
+JUDGE_TEXT_LIMIT = int(os.environ.get("JUDGE_TEXT_LIMIT", "1800"))
+JUDGE_CAPTION_LIMIT = int(os.environ.get("JUDGE_CAPTION_LIMIT", "900"))
+
+# Public group commands reply with reply_text, which bumps the triggering
+# message to the top of the chat. Without a cooldown anyone can spam a command
+# and have the bot repeatedly bump their own ad. Seconds, per chat, non-admins
+# only — admins and private chats are never limited.
+GROUP_CMD_COOLDOWN = int(os.environ.get("GROUP_CMD_COOLDOWN", "60"))
+
 # Admin user ID (auto-detected from first /start)
 ADMIN_USER_ID = None

modules/chat.py

@@ -90,6 +90,22 @@ def _deflect():
     return random.choice(lines)
 
 
+def _clip(text, limit):
+    """Keep the head AND the tail of an over-long message, not just the head.
+
+    The old text[:1000] / caption[:500] cut the message before the judge ever saw
+    it, while Telegram allows 4096 characters in one message — so pasting a news
+    article in front and appending the payload at the end hid the payload
+    completely. Taking half from each end guarantees an ad tacked onto the tail
+    lands inside the judged range.
+    """
+    t = text or ""
+    if len(t) <= limit:
+        return t
+    half = limit // 2
+    return t[:half] + "\n…(middle omitted)…\n" + t[-half:]
+
+
 def _is_spam(raw):
     """Parse a spam-judge reply into True / False / None (couldn't parse it).
 
@@ -167,7 +183,7 @@ async def ai_judge_group_message(text, sender_context=""):
         prompt = ANTISPAM_TEXT_PROMPT
         if sender_context:
             prompt += "\n\nSender context: " + sender_context
-        prompt += "\n\nMessage content: " + text[:1000]
+        prompt += "\n\nMessage content: " + _clip(text, getattr(config, "JUDGE_TEXT_LIMIT", 1800))
         # 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.
@@ -188,7 +204,7 @@ async def ai_judge_group_image(image_bytes, caption="", sender_context=""):
         if sender_context:
             prompt += "\nSender context: " + sender_context
         if caption:
-            prompt += "\nCaption: " + caption[:500]
+            prompt += "\nCaption: " + _clip(caption, getattr(config, "JUDGE_CAPTION_LIMIT", 900))
         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

modules/lexicon.py

@@ -1,54 +1,118 @@
 """
-中文黑话/擦边词库层（功能4）。
+Chinese slang / evasion lexicon layer.
 
-解决通用模型判不出"收米""上车""日结"这类抖音直播式规避话术的问题。
-两步：
-1. normalize() 先把文本归一化 —— 全角转半角、去零宽字符、同形字（西里尔/希腊字母伪装）还原、转小写，
-   破掉 spam 常用的 Unicode 花招。
-2. score() 在归一化后的文本上匹配词库打分，并对"搞钱词 + 联系方式规避词"同时出现做组合加成。
+General-purpose models do not recognise livestream-style slang like 收米 / 上车 /
+日结, so this layer scores it with a plain word table. Three steps:
 
-用法（在 bot.py 判定前调用）：
+1. normalize() folds the text — fullwidth to halfwidth, zero-width characters
+   stripped, homoglyphs restored (Cyrillic / Greek / lookalike Han characters),
+   traditional to simplified, lowercased.
+2. strip_separators() additionally removes in-word separators, which breaks the
+   "split the word up" trick (叚*币 / 假-币 / 假 币).
+3. score() matches the table on all three tracks and adds two bonuses:
+   - combo bonus: a money/scam term AND a contact-evasion term in one message
+   - evasion bonus: the term only matches AFTER normalizing / de-separating
+
+Usage (called before the judge in bot.py):
     s, terms = lexicon.score(text)
-    if s >= config.LEXICON_HARD_THRESHOLD:   # 硬命中，直接判 spam，省一次 AI 调用
+    if s >= config.LEXICON_HARD_THRESHOLD:   # hard hit — spam, no AI call needed
         ...
-    else:                                     # 软命中，把 terms 作为线索喂给 AI
+    else:                                     # soft hit — feed terms to the AI
         ...
 
-词库可通过 config.LEXICON_EXTRA 扩展，群主不用改代码就能加词。
+The table is extensible through config.LEXICON_EXTRA, so an operator can add
+terms without touching code.
+
+Why the evasion bonus exists
+----------------------------
+**Deliberate obfuscation is itself evidence of intent.** Somebody discussing or
+complaining about counterfeit money has no reason to write 假 as 叚. Making that
+substitution means the sender knows the word gets blocked — which is an
+admission that what they are posting is the thing that gets blocked.
+
+So the same word carries a completely different risk depending on how it was
+written:
+    "假币"    → could be news, a complaint, a question → weight 4, under the
+                hard threshold, goes to the AI for context
+    "叚*币"   → 4 + evasion bonus 3 = 7 → over the threshold, deleted at once
+
+This does not depend on enumerating every lookalike character: swap in any rare
+character or insert any separator and, as long as the folded text spells the
+term, the bonus applies automatically.
 """
 
+import re
 import unicodedata
 
 import config
 
-# 零宽字符 / 方向控制符（spam 常插进词里破坏关键词匹配）
+# Zero-width / directional control characters (spam inserts these mid-word to
+# break keyword matching).
 _ZERO_WIDTH = dict.fromkeys(
     map(ord, "​‌‍‎‏‪‫‬⁠"), None
 )
 
-# 常见同形字：西里尔 / 希腊字母 → 拉丁（伪装成英文字母的花招）
+# Common homoglyphs: Cyrillic / Greek → Latin (letters disguised as English).
 _HOMOGLYPH = {
     "а": "a", "е": "e", "о": "o", "р": "p", "с": "c", "х": "x", "у": "y",
     "ѕ": "s", "і": "i", "ј": "j", "к": "k", "н": "h", "в": "b", "м": "m", "т": "t",
     "ο": "o", "ρ": "p", "α": "a", "ν": "v", "τ": "t", "ϲ": "c",
 }
 
+# Lookalike Han characters / traditional / Japanese shinjitai → simplified.
+# NFKC does **nothing** for these: it handles fullwidth and compatibility forms,
+# not distinct characters that merely look alike, and it does no traditional →
+# simplified conversion. 叚 (U+53DA) and 假 (U+5047) are two separate characters.
+_CJK_HOMOGLYPH = {
+    # Lookalike substitutions actually observed in spam
+    "叚": "假", "仮": "假", "葭": "假",
+    "帀": "币", "巿": "币",
+    # Traditional / variant → simplified (outside NFKC's remit)
+    "幣": "币", "鈔": "钞", "偽": "伪", "僞": "伪", "貨": "货", "錢": "钱",
+    "髙": "高", "證": "证", "護": "护",
+    "銀": "银", "帳": "账", "號": "号", "軟": "软", "體": "体",
+    "電": "电", "報": "报", "聯": "联", "係": "系", "繫": "系",
+    "點": "点", "擊": "击", "賣": "卖", "買": "买", "貸": "贷",
+}
+
+# Characters commonly pushed into the middle of a word as separators (the * in
+# 叚*币). Stripping zero-width characters is not enough — these are visible
+# characters and NFKC leaves them alone.
+_SEPARATORS = re.compile(r"[\*\-_\.·・~｜|/\\\s、，,。:：;；'\"“”‘’()（）\[\]【】<>《》!！?？#＃]+")
+
 
 def normalize(text):
+    """Fullwidth → halfwidth, drop zero-width, restore homoglyphs, lowercase."""
     if not text:
         return ""
-    t = unicodedata.normalize("NFKC", text)          # 全角 → 半角
-    t = t.translate(_ZERO_WIDTH)                      # 去零宽/方向符
-    t = "".join(_HOMOGLYPH.get(ch, ch) for ch in t)  # 同形字还原
+    t = unicodedata.normalize("NFKC", text)              # fullwidth → halfwidth
+    t = t.translate(_ZERO_WIDTH)                          # drop zero-width/marks
+    t = "".join(_HOMOGLYPH.get(ch, ch) for ch in t)      # Cyrillic/Greek → Latin
+    t = "".join(_CJK_HOMOGLYPH.get(ch, ch) for ch in t)  # lookalike Han → simplified
     return t.lower()
 
 
-# 词库：term -> (含义, 权重, 类别)
-# 类别 money=搞钱/招募  contact=联系方式规避  pay=支付/加密货币  scam=诈骗盘
-# 权重越高越可疑；单个词一般不足以直接判 spam（见 LEXICON_HARD_THRESHOLD），
-# 靠组合 + 阈值控制误伤（例如"收米"在直播打赏语境是正常词）。
+def strip_separators(text):
+    """Remove in-word separators, defeating 叚*币 / 假-币 / 假 币 style splitting.
+
+    This crosses legitimate punctuation boundaries ("美国。币安" → "美国币安"), so
+    it is used **only as an auxiliary match track and every hit on it carries the
+    evasion bonus** — it is never a verdict on its own.
+    """
+    return _SEPARATORS.sub("", text or "")
+
+
+# Table: term -> (meaning, weight, category)
+# Categories: money=earning/recruiting  contact=contact-detail evasion
+#             pay=payment/crypto  scam=fraud scheme
+#             fake=counterfeit currency/documents (serious, and the ad format is
+#                  "the account itself is the contact detail")
+# Higher weight = more suspicious. A single term is usually not enough to call
+# something spam on its own (see LEXICON_HARD_THRESHOLD) — combinations and the
+# threshold keep false positives down (收米, for example, is an ordinary word in a
+# livestream-tipping context).
 SLANG = {
-    # ---- 搞钱 / 招募 ----
+    # ---- Earning / recruiting ----
     "收米": ("收钱", 3, "money"),
     "上车": ("入局/加入项目", 2, "money"),
     "车头": ("项目发起人", 2, "money"),
@@ -68,7 +132,24 @@ SLANG = {
     "躺赚": ("虚假收益", 2, "scam"),
     "内部消息": ("荐股诈骗", 2, "scam"),
     "带你飞": ("带单诱导", 2, "money"),
-    # ---- 联系方式规避 ----
+    # ---- Counterfeit currency ----
+    # Serious offence, but the plain spelling gets weight 4 (under the hard
+    # threshold) so context still goes to the AI; obfuscated it picks up the
+    # evasion bonus and hard-hits on its own.
+    # Note 冥币 (joss paper, a funeral good) is deliberately NOT in this table.
+    "假币": ("伪造货币", 4, "fake"),
+    "假钞": ("伪造钞票", 4, "fake"),
+    "伪钞": ("伪造钞票", 4, "fake"),
+    "假钱": ("伪造货币", 3, "fake"),
+    # These are pure trade jargon — they do not turn up in ordinary conversation,
+    # so one occurrence is enough. Weight 6 clears the threshold by itself.
+    "高仿钞": ("高仿伪钞", 6, "fake"),
+    "仿真钞": ("仿真伪钞", 6, "fake"),
+    "1:1真钞": ("伪钞话术", 6, "fake"),
+    # 练功券 is a bank note-counting practice pad — a legal product — so it only
+    # gets 4 and the AI decides from context.
+    "练功券": ("点钞练习券(常被用作伪钞幌子)", 4, "fake"),
+    # ---- Contact-detail evasion ----
     "薇": ("微信", 2, "contact"),
     "威": ("微信", 2, "contact"),
     "维": ("微信", 2, "contact"),
@@ -81,12 +162,19 @@ SLANG = {
     "扣v": ("加QQ/微信", 2, "contact"),
     "纸飞机": ("Telegram", 2, "contact"),
     "电报": ("Telegram", 1, "contact"),
+    # A bare 飞机 cannot go in — "我坐飞机去北京" would be a false positive. Only
+    # the multi-character forms that unambiguously mean a contact handle.
+    "飞机号": ("Telegram 账号", 2, "contact"),
+    "联系飞机": ("Telegram 联系", 2, "contact"),
+    "飞机搜": ("Telegram 搜索", 2, "contact"),
+    "tg号": ("Telegram 账号", 2, "contact"),
+    "电报号": ("Telegram 账号", 2, "contact"),
     "蝙蝠": ("BatChat 加密聊天", 2, "contact"),
     "皮皮虾": ("加密聊天软件", 2, "contact"),
     "私我": ("私聊引流", 1, "contact"),
     "详聊": ("私下详谈引流", 1, "contact"),
     "加我": ("引流加好友", 1, "contact"),
-    # ---- 支付 / 加密货币 ----
+    # ---- Payment / crypto ----
     "usdt": ("USDT 加密货币支付", 2, "pay"),
     "泰达": ("USDT", 2, "pay"),
     "承兑": ("加密货币承兑洗钱", 3, "pay"),
@@ -94,12 +182,29 @@ SLANG = {
     "四方": ("四方支付(灰产收款)", 3, "pay"),
 }
 
+# Evasion bonus: added when a term only matches after normalizing / removing
+# separators. 3 is chosen so a single obfuscated fake-currency term (weight 4)
+# clears the default hard threshold of 6, while the same term spelled plainly
+# stays at 4 and still goes to the AI.
+_EVASION_BONUS = 3
+
 
 def score(text):
-    """返回 (总分, 命中词列表'词=含义')。文本先归一化再匹配。"""
-    t = normalize(text)
-    if not t:
+    """Return (total, ['term=meaning', ...]). Each term scores at most once.
+
+    Three match tracks:
+      raw    the original text, lowercased only  — direct hit, no bonus
+      norm   after normalize()                   — needed folding = evasion
+      strip  after normalize() + strip_separators() — same
+    """
+    if not text:
         return 0, []
+    raw = text.lower()
+    norm = normalize(text)
+    strip = strip_separators(norm)
+    if not norm:
+        return 0, []
+
     table = dict(SLANG)
     extra = getattr(config, "LEXICON_EXTRA", None) or {}
     table.update(extra)
@@ -109,20 +214,30 @@ def score(text):
     cats = set()
     for term, meta in table.items():
         meaning, weight, cat = meta
-        if term in t:
-            total += weight
-            cats.add(cat)
+        hit_raw = term in raw
+        if not (hit_raw or term in norm or term in strip):
+            continue
+        total += weight
+        cats.add(cat)
+        if hit_raw:
             matched.append(term + "=" + meaning)
-
-    # 组合加成：搞钱/诈骗词 + 联系方式规避词 同时出现 → 强烈可疑
-    if cats & {"money", "scam", "pay"} and "contact" in cats:
+        else:
+            # Only matched after folding → the sender obfuscated it on purpose,
+            # which is evidence of intent in itself.
+            total += _EVASION_BONUS
+            matched.append(term + "=" + meaning + " (obfuscated)")
+
+    # Combo bonus: an earning/scam/counterfeit term together with a
+    # contact-evasion term is strongly suspicious.
+    if cats & {"money", "scam", "pay", "fake"} and "contact" in cats:
         total += 3
 
     return total, matched
 
 
 def is_hard_spam(text):
-    """归一化打分 >= 硬阈值(config.LEXICON_HARD_THRESHOLD, 默认6) → 直接判 spam。
-    给 prefilter 用：黑话硬命中直接判、省一次 AI 调用，且破全角/同形字/零宽规避。"""
+    """Normalized score >= the hard threshold (config.LEXICON_HARD_THRESHOLD,
+    default 6) → spam outright. Used by the prefilter: a hard slang hit saves an
+    AI call and defeats fullwidth / lookalike / zero-width / split-word evasion."""
     s, _ = score(text)
     return s >= getattr(config, "LEXICON_HARD_THRESHOLD", 6)

modules/prefilter.py

@@ -94,7 +94,10 @@ def keyword_spam(text):
 
 def forward_spam(msg):
     """Forwarded message with link/contact = spam."""
-    if not msg.forward_date:
+    # forward_origin, not forward_date: Bot API 7.0 replaced the flat forward_*
+    # fields and PTB dropped the attribute entirely, so reading msg.forward_date
+    # raises AttributeError — which crashed this filter on every message.
+    if not getattr(msg, "forward_origin", None):
         return False
     text = msg.text or msg.caption or ""
     if URL_PATTERN.search(text) or CONTACT_PATTERN.search(text):
@@ -121,6 +124,27 @@ def new_account_spam(user, text):
     return suspicious >= 2
 
 
+def has_judgeable_media(msg):
+    """True when the message carries something a judge can actually look at.
+
+    Used to decide whether a caption-less message is worth an AI call. It is not
+    just photo/video: a sticker, a GIF, a round video and a document all have a
+    thumbnail the vision judge can read, and a poll, a shared contact, a venue or
+    an audio file all carry sender-controlled text (question and options, name
+    and phone number, file name, track title) that the text judge can read.
+
+    Voice notes, locations and dice are deliberately absent — there is no text
+    and no image on them, so an AI call would be judging the sender's display
+    name and nothing else.
+    """
+    return bool(
+        msg.photo or msg.video or msg.document or msg.sticker or
+        msg.animation or msg.video_note or msg.audio or
+        msg.poll or msg.contact or msg.venue or
+        getattr(msg, "game", None) or getattr(msg, "invoice", None)
+    )
+
+
 def should_use_ai(msg):
     """Decide if this message needs AI analysis or if we should skip/sample."""
     if not api_limiter.can_call():
@@ -166,8 +190,14 @@ def prefilter(msg, user, text):
         logger.info("PREFILTER new_account_spam: user=" + str(user.id))
         return "spam"
 
-    # Layer 4: No text, no media = nothing to check
-    if not text and not msg.photo and not msg.video:
+    # Layer 4: nothing to check at all.
+    # Tested against msg, not the text argument: the caller passes a judge string
+    # that also carries hidden text (link targets, forward origin, display name),
+    # so it is practically never empty and this layer would never fire. It also
+    # used to list only photo/video, which meant every caption-less sticker,
+    # document, GIF or poll was declared clean here and the judging branches for
+    # them downstream could never run.
+    if not (msg.text or msg.caption) and not has_judgeable_media(msg):
         return "clean"
 
     # Layer 5: Rate limiter — can we afford an AI call?

modules/probe.py

@@ -97,24 +97,39 @@ async def add_flag(chat_id, user_id):
         return row[0] if row else 0
 
 
+# check() return values. Both are truthy, so "was this a probe?" stays a plain
+# boolean test; the caller only needs to tell them apart to decide whether the
+# message still exists (DELETED means the rest of the handler chain must not try
+# to reply to it).
+FLAGGED = "flagged"
+DELETED = "deleted"
+
+
 async def check(msg, chat_id, user_id, my_username=""):
-    """Flag a probe message. Returns True if this message was one (caller stops).
+    """Flag a probe message. Returns FLAGGED / DELETED, or None if not a probe.
 
     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
+        return None
+    is_foreign_start = looks_like_foreign_start(msg.text, my_username)
+    if not (looks_like_probe(msg.text) or is_foreign_start):
+        return None
     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):
+    # A foreign /start goes on the first hit, not on the threshold. Check-in
+    # filler earns a free pass because a real member may post it once without
+    # meaning anything by it; announcing another bot in a group does not happen
+    # by accident. Observed in the wild: two throwaway accounts posting it once
+    # each — under a threshold of 2 neither would ever have been touched.
+    if is_foreign_start or flags >= getattr(config, "PROBE_FLAG_DELETE", 2):
         # Mark-only layer: delete quietly, never ban, never warn.
         try:
             await msg.delete()
+            return DELETED
         except Exception as e:
             logger.warning("PROBE delete failed: " + str(e))
-    return True
+    return FLAGGED

prompts_demo/antispam.ilang

@@ -23,6 +23,13 @@
 ::IMMUNE{UNICODE_VARIANT, DETECT}
 # Fullwidth chars, Cyrillic lookalikes, special spaces
 
+::IMMUNE{CJK_LOOKALIKE, DETECT}
+# Look-alike Han characters swapped in: 叚 for 假, 幣 for 币, 仮 for 假.
+# The stealthiest variant — the word reads normally to a human, matches nothing.
+
+::IMMUNE{INWORD_SEPARATOR, DETECT}
+# A separator pushed into the middle of a word: 叚*币, 假-币, 假 币
+
 ::IMMUNE{EMOJI_STUFFING, DETECT}
 # Text broken up by emojis to avoid keyword filters
 
@@ -35,6 +42,9 @@
 ::IMMUNE{TRANSLITERATION, DETECT}
 # Pinyin, romanization, phonetic spelling to dodge filters
 
+::IMMUNE{OBFUSCATION_IS_INTENT, WEIGH}
+# Obfuscation is not just a filter to see through — it is evidence in itself.
+
 # ============================================================
 # TEXT SPAM JUDGE
 # ============================================================
@@ -50,10 +60,24 @@ Step 3 — VERDICT based on these patterns:
 - Crypto/airdrop/token + link = crypto scam
 - Sexual services / hookup = sexual spam
 - Gambling / betting / lottery = gambling spam
+- Contraband trade — counterfeit currency (假币 / 假钞 / 高仿钞), forged documents,
+  trafficked ID cards and bank cards, weapons, drugs = spam
 - Normal conversation / question / complaint / emoji / reply = OK
 - Key insight: spam often disguises as normal content. Product codes may be hidden contact info. "Discount" may mean stolen goods.
 - Key insight: normal members rarely forward product info with contact details
 
+Key test — deliberate obfuscation is itself evidence of intent:
+Someone discussing, complaining about, or asking for help identifying a sensitive
+topic has no reason to write the word with look-alike characters or a separator
+wedged into it. Doing so means the sender knows the word gets blocked — an
+admission that what they are posting is the thing that gets blocked.
+So the same word can go either way depending on how it was written:
+  "the bank seized a batch of 假币" (news, plain spelling) → ok
+  "叚*币" (three characters, no context) → spam. This is not a truncated ad, it
+  IS the complete ad — the contact detail is the poster's own profile, anyone
+  who sees it taps through and messages them privately. Leaving out the contact
+  detail is only there to dodge the filter.
+
 Reply ONLY: spam or ok. No explanation.
 
 # ============================================================