"""消息监控 — 全列表指纹对比 + 窗口冻结检测 + ControlFromHandle 强制刷新"""

import time
import logging
import threading
import traceback
import unicodedata
import faulthandler
import sqlite3
import hashlib
from typing import Optional, Callable, List

faulthandler.enable()  # 捕获 C 扩展段错误，输出 traceback 到 stderr

logging.getLogger("comtypes").setLevel(logging.WARNING)
logger = logging.getLogger("msgbot.monitor")

# ⚠ 顺序重要: torch/easyocr 必须在 COM 模块 (uiautomation/winrt) 之前导入,
#   否则 c10.dll 会因 COM 初始化冲突抛出 WinError 1114。
_HAS_EASYOCR = False
_easyocr = None
_np = None
try:
    import easyocr as _easyocr
    import numpy as _np
    _HAS_EASYOCR = True
except (ImportError, OSError) as _e:
    import traceback as _tb
    _easyocr = None
    _np = None
    logger.debug(f"[ocr] EasyOCR 导入失败: {type(_e).__name__}: {_e}")
    logger.debug(f"[ocr] Traceback: {_tb.format_exc()}")

import uiautomation as auto
import win32gui
import win32con
import win32api
import win32process
import re
import sys
import ctypes
import difflib
import os

# ⭐ 偏旁部首 Unicode 库：用于 OCR 碎片过滤
# 单一数据源 = unicode_radicals.md（人和机器共用）：
#   - 人用肉眼看「偏旁」列维护
#   - bot 启动时解析「Unicode」列（U+XXXX）构建码点集合，比对只看码点
# 维护方式：编辑 md 添加/删除行即可，无需改代码。
# 仅当 md 缺失/解析失败时才回退到硬编码码位范围（保底，正常不触发）。
_RADICALS_MD = os.path.join(os.path.dirname(os.path.abspath(__file__)), "unicode_radicals.md")
# 保底范围：CJK Radicals Supplement U+2E80-U+2EFF + Extended-A U+2F00-U+2FDF
_RADICAL_RANGES_FALLBACK = (
    (0x2E80, 0x2EFF),  # CJK Radicals Supplement
    (0x2F00, 0x2FDF),  # CJK Radicals Extended-A
)

def _load_radical_codepoints() -> frozenset:
    """从 unicode_radicals.md 解析「Unicode」列，返回码点集合。

    行格式: | 亻 | U+2E80 | 单人旁 | 件→亻牛 | 件 |
    Unicode 列必须是 U+XXXX / U+XXXXX 十六进制；解析失败的行跳过。
    """
    cps = set()
    try:
        with open(_RADICALS_MD, "r", encoding="utf-8") as f:
            for line in f:
                m = re.search(r"U\+([0-9A-Fa-f]{4,5})\b", line)
                if m:
                    cps.add(int(m.group(1), 16))
    except OSError as e:
        logger.warning(f"[ocr] 偏旁库 {_RADICALS_MD} 读取失败({e})，回退码位范围")
        return frozenset()
    if not cps:
        logger.warning("[ocr] 偏旁库为空，回退码位范围")
        return frozenset()
    logger.debug(f"[ocr] 偏旁库加载 {len(cps)} 个码点 <- {_RADICALS_MD}")
    return frozenset(cps)

_RADICAL_CODEPOINTS = _load_radical_codepoints()

def _is_radical_char(ch: str) -> bool:
    """检查字符是否为 CJK 偏旁字符。

    优先查 md 库的 Unicode 码点（维护只改 md）；
    库未加载成功时回退到硬编码码位范围（保底）。
    """
    cp = ord(ch)
    if _RADICAL_CODEPOINTS:
        return cp in _RADICAL_CODEPOINTS
    return any(lo <= cp <= hi for lo, hi in _RADICAL_RANGES_FALLBACK)

import subprocess
import json
import psutil
import os
import random
from datetime import datetime, timedelta
import signal
from PIL import Image, ImageGrab, ImageEnhance, ImageFilter
from winrt.windows.media.ocr import OcrEngine
from winrt.windows.globalization import Language
from winrt.windows.graphics.imaging import SoftwareBitmap, BitmapPixelFormat

if not _HAS_EASYOCR:
    logger.debug("[ocr] EasyOCR 未就绪，仅使用 Windows OCR")

# ===== 主动防御: 全平台 UI 按钮/标签/面板标题黑名单 =====
# 微信/TIM/QQ 各界面按钮、标签、状态栏文本，OCR 读到后直接丢弃。
# 仅精确匹配（整行），零误杀风险。
_UI_EXACT_BLOCKLIST = frozenset({
    # — 微信 顶栏/导航 —
    '微信', '通讯录', '发现', '我',
    # — 微信 发现页 —
    '朋友圈', '视频号', '看一看', '搜一搜', '直播', '附近',
    '扫一扫', '摇一摇', '小程序',
    # — 微信 我页 —
    '服务', '购物', '收藏', '卡包', '表情', '游戏中心', '设置',
    '切换账号', '退出登录',
    # — 微信 设置页 —
    '开启群聊验证', '朋友权限', '停用', '更新',
    '存储空间', '清空缓存', '帮助与反馈',
    # — 微信 桌面版面板 —
    '小程序面板', '朋友圈',  # 紧凑版面板标题
    # — 微信 聊天会话列表 —
    '新的朋友', '群聊', '标签', '公众号', '我的设备', '我的收藏',
    # — 微信 输入栏 —
    '输入', '按住说话', '松开发送',
    # — 微信 聊天附加功能 —
    '视频通话', '语音通话', '个人名片', '位置共享',
    '红包', '转账', '相机', '相册', '文件', '音乐',
    # — 微信 群聊信息面板 —
    '群聊名称', '群二维码', '群公告', '群聊信息', '群成员',
    '全部', '未读', '置顶', '免打扰', '置顶聊天',
    '我在本群的昵称', '显示群成员昵称',
    '聊天记录', '查找聊天记录', '聊天文件', '清空聊天记录',
    '投诉', '成员', '邀请', '添加成员', '移出群聊', '解散群聊',
    # — 微信 公众号 —
    '关注', '赞', '在看', '分享', '留言', '作者',
    '阅读原文', '不让看', '取消关注',
    # — TIM/QQ 顶栏/侧栏 —
    '消息', '联系人', '勋章墙', '收藏', '文件', '设置',
    # — TIM/QQ 状态 —
    '在线', '离线', '忙碌', '隐身', 'Q我吧', '离开',
    # — TIM/QQ 搜索 —
    '搜索', '查找', '搜索聊天记录',
    # — TIM/QQ 联系人/群管理 —
    '我的设备', '我的收藏', '最近联系人', '创建群聊',
    '添加好友', '添加群', '添加群聊', '创建讨论组',
    # — TIM/QQ 聊天窗口 —
    '截图', '文件传输', '远程桌面', '远程控制',
    '发送文件', '发送图片',
    '关闭', '最小化', '最大化',
    '窗口抖动', '抖动',
    # — TIM/QQ 面板 —
    'QQ会员', 'QQ空间', '应用宝', '兴趣部落', '同城服务',
    '我的文件', '网络硬盘', '收藏夹', '好友动态',
    # — 自定义插件 —
    '启用监控', '停止监控', '监控已启用', '监控已停止',
    # — 通用系统提示 —
    '加载中', '加载失败', '正在连接', '连接失败',
    '网络连接成功', '网络连接断开', '连接中',
    '已连接', '已断开', '重新连接',
    '消息发送失败', '消息已发出', '对方正在输入',
    '点击查看', '点击进入',
    '已显示全部消息', '以上是历史消息',
    '你已添加了', '现在可以开始聊天了',
    '当前网络不可用', '请检查网络设置',
    '操作失败', '操作成功', '请求超时',
    # — Smart-Dump 漏网 —
    '手机',
})

# ===== 主动防御: UI 子串黑名单（含其中任何子串即跳过）=====
# 这些词在用户日常聊天中极不可能出现，只在 UI 面板/系统标签中出现。
# 防止 OCR 碎片精确匹配失败但子串命中。
_UI_SUBSTR_BLOCKLIST = frozenset({
    '启用监控', '停止监控', '数据看板', '应用设置',
    '债券总和', '注册用户总数', 'php管理员', '消息漫游',
    # QQ 群"共同好友"推荐（非聊天内容，OCR误读触发查库）
    '共同好友', '点击添加好友',
    # 微信/QQ "拍了拍" 系统通知（UI按钮触发，非用户消息）
    '拍了拍',
})


class MessageHistory:
    """管理消息历史数据库，用于判断无时间戳消息是否应放行"""

    def __init__(self, db_path: str = "msg_history.db"):
        self.db_path = db_path
        self._init_db()

    def _init_db(self):
        """初始化数据库表"""
        conn = sqlite3.connect(self.db_path, check_same_thread=False)
        conn.execute("PRAGMA journal_mode=WAL")
        conn.execute("""
            CREATE TABLE IF NOT EXISTS message_history (
                id INTEGER PRIMARY KEY AUTOINCREMENT,
                platform TEXT NOT NULL,
                sender_type TEXT NOT NULL,
                content TEXT NOT NULL,
                content_hash TEXT NOT NULL,
                created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP
            )
        """)
        conn.execute("""
            CREATE INDEX IF NOT EXISTS idx_content_hash ON message_history(content_hash)
        """)
        conn.execute("""
            CREATE INDEX IF NOT EXISTS idx_platform_time ON message_history(platform, created_at)
        """)
        conn.commit()
        conn.close()

    def _get_conn(self):
        """获取数据库连接"""
        return sqlite3.connect(self.db_path, check_same_thread=False)

    def record_bot_reply(self, platform: str, content: str):
        """记录bot回复"""
        content_hash = hashlib.md5(content.strip().encode('utf-8')).hexdigest()
        conn = self._get_conn()
        try:
            conn.execute(
                "INSERT INTO message_history (platform, sender_type, content, content_hash) VALUES (?, 'bot', ?, ?)",
                (platform, content.strip(), content_hash)
            )
            conn.commit()
        finally:
            conn.close()

    def record_user_message(self, platform: str, content: str):
        """记录用户消息（用于后续去重）"""
        content_hash = hashlib.md5(content.strip().encode('utf-8')).hexdigest()
        conn = self._get_conn()
        try:
            conn.execute(
                "INSERT INTO message_history (platform, sender_type, content, content_hash) VALUES (?, 'user', ?, ?)",
                (platform, content.strip(), content_hash)
            )
            conn.commit()
        finally:
            conn.close()

    def is_user_message_replied(self, platform: str, content: str) -> bool:
        """检查用户消息是否已被回复过（数据库中有相同内容的bot回复）"""
        content_hash = hashlib.md5(content.strip().encode('utf-8')).hexdigest()
        conn = self._get_conn()
        try:
            cursor = conn.execute(
                "SELECT COUNT(*) FROM message_history WHERE platform=? AND sender_type='bot' AND content_hash=?",
                (platform, content_hash)
            )
            count = cursor.fetchone()[0]
            return count > 0
        finally:
            conn.close()

    def last_bot_reply_time(self, platform: str) -> float:
        """获取该平台最近一次bot回复的时间戳（Unix时间）"""
        conn = self._get_conn()
        try:
            cursor = conn.execute(
                "SELECT created_at FROM message_history WHERE platform=? AND sender_type='bot' ORDER BY id DESC LIMIT 1",
                (platform,)
            )
            row = cursor.fetchone()
            if row:
                # 将SQLite时间戳转换为Unix时间
                from datetime import datetime
                dt = datetime.strptime(row[0], '%Y-%m-%d %H:%M:%S')
                return dt.timestamp()
            return 0.0
        finally:
            conn.close()


class MessageMonitor:
    """多线程消息监控器"""

    def __init__(self, on_message: Optional[Callable[[str, str], None]] = None):
        self._running = False
        self._thread: Optional[threading.Thread] = None
        self._poll_interval = 2.0
        self._on_message = on_message
        self._wechat_enabled = True
        self._qq_enabled = False

        # 全列表签名 & 完整文本列表 (用于新消息比对)
        self._last_sig: dict = {}
        self._last_texts: dict = {}
        # 最新消息文本（供 GUI 展示）
        self._last_msg: dict = {}

        # 轮询计数
        self._poll_count: dict = {}
        # QQ 轮询跳过计数（每 3 周期 poll 一次）
        self._qq_skip_counter = 0

        # 窗口句柄缓存（存 HWND，不存 Control 引用）
        self._cached_hwnd: dict = {}
        # 窗口对应进程 ID（验证窗口是否仍属同一进程）
        self._cached_pid: dict = {}
        # 窗口未找到冷却截止时间（time.time 值），期内跳过搜索
        self._window_not_found_until: dict = {}
        # 连续相同签名计数（用于冻结检测）
        self._stale_count: dict = {}
        # 连续空读
        self._empty_reads: dict = {}
        # 剪贴板原始文本（用于自动回复提取发送者）
        self._raw_clipboard: dict = {}

        # 发送中事件锁（防止自动回复时监控轮询干扰）
        self._sending_event = threading.Event()
        # 应用变体：qq→"qq_nt"或"tim"
        self._app_variant: dict = {}

        # 已处理消息的全局持久化集合（跨平台、跨轮次，防回环）
        self._seen_messages: set = set()
        # 已回复文本的永久集—永不裁切（剪贴板读到自己回复时必拦）
        self._replied_texts: set = set()
        # 上次回复时间戳（冷却期内跳过该平台 poll）
        self._last_reply_time: dict = {}
        # 同平台新消息冷却：同一 poll 或相邻 poll 内多条消息只处理第一条
        self._last_new_msg_time: dict = {}
        self._new_msg_cooldown: float = 3.0  # 同平台 3 秒内不重复处理
        # 发送失败消息冷却：msg_hash → 失败时间，冷却期内不再尝试回复（防止卡死）
        self._failed_send_cooldown: dict = {}  # platform → timestamp

        # 跨平台前台冷却：某平台刚切过前台（回复后），对端平台等待此时间再截图
        self._foreground_cooldown_until: dict = {}  # platform → float(time.time)
        # 同平台回复冷却：回复后此秒数内同平台跳过 OCR（防读到自身回复回声）
        self._self_reply_cooldown_until: dict = {}  # platform → float(time.time)

        # 本轮选中的 OCR 引擎（用于日志标记）
        self._last_chosen_engine: dict = {}  # platform → "windows"|"easyocr"

        # OCR 引擎（Windows 原生，lazy init）
        self._ocr_engine = None
        # EasyOCR 备用引擎（lazy init）
        self._easyocr_reader = None
        # EasyOCR 子进程（GPU crash 隔离，崩溃只杀子进程不冻电脑）
        self._easyocr_proc: Optional['subprocess.Popen'] = None
        self._easyocr_broken: bool = False
        # EasyOCR 子进程崩溃冷却：崩溃后 30s 内不重试（防快速崩溃循环刷屏）
        self._easyocr_retry_until: float = 0.0
        # EasyOCR 子进程调用计数：累积 GPU 内存泄漏，每 MAX 次主动重启清缓存
        self._easyocr_call_count: int = 0
        self._easyocr_max_calls: int = 3  # 最多 3 次后重启子进程
        # EasyOCR 连续失败计数：前2次保留子进程（预留初始化时间），第3次杀进程重来
        self._easyocr_consecutive_failures: int = 0
        self._easyocr_max_failures: int = 3  # 连续3次失败后杀进程
        # EasyOCR CUDA 错误计数：≥2 次 OOM/kernel error → 下次启动强制 CPU（防冻结）
        self._easyocr_cuda_oom_count: int = 0
        # 引擎选择计数器
        self._ocr_engine_wins: dict = {"windows": 0, "easyocr": 0}
        # 上次 OCR 原始文本（用于增量检测）
        self._ocr_last_text: dict = {}

        # OCR 垃圾连续计数（连续垃圾超过阈值清缓存重找）
        self._ocr_garbage_count: dict = {}

        # 截图 hash（像素级，截图不变→OCR 必然无新消息）
        self._last_screenshot_hash: dict = {}  # platform → str
        self._ocr_unchanged: dict = {}         # platform → bool（本轮因截图不变跳过）
        self._last_ocr_time: dict = {}         # platform → float（上次真正做OCR的时间戳）

        # OCR 截屏定时清理：保存后不再立即删（高频 create+delete 易触发 360 误报），
        # 改由 _maybe_clean_ocr_dir 每 30~60 秒随机间隔清理一次过期截图。
        self._next_ocr_clean_at: float = 0.0
        self._ocr_clean_ttl: float = 60.0     # 保留最近 60 秒内的截图，更早的删除

        # EasyOCR 子进程锁（QQ/微信独立线程共用同一子进程）
        self._easyocr_lock = threading.Lock()
        # QQ 独立轮询线程（不阻塞微信主循环）
        self._qq_thread: Optional[threading.Thread] = None
        # 双击 ESC 急停线程
        self._emergency_thread: Optional[threading.Thread] = None

        # 消息历史数据库（用于无时间戳消息放行判断）
        self._msg_history = MessageHistory()

        # 剪贴板内容 hash（防止跨平台读到过时数据）
        self._last_clipboard_hash: dict = {}  # platform → str(hash)
        # 紧急停止回调（通知 GUI 更新状态）
        self._emergency_stop_callback: Optional[Callable[[], None]] = None
        # 底层键盘钩子回调引用（防止 GC 回收导致系统崩溃）
        self._esc_hook_proc = None

    def set_poll_interval(self, seconds: float):
        self._poll_interval = max(0.5, seconds)

    def set_enabled_platforms(self, wechat: bool = True, qq: bool = False):
        self._wechat_enabled = wechat
        self._qq_enabled = qq

    def set_callback(self, cb: Callable[[str, str], None]):
        self._on_message = cb

    def set_emergency_callback(self, cb: Callable[[], None]):
        self._emergency_stop_callback = cb

    def start(self, full_restart: bool = False):
        """启动监控。
        
        Args:
            full_restart: True=彻底重启（进程级，重新检测内存恢复GPU）
                         False=急停/手动停止恢复（软重启，不重新检测内存）
        """
        if self._running:
            return
        self._running = True
        # ⭐ 重置 EasyOCR 状态：确保停止/急停后双引擎仍能搭档作业
        # stop() 会杀死子进程，但如果此时有 _call_easyocr_safe 在运行，
        # BrokenPipeError 会设置 _easyocr_broken=True，导致重启后 EasyOCR 永久不可用
        self._easyocr_broken = False
        self._easyocr_retry_until = 0.0  # 清除崩溃冷却
        self._easyocr_call_count = 0
        self._easyocr_consecutive_failures = 0  # ⭐ 清除连续超时计数（stop/急停后不残留）
        
        # ⭐ 彻底重启时重新检测内存，尝试恢复GPU模式
        # 急停/手动停止恢复时保持上次状态，不重新检测
        if full_restart:
            self._easyocr_cuda_oom_count = 0  # 重新评估 GPU/CPU
            logger.info("[ocr] 彻底重启：重新检测内存，尝试恢复GPU模式")
        else:
            # 急停/手动停止恢复：保持上次的降级状态（如果上次因OOM降级CPU，这次仍用CPU）
            logger.info(f"[ocr] 软重启：保持上次EasyOCR状态(cuda_oom_count={self._easyocr_cuda_oom_count})")
        
        self._easyocr_proc = None  # 确保 clean state
        # ⭐ OCR 状态清零：截图hash/垃圾计数/引擎选择/冷却等，确保重启不残留上一轮状态
        #   （上次 CUDA 报错降级 CPU 的计数、超时计数、截图指纹都从头开始）
        self._last_screenshot_hash.clear()
        self._ocr_unchanged.clear()
        self._last_ocr_time.clear()
        self._ocr_garbage_count.clear()
        self._ocr_last_text.clear()
        self._last_chosen_engine.clear()
        self._self_reply_cooldown_until.clear()
        self._ocr_engine_wins = {"windows": 0, "easyocr": 0}
        # OCR 截屏定时清理：启动后 30~60 秒随机触发第一次
        self._next_ocr_clean_at = time.time() + random.uniform(30, 60)
        # EasyOCR 已在子进程隔离（easyocr_worker.py），不需在主线程预加载
        # ⭐ 预热子进程：后台启动 + 60s 初始化握手，主循环不阻塞
        #    否则首次 OCR 时 10s 请求超时会把初始化中的进程杀掉 → 永远超时
        if _HAS_EASYOCR and not self._easyocr_broken:
            _warm = threading.Thread(target=self._ensure_easyocr_subprocess, daemon=True, name="easyocr-warmup")
            _warm.start()
        self._thread = threading.Thread(target=self._run_loop, daemon=True, name="monitor")
        self._thread.start()
        # QQ 独立轮询线程，不阻塞微信主循环（WeChat EasyOCR ~15-20s 每轮）
        self._qq_thread = threading.Thread(target=self._qq_poll_loop, daemon=True, name="monitor-qq")
        self._qq_thread.start()
        # 双击 ESC 急停检测线程
        self._emergency_thread = threading.Thread(target=self._esc_check_loop, daemon=True, name="monitor-esc")
        self._emergency_thread.start()
        logger.info("消息监控已启动")

    def stop(self):
        self._running = False
        if self._thread and self._thread.is_alive():
            self._thread.join(timeout=3)
            self._thread = None
        if self._qq_thread and self._qq_thread.is_alive():
            self._qq_thread.join(timeout=3)
            self._qq_thread = None
        if self._emergency_thread and self._emergency_thread.is_alive():
            # Post WM_QUIT 唤醒 GetMessage 阻塞，让钩子线程退出
            try:
                ctypes.windll.user32.PostThreadMessageW(
                    self._emergency_thread.ident, 0x0012, 0, 0  # WM_QUIT = 0x0012
                )
            except Exception:
                pass
            self._emergency_thread.join(timeout=2)
            self._emergency_thread = None
        # 杀死 EasyOCR 子进程（防止 GPU 推理残留吃资源/冻电脑）
        try:
            if self._easyocr_proc and self._easyocr_proc.poll() is None:
                self._easyocr_proc.kill()
                self._easyocr_proc.wait(timeout=3)
                logger.info("[stop] EasyOCR 子进程已杀死")
        except Exception as e:
            logger.debug(f"[stop] 杀 EasyOCR 异常: {e}")
        self._easyocr_proc = None
        # ⭐ 重置 broken 标记：stop 后 start 应能重新拉起 EasyOCR
        self._easyocr_broken = False
        self._easyocr_retry_until = 0.0  # 清除崩溃冷却
        self._easyocr_call_count = 0
        self._easyocr_consecutive_failures = 0  # ⭐ 清除连续超时计数（stop/急停后不残留）
        self._easyocr_cuda_oom_count = 0  # 重启后重新评估 GPU/CPU

        # 释放钩子回调引用（防止 GC 延迟导致卸载后崩溃）
        if hasattr(self, '_esc_hook_proc'):
            del self._esc_hook_proc
        self._cached_hwnd.clear()
        self._cached_pid.clear()
        self._last_sig.clear()
        self._last_msg.clear()
        self._stale_count.clear()
        self._empty_reads.clear()
        self._poll_count.clear()
        logger.info("消息监控已停止")

    @property
    def is_running(self) -> bool:
        return self._running

    # ── 轮询主循环 ──────────────────────────────────────────

    def _run_loop(self):
        # 创建 Windows 消息队列（使 AttachThreadInput / SetForegroundWindow 在 daemon 线程生效）
        try:
            ctypes.windll.user32.PeekMessageW(None, 0, 0, 0, 1)  # PM_NOREMOVE
        except Exception:
            pass
        heartbeat = 0
        logger.debug("_run_loop 进入 while 循环")
        while self._running:
            try:
                # OCR 截屏定时清理（每 30~60 秒随机触发，删除过期截图）
                self._maybe_clean_ocr_dir()
                if self._wechat_enabled and not self._sending_event.is_set():
                    self._poll("wechat")
            except Exception as e:
                logger.error(f"轮询异常: {e}\n{traceback.format_exc()}")

            heartbeat += 1
            if heartbeat % 10 == 0:
                logger.info(f"[♡] 心跳 #{heartbeat}")
            time.sleep(self._poll_interval)

    def _qq_poll_loop(self):
        """QQ 独立轮询线程：不阻塞微信 OCR，每轮间隔 ~2s。
        
        QQ OCR 截图通常较小（裁剪后），EasyOCR 耗时 1-3s；
        微信 OCR 每轮 ~15-20s。分开线程后 QQ 响应从 ~34s 降到 ~3-5s。
        """
        try:
            ctypes.windll.user32.PeekMessageW(None, 0, 0, 0, 1)
        except Exception:
            pass
        # 随机 stagger 3-5s，避免 QQ/微信同时 OCR 抢镜
        stagger = random.uniform(3, 5)
        logger.debug(f"[qq] 轮询延迟 {stagger:.1f}s 与微信错开")
        time.sleep(stagger)
        while self._running:
            try:
                if self._qq_enabled and not self._sending_event.is_set():
                    self._poll("qq")
            except Exception as e:
                logger.error(f"QQ轮询异常: {e}\n{traceback.format_exc()}")
            time.sleep(self._poll_interval)

    def _maybe_clean_ocr_dir(self):
        """OCR 截屏定时清理：每 30~60 秒随机触发一次，删除超过保留期的过期截图。

        保存截图后不再立即按数量清理（高频 create+delete 循环易触发 360 勒索启发式误报），
        改为低频定时批量清理：保留最近 _ocr_clean_ttl 秒内的截图，删除更早的全部
        （img/raw 原图 + img/processed 处理后图都清）。每次清理后随机设置下一次
        触发时间（30~60 秒），避免固定周期被安全软件识别为规律行为。
        """
        now = time.time()
        if now < self._next_ocr_clean_at:
            return
        # 下一次清理时间：随机 30~60 秒后
        self._next_ocr_clean_at = now + random.uniform(30, 60)
        cutoff = now - self._ocr_clean_ttl
        # 清理平台子目录（当前存放位置）+ 根目录（历史遗留文件）
        dirs_to_clean = [
            _get_ocr_raw_dir("qq"), _get_ocr_raw_dir("wechat"),
            _get_ocr_processed_dir("qq"), _get_ocr_processed_dir("wechat"),
            _get_ocr_raw_dir(), _get_ocr_processed_dir(),
        ]
        for d in dirs_to_clean:
            try:
                for f in os.listdir(d):
                    p = os.path.join(d, f)
                    try:
                        if os.path.getmtime(p) < cutoff:
                            os.remove(p)
                            logger.debug(f"[ocr] 定时清理过期截图: {f}")
                    except OSError:
                        pass
            except Exception:
                pass

    # ── 双击 ESC 急停 ──────────────────────────────────────

    def _esc_check_loop(self):
        """独立 daemon 线程：RegisterHotKey 全局热键检测双击 ESC → 强制急停。

        使用 RegisterHotKey 注册全局热键 + GetMessage 消息泵，
        不依赖窗口焦点，任何进程按 ESC 都能捕获。
        比 WH_KEYBOARD_LL 更可靠（避免 ctypes 64位调用约定问题）。
        """
        from ctypes import wintypes

        _VK_ESCAPE = 0x1B
        _WM_HOTKEY = 0x0312
        _HOTKEY_ID_ESC = 0x4553  # 'ES'

        # ⭐ 步骤1: 创建消息队列
        _msg = wintypes.MSG()
        ctypes.windll.user32.PeekMessageW(ctypes.byref(_msg), None, 0, 0, 0)

        # ⭐ 步骤2: 注册全局热键（hwnd=NULL → 投递到线程消息队列）
        #   MOD_NOREPEAT = 0x4000：长按不重复触发，只有按下时触发一次
        ok = ctypes.windll.user32.RegisterHotKey(None, _HOTKEY_ID_ESC, 0x4000, _VK_ESCAPE)
        if not ok:
            err = ctypes.windll.kernel32.GetLastError()
            # err=1409 = ERROR_HOTKEY_ALREADY_REGISTERED，其他热键已占 ESC
            logger.error("[急停] RegisterHotKey 失败 (err=%d) — ESC 急停不可用", err)
            return
        logger.info("[急停] 全局热键注册成功，双击 ESC 急停已激活")

        # ⭐ 步骤3: 消息泵 — 检测双击 ESC
        last_esc_time = 0.0
        while self._running:
            ret = ctypes.windll.user32.GetMessageW(ctypes.byref(_msg), None, 0, 0)
            if ret <= 0:
                break
            if _msg.message == _WM_HOTKEY and _msg.wParam == _HOTKEY_ID_ESC:
                now = time.time()
                if last_esc_time > 0 and (now - last_esc_time) < 0.5:
                    last_esc_time = 0.0
                    logger.warning("⚠️ 双击ESC急停触发！强制终止所有操作...")
                    self._emergency_stop()
                else:
                    last_esc_time = now

        # 线程退出 → 注销热键
        ctypes.windll.user32.UnregisterHotKey(None, _HOTKEY_ID_ESC)

    def _emergency_stop(self):
        """强制停止监控+杀死 EasyOCR+清空发送锁。"""
        self._running = False

        # 释放发送锁（防止被 hang 的发送操作卡住）
        self._sending_event.clear()

        # 杀死 EasyOCR 子进程（GPU 推理可能卡死不响应）
        try:
            if self._easyocr_proc and self._easyocr_proc.poll() is None:
                self._easyocr_proc.kill()
                self._easyocr_proc.wait(timeout=2)
                logger.warning("[急停] EasyOCR 子进程已杀死")
        except Exception as e:
            logger.debug(f"[急停] 杀 EasyOCR 异常: {e}")
        self._easyocr_proc = None

        # ⭐ 清零全部 OCR/EasyOCR 计数器：急停后不残留（下次启动从头评估 GPU/CPU）
        #   CUDA 报错降级 CPU 的计数、连续超时计数、截图指纹等全部归零
        self._easyocr_broken = False
        self._easyocr_retry_until = 0.0  # 清除崩溃冷却
        self._easyocr_call_count = 0
        self._easyocr_consecutive_failures = 0  # 清除连续超时计数
        self._easyocr_cuda_oom_count = 0  # 清除 CUDA 错误计数（不继承本次降级）
        self._last_screenshot_hash.clear()
        self._ocr_unchanged.clear()
        self._last_ocr_time.clear()
        self._ocr_garbage_count.clear()
        self._ocr_last_text.clear()
        self._last_chosen_engine.clear()
        self._self_reply_cooldown_until.clear()
        self._ocr_engine_wins = {"windows": 0, "easyocr": 0}

        # 通知回调（GUI 更新状态）
        try:
            if self._emergency_stop_callback:
                self._emergency_stop_callback()
        except Exception as e:
            logger.debug(f"[急停] 回调异常: {e}")

        logger.warning("⚠️ 急停完成 — 消息监控已停止，点击开关可重新启动")

    # ── 窗口定位 ─────────────────────────────────────────────

    def _ensure_hwnd(self, platform: str) -> Optional[int]:
        """查找窗口并返回 HWND（不缓存 Control）。"""
        hwnd = self._cached_hwnd.get(platform)
        try:
            if hwnd:
                if win32gui.IsWindow(hwnd):
                    return hwnd
        except Exception:
            pass

        self._cached_hwnd.pop(platform, None)
        self._cached_pid.pop(platform, None)

        # 非阻塞：窗口未找到冷却期内直接跳过搜索，不浪费 12s 超时
        cooldown_until = self._window_not_found_until.get(platform, 0)
        if time.time() < cooldown_until:
            return None

        if platform == "wechat":
            for name in ["微信", "WeChat"]:
                try:
                    w = auto.WindowControl(Name=name)
                    if w.Exists(maxSearchSeconds=0.5):
                        rect = w.BoundingRectangle
                        if rect.width() > 200 and rect.height() > 100:
                            h = w.NativeWindowHandle
                            # 确保存顶层窗口句柄（与 GetForegroundWindow 返回值一致）
                            top = win32gui.GetAncestor(h, win32con.GA_ROOT)
                            # 窗口不可见（最小化/隐藏）→ 跳过
                            # 注意：IsWindowVisible 检查 WS_VISIBLE 标志位，只要窗口在 Z 顺序中
                            # 未被标记为隐藏即返回 True（即使被其他窗口覆盖），符合需求。
                            if not win32gui.IsWindowVisible(top):
                                continue
                            self._cached_hwnd[platform] = top
                            self._cached_pid[platform] = win32process.GetWindowThreadProcessId(top)[1]
                            self._window_not_found_until.pop(platform, None)
                            logger.info(f"[{platform}] 窗口已定位: {name} handle={top}")
                            return top
                except Exception:
                    pass

            # 兜底：通过 Win32 API 按进程名查找微信窗口（UIAutomation 在窗口被覆盖时可能找不到）
            # 只要窗口可见（未被最小化/隐藏）就返回，与 QQ 逻辑一致
            for proc_name in ["WeChat.exe", "微信"]:
                try:
                    for proc in psutil.process_iter(['name', 'pid']):
                        if proc.info['name'] and proc.info['name'].lower() == proc_name.lower():
                            pid = proc.info['pid']
                            pid_windows = []

                            def _pid_enum_cb(hwnd, results, _pid=pid):
                                try:
                                    _, found_pid = win32process.GetWindowThreadProcessId(hwnd)
                                    if found_pid == _pid:
                                        top = win32gui.GetAncestor(hwnd, win32con.GA_ROOT)
                                        if top not in results:
                                            results.append(top)
                                except Exception:
                                    pass
                                return True

                            win32gui.EnumWindows(_pid_enum_cb, pid_windows)

                            for top in pid_windows:
                                if not (win32gui.IsWindow(top) and win32gui.IsWindowVisible(top)):
                                    continue
                                rect = win32gui.GetWindowRect(top)
                                if (rect[2] - rect[0]) > 200 and (rect[3] - rect[1]) > 100:
                                    self._cached_hwnd[platform] = top
                                    self._cached_pid[platform] = pid
                                    self._window_not_found_until.pop(platform, None)
                                    title = win32gui.GetWindowText(top)
                                    logger.info(f"[{platform}] 窗口已定位(Win32 进程枚举): {proc_name} pid={pid} title={title!r} top={top}")
                                    return top
                except Exception:
                    continue
        elif platform == "qq":
            # 只按进程名找窗口，不管标题是什么。
            # TIM/QQ 标题是动态的（跟随会话显示），任何标题都合法。
            for proc_name in ["TIM.exe", "QQ.exe"]:
                try:
                    for proc in psutil.process_iter(['name', 'pid']):
                        if proc.info['name'] and proc.info['name'].lower() == proc_name.lower():
                            pid = proc.info['pid']
                            pid_windows = []

                            def _pid_enum_cb(hwnd, results, _pid=pid):
                                try:
                                    _, found_pid = win32process.GetWindowThreadProcessId(hwnd)
                                    if found_pid == _pid:
                                        top = win32gui.GetAncestor(hwnd, win32con.GA_ROOT)
                                        if top not in results:
                                            results.append(top)
                                except Exception:
                                    pass
                                return True
                            win32gui.EnumWindows(_pid_enum_cb, pid_windows)

                            # 所有属于该进程的顶层窗口中，取第一个尺寸>=聊天区的、可见的
                            for top in pid_windows:
                                if not (win32gui.IsWindow(top) and win32gui.IsWindowVisible(top)):
                                    continue
                                rect = win32gui.GetWindowRect(top)
                                if (rect[2] - rect[0]) > 200 and (rect[3] - rect[1]) > 100:
                                    variant = "tim" if "TIM" in proc_name.upper() else "qq_nt"
                                    self._app_variant[platform] = variant
                                    self._cached_hwnd[platform] = top
                                    self._cached_pid[platform] = pid
                                    self._window_not_found_until.pop(platform, None)
                                    title = win32gui.GetWindowText(top)
                                    logger.info(f"[{platform}] 窗口已定位: {proc_name} pid={pid} title={title!r} top={top}")
                                    return top
                except Exception:
                    continue
            # 兜底：UIA 搜索 TXGuiFoundation 类名窗口（进程已启动但窗口尚未就绪时）
            try:
                root = auto.GetRootControl()
                for child in root.GetChildren():
                    try:
                        if child.ClassName == "TXGuiFoundation":
                            rect = child.BoundingRectangle
                            if rect.width() > 200 and rect.height() > 100:
                                h = child.NativeWindowHandle
                                top = win32gui.GetAncestor(h, win32con.GA_ROOT)
                                pid = win32process.GetWindowThreadProcessId(top)[1]
                                self._app_variant[platform] = "qq_nt"
                                self._cached_hwnd[platform] = top
                                self._cached_pid[platform] = pid
                                self._window_not_found_until.pop(platform, None)
                                logger.info(f"[{platform}] 窗口已定位(UIA TXGuiFoundation): top={top}")
                                return top
                    except Exception:
                        continue
            except Exception:
                pass
        # 搜索完毕没找到 → 设冷却避免重复 12s 超时
        self._window_not_found_until[platform] = time.time() + 30
        return None

    def _ensure_hwnd_with_timeout(self, platform: str, timeout: float = 12.0) -> Optional[int]:
        """_ensure_hwnd 包装 daemon 线程超时保护。

        ThreadPoolExecutor 创建非 daemon 线程 → Ctrl+C 进程不退出。
        改用 daemon thread + Event.wait(timeout)，daemon 线程不阻塞进程退出。
        """
        # 冷却期内免线程直接跳过
        cooldown_until = self._window_not_found_until.get(platform, 0)
        if time.time() < cooldown_until:
            return None

        result = [None]
        done = threading.Event()

        def worker():
            # 如果外层已设冷却（超时后立即设），不再重复 UIA 搜索
            cooldown_until = self._window_not_found_until.get(platform, 0)
            if time.time() < cooldown_until:
                done.set()
                return
            result[0] = self._ensure_hwnd(platform)
            done.set()

        t = threading.Thread(target=worker, daemon=True)
        t.start()
        if not done.wait(timeout=timeout):
            logger.warning(f"[{platform}] _ensure_hwnd 超时({timeout:.0f}s)，跳过本轮")
            self._window_not_found_until[platform] = time.time() + 30
            return None
        return result[0]

    # ── 强制刷新 UIA ──────────────────────────────────────────

    def _fresh_window(self, platform: str):
        """从缓存 HWND 创建全新的 WindowControl（绕过 UIA 缓存）。"""
        hwnd = self._cached_hwnd.get(platform)
        if not hwnd:
            return None
        try:
            # 用 NativeWindowHandle 重建，保证 UIA 新缓存
            win = auto.ControlFromHandle(hwnd)
            if win is not None:
                return win
        except Exception:
            pass
        return None

    def _find_qq_window_fresh(self):
        """通过类名重新查找 QQ/TIM 窗口，绕过 UIA 缓存（比 ControlFromHandle 更彻底）。"""
        try:
            # 先按窗口名称查找
            for name in ["QQ", "TIM"]:
                try:
                    w = auto.WindowControl(Name=name)
                    if w.Exists(maxSearchSeconds=0.2):
                        rect = w.BoundingRectangle
                        if rect.width() > 200 and rect.height() > 100:
                            return w
                except Exception:
                    pass
            # 按 TXGuiFoundation 类名深度查找
            root = auto.GetRootControl()
            for child in root.GetChildren():
                try:
                    if child.ClassName == "TXGuiFoundation":
                        rect = child.BoundingRectangle
                        if rect.width() > 200 and rect.height() > 100:
                            return child
                except Exception:
                    pass
        except Exception:
            pass
        return None

    def _force_uia_refresh(self, platform: str):
        """通过交互强制窗口更新 UIA 控件树。"""
        hwnd = self._cached_hwnd.get(platform)
        if not hwnd:
            return
        try:
            # 方式1: 窗口重绘
            win32gui.InvalidateRect(hwnd, None, True)
            win32gui.UpdateWindow(hwnd)
            # QQ: 避免标题栏点击（不会干扰用户操作）
            if platform == "qq":
                win32gui.PostMessage(hwnd, win32con.WM_VSCROLL, win32con.SB_BOTTOM, 0)
                win32gui.PostMessage(hwnd, win32con.WM_KEYDOWN, win32con.VK_END, 0)
                win32gui.PostMessage(hwnd, win32con.WM_KEYUP, win32con.VK_END, 0)
            else:
                # 方式2: 向窗口发送非客户区点击（仅微信）
                win32gui.PostMessage(hwnd, 0x00A1, 2, 0)  # WM_NCLBUTTONDOWN
                win32gui.PostMessage(hwnd, 0x00A2, 2, 0)  # WM_NCLBUTTONUP
            logger.debug(f"[{platform}] UIA强制刷新")
        except Exception as e:
            logger.debug(f"[{platform}] 强制刷新失败: {e}")

    def _force_scroll_bottom(self, platform: str):
        """滚动窗口到底部，触发 UI 更新。"""
        hwnd = self._cached_hwnd.get(platform)
        if not hwnd:
            return
        try:
            # 1. WM_VSCROLL SB_BOTTOM
            win32gui.PostMessage(hwnd, win32con.WM_VSCROLL, win32con.SB_BOTTOM, 0)
            # 2. Ctrl+End 快捷键
            win32gui.PostMessage(hwnd, win32con.WM_KEYDOWN, win32con.VK_CONTROL, 0)
            win32gui.PostMessage(hwnd, win32con.WM_KEYDOWN, win32con.VK_END, 0)
            win32gui.PostMessage(hwnd, win32con.WM_KEYUP, win32con.VK_END, 0)
            win32gui.PostMessage(hwnd, win32con.WM_KEYUP, win32con.VK_CONTROL, 0)
            # 3. InvalidateRect 强制重绘
            win32gui.InvalidateRect(hwnd, None, True)
        except Exception as e:
            logger.debug(f"[{platform}] 滚动到底失败: {e}")

    def _ensure_visible(self, hwnd) -> bool:
        """确保窗口可见，尝试置前但不强制要求前台（用户操作不打断截屏）。

        截屏用 ImageGrab.grab(bbox) 截的是整屏坐标，只要窗口在屏幕上可见
        （未被其他窗口完全遮挡），截屏就能拿到正确内容。用户操作鼠标/键盘
        会抢走前台焦点，但不等于窗口被遮挡——不应因此放弃截屏。

        流程：恢复最小化/隐藏 → AllowSetForegroundWindow 解除限制 →
        SetForegroundWindow + SwitchToThisWindow 尽力置前（重试3次）→
        若置前成功直接返回；若置前失败但窗口仍然可见（IsWindowVisible + !IsIconic），
        也返回 True 继续截图。仅当窗口真的不可见时返回 False。
        """
        root_hwnd = win32gui.GetAncestor(hwnd, win32con.GA_ROOT)
        if not root_hwnd or not win32gui.IsWindow(root_hwnd):
            return False
        # 1) 恢复最小化 / 显示隐藏窗口
        if win32gui.IsIconic(root_hwnd):
            win32gui.ShowWindow(root_hwnd, win32con.SW_RESTORE)
            time.sleep(0.2)
        if not win32gui.IsWindowVisible(root_hwnd):
            win32gui.ShowWindow(root_hwnd, win32con.SW_SHOWNORMAL)
            time.sleep(0.2)
        # 2) 解除系统前台限制（ASFW_ANY），让后台线程也能 SetForegroundWindow
        try:
            ctypes.windll.user32.AllowSetForegroundWindow(-1)
        except Exception:
            pass
        # 3) 尽力置前：SetForegroundWindow + SwitchToThisWindow 兜底，重试 3 次
        for _ in range(3):
            try:
                win32gui.SetForegroundWindow(root_hwnd)
            except Exception:
                pass
            time.sleep(0.12)
            try:
                ctypes.windll.user32.SwitchToThisWindow(root_hwnd, True)
            except Exception:
                pass
            time.sleep(0.1)
            if self._check_foreground(root_hwnd):
                return True
        # 4) 前台校验失败 —— 但窗口可能仍然可见（用户操作抢走了前台焦点）
        #    ImageGrab.grab 只需要窗口在屏幕上可见即可，不要求前台。
        #    仅当窗口真的不可见（被完全遮挡/最小化）时才放弃。
        if win32gui.IsWindowVisible(root_hwnd) and not win32gui.IsIconic(root_hwnd):
            logger.debug(f"[{self.__class__.__name__}] 窗口 {root_hwnd} 未获得前台但仍然可见，继续截图")
            return True
        logger.warning(f"[{self.__class__.__name__}] 窗口 {root_hwnd} 不可见，跳过本轮")
        return False

    def _ensure_foreground(self, hwnd, max_retries=5) -> bool:
        """确保窗口在前台，重试多次。失败返回 False，不强行发送。"""
        root_hwnd = win32gui.GetAncestor(hwnd, win32con.GA_ROOT)
        if not root_hwnd or not win32gui.IsWindow(root_hwnd):
            logger.warning(f"[前台] 无效句柄 {hwnd}")
            return False

        # 前置条件：最小化则恢复，隐藏则显示
        if win32gui.IsIconic(root_hwnd):
            win32gui.ShowWindow(root_hwnd, win32con.SW_RESTORE)
            time.sleep(0.2)
        if not win32gui.IsWindowVisible(root_hwnd):
            win32gui.ShowWindow(root_hwnd, win32con.SW_SHOWNORMAL)
            time.sleep(0.2)

        # 允许任意进程 SetForegroundWindow（移除系统限制，与发送路径一致）
        try:
            ctypes.windll.user32.AllowSetForegroundWindow(-1)  # ASFW_ANY
        except Exception:
            pass

        for i in range(max_retries):
            # Method 1: AttachThreadInput + SetForegroundWindow
            self._attach_set_foreground(root_hwnd)
            time.sleep(0.15)
            if self._check_foreground(root_hwnd):
                return True

            # Method 2: SwitchToThisWindow（权限要求低，轻量）
            try:
                ctypes.windll.user32.SwitchToThisWindow(root_hwnd, True)
                time.sleep(0.15)
                if self._check_foreground(root_hwnd):
                    return True
            except Exception:
                pass

            time.sleep(0.1)

        logger.warning(f"无法将窗口 {hwnd} 带到前台，放弃操作")
        return False

    @staticmethod
    def _check_foreground(root_hwnd) -> bool:
        """检查窗口是否在前台（或其子窗口）。"""
        try:
            fg = win32gui.GetForegroundWindow()
            if fg == root_hwnd:
                return True
            if fg and win32gui.IsChild(root_hwnd, fg):
                return True
        except Exception:
            pass
        return False

    def _attach_set_foreground(self, hwnd):
        """AttachThreadInput + SetForegroundWindow，从 daemon 线程也能成功。"""
        try:
            current_tid = ctypes.windll.kernel32.GetCurrentThreadId()
            target_tid = ctypes.windll.user32.GetWindowThreadProcessId(hwnd, None)
            if ctypes.windll.user32.AttachThreadInput(current_tid, target_tid, True):
                try:
                    win32gui.SetForegroundWindow(hwnd)
                except Exception:
                    pass
                finally:
                    ctypes.windll.user32.AttachThreadInput(current_tid, target_tid, False)
                return
            # AttachThreadInput 失败 → 裸 SetForegroundWindow
            try:
                win32gui.SetForegroundWindow(hwnd)
            except Exception:
                pass
        except Exception:
            try:
                win32gui.SetForegroundWindow(hwnd)
            except Exception:
                pass

    def _read_win32_texts(self, platform: str) -> list:
        """Win32 API 读窗口文本，递归枚举（depth 不限）。"""
        hwnd = self._cached_hwnd.get(platform)
        if not hwnd:
            return []
        texts = []

        def enum_callback(child_hwnd, _):
            try:
                text = win32gui.GetWindowText(child_hwnd)
                if text and len(text.strip()) >= 2:
                    texts.append(text.strip())
            except Exception:
                pass
            return True

        try:
            main_text = win32gui.GetWindowText(hwnd)
            if main_text and len(main_text.strip()) >= 2:
                texts.append(main_text.strip())
            win32gui.EnumChildWindows(hwnd, enum_callback, None)
        except Exception:
            pass
        return texts

    # ── OCR 读屏（QQ 专用，Windows 原生 OCR） ──────────────────

    def _ocr_ensure_engine(self):
        """惰性初始化 OCR 引擎（中文简体）。"""
        if self._ocr_engine is None:
            try:
                self._ocr_engine = OcrEngine.try_create_from_language(
                    Language('zh-CN')
                )
                if self._ocr_engine:
                    logger.info(f"[ocr] OCR引擎就绪: {self._ocr_engine.recognizer_language.display_name}")
                else:
                    logger.warning("[ocr] 创建OCR引擎失败")
            except Exception as e:
                logger.error(f"[ocr] OCR引擎初始化异常: {e}")
        return self._ocr_engine

    @staticmethod
    def _normalize_ocr_text(text: str) -> str:
        """Windows OCR 给 CJK 字符间强加空格 → 去除这些空格使文本可去重。

        "问 题 1 ： 你 答 ： 你 好" → "问题1：你答：你好"
        "你 好 he llo" → "你好 he llo"（ASCII 词内空格保留）

        此外修复常见 Windows OCR 字符混淆错误（只在非 md 文本上运行，
        md 文档由分割后逐片段 md 检测过滤，不受影响）。
        """
        # 所有紧邻 CJK/全角字符的空格全部去掉
        # CJK 范围：汉字 (u4e00-) + 扩展 (u3400-) + 全角/兼容 (uff00-)
        text = re.sub(
            r'(?<=[\u4e00-\u9fff\u3400-\u4dbf\uff00-\uffef\u3000-\u303f])'
            r'\s+',
            '', text
        )
        text = re.sub(
            r'\s+'
            r'(?=[\u4e00-\u9fff\u3400-\u4dbf\uff00-\uffef\u3000-\u303f])',
            '', text
        )

        # ⭐ Windows OCR 字符混淆修复
        # 《》→ <>：Minecraft 聊天大量使用 <player> 等尖括号，OCR 误读为中文书名号
        text = text.replace('《', '<').replace('》', '>')

        # l→| 管道分隔符：|quiz| / |start| / |info| 误读为 lquizl / lstartl / linfol
        text = re.sub(r'(?<=\s)l([A-Za-z]\w*?)l(?=\s)', r'|\1|', text)

        # ．→ . 全角点→半角数字小数点 (0．45 → 0.45)
        text = re.sub(r'(\d)[．](\d)', r'\1.\2', text)

        # 清理消息末尾的状态标记（如 "0~" "O~" "C~" "0~O~"），避免污染 KB 匹配
        text = re.sub(r'\s*(?:[A-Za-z0-9]~)+\s*$', '', text)

        # 清理 HTML 标签（OCR 截到网页/终端时常带 <br> <div> 等）
        text = re.sub(r'<\s*br\s*/?\s*>', '\n', text, flags=re.IGNORECASE)
        text = re.sub(r'<\s*div\s*/?\s*>', '\n', text, flags=re.IGNORECASE)
        text = re.sub(r'<[^>]+>', '', text)

        # ⭐ Windows OCR 常见汉字误识别纠错（词级，降低误伤）
        # OCR 把相似笔画/结构的字搞混，只在确认是误识别的词组上替换
        _ocr_fixes = {
            '手髓': '手续',   # 髓(骨髓) → 续(手续)，笔画结构相似
            'β余': '多余',   # β(希腊字母) → 多，OCR把"多"拆成β形状
            '早原': '草原',   # 早 → 草，上半部分相似
            '届件': '插件',   # 届 → 插，结构相似
            '文|牛': '文件',  # 文|牛 → 文件，OCR把"件"拆成|牛
            '日何': '如何',   # 日 → 如，结构相似
            '何使': '如何使', # 兜底：如果"如何"被拆成"日何"但前面有字
        }
        for wrong, right in _ocr_fixes.items():
            text = text.replace(wrong, right)

        return text.strip()

    @staticmethod
    def _is_ocr_console_garbage(text: str) -> bool:
        """OCR 输出的文本是否明显是控制台/Python 垃圾。

        当 OCR 截错窗口（如读到终端窗口）时，文本包含：
        - Python 路径/模块名：comtypes, uiautomation, sklearn, jieba, winrt
        - 脚本文件名：monitor.py, main.py
        - 虚拟环境路径：.venv
        - 日志关键词：DEBUG, INFO, WARNING, msgbot
        - 控制台序列：←[, [32m, [0m
        返回 True = 应当丢弃。
        """
        garbage_patterns = [
            r'comtypes', r'uiautomation', r'sklearn', r'jieba',
            r'winrt\.', r'msgbot\.', r'monitor\.py', r'main\.py',
            r'\.venv', r'Loading model', r'Prefix dict',
            r'WARNING', r'UserWarning', r'Building prefix',
            r'←\[', r'\[32m', r'\[0m', r'\\n',
        ]
        for pat in garbage_patterns:
            if re.search(pat, text, re.IGNORECASE):
                return True
        cjk_count = sum(1 for c in text if '\u4e00' <= c <= '\u9fff')
        # 全字母数字+标点无中文 → 肯定是非聊天内容（阈值降到 15）
        if cjk_count == 0 and len(text.strip()) > 15:
            return True
        # OCR 随机字符垃圾：无中文 + 特殊字符比例高（如 = ~ @ # $ % ^ & *）
        # EasyOCR 在包含头像/表情/特殊 UI 的区域会输出 544UUJ1W H V=YJ~JL:e 这类乱码
        if cjk_count == 0 and len(text.strip()) >= 8:
            special_chars = sum(1 for c in text if c in '=~@#$%^&*_+{}[]|\\<>/`!')
            alpha_count = sum(1 for c in text if c.isalpha())
            digit_count = sum(1 for c in text if c.isdigit())
            # 特殊字符占比过高（>15%）且字母数字混杂 → OCR 乱码
            if special_chars / len(text) > 0.15 and alpha_count >= 2 and digit_count >= 2:
                return True
        return False

    def _validate_qq_window(self, hwnd: int) -> bool:
        """验证窗口是否确实是 QQ/TIM 进程。

        不尝试自动恢复隐藏/最小化窗口——交给剪贴板兜底的 _ensure_foreground 处理。
        _ensure_foreground 有多重重试+SetForegroundWindow，比这里抢先 ShowWindow
        更能正确弹出主窗口而非托盘预览。
        """
        if not win32gui.IsWindow(hwnd):
            return False
        if not win32gui.IsWindowVisible(hwnd):
            return False
        if win32gui.IsIconic(hwnd):
            return False
        # 验证进程名
        try:
            _, pid = win32process.GetWindowThreadProcessId(hwnd)
            hproc = win32api.OpenProcess(
                0x0400 | 0x0010,  # PROCESS_QUERY_INFORMATION | PROCESS_VM_READ
                False, pid
            )
            if hproc:
                exe_path = win32process.GetModuleFileNameEx(hproc, 0)
                win32api.CloseHandle(hproc)
                exe_name = exe_path.split('\\')[-1].lower() if exe_path else ''
                if exe_name in ('qq.exe', 'tim.exe'):
                    return True
        except Exception:
            pass
        return False

    @staticmethod
    def _fuzzy_duplicate(new_text: str, seen_set: set, threshold: float = 0.80) -> bool:
        """检查 new_text 是否与 seen_set 中已有文本相似度超阈值。

        OCR 输出有噪声（每次勖彐碎片、行首数字、尾部截断不同），精确匹配无法去重。
        用 difflib.SequenceMatcher 的 quick_ratio() 做快速上界剪枝。
        """
        if not new_text or len(new_text) < 4:
            return False
        for existing in seen_set:
            if abs(len(existing) - len(new_text)) > max(len(existing), len(new_text)) * 0.4:
                # 长度差距超 40%，不可能相似（quick_ratio 上界 = 2*min/max < 阈值）
                continue
            ratio = difflib.SequenceMatcher(None, new_text, existing).quick_ratio()
            if ratio >= threshold:
                return True
        return False

    # ── 双 OCR 引擎 ──────────────────────────────────────────

    def _init_easyocr(self):
        """惰性初始化 EasyOCR（首次约 3-10 秒）。"""
        if not _HAS_EASYOCR or self._easyocr_reader is not None:
            return
        try:
            logger.info("[ocr] EasyOCR 初始化中（首次约 3-10 秒）...")
            # 限制 torch 线程数，避免 MKL/OpenMP 在多线程环境段错误
            import torch
            torch.set_num_threads(1)
            
            # 检测可用内存，决定是否使用GPU
            use_gpu = torch.cuda.is_available()
            if use_gpu:
                mem = psutil.virtual_memory()
                available_gb = mem.available / (1024**3)
                # 可用内存 < 2GB 时强制降级CPU，防止OOM崩溃
                if available_gb < 2.0:
                    logger.warning(f"[ocr] 可用内存不足({available_gb:.1f}GB < 2GB)，EasyOCR 降级CPU模式")
                    use_gpu = False
                else:
                    logger.info(f"[ocr] 可用内存充足({available_gb:.1f}GB)，尝试GPU模式")
            
            self._easyocr_reader = _easyocr.Reader(['ch_sim', 'en'], gpu=use_gpu)
            if use_gpu:
                logger.info("[ocr] EasyOCR 就绪（GPU 模式）")
            else:
                logger.info("[ocr] EasyOCR 就绪（CPU 模式）")
        except Exception as e:
            logger.error(f"[ocr] EasyOCR 初始化失败: {e}")
            self._easyocr_reader = None

    # ── EasyOCR 子进程隔离 ────────────────────────────────────
    # 直接 GPU 推理 crash（access violation）会杀整个进程 + 冻电脑。
    # 子进程方案：GPU crash 只杀子进程，主进程降级到 Windows OCR。

    def _ensure_easyocr_subprocess(self) -> bool:
        """确保 EasyOCR 子进程在运行。返回 True = 可用。

        启动后等待 worker 的 {"ready": true} 握手（最长 60s 初始化预算），
        初始化时间不计入请求超时。子进程崩溃/超时 → 杀进程 + 设置冷却，
        冷却期后自动重试（不再永久 _easyocr_broken）。
        """
        if self._easyocr_broken:
            return False
        if self._easyocr_proc is not None:
            if self._easyocr_proc.poll() is None:
                return True  # 还在跑
            logger.warning("[ocr] EasyOCR 子进程已退出，重启...")
            self._easyocr_proc = None

        # 冷却期：子进程刚崩溃，30s 内不立即重试（防快速崩溃循环刷屏）
        if time.time() < self._easyocr_retry_until:
            return False

        # ⭐ 页面文件预检：如果虚拟内存不足，直接跳过 EasyOCR（避免反复崩溃循环）
        try:
            import ctypes
            class _MEMORYSTATUSEX(ctypes.Structure):
                _fields_ = [
                    ("dwLength", ctypes.c_ulong), ("dwMemoryLoad", ctypes.c_ulong),
                    ("ullTotalPhys", ctypes.c_ulonglong), ("ullAvailPhys", ctypes.c_ulonglong),
                    ("ullTotalPageFile", ctypes.c_ulonglong), ("ullAvailPageFile", ctypes.c_ulonglong),
                    ("ullTotalVirtual", ctypes.c_ulonglong), ("ullAvailVirtual", ctypes.c_ulonglong),
                    ("ullAvailExtendedVirtual", ctypes.c_ulonglong),
                ]
            _mem = _MEMORYSTATUSEX()
            _mem.dwLength = ctypes.sizeof(_MEMORYSTATUSEX)
            ctypes.windll.kernel32.GlobalMemoryStatusEx(ctypes.byref(_mem))
            _avail_page_gb = _mem.ullAvailPageFile / (1024**3)
            _commit_pct = round((1 - _mem.ullAvailPageFile / max(_mem.ullTotalPageFile, 1)) * 100, 1)
            if _avail_page_gb < 2.0:
                logger.error(f"[ocr] ⚠️ 页面文件不足: 剩余{_avail_page_gb:.1f}GB(提交{_commit_pct}%)，"
                             f"EasyOCR 冷却1小时。建议：增大 Windows 页面文件")
                self._easyocr_retry_until = time.time() + 3600
                return False
        except Exception:
            pass  # 获取失败则不阻断

        worker_path = os.path.join(
            os.path.dirname(os.path.abspath(__file__)),
            'easyocr_worker.py'
        )
        if not os.path.exists(worker_path):
            logger.error(f"[ocr] EasyOCR worker 不存在: {worker_path}")
            self._easyocr_broken = True
            return False

        try:
            _worker_env = dict(os.environ)
            # ⭐ CUDA_LAUNCH_BLOCKING=1: CUDA 操作同步化，access violation 时只杀子进程不冻整机
            _worker_env["CUDA_LAUNCH_BLOCKING"] = "1"
            # ⭐ EASYOCR_WORKER=1: 让 main.py 检测到 worker 模式，跳过 GUI 初始化
            _worker_env["EASYOCR_WORKER"] = "1"
            
            # 内存检测：可用内存 < 2GB 时强制CPU模式，防止OOM崩溃
            try:
                mem = psutil.virtual_memory()
                available_gb = mem.available / (1024**3)
                if available_gb < 2.0:
                    _worker_env["EASYOCR_FORCE_CPU"] = "1"
                    logger.warning(f"[ocr] 可用内存不足({available_gb:.1f}GB)，EasyOCR 子进程强制CPU模式")
                elif self._easyocr_cuda_oom_count >= 2:
                    # ⭐ 连续 CUDA OOM/kernel error → 强制 CPU 模式启动（显存不足时防冻结）
                    _worker_env["EASYOCR_FORCE_CPU"] = "1"
                    logger.warning("[ocr] EasyOCR 连续CUDA错误≥2次，本次强制 CPU 模式启动 worker")
            except Exception:
                pass  # 获取内存失败不阻断
            
            self._easyocr_proc = subprocess.Popen(
                [sys.executable, '-u', worker_path],
                stdin=subprocess.PIPE,
                stdout=subprocess.PIPE,
                stderr=subprocess.PIPE,      # 捕获 worker 错误日志（防崩溃排查）
                text=True,
                bufsize=1,  # 行缓冲
                env=_worker_env,
            )
            logger.debug("[ocr] EasyOCR 子进程已启动，等待初始化握手...")
        except Exception as e:
            logger.error(f"[ocr] 启动 EasyOCR 子进程失败: {e}")
            self._easyocr_broken = True
            self._easyocr_proc = None
            return False

        # ⭐ 等待 ready 握手（60s 初始化预算，不计入请求超时）
        try:
            from queue import Queue, Empty as _QueueEmpty
            _q = Queue()
            def _read_ready():
                try:
                    _q.put(self._easyocr_proc.stdout.readline())
                except Exception:
                    pass
            _t = threading.Thread(target=_read_ready, daemon=True)
            _t.start()
            try:
                line = _q.get(timeout=60)
            except _QueueEmpty:
                logger.error("[ocr] EasyOCR 子进程初始化超时(60s)，杀死进程，30s 后重试")
                self._easyocr_proc.kill()
                self._easyocr_proc.wait(timeout=3)
                self._easyocr_proc = None
                self._easyocr_retry_until = time.time() + 30
                return False
            if not line:
                # stdout 关闭 = worker 崩溃，读 stderr + 崩溃日志看原因
                err = ""
                try:
                    err = self._easyocr_proc.stderr.read()[:500]
                except Exception:
                    pass
                crash = _read_easyocr_crash_tail()
                detail = err.strip()
                if crash:
                    detail = (detail + "\n[ocr] worker 崩溃日志(easyocr_crash.log):\n" + crash).strip()
                logger.error(f"[ocr] EasyOCR worker 启动即崩溃: {detail}")
                # ⭐ 检测 CUDA 相关崩溃（access violation / torch 错误）→ 增加 OOM 计数，下次强制 CPU
                if crash and ("access violation" in crash.lower() or "torch" in crash.lower()):
                    self._easyocr_cuda_oom_count += 1
                    logger.warning(f"[ocr] 检测到 CUDA 崩溃，累计{self._easyocr_cuda_oom_count}次，下次可能强制 CPU")
                # ⭐ 检测页面文件不足（WinError 1455）→ 长期冷却，不反复重试
                _is_pagefile_error = "页面文件" in str(detail) or "1455" in str(detail)
                if _is_pagefile_error:
                    self._easyocr_retry_until = time.time() + 3600  # 1小时冷却（系统级问题）
                    logger.error("[ocr] ⚠️ 页面文件不足(WinError 1455)，EasyOCR 冷却1小时。"
                                 "建议：增大 Windows 页面文件大小（系统属性→高级→性能→虚拟内存）")
                else:
                    self._easyocr_retry_until = time.time() + 30
                self._easyocr_proc = None
                return False
            try:
                payload = json.loads(line)
                if payload.get("ready"):
                    logger.debug("[ocr] EasyOCR 子进程就绪")
                    return True
            except Exception:
                pass
            # 非 ready 响应 → 协议异常
            logger.error(f"[ocr] EasyOCR worker 异常响应: {line[:100]!r}")
            self._easyocr_proc.kill()
            self._easyocr_proc.wait(timeout=3)
            self._easyocr_proc = None
            self._easyocr_retry_until = time.time() + 30
            return False
        except Exception as e:
            logger.error(f"[ocr] EasyOCR 握手失败: {e}")
            try:
                if self._easyocr_proc and self._easyocr_proc.poll() is None:
                    self._easyocr_proc.kill()
            except Exception:
                pass
            self._easyocr_proc = None
            self._easyocr_retry_until = time.time() + 30
            return False

    def _call_easyocr_safe(self, img_np, timeout: Optional[float] = None) -> Optional[str]:
        """通过子进程安全调用 EasyOCR。返回识别文本，失败/崩溃/超时时返回 None。
        
        使用 _easyocr_lock 保护子进程 stdin/stdout，避免 QQ/微信独立线程并发写乱。
        timeout — 子进程读取超时秒数，None=无限等待；超时后杀死子进程下次重启。
        """
        import io
        import base64

        if not self._ensure_easyocr_subprocess():
            return None

        try:
            # numpy → PIL → PNG bytes → base64
            img_pil = Image.fromarray(img_np)
            buf = io.BytesIO()
            img_pil.save(buf, format='PNG')
            img_b64 = base64.b64encode(buf.getvalue()).decode()

            with self._easyocr_lock:
                # ⚠ 竞态保护：另一个线程可能已杀死进程并设 None
                if not self._easyocr_proc or self._easyocr_proc.poll() is not None:
                    return None
                self._easyocr_proc.stdin.write(json.dumps({"img": img_b64}) + "\n")
                self._easyocr_proc.stdin.flush()

                from queue import Queue, Empty as _QueueEmpty
                # readline 包装超时：用 daemon 线程 + Queue 实现跨平台
                if timeout is not None:
                    _q = Queue()
                    def _read_worker():
                        try:
                            proc = self._easyocr_proc
                            if proc and proc.poll() is None:
                                _q.put(proc.stdout.readline())
                        except Exception:
                            pass
                    _t = threading.Thread(target=_read_worker, daemon=True)
                    _t.start()
                    # ⭐ 急停检查：轮询 _running，急停后立即放弃等待（丢弃未出结果的 OCR）
                    _deadline = time.time() + timeout
                    line = None
                    while self._running and time.time() < _deadline:
                        try:
                            line = _q.get(timeout=0.05)
                            break
                        except _QueueEmpty:
                            continue
                    if line is None:
                        if not self._running:
                            logger.debug("[ocr] EasyOCR 等待期间急停，丢弃未出结果的 OCR 请求")
                        else:
                            self._easyocr_consecutive_failures += 1
                            if self._easyocr_consecutive_failures >= self._easyocr_max_failures:
                                logger.debug(f"[ocr] EasyOCR 连续{self._easyocr_consecutive_failures}次超时，杀子进程重来")
                                try:
                                    if self._easyocr_proc and self._easyocr_proc.poll() is None:
                                        self._easyocr_proc.kill()
                                except Exception:
                                    pass
                                self._easyocr_proc = None
                                self._easyocr_consecutive_failures = 0
                            else:
                                logger.debug(f"[ocr] EasyOCR 第{self._easyocr_consecutive_failures}次超时({timeout}s)，保留子进程不杀")
                        return None
                else:
                    line = self._easyocr_proc.stdout.readline()
                if not line:
                    crash = _read_easyocr_crash_tail()
                    msg = "EasyOCR 子进程 stdout 关闭"
                    if crash:
                        msg += f"（崩溃日志: {crash}）"
                    raise ConnectionError(msg)
            result = json.loads(line)
            if result.get("ok"):
                # 成功 → 重置连续失败计数
                self._easyocr_consecutive_failures = 0
                # 计数 + 主动重启：EasyOCR GPU 内存泄漏累积 → OOM → 冻结
                self._easyocr_call_count += 1
                if self._easyocr_call_count >= self._easyocr_max_calls:
                    logger.debug(f"[ocr] EasyOCR 正常资源释放：{self._easyocr_max_calls}次调用完成，重启子进程清GPU缓存（非错误，不计入失败计数器）")
                    try:
                        if self._easyocr_proc and self._easyocr_proc.poll() is None:
                            self._easyocr_proc.kill()
                            self._easyocr_proc.wait(timeout=3)
                    except Exception:
                        pass
                    self._easyocr_proc = None
                    self._easyocr_call_count = 0
                return result["text"]
            else:
                err = result.get('error', '?')[:100]
                logger.debug(f"[ocr] EasyOCR worker 错误: {err}")
                # ⭐ CUDA OOM / kernel error：worker 即将自杀退出（context 已损坏），
                #   这里立即确认杀掉 + 冷却，避免后续轮询继续往坏进程发图
                if 'cuda' in err.lower() or 'out of memory' in err.lower():
                    self._easyocr_cuda_oom_count += 1
                    logger.warning(
                        f"[ocr] EasyOCR CUDA 错误(累计{self._easyocr_cuda_oom_count}次)，"
                        f"杀子进程+冷却，{('下次强制CPU' if self._easyocr_cuda_oom_count >= 2 else '保持GPU')}")
                    try:
                        if self._easyocr_proc and self._easyocr_proc.poll() is None:
                            self._easyocr_proc.kill()
                            self._easyocr_proc.wait(timeout=3)
                    except Exception:
                        pass
                    self._easyocr_proc = None
                    self._easyocr_retry_until = time.time() + 30
                return None
        except (BrokenPipeError, ConnectionError, OSError) as e:
            logger.debug(f"[ocr] EasyOCR 子进程通信断开: {e}，30s 后自动重试")
            self._easyocr_proc = None
            self._easyocr_retry_until = time.time() + 30  # 冷却后自动重试，不永久 broken
            return None
        except Exception as e:
            logger.debug(f"[ocr] EasyOCR 子进程异常: {e}")
            return None

    @staticmethod
    def _score_ocr_text(text: str) -> float:
        """为 OCR 结果质量打分（越高越好）。对比引擎用。"""
        if not text or len(text.strip()) < 5:
            return 0.0
        score = 0.0
        # 1) 有效 CJK 数量（越多 = 识别越好）
        cjk = sum(1 for c in text if '\u4e00' <= c <= '\u9fff')
        score += cjk * 0.5
        # 2) Unicode 垃圾字符扣分（OCR 常见误识碎片）
        junk = set('勖彐丬亻俨冉勹刂冫孑亠丷')
        junk_count = sum(1 for c in text if c in junk)
        score -= junk_count * 3
        # 3) CJK 间空格比例扣分（Windows OCR 特有毛病）
        #    "你 好" vs "你好" — 空格越多说明识别越差
        total = len(text)
        spaces = text.count(' ')
        if total > 0 and cjk > 0:
            space_penalty = (spaces / total) * 10
            score -= space_penalty
        # 4) 时间戳加分 = 消息结构更完整
        timestamps = len(re.findall(r'\d{1,2}:\d{2}', text))
        score += min(timestamps * 2, 6)
        return max(score, 0.0)

    def _pick_ocr_text(self, win_text: str, easy_text: str, image: Image.Image) -> tuple:
        """双引擎对比，选质量更高的结果。日志记录引擎胜负统计。返回 (text, engine_name)。

        ⭐ 长度保护：当一引擎识别行数显著多于另一方（>=1.5x）时，
        即使分数略低也优先选更长文本——避免 Windows OCR 截断丢消息。
        """
        if not easy_text:
            return (win_text, "windows")
        if not win_text:
            return (easy_text, "easyocr")
        win_score = self._score_ocr_text(win_text)
        easy_score = self._score_ocr_text(easy_text)
        win_lines = len([l for l in win_text.split('\n') if l.strip()])
        easy_lines = len([l for l in easy_text.split('\n') if l.strip()])
        win_len = len(win_text.strip())
        easy_len = len(easy_text.strip())

        # 长度保护：一方行数 >= 1.5x 另一方 → 倾向更长文本（分数差 < 10 时触发）
        chosen = "windows" if win_score >= easy_score else "easyocr"
        score_diff = abs(win_score - easy_score)
        if score_diff < 10:
            if easy_lines >= win_lines * 1.5 and easy_len > win_len * 1.3:
                chosen = "easyocr"
                logger.debug(
                    f"[ocr] 长度保护: easy行数{easy_lines}>=1.5x win行数{win_lines}，"
                    f"分数差仅{score_diff:.1f}，强制选easyocr"
                )
            elif win_lines >= easy_lines * 1.5 and win_len > easy_len * 1.3:
                chosen = "windows"
                logger.debug(
                    f"[ocr] 长度保护: win行数{win_lines}>=1.5x easy行数{easy_lines}，"
                    f"分数差仅{score_diff:.1f}，强制选windows"
                )

        self._ocr_engine_wins[chosen] = self._ocr_engine_wins.get(chosen, 0) + 1
        total = sum(self._ocr_engine_wins.values())
        ratio = self._ocr_engine_wins.get(chosen, 0) / max(total, 1)
        logger.debug(
            f"[ocr] 引擎对比: win={win_score:.1f}(行{win_lines},字符{win_len}) "
            f"vs easy={easy_score:.1f}(行{easy_lines},字符{easy_len}) "
            f"→ 选{chosen}(分数差{score_diff:.1f}, 胜率{ratio:.0%}, {total}轮)"
        )
        return (win_text, chosen) if chosen == "windows" else (easy_text, chosen)

    def _safe_screenshot(self, bbox: tuple, timeout: float = 3.0):
        """带超时的屏幕截图。ImageGrab.grab() 的 BitBlt 可能因 DWM 卡死→整机冻结 2-3min。

        用线程+timeout 隔离：BitBlt 卡死只杀线程，不波及 DWM/桌面。
        timeout=3.0: 3 秒截不到就跳过本轮，bot 继续下次轮询。
        ⭐ 等待期间轮询 _running：急停/停止后立即折返，不等截屏结果。
        """
        _im = [None]
        def _grab():
            try:
                _im[0] = ImageGrab.grab(bbox=bbox)
            except Exception:
                pass

        import threading
        t = threading.Thread(target=_grab, daemon=True)
        t.start()
        # ⭐ 急停检查：join 期间轮询 _running，急停/停止后立即折返，不等截屏结果
        deadline = time.time() + timeout
        while self._running and t.is_alive() and time.time() < deadline:
            t.join(0.05)
        if t.is_alive():
            if not self._running:
                logger.debug("[ocr] 截图期间急停，丢弃未完成的截屏")
            else:
                logger.warning(f"[ocr] 截图超时 ({timeout}s)，BitBlt 可能卡在 DWM，跳过本轮")
            return None
        return _im[0]

    def _ocr_dual_engine(self, im_processed: Image.Image, im_original: Image.Image, platform: str) -> tuple:
        """双引擎并发 OCR：Windows OCR + EasyOCR 同时跑，最多等 10 秒。

        哪個先出用哪個，兩個都出時 _pick_ocr_text 質量對比選優。

        im_processed: 预处理后的图（2x resize + sharpen + contrast, RGBA）
        im_original:  原始截图（bad allocation 降级用）

        返回 (raw_text, engine_name) 含義同 _pick_ocr_text。

        ⚠ 不用 ThreadPoolExecutor with 块：__exit__ 调 shutdown(wait=True) 会在
        Windows OCR 卡死时永久阻塞主线程 → 电脑冻结。改用 daemon 线程 + join(timeout)。
        """

        engine = self._ocr_ensure_engine()
        if not engine:
            return ("", "")

        win_text: list[str] = [""]
        easy_text: list[str] = [""]

        def _win_worker():
            try:
                im = im_processed
                if im.mode != 'RGBA':
                    im = im.convert('RGBA')
                sb = SoftwareBitmap(BitmapPixelFormat.RGBA8, im.width, im.height)
                sb.copy_from_buffer(im.tobytes())
                # recognize_async().get() 无超时保护——卡死会冻住整个线程
                op = engine.recognize_async(sb)
                result = op.get()  # ⚠ 此处可能卡死：Windows OCR 引擎无响应
                win_text[0] = result.text.strip()
            except (RuntimeError, OSError) as e:
                estr = str(e)
                if "bad allocation" in estr or "memory" in estr.lower():
                    try:
                        im2 = im_original
                        if im2.mode != 'RGBA':
                            im2 = im2.convert('RGBA')
                        sb2 = SoftwareBitmap(BitmapPixelFormat.RGBA8, im2.width, im2.height)
                        sb2.copy_from_buffer(im2.tobytes())
                        op2 = engine.recognize_async(sb2)
                        result2 = op2.get()
                        win_text[0] = result2.text.strip()
                    except Exception:
                        pass
                # 其他异常静默处理

        def _easy_worker():
            if not _HAS_EASYOCR or self._easyocr_broken:
                return
            # EasyOCR 用原图（1x）：2x 图送 GPU 显存压力大 + 加速泄漏
            img_np = _np.array(im_original)
            # inner timeout 必须 < 外层 _OCR_TIMEOUT (10s)，
            # 否则线程永远在外层 join 超时前不会结束 → 永远 "线程存活，跳过"。
            _inner_timeout = max(_OCR_TIMEOUT - 1, 1)
            text = self._call_easyocr_safe(img_np, timeout=_inner_timeout)
            if text:
                easy_text[0] = text

        # ── 用 daemon 线程替代 ThreadPoolExecutor ──
        # ThreadPoolExecutor.__exit__ 调 shutdown(wait=True) 会永久阻塞主线程。
        # daemon 线程：join 超时后直接丢弃，线程随进程退出自动回收。
        _t_win = threading.Thread(target=_win_worker, daemon=True, name="ocr-win")
        _t_easy = threading.Thread(target=_easy_worker, daemon=True, name="ocr-easy")

        _t_win.start()
        _t_easy.start()

        # ⭐ 急停检查：join 期间轮询 _running，急停/停止后立即折返，不等 OCR 结果
        _OCR_TIMEOUT = 10.0  # 总超时秒数（单次OCR请求）
        _deadline = time.time() + _OCR_TIMEOUT
        while self._running and time.time() < _deadline:
            if not _t_win.is_alive() and not _t_easy.is_alive():
                break
            _t_win.join(0.05)
            _t_easy.join(0.05)
        if not self._running:
            logger.debug(f"[{platform}] 双引擎 OCR 期间急停，丢弃未出结果的 OCR")

        # 超时的线程还在跑？记录警告，不阻塞——daemon 线程随进程退出自动回收
        if _t_win.is_alive():
            logger.warning(f"[{platform}] Windows OCR 超时({_OCR_TIMEOUT}s)线程存活，跳过")
        if _t_easy.is_alive():
            logger.warning(f"[{platform}] EasyOCR 超时({_OCR_TIMEOUT}s)线程存活，跳过")

        wt = win_text[0]
        et = easy_text[0]

        # 日志（原始输出逐行记录，用於長期對比兩引擎能力）
        if wt:
            for i, l in enumerate(wt.split('\n')):
                if l.strip():
                    logger.info(f"[ocr] [windows/原始] line[{i}]: {l.strip()[:120]!r}")
        if et:
            for i, l in enumerate(et.split('\n')):
                if l.strip():
                    logger.info(f"[ocr] [easyocr/原始] line[{i}]: {l.strip()[:120]!r}")

        if not wt and not et:
            return ("", "")

        return self._pick_ocr_text(wt, et, im_processed)

    def _ocr_read_qq(self) -> list:
        """OCR 截屏 QQ 消息区域 -> 双引擎（Windows OCR + EasyOCR）提取文本。
        包含窗口验证 + 垃圾过滤 + 连续垃圾清缓存。
        """
        # 同平台冷却：回复后 15s 内跳过，防读到自身回复回声
        # 冷却期间也设 _ocr_unchanged → _read_messages 跳过所有 fallback
        # （_read_via_clipboard_once 调 _ensure_foreground → AttachThreadInput → 崩 TIM Electron）
        if time.time() < self._self_reply_cooldown_until.get("qq", 0):
            self._ocr_unchanged["qq"] = True
            return []
        hwnd = self._cached_hwnd.get("qq")
        if not hwnd:
            return []
        if not self._validate_qq_window(hwnd):
            gc = self._ocr_garbage_count.get("qq", 0) + 1
            self._ocr_garbage_count["qq"] = gc
            if gc == 1:
                # 首次失败时详细日志
                visible = win32gui.IsWindowVisible(hwnd) if win32gui.IsWindow(hwnd) else False
                iconic = win32gui.IsIconic(hwnd) if win32gui.IsWindow(hwnd) else False
                logger.debug(f"[qq] OCR: 窗口不可用(visible={visible}, iconic={iconic})")
            if gc >= 3:
                logger.info("[qq] OCR: 窗口不合法连续3次，清缓存")
                self._cached_hwnd.pop("qq", None)
                self._cached_pid.pop("qq", None)
                self._app_variant.pop("qq", None)
                self._ocr_garbage_count["qq"] = 0
            return []
        engine = self._ocr_ensure_engine()
        if not engine:
            return []
        try:
            # ⚠️ 急停检查：截屏+OCR是耗时操作，开始前必须检查
            if not self._running:
                return []
            # ⭐ 先唤醒再取窗口 rect（最小化恢复后位置会变化），再截屏
            # ImageGrab.grab 截整屏坐标，若 QQ 被遮挡(用户停在终端)截到的就是遮挡物
            if not self._ensure_visible(hwnd):
                logger.debug("[qq] 窗口不可见，退避5秒(用户可能在接管)")
                # 退避期间也要检查急停，避免阻塞5秒
                for _ in range(50):
                    if not self._running:
                        return []
                    time.sleep(0.1)
                return []
            time.sleep(0.4)
            rect = win32gui.GetWindowRect(hwnd)
            if not rect:
                return []
            left, top, right, bottom = rect
            win_w = right - left
            win_h = bottom - top
            # QQ NT 窗口布局: ~0-5% 标签栏, ~5-30% 联系人/群列表, ~30-55% 会话列表, ~55-100% 消息面板

            variant = self._app_variant.get("qq", "")
            # TIM (Electron) 安全：不做 PostMessage 点击 + 不做 keybd_event 全局键
            # 只做 PostMessage VK_END（异步，安全），避免干扰 Electron 渲染进程
            if variant == "tim":
                win32gui.PostMessage(hwnd, win32con.WM_KEYDOWN, win32con.VK_END, 0)
                win32gui.PostMessage(hwnd, win32con.WM_KEYUP, win32con.VK_END, 0)
                time.sleep(0.3)
            else:
                # 点一下消息面板区域设置焦点（QQ NT 默认焦点在会话列表，VK_END 只会滚会话列表）
                try:
                    click_x = int(win_w * 0.72)   # 消息面板中心偏右
                    click_y = int(win_h * 0.50)
                    lparam = win32api.MAKELONG(click_x, click_y)
                    win32gui.PostMessage(hwnd, win32con.WM_LBUTTONDOWN, win32con.MK_LBUTTON, lparam)
                    win32gui.PostMessage(hwnd, win32con.WM_LBUTTONUP, 0, lparam)
                    logger.debug(f"[qq] 点击消息面板({click_x},{click_y})设置焦点")
                    time.sleep(0.15)
                except Exception as e:
                    logger.debug(f"[qq] 点击消息面板失败: {e}")

                # Ctrl+End 滚动到底部，只截最新消息（避开历史堆积+bot 旧回复）
                VK_CONTROL = 0x11
                VK_END = 0x23
                # 方式A: keybd_event（窗口在前台时生效）
                ctypes.windll.user32.keybd_event(VK_CONTROL, 0, 0, 0)
                ctypes.windll.user32.keybd_event(VK_END, 0, 0, 0)
                time.sleep(0.05)
                ctypes.windll.user32.keybd_event(VK_END, 0, 2, 0)
                ctypes.windll.user32.keybd_event(VK_CONTROL, 0, 2, 0)
                # 方式B: PostMessage 兜底（keybd_event 可能被 TIM 忽略）
                win32gui.PostMessage(hwnd, win32con.WM_KEYDOWN, win32con.VK_END, 0)
                win32gui.PostMessage(hwnd, win32con.WM_KEYUP, win32con.VK_END, 0)
                time.sleep(0.3)
            # TIM/QQ 窗口布局: ~5-30% 左栏, ~30-50% 会话列表(含文档预览), ~50-100% 消息面板
            # cap_left=25% 继续右移（用户反馈20%仍会捕捉到消息列表的时间戳，干扰消息判定）
            cap_left = int(left + win_w * 0.25)
            cap_top = top + max(80, int(win_h * 0.06))      # 跳过标题栏+群名头栏
            cap_right = int(left + win_w * 0.78)            # 跳过右栏群成员列表(~80%+) 和滚动条
            cap_bottom = bottom - max(100, int(win_h * 0.10))  # 输入框上方
            if cap_right <= cap_left or cap_bottom <= cap_top:
                return []
            im = self._safe_screenshot((cap_left, cap_top, cap_right, cap_bottom))
            if im is None:
                return []
            if im.width < 50 or im.height < 50:
                return []

            # 保存调试截图（在颜色/哈希检查之前，即使跳过也有图可查）
            _dbg_path = ""
            try:
                debug_dir = _get_ocr_raw_dir("qq")
                im.save(_dbg_path, format="PNG")
                # 删除放缓：不在这里立即清理，改由 _maybe_clean_ocr_dir 每 30~60s 随机定时清理
                if os.path.exists(_dbg_path):
                    logger.info(f"[qq] 调试截图已保存: {_dbg_path}")
                else:
                    logger.warning(f"[qq] 调试截图保存后未找到文件: {_dbg_path}")
            except Exception as e:
                logger.warning(f"[qq] 调试截图保存失败: {e} (路径: {_dbg_path})")

            # ⭐ 颜色像素检测：如果截图中只有 bot 蓝色气泡，无白色用户消息，跳过
            if not self._has_user_colors(im, "qq"):
                self._ocr_unchanged["qq"] = True
                logger.debug(f"[qq] 像素检测: 无对方消息, 跳过OCR (截图: {os.path.basename(_dbg_path)})")
                return []
            # ⭐ 截图 hash：像素级指纹——内容没变就直接跳过整轮（easyocr 同一截图每次输出不同文本）
            # dHash + 5秒强制刷新：即使hash相同，每5秒也强制做一次OCR，防止永久卡死
            h = self._image_hash(im)
            now = time.time()
            last_hash = self._last_screenshot_hash.get("qq", "")
            last_time = self._last_ocr_time.get("qq", 0)
            if h == last_hash and (now - last_time) < 5:
                self._ocr_unchanged["qq"] = True
                logger.debug(f"[qq] 截图 hash 相同，屏幕无变化，跳过本轮")
                return []
            self._last_screenshot_hash["qq"] = h
            self._last_ocr_time["qq"] = now
            self._ocr_unchanged.pop("qq", None)

            # 图像预处理：提升 Windows OCR 识别准确率
            # Windows OCR 对低 DPI/未处理截图识别差——CJK 空格、字符混淆
            # 2x LANCZOS 放大 + 锐化 + 对比度增强
            # ⚠️ 锐化/对比度过高会导致汉字边缘断裂成偏旁部首
            im_original = im  # 保留原图，bad allocation 时降级
            try:
                im = im.resize((im.width * 2, im.height * 2), Image.LANCZOS)
                im = ImageEnhance.Sharpness(im).enhance(1.2)  # 降低锐化，防字符断裂
                im = ImageEnhance.Contrast(im).enhance(1.2)   # 降低对比度，保持笔画连贯
                logger.debug(f"[ocr] 预处理: resize 2x + sharpen(1.2) + contrast(1.2)")
                    # 保存OCR处理后的图片（JPG格式）用于肉眼对比
                try:
                    debug_dir = _get_ocr_processed_dir("qq")
                    ts = time.strftime("%Y%m%d_%H%M%S")
                    _processed_path = os.path.join(debug_dir, f"ocr_processed_qq_{ts}.jpg")
                    # 转换为RGB模式保存JPG（不支持RGBA）
                    if im.mode == 'RGBA':
                        im_rgb = im.convert('RGB')
                    else:
                        im_rgb = im
                    im_rgb.save(_processed_path, format="JPEG", quality=95)
                    # 删除放缓：不在这里立即清理，改由 _maybe_clean_ocr_dir 每 30~60s 随机定时清理
                    if os.path.exists(_processed_path):
                        logger.debug(f"[qq] OCR处理后图片已保存: {_processed_path}")
                except Exception as e:
                    logger.debug(f"[qq] OCR处理后图片保存失败: {e}")
            except Exception as e:
                logger.debug(f"[ocr] 预处理失败(跳过): {e}")

            # ── 双引擎并发 OCR（Windows OCR + EasyOCR 同时跑，最多等 10 秒）──
            raw_text, chosen_engine = self._ocr_dual_engine(im, im_original, "qq")
            if not raw_text:
                return []
            self._last_chosen_engine["qq"] = chosen_engine
            return self._process_ocr_output(raw_text, "qq")
        except Exception as e:
            logger.debug(f"[qq] OCR失败: {e}")
            return []

    def _ocr_read_wechat(self) -> list:
        """OCR 截屏微信消息区域 -> 双引擎提取文本。

        微信 UIA 树不暴露聊天消息内容（新版微信 UIA 架构变化），必须用 OCR。
        微信自绘控件，keybd_event 无法滚动，只截屏当前可见区域。
        """
        # 同平台冷却：回复后 15s 内跳过，防读到自身回复回声
        if time.time() < self._self_reply_cooldown_until.get("wechat", 0):
            return []
        hwnd = self._cached_hwnd.get("wechat")
        if not hwnd:
            return []
        if not win32gui.IsWindow(hwnd):
            self._cached_hwnd.pop("wechat", None)
            self._cached_pid.pop("wechat", None)
            return []

        engine = self._ocr_ensure_engine()
        if not engine:
            return []

        try:
            # ⚠️ 急停检查：截屏+OCR是耗时操作，开始前必须检查
            if not self._running:
                return []
            # ⭐ 先唤醒再截屏：ImageGrab.grab 截整屏坐标，若微信被遮挡(用户停在终端)
            # 截到的就是遮挡物。唤醒后才取窗口 rect（最小化恢复后位置会变化）。
            # 用 _ensure_foreground（AttachThreadInput 强置前）：微信原生窗口安全。
            # 若置前失败但窗口仍然可见(未被最小化/隐藏)，仍应尝试截图，
            # 与QQ逻辑一致：只要窗口在屏幕上就截，避免漏掉消息。
            fg_ok = self._ensure_foreground(hwnd)
            if not fg_ok:
                # 检查窗口是否可见（未被最小化到托盘/隐藏）
                root_hwnd = win32gui.GetAncestor(hwnd, win32con.GA_ROOT)
                is_visible = root_hwnd and win32gui.IsWindowVisible(root_hwnd) and not win32gui.IsIconic(root_hwnd)
                if is_visible:
                    logger.debug("[wechat] 窗口未获得前台但仍然可见，继续截图")
                else:
                    logger.debug("[wechat] 窗口未前置且不可见，退避5秒(用户可能在接管)")
                    # ⭐ 保存"窗口不可见"现场截图：即使整轮跳过也有图可查
                    try:
                        _r = win32gui.GetWindowRect(hwnd)
                        if _r and (_r[2] - _r[0]) > 200 and (_r[3] - _r[1]) > 100:
                            _im = self._safe_screenshot((_r[0], _r[1], _r[2], _r[3]))
                            if _im is not None and _im.width > 50 and _im.height > 50:
                                debug_dir = _get_ocr_raw_dir("wechat")
                                _ts = datetime.now().strftime('%Y%m%d_%H%M%S.%f')[:19]
                                _p = os.path.join(debug_dir, f"ocr_debug_wx_{_ts}.png")
                                _im.save(_p, format="PNG")
                                logger.info(f"[wechat] 窗口不可见现场截图已保存: {_p}")
                    except Exception as _e:
                        logger.debug(f"[wechat] 现场截图保存失败: {_e}")
                    # 退避期间也要检查急停，避免阻塞5秒
                    for _ in range(50):
                        if not self._running:
                            return []
                        time.sleep(0.1)
                    return []
            time.sleep(0.4)  # 让 DWM 完成窗口激活的合成，防紧接 BitBlt 卡死

            rect = win32gui.GetWindowRect(hwnd)
            if not rect:
                return []
            left, top, right, bottom = rect
            win_w = right - left
            win_h = bottom - top

            # WeChat 窗口布局: ~0-6% icon tab栏, ~6-32% 会话列表, ~32-98% 消息面板
            # 左边界 30% 跳过会话列表（含通讯录/视频号/游戏中心等快捷入口）— 原34%太右，用户消息被裁切
            # 顶部跳过导航栏（微信/通讯录/朋友圈/视频号 tab）
            cap_left = int(left + win_w * 0.30)
            cap_top = top + max(80, int(win_h * 0.08))
            cap_right = right - max(20, int(win_w * 0.02))    # 跳过滚动条+右边框（2%宽度）
            cap_bottom = bottom - max(65, int(win_h * 0.07))  # 跳过输入框
            if cap_right <= cap_left or cap_bottom <= cap_top:
                return []

            im = self._safe_screenshot((cap_left, cap_top, cap_right, cap_bottom))
            if im is None:
                return []
            if im.width < 50 or im.height < 50:
                return []

            # 保存调试截图（在颜色/哈希检查之前，即使跳过也有图可查）
            _dbg_path = ""
            try:
                debug_dir = _get_ocr_raw_dir("wechat")
                ts = datetime.now().strftime('%Y%m%d_%H%M%S.%f')[:19]
                _dbg_path = os.path.join(debug_dir, f"ocr_debug_wx_{ts}.png")
                im.save(_dbg_path, format="PNG")
                # 删除放缓：不在这里立即清理，改由 _maybe_clean_ocr_dir 每 30~60s 随机定时清理
                if os.path.exists(_dbg_path):
                    logger.info(f"[wechat] 调试截图已保存: {_dbg_path}")
                else:
                    logger.warning(f"[wechat] 调试截图保存后未找到文件: {_dbg_path}")
            except Exception as e:
                logger.warning(f"[wechat] 调试截图保存失败: {e} (路径: {_dbg_path})")

            # ⭐ 颜色像素检测：如果截图中只有自身绿色气泡，无对方白色消息，跳过
            if not self._has_user_colors(im, "wechat"):
                self._ocr_unchanged["wechat"] = True
                logger.debug(f"[wechat] 像素检测: 无对方消息(自身消息已过滤), 跳过OCR")
                return []

            # ⭐ 截图 hash：像素级指纹——内容没变就直接跳过整轮
            # dHash + 5秒强制刷新：即使hash相同，每5秒也强制做一次OCR，防止永久卡死
            h = self._image_hash(im)
            now = time.time()
            last_hash = self._last_screenshot_hash.get("wechat", "")
            last_time = self._last_ocr_time.get("wechat", 0)
            if h == last_hash and (now - last_time) < 5:
                self._ocr_unchanged["wechat"] = True
                logger.debug(f"[wechat] 截图 hash 相同，屏幕无变化，跳过本轮")
                return []
            self._last_screenshot_hash["wechat"] = h
            self._last_ocr_time["wechat"] = now
            self._ocr_unchanged.pop("wechat", None)

            # 图像预处理（同 QQ）
            # ⚠️ 锐化/对比度过高会导致汉字边缘断裂成偏旁部首
            im_original = im  # 保留原图，bad allocation 时降级
            try:
                im = im.resize((im.width * 2, im.height * 2), Image.LANCZOS)
                im = ImageEnhance.Sharpness(im).enhance(1.2)  # 降低锐化，防字符断裂
                im = ImageEnhance.Contrast(im).enhance(1.2)   # 降低对比度，保持笔画连贯
                # 保存OCR处理后的图片（JPG格式）用于肉眼对比
                try:
                    debug_dir = _get_ocr_processed_dir("wechat")
                    ts = datetime.now().strftime('%Y%m%d_%H%M%S.%f')[:19]
                    _processed_path = os.path.join(debug_dir, f"ocr_processed_wx_{ts}.jpg")
                    # 转换为RGB模式保存JPG（不支持RGBA）
                    if im.mode == 'RGBA':
                        im_rgb = im.convert('RGB')
                    else:
                        im_rgb = im
                    im_rgb.save(_processed_path, format="JPEG", quality=95)
                    # 删除放缓：不在这里立即清理，改由 _maybe_clean_ocr_dir 每 30~60s 随机定时清理
                    if os.path.exists(_processed_path):
                        logger.debug(f"[wechat] OCR处理后图片已保存: {_processed_path}")
                except Exception as e:
                    logger.debug(f"[wechat] OCR处理后图片保存失败: {e}")
            except Exception as e:
                logger.debug(f"[wechat] OCR 预处理失败(跳过): {e}")

            # ── 双引擎并发 OCR（Windows OCR + EasyOCR 同时跑，最多等 10 秒）──
            raw_text, chosen_engine = self._ocr_dual_engine(im, im_original, "wechat")
            if not raw_text:
                return []
            self._last_chosen_engine["wechat"] = chosen_engine
            return self._process_ocr_output(raw_text, "wechat")
        except Exception as e:
            logger.debug(f"[wechat] OCR失败: {e}")
            return []

    def _process_ocr_output(self, raw_text: str, platform: str) -> list:
        """OCR 原始文本的通用后处理：垃圾检测 → 时间戳分割 → 过滤清洗。

        供 QQ / 微信 OCR 路径共用。
        """
        # ⚠️ 急停检查：OCR 文本处理耗时，开始前检查
        if not self._running:
            return []
        # —— WeChat 跨窗口污染检测：OCR 读到 QQ/TIM 调试输出时丢弃整批 ——
        if platform == "wechat":
            # 注意: WinOCR 输出带空格和全角符号（如"完 成 ： 553 chars"），
            #       EasyOCR 用 ASCII 符号。regex 需兼容两种。
            _cross_pollution_markers = [
                r'sharpen',                      # 图片预处理参数
                r'contrast\b',                   # 对比度参数
                r'设置焦点',                      # UIA 调试输出
                r'污染.*标记',                    # 自家 log: "污染（5/7标记）"
                r'丢弃.*整批',                    # 自家 log: "丢弃整批13 items"
                r'last=',                        # 自家 log: "last=\"关闭\""
                r'OCR\s*完\s*[成]',               # OCR完成 / OCR 完 成  — 自家 log
                r'(?:完成|完成)\s*[:\uFF1A]\s*\d+\s+Char',  # 完成:553 chars / 完成 ： 553 Chars
                r'[（(]\s*\d+[\s,，\/]*\d+\s*[)）]',  # (1005,476) / （ 5 / 7 ）坐标
                r'原始\s*[\]）]',                  # 原始] / 原始 ]
                r'后处理\s*[\]）]',                # 后处理] / 后处理 ]
                r'line\s*[\[（]\s*[\d@]\s*[\])）]',  # line[0] / line [0] / line（0）
                r'reader\s*就绪',                  # reader就绪状态 / reader 就绪
                r'(?:扫描|跳过|丢弃)\s*本\s*轮',    # 跳过本轮 / 跳 过 本 轮 — 自家 log
            ]
            _hit = sum(1 for m in _cross_pollution_markers if re.search(m, raw_text, re.IGNORECASE))
            # WinOCR 给 CJK 加空格（"完 成 ： 553 chars"）→ raw regex 匹配不到
            # 归一化后再查一次，双路覆盖两种引擎格式
            if _hit < 2:
                norm = self._normalize_ocr_text(raw_text)
                _hit = sum(1 for m in _cross_pollution_markers if re.search(m, norm, re.IGNORECASE))
            if _hit >= 2:
                logger.warning(f"[{platform}] 跨窗口污染({_hit}/{len(_cross_pollution_markers)}标记)，丢弃整批")
                return []

        # —— 垃圾检测 ——
        if self._is_ocr_console_garbage(raw_text):
            gc = self._ocr_garbage_count.get(platform, 0) + 1
            self._ocr_garbage_count[platform] = gc
            if gc >= 3:
                logger.info(f"[{platform}] OCR: 垃圾连续3次，清缓存")
                self._cached_hwnd.pop(platform, None)
                self._cached_pid.pop(platform, None)
                self._ocr_garbage_count[platform] = 0
            return []
        self._ocr_garbage_count[platform] = 0
        self._ocr_last_text[platform] = raw_text

        # —— JSON/YAML 配置块剥离 ——
        # 微信 OCR 截屏范围 40%-98%，常把右侧文档/配置面板（JSON/YAML）一起截入
        # JSON 块（"key": value, {, }）和 YAML 块（key: value）跟用户消息混在一起
        # 在 split 前先剥离这些行，避免 JSON 碎片污染用户消息
        raw_text = self._strip_json_yaml_blocks(raw_text, platform)

        # —— 可见时间戳新鲜性检查 ——
        # 若文本中有可见时间戳（HH:MM），但全部过期（>300s），视为历史消息直接丢弃
        # 防止 OCR 混入旧消息内容误触发回复
        if not self._ocr_text_has_fresh_timestamp(raw_text, platform):
            logger.debug(f"[{platform}] OCR 历史消息(无可识别新鲜时间戳)，丢弃: {raw_text[:80]!r}")
            return []

        # —— 行切割 + 尾标清理 ——
        ocr_lines = []
        for l in raw_text.split('\n'):
            l = re.sub(r'\s*(?:[A-Za-z0-9]~)+\s*$', '', l).strip()
            if l:
                ocr_lines.append(l)
        engine_label = self._last_chosen_engine.get(platform, "")
        for i, rl in enumerate(ocr_lines):
            logger.info(f"[ocr] [{engine_label}/后处理] line[{i}]: {rl[:120]!r}")

        # —— 时间戳分割（跨行继承） ——
        expanded = []
        _inherited_ts = None  # 跨行继承：上一行的时间戳，供当前行无时间戳时使用
        for i, rl in enumerate(ocr_lines):
            before = rl
            rl = self._normalize_ocr_text(rl)
            logger.debug(f"[ocr] stage[{i}] normalize: len={len(before)} -> {rl[:120]!r}")
            rl = rl.replace('&', '')
            rl = rl.replace('：', ':')
            logger.debug(f"[ocr] stage[{i}] clean: len={len(rl)} -> {rl[:120]!r}")
            rl = re.sub(r'\s+', ' ', rl)
            # 移除中文日期前缀（昨天、前天、星期X等），只保留数字时间
            rl = re.sub(r'(昨天|前天|大前天|星期[一二三四五六日天]|\d+天前|今天|明天)\s*(?=\d{1,2}[:：.;]\d{1,2})', '', rl)
            # 标准化 EasyOCR 时间戳：16.47 → 16:47, 15;39 → 15:39, 16:03.41 → 16:03:41
            rl = re.sub(r'(\d{1,2})[.;](\d{2})(?:[.;](\d{2}))?', r'\1:\2:\3', rl)
            parts = re.split(r'(\d{1,2}:\d{1,2}(?::\d{1,2})?)', rl)
            logger.debug(f"[ocr] stage[{i}] split -> {len(parts)} parts: "
                         f"{[p[:60] for p in parts if p.strip()]}")
            buf = ''
            last_ts = _inherited_ts  # 继承前一行的时间戳
            for part in parts:
                if re.match(r'^\d{1,2}:\d{1,2}', part):
                    if buf.strip():
                        if not last_ts:
                            # ⭐ 无前置时间戳：此消息位于首个时间戳之前 = 更早的历史
                            #   （时间戳被裁切/漏识别）。无法验证新鲜性 → 丢弃，
                            #   防止"肉眼已不可见/被覆盖的旧消息"被误当新消息回复
                            logger.debug(f"[ocr] stage[{i}] 无时间戳归属，视为历史丢弃: {buf.strip()[:60]!r}")
                            buf = ''
                            last_ts = part
                            continue
                        _fresh = self._looks_fresh_content(buf.strip())
                        if last_ts and self._is_timestamp_old(last_ts, 300):
                            # 仅当时间戳不是太久（<600s）且内容明确新鲜时才放行
                            if _fresh and not self._is_timestamp_old(last_ts, 600):
                                logger.debug(f"[ocr] stage[{i}] 时间戳{last_ts}过旧({300}s)但较新且含新鲜特征，放行: {buf.strip()[:60]!r}")
                            else:
                                logger.debug(f"[ocr] stage[{i}] 时间戳{last_ts}过旧({300}s)，跳过: {buf.strip()[:60]!r}")
                                buf = ''
                                last_ts = part
                                continue
                        if self._is_markdown_document(buf.strip()):
                            logger.debug(f"[ocr] stage[{i}] md文档直接跳过: {buf.strip()[:80]!r}")
                        elif self._is_noise_text(buf.strip()):
                            logger.debug(f"[ocr] stage[{i}] 噪声文本跳过: {buf.strip()[:80]!r}")
                        else:
                            msg = re.sub(r'\s*(?:[A-Za-z0-9]~)+\s*$', '', buf.strip())
                            if msg:
                                msg = re.sub(r'\s+#[\u4e00-\u9fff][^\s#\n]{0,30}$', '', msg).strip()
                                if msg:
                                    if self._is_reply_fragment(msg):
                                        logger.debug(f"[ocr] stage[{i}] 回复残片跳过: {msg[:60]!r}")
                                    else:
                                        logger.debug(f"[ocr] stage[{i}] 消息通过所有过滤器，添加到expanded: {msg[:60]!r}")
                                        expanded.append(msg)
                    buf = ''
                    last_ts = part
                else:
                    buf += part
            if buf.strip():
                # 尾部检查：如果最后一个可见时间戳已过期（≥300s），尾部内容也是历史消息
                # 注释：21:56:17清晰可见但已过期 → 尾部内容不应被当成新消息
                # ⚠ 例外：尾部含明确新鲜特征且时间戳<600s → 可能是无独立时间戳的新消息，放行
                if not last_ts:
                    # ⭐ 尾部无任何时间戳归属：整行无时间戳 → 无法验证新鲜性 → 丢弃
                    #   （若整批都无时间戳，_ocr_text_has_fresh_timestamp 已提前拦截）
                    logger.debug(f"[ocr] stage[{i}] 尾部无时间戳归属，视为历史丢弃: {buf.strip()[:60]!r}")
                    buf = ''
                else:
                    _fresh_tail = self._looks_fresh_content(buf.strip())
                    if last_ts and self._is_timestamp_old(last_ts, 300):
                        if _fresh_tail and not self._is_timestamp_old(last_ts, 600):
                            logger.debug(f"[ocr] stage[{i}] 尾部时间戳{last_ts}过旧但较新且含新鲜特征，放行: {buf.strip()[:60]!r}")
                        else:
                            logger.debug(f"[ocr] stage[{i}] 尾部时间戳{last_ts}已过期(≥{300}s)，跳过尾部: {buf.strip()[:60]!r}")
                            buf = ''
                    if buf.strip():
                        if self._is_markdown_document(buf.strip()):
                            logger.debug(f"[ocr] stage[{i}] md文档直接跳过(尾部): {buf.strip()[:80]!r}")
                        elif self._is_noise_text(buf.strip()):
                            logger.debug(f"[ocr] stage[{i}] 噪声文本跳过(尾部): {buf.strip()[:80]!r}")
                        else:
                            msg = re.sub(r'\s*(?:[A-Za-z0-9]~)+\s*$', '', buf.strip())
                            if msg:
                                msg = re.sub(r'\s+#[\u4e00-\u9fff][^\s#\n]{0,30}$', '', msg).strip()
                                if msg:
                                    if self._is_reply_fragment(msg):
                                        logger.debug(f"[ocr] stage[{i}] 回复残片跳过: {msg[:60]!r}")
                                    else:
                                        logger.debug(f"[ocr] stage[{i}] 尾部消息通过所有过滤器，添加到expanded: {msg[:60]!r}")
                                        # EasyOCR 常把横向相邻的两条消息（用户消息+群昵称/UI文字）
                                        # 检测为同一行，导致"兑换码导入错误时如何处置?游戏专用小筑憩-草一"
                                        # 这种合并文本。尝试在中文句尾标点处拆分为多条。
                                        split_msgs = self._split_merged_ocr_text(msg)
                                        for sm in split_msgs:
                                            expanded.append(sm)
            # 更新跨行继承时间戳
            if last_ts:
                _inherited_ts = last_ts

        # —— 逐行过滤 ——
        ocr_lines = expanded
        texts = []
        for line in ocr_lines:
            if not line:
                continue
            if line in ("查看更多", "收起", "选择会话开始聊天"):
                continue
            if re.match(r'^[✿♡♥❤★☆✦✧❀❁❂❃❄❅❆❇❈❉❊❋➠➡➢➣➤.·•●○◦◎◉◍◐◑◒◓◔◕◖◗◢◣◤◥☺☻☼♠♣♦♤♧♡♢♔♕♖♗♘♙🕐-🕧\s]{1,3}$', line):
                continue
            line = re.sub(r'^0+', '', line)
            line = re.sub(r'[勖彐"\'\s\u2000-\u206f]+$', '', line)
            # 末尾裸字母：OCR checkbox [V] 碎成 "? O"、"  O"、" V"
            line = re.sub(r'\s+[OV]\s*$', '', line)
            if not line:
                continue
            if re.match(r'^问题\d+\s*[:：]', line):
                continue
            if re.match(r'^[\d:\s]+$', line):
                continue
            line = re.sub(r'^\d+[\.．]\d+s?\s*\d*[．\.]?\d*', '', line)
            line = re.sub(r'^[\d．\.\s]{2,20}[一-鿿]{1,5}?[，。、]', '', line)
            if not line:
                continue
            if self._is_system_message(line):
                continue
            if re.search(r'群成员|索群成员|搜索成员', line):
                logger.debug(f"[{platform}] OCR 过滤: 群成员侧栏 line={line[:60]!r}")
                continue
            if re.match(r'^[^）】〕」]{2,40}[（【〔「][^）】〕」]{1,15}[）】〕」]', line):
                logger.debug(f"[{platform}] OCR 过滤: 群名头栏 line={line[:60]!r}")
                continue
            if re.match(r'^[一-鿿]{1}$', line):
                continue
            # OCR 碎片：≤8 字符且无中文 → 时间戳/checkbox 残片
            if len(line) <= 8 and not re.search(r'[\u4e00-\u9fff]', line):
                continue
            # OCR 随机字符垃圾：无中文 + 特殊字符比例高（如 `544UUJ1W H V=YJ~JL:e`）
            # EasyOCR 对头像/表情/特殊 UI 区域会输出这类无意义字母数字符号组合
            if not re.search(r'[\u4e00-\u9fff]', line) and len(line) >= 10:
                special_chars = sum(1 for c in line if c in '=~@#$%^&*_+{}[]|\\<>/`')
                alpha_count = sum(1 for c in line if c.isalpha())
                digit_count = sum(1 for c in line if c.isdigit())
                if special_chars / len(line) > 0.15 and alpha_count >= 2 and digit_count >= 2:
                    logger.debug(f"[{platform}] OCR 过滤: 随机字符垃圾 line={line!r}")
                    continue
            # checkbox 残片：`[V]` `[X]` `[√]` 开头，明显不是用户提问
            if re.match(r'^\[[VX√✗]\s*\](?:\s*[A-Za-z0-9_\-./]+)?\s*$', line):
                logger.debug(f"[{platform}] OCR 过滤: checkbox残片 line={line!r}")
                continue
            # 多 checkbox 碎片：一行含 2+ 个 [V] 标记，md 列表 OCR 残留
            if len(re.findall(r'\[\s*[VXvx√✗]\s*\]', line)) >= 2:
                logger.debug(f"[{platform}] OCR 过滤: 多checkbox碎片 line={line!r}")
                continue
            # 全角括号 md 链接碎片：`[text]（url` 或 `]（` — md 链接 OCR 全角退化
            if re.search(r'\]（', line):
                logger.debug(f"[{platform}] OCR 过滤: 全角括号碎片 line={line!r}")
                continue
            if re.match(r'^\d{1,2}[:：\s]\d{1,2}', line):
                continue
            if re.match(r'^\d{4}[/-]\d{1,2}', line):
                continue
            # ===== 主动防御: UI 子串黑名单 (全平台) =====
            # 含特定 UI 面板词的碎片直接丢弃，不依赖精确匹配
            if any(sub in line for sub in _UI_SUBSTR_BLOCKLIST):
                logger.debug(f"[{platform}] OCR 过滤: UI子串 line={line!r}")
                continue

            # ===== 主动防御: UI 按钮/标签黑名单 (精确匹配, 全平台) =====
            if line in _UI_EXACT_BLOCKLIST:
                logger.debug(f"[{platform}] OCR 过滤: UI黑名单 line={line!r}")
                continue

            # ===== 主动防御: 系统状态计数 (全平台) =====
            if re.search(r'(?:浏览|阅读|查看)\d+[个条款篇张次]', line):
                logger.debug(f"[{platform}] OCR 过滤: 浏览状态 line={line!r}")
                continue

            # ===== 主动防御: 多段数据面板 (全平台) =====
            segs = [s.strip() for s in re.split(r'[。；]', line) if s.strip()]
            if len(segs) >= 3:
                digit_segs = sum(1 for s in segs if re.search(r'\d', s))
                short_segs = sum(1 for s in segs if len(s) < 30)
                if digit_segs >= 2 and short_segs >= 3:
                    logger.debug(f"[{platform}] OCR 过滤: 数据面板 line={line!r}")
                    continue

            # ===== log/log排版残余: OCR 截到自身调试日志的尾巴 (全平台) =====
            # "] line[0]" "line[o]:" — 引擎日志行号残留
            if re.search(r'\]\s*line\s*\[\d', line, re.IGNORECASE):
                logger.debug(f"[{platform}] OCR 过滤: log行号 line={line!r}")
                continue
            # "Pkdown" — "markdown" 的 OCR 乱码碎片
            if re.search(r'[Pp]kdown', line):
                logger.debug(f"[{platform}] OCR 过滤: Pkdown碎片 line={line!r}")
                continue
            # "fragment skipped" — log 文本直接裸露
            if 'fragment skipped' in line.lower():
                logger.debug(f"[{platform}] OCR 过滤: fragment-skipped line={line!r}")
                continue
            # 引号前缀 OCR 残余: "' '玩家..." "'注册用户总数' ,"
            if re.match(r"^'+[\s,)]", line) or re.match(r"^'+[^']+'+\s*,", line):
                logger.debug(f"[{platform}] OCR 过滤: 引号残余 line={line!r}")
                continue
            # 引号后缀 OCR 残余: "注册用户总数' ,"（中文后跟引号逗号）
            if re.search(r"[\u4e00-\u9fff]'\s*,?\s*$", line):
                logger.debug(f"[{platform}] OCR 过滤: 引号尾缀 line={line!r}")
                continue

            # URL-only: 无中文且含 http/https → OCR 面板图片URL碎片
            # OCR 常把 https://img.ypshidifu.cn 识别为 httpsLlimgypshidifu（丢失 ://）
            if not re.search(r'[\u4e00-\u9fff]', line) and re.search(r'https?\S', line, re.IGNORECASE):
                logger.debug(f"[{platform}] OCR 过滤: URL-only碎片 line={line!r}")
                continue

            # —— 纯非中文乱码：QQ/微信中文群消息都至少有中文 ——
            # URL 被 OCR 啃成 hpsllimgypshidifu cnli/...（丢失 https://）时 URL-only 漏网
            # 排除游戏指令前缀 / 以免误杀 /register password 等合法消息
            if len(line) > 10 and not re.search(r'[\u4e00-\u9fff]', line) and not line.startswith('/'):
                logger.debug(f"[{platform}] OCR 过滤: 纯非中文乱码 line={line!r}")
                continue

            # —— CJK 比例过低乱码：EasyOCR 把 URL/代码认成罕见汉字混一堆字母 ——
            # 如 "刈甘珂呋; .怂U止X旋XLeJ(ILUS.//OITIUU" — 含中文但中文极少
            # 用户正常消息的 CJK 比例通常 > 30%
            if len(line) > 15 and re.search(r'[A-Za-z]', line):
                cjk_count = sum(1 for c in line if '\u4e00' <= c <= '\u9fff')
                if cjk_count > 0 and cjk_count / max(len(line), 1) < 0.15:
                    logger.debug(f"[{platform}] OCR 过滤: CJK比例过低乱码 line={line!r}")
                    continue

            # —— 游戏UI / 非聊天文本乱码（CJK+英文混合） ——
            # QQ/微信 OCR 在非聊天区域（服务器列表/物品栏/群公告）产出
            # CJK+英文混合乱码，特征：下划线英文("Ierite_spear")、CJK后跟大写英文("玩家Ierite")
            has_cjk = bool(re.search(r'[\u4e00-\u9fff]', line))
            has_alpha = bool(re.search(r'[A-Za-z]', line))
            if has_cjk and has_alpha and len(line) > 10:
                # 下划线英文 — 正常中文聊天极少包含（"Ierite_spear" 游戏ID/代码残片）
                if re.search(r'[a-zA-Z]+_[a-zA-Z]+', line):
                    logger.debug(f"[{platform}] OCR 过滤: 游戏UI乱码(下划线英文) line={line!r}")
                    continue
                # CJK+大写英文组合（"玩家Ierite" "比武Mtp"）— 游戏UI公告/服务器列表特有
                # 但正常句子也可能包含英文名词（如"Minecraft"），需区分：
                # 若中文字符数 >= 英文字母数，视为正常句子不过滤
                if re.search(r'[\u4e00-\u9fff][A-Z][a-z]{1,}', line):
                    cjk_count = len(re.findall(r'[\u4e00-\u9fff]', line))
                    alpha_count = len(re.findall(r'[A-Za-z]', line))
                    if alpha_count > 0 and cjk_count < alpha_count:
                        logger.debug(f"[{platform}] OCR 过滤: 游戏UI乱码(CJK+大写英文) line={line!r}")
                        continue

            # —— 绿色气泡 OCR 乱码：| 管道符混中文 ——
            # bot 的绿色气泡/蓝色气泡文字经过 OCR 后常把 :; 识别为 |，
            # 正常中文聊天从不混用 | 与中文。如 "GU |进行配置" "SMTP | 设置"
            if '|' in line and re.search(r'[\u4e00-\u9fff]', line) and len(line) > 5:
                logger.debug(f"[{platform}] OCR 过滤: 管道符碎片(绿色气泡) line={line!r}")
                continue

            # —— 游戏指令列表碎片：重复 /cmd 模式 ——
            # OCR 截到命令帮助文本如 "/sdfl主指令 /sdfl reload /sdfl update"
            # 正常用户消息极少含 ≥2 个独立 /command
            slash_cmds = re.findall(r'(?:^|\s)/(\w{2,})', line)
            if len(slash_cmds) >= 2:
                logger.debug(f"[{platform}] OCR 过滤: 指令列表碎片(多/cmd={slash_cmds}) line={line!r}")
                continue

            # —— 斜线英文命令碎片："/sdfl undo撤销导入" "/register密码" ——
            # 首字符是 / 且紧跟 ASCII 字母 → 命令帮助/参考碎片，非用户普通对话
            # 不拦截 "/兑换码怎么用"（斜线后是中文）
            if re.match(r'^/[A-Za-z]', line):
                logger.debug(f"[{platform}] OCR 过滤: 斜线英文命令 line={line!r}")
                continue
            # 消息中段含 /英文命令（如"怎么办？/printer玩家名"）→ 指令碎片拼接
            if re.search(r'(?<=[\s？?。！,，])/[A-Za-z]{2,}', line):
                logger.debug(f"[{platform}] OCR 过滤: 斜线命令碎片(中段) line={line!r}")
                continue

            # —— OCR 误读斜线为 I/J："/sdfl"→"Isdfl", "/import"→"Jimport" ——
            # 特征1：含已知命令关键词（sdfl/sdf1），零误杀
            if re.match(r'^[A-Za-z]', line) and ('sdfl' in line.lower() or 'sdf1' in line.lower()):
                logger.debug(f"[{platform}] OCR 过滤: 变形命令(sdfl) line={line!r}")
                continue
            # 特征2：大写字母+4+小写 + CJK + >10 字符 → 非自然对话
            if re.match(r'^[A-Z][a-z]{4,}', line) and re.search(r'[\u4e00-\u9fff]', line) and len(line) > 10:
                logger.debug(f"[{platform}] OCR 过滤: 变形命令(大写+字母) line={line!r}")
                continue

            # —— Bot自身回复过滤：pipe 表格格式（|参数1|参数2|参数3|结果|） ——
            # OCR 截屏可能截到旧的 bot 回复，pipe 表格不应进入 KB 匹配
            pipe_count = line.count('|')
            if pipe_count >= 3 and len(line) > 30:
                logger.debug(f"[{platform}] OCR 过滤: bot表格(pipe={pipe_count}) line={line!r}")
                continue

            # —— Bot回复内容过滤：英文key=value配置格式 ——
            # OCR截屏截到bot旧回复中的配置内容，如 "invite referral bonus=5afii"
            # 特征：英文key + = + 值，正常中文用户对话不含这种格式
            if re.search(r'[a-zA-Z_][\w]*\s*=\s*\S', line) and not re.search(r'[\u4e00-\u9fff]', line):
                logger.debug(f"[{platform}] OCR 过滤: bot配置(key=value) line={line!r}")
                continue

            # —— Bot回复内容过滤：配置文件描述片段 ——
            # OCR截屏截到bot旧回复中的配置说明，如 "配置此处的文件，负责展示..."
            # 这些是KB中的配置说明文本，不是用户消息
            # ⚠️ 要求同时包含配置短语 + 英文关键词 + 配置格式(=或:)，避免误过滤用户讨论配置的消息
            _config_phrases = ('配置此处的文件', '负责展示', '对应一个商品', '使用md文件格式',
                               '配置文件', '该配置', '此配置', '参数配置', '配置项')
            _config_keywords = ('invite', 'referral', 'reward', 'bonus')
            has_config_phrase = any(p in line for p in _config_phrases)
            has_config_keyword = re.search(r'invite|referral|reward|bonus', line, re.IGNORECASE)
            has_config_format = re.search(r'[=:]\s*\S', line)  # 包含 = 或 : 后跟非空白字符
            if has_config_phrase and has_config_keyword and has_config_format:
                logger.debug(f"[{platform}] OCR 过滤: bot配置说明(三重匹配) line={line!r}")
                continue

            # —— KB内容回读过滤：bot旧回复中的KB段落标题/内容 ——
            # OCR截屏截到bot之前回复的KB内容，如"奖励:邀请人可获得该新用户首充金额的30%"
            # 特征：包含"奖励:"、"规则:"、"配置:"等KB段落标记 + 内容描述
            _kb_markers = ('奖励:', '规则:', '配置:', '说明:', '要求:', '限制:', '条件:', '流程:',
                           '奖励：', '规则：', '配置：', '说明：', '要求：', '限制：', '条件：', '流程：')
            if any(m in line for m in _kb_markers):
                logger.debug(f"[{platform}] OCR 过滤: KB内容回读 line={line!r}")
                continue

            # —— Bot回复内容过滤：百分比+金额描述 ——
            # OCR截屏截到bot旧回复中的奖励金额描述，如"首充金额的30 作"
            # 正常用户对话不含这种精确百分比+金额的描述
            if re.search(r'\d+\s*%', line) and re.search(r'(金额|奖励|积分|返利|分成)', line):
                logger.debug(f"[{platform}] OCR 过滤: 奖励金额描述 line={line!r}")
                continue

            # —— JSON/YAML 碎片兜底：OCR 截屏混入配置面板 ——
            # 行首是 "key": value 或 key: value（YAML）→ 配置面板碎片
            if re.match(r'^["\']?[a-zA-Z_][\w]*["\']?\s*:\s*["\d\[\{tfn]', line):
                logger.debug(f"[{platform}] OCR 过滤: JSON行 {line!r}")
                continue
            if re.match(r'^[a-zA-Z_][\w]*\s*:\s*["\w\d]', line) and \
               not re.match(r'^(https?|ftp)://', line) and \
               not re.match(r'^[a-zA-Z_][\w]*\s*:\s*/', line):
                logger.debug(f"[{platform}] OCR 过滤: YAML行 {line!r}")
                continue

            # —— 末尾 #标题 碎片兜底 ——
            # OCR 时间戳分割可能遗漏尾部 " #测试" " #草" 等 md 标题碎片
            # 注：\s+ 要求空格在前，避免误杀 "C#语言" "中文#标签"
            if re.search(r'#[\u4e00-\u9fff]', line):
                cleaned = re.sub(r'\s+#[\u4e00-\u9fff][^\s#\n]{0,30}$', '', line).strip()
                if cleaned != line:
                    if not cleaned or MessageMonitor._is_markdown_document(cleaned):
                        logger.debug(f"[{platform}] OCR 过滤: 末尾#标题碎片 line={line!r}")
                        continue
                    line = cleaned
                # 如果 line 本身以 # 开头（纯 md），前面的 _is_markdown_document 应该已捕获
                # 但此处再补一刀
                if MessageMonitor._is_markdown_document(line):
                    logger.debug(f"[{platform}] OCR 过滤: md纯标题碎片 line={line!r}")
                    continue

            # —— OCR 幻觉乱码检测：连续重复字符（LLL / 111 / ===） ——
            # EasyOCR 对头像/特殊 UI 输出如 ":山LeLyeeuCL...ggsegU凶>债券管理"
            # 普通消息不含连续 5+ 相同字符
            if re.search(r'([A-Za-z0-9])\1{4,}', line):
                logger.debug(f"[{platform}] OCR 过滤: 幻觉乱码(重复) line={line!r}")
                continue

            # —— OCR 乱码检测：CJK+拉丁混合乱码（如"默i"、"鼍"） ——
            # 正常中文消息不会出现单个拉丁字母夹在CJK之间
            if re.search(r'[\u4e00-\u9fff][a-zA-Z][\u4e00-\u9fff]', line):
                logger.debug(f"[{platform}] OCR 过滤: CJK+拉丁混合乱码 line={line!r}")
                continue
            # 生僻字/罕见字检测：CJK扩展区字符（U+3400-U+4DBF, U+20000-U+2A6DF）
            if re.search(r'[\u3400-\u4dbf\U00020000-\U0002a6df]', line):
                logger.debug(f"[{platform}] OCR 过滤: 生僻字/罕见字 line={line!r}")
                continue

            # —— 英文配置格式+乱码过滤：key=value 或 key: value 后跟乱码 ——
            # 如 "invite referral bonus=5a激<5"、"config=file.txt乱码"
            if re.search(r'[a-zA-Z_]{2,}\s*[=:]\s*\S+', line):
                # 检查是否包含乱码特征：特殊字符、数字字母混合、非正常英文单词
                乱码特征 = False
                # 特征1：等号或冒号后包含特殊字符（<>!@#$%^&*等）
                if re.search(r'[=:]\s*[a-zA-Z0-9]*[<>!@#$%^&*()\[\]{}|\\/:;\'",.?~`]+', line):
                    乱码特征 = True
                # 特征2：等号或冒号后包含数字字母混合但无空格（如"5a激<5"）
                if re.search(r'[=:]\s*[a-zA-Z0-9]{3,}[^\s,.;:!?。，；：！？\u4e00-\u9fff]', line):
                    乱码特征 = True
                if 乱码特征:
                    logger.debug(f"[{platform}] OCR 过滤: 英文配置+乱码 line={line!r}")
                    continue

            # —— 系统配置内容过滤：Wiki/文档页面内容 ——
            if re.search(r'概览|数据看板|在线玩家|注册用户|活跃玩家|玩家数据', line):
                logger.debug(f"[{platform}] OCR 过滤: 系统配置内容(Wiki) line={line!r}")
                continue

            # —— 微信专属：气泡上下文验证 ——
            # 微信截图可能混入 Windows 弹窗/通知/非聊天内容
            # 真实用户消息通常含时间戳(14:30格式) 或 冒号分隔符(用户名：消息)
            # 纯粹的碎片文本（无时间戳、无冒号、无标点结尾）→ 高概率是非消息内容
            if platform == "wechat":
                has_timestamp = bool(re.search(r'\d{1,2}:\d{2}', line))
                has_colon = bool(re.search(r'[:：]', line))
                has_punct_end = bool(re.search(r'[。！？!?]$', line))
                # 短句(≤8字)含中文 → 可能是合法短消息（如"好的"、"嗯"），不拦截
                if len(line) <= 8 and re.search(r'[\u4e00-\u9fff]', line):
                    pass  # 放行短中文消息
                # 无时间戳 + 无冒号 + 无标点结尾 → 高概率是非消息碎片（弹窗/通知/UI）
                elif not has_timestamp and not has_colon and not has_punct_end:
                    # 再放宽：含问词(怎么办/为什么/能不能)或感叹词 → 可能是真实消息
                    if not re.search(r'怎么办|为什么|能不能|怎么|如何|什么|可以|帮忙|谢谢|好的|嗯|收到|OK|ok', line):
                        logger.debug(f"[{platform}] OCR 过滤: 微信非消息碎片(无上下文) line={line!r}")
                        continue

            # —— 回复内容片段检测：OCR 捕获 bot 自己刚发的回复 ——
            # 用 SequenceMatcher 找 OCR 行与 replied 文本的最长公共子串
            # 先试原始文本（含字母数字），再试 CJK-only（阈值 6，防短碎片漏网）
            if self._replied_texts and len(line) > 8:
                import difflib
                is_match = False
                # 第一轮：原始文本匹配
                for r in self._replied_texts:
                    if len(r) < 5:
                        continue
                    sm = difflib.SequenceMatcher(None, line, r)
                    if sm.find_longest_match(0, len(line), 0, len(r)).size >= 6:
                        is_match = True
                        break
                # 第二轮：CJK-only 降阈值匹配（OCR 碎片字母被啃掉时）
                if not is_match:
                    cjk_line = ''.join(c for c in line if '\u4e00' <= c <= '\u9fff')
                    if len(cjk_line) >= 5:
                        for r in self._replied_texts:
                            r_cjk = ''.join(c for c in r if '\u4e00' <= c <= '\u9fff')
                            if len(r_cjk) < 5:
                                continue
                            sm = difflib.SequenceMatcher(None, cjk_line, r_cjk)
                            if sm.find_longest_match(0, len(cjk_line), 0, len(r_cjk)).size >= 5:
                                is_match = True
                                break
                if is_match:
                    logger.debug(f"[{platform}] OCR 过滤: 回复内容片段 line={line[:60]!r}")
                    continue

            # === 全面 md 语法兜底：正常用户不写 md，只可能是 bot 回复 ===
            # ** 加粗标记（用户聊天从不打 **）
            if '**' in line:
                logger.debug(f"[{platform}] OCR 过滤: 加粗语法 line={line!r}")
                continue
            # 行首 # 标题（未在前面的 md 检测中被捕获的）
            if re.match(r'^#{1,6}(?:\s|\d|\[|[\u4e00-\u9fff])', line):
                logger.debug(f"[{platform}] OCR 过滤: 行首标题 line={line!r}")
                continue
            # 编号列表：1. 2) 3、 开头
            if re.match(r'^\d{1,3}[\.\)、]\s', line):
                logger.debug(f"[{platform}] OCR 过滤: 编号列表 line={line!r}")
                continue
            # 全角 md 链接残片：]（ 或 [text]（url
            if re.search(r'\]（', line) or re.search(r'\[.+?\]（', line):
                logger.debug(f"[{platform}] OCR 过滤: 全角链接残片 line={line!r}")
                continue

            # —— * 开头 md 残片：OCR 吞了另一半，如 *如有错误。请您 ——
            # 正常用户在 QQ/微信聊天从不以 * 开头
            if line.startswith('*'):
                logger.debug(f"[{platform}] OCR 过滤: *开头残片 line={line!r}")
                continue

            # —— *...* 配对残片：OCR 把 **使用** 啃成 *x但不衢...x* ——
            # 任何 * 包裹内容（不论内容如何）都是 md 语法残余
            if re.search(r'\*[^*]+\*', line):
                logger.debug(f"[{platform}] OCR 过滤: *配对残片 line={line!r}")
                continue

            # —— 结构化数据面板：QQ/TIM 指令面板（指令:/rtp 权限类型:玩家 图标:标题:）——
            # 3+ 个 中文短词:值 结构，用户聊天从不会连续3+个冒号键值对
            colon_kv = re.findall(r'[\u4e00-\u9fff]{1,6}[：:](?:[A-Za-z0-9/]|[\u4e00-\u9fff])', line)
            if len(colon_kv) >= 3:
                logger.debug(f"[{platform}] OCR 过滤: 结构化面板 line={line!r}")
                continue

            # —— OCR 偏旁碎片过滤：包含偏旁字符就丢弃 ——
            # 偏旁字符（U+2E80-U+2FDF）在正常中文聊天中不会出现
            # OCR 拆字碎片如"亻牛""彡"只要出现就是碎片
            if any(_is_radical_char(ch) for ch in line):
                logger.debug(f"[{platform}] OCR 过滤: 包含偏旁字符(丢弃) line={line!r}")
                continue
            # —— 系统配置内容过滤：SMTP/邮件地址/代码片段不是用户消息 ——
            if re.search(r'@example|smtp|\.py\b|\.bat\b|\.sh\b|//.*\.\w{2,4}\b', line, re.IGNORECASE):
                logger.debug(f"[{platform}] OCR 过滤: 系统配置内容 line={line!r}")
                continue
            if re.search(r'@\w+\.\w{2,4}[,.\s]', line) and re.search(r'[a-zA-Z0-9._%+-]+@[a-zA-Z0-9.-]+\.[a-zA-Z]{2,}', line):
                logger.debug(f"[{platform}] OCR 过滤: 邮件地址格式 line={line!r}")
                continue

            # —— OCR 短句/病句检测：OCR 把消息"嚼碎"生成碎片 ——
            # 通用疑问词（有这些词说明有查询意向，放行）
            _q_words = {"什么", "怎么", "如何", "为什么", "吗", "呢", "吧", "能", "可以", "有没有", "哪些", "哪", "哪几个",
                        "是不是", "会不会", "能不能", "怎么办", "好不好", "行不行"}
            # "自行修？" → 3字无查询意向碎片；"将其修正后重三" → 病句
            if len(line) <= 8:
                # ≤8字短句：必须包含疑问词才放行，否则是OCR碎片
                # 有问号但无疑问词 → 病句（如"自行修？"无查询意向）
                has_q = any(w in line for w in _q_words)
                if not has_q:
                    logger.debug(f"[{platform}] OCR 过滤: 短句碎片(≤8字无问词) line={line!r}")
                    continue
            # ★ 以特殊符号(~、`等)开头 → OCR把"一键"识别为"~键"等碎片
            if re.match(r'^[~`～]', line):
                logger.debug(f"[{platform}] OCR 过滤: 特殊符号开头碎片 line={line!r}")
                continue
            if 5 < len(line) < 50:
                # 病句1：句子以动词/助词结尾但缺少宾语且无标点
                if re.search(r'[后以了过]+.{0,3}$', line) and not re.search(r'[。！？，,；;：:？]$', line):
                    logger.debug(f"[{platform}] OCR 过滤: 病句(动词结尾) line={line!r}")
                    continue
                # 病句2：句子以"三"结尾（OCR误读"试"为"三"）
                if re.search(r'重三$', line):
                    logger.debug(f"[{platform}] OCR 过滤: 病句(重三) line={line!r}")
                    continue
                # 病句3：句子缺少主语且无标点（如"将其修正后重三" "认管理员密码多少"）
                #   OCR常把"默认"识别丢掉→"认管理员密码多少"、把"帮"识别丢掉→"查xx"
                if re.match(r'^[其将把被认查问帮试想]', line) and not re.search(r'[。！？，,；;：:？]$', line):
                    logger.debug(f"[{platform}] OCR 过滤: 病句(缺主语) line={line!r}")
                    continue
                # 病句4：OCR 把用户消息和系统提示拼接的复合碎片
                # 如"自行修？# 本插件" "请自行下载源码修改...使用类json"
                if '#' in line or '源码' in line and '修改' in line:
                    # 含文档标记或系统提示特征
                    if re.search(r'#\s*本|请自行|源码.*修改|修改.*源码', line):
                        logger.debug(f"[{platform}] OCR 过滤: 病句(系统提示拼接) line={line!r}")
                        continue
                # 病句5：句子含"修"但不是完整查询（如"自行修？" "帮我修" "能不能修"）
                # 除非有明确疑问词，否则"修"碎片不应触发查库
                if re.search(r'修[？?。]?\s*$', line) and not any(w in line for w in _q_words):
                    logger.debug(f"[{platform}] OCR 过滤: 病句(修字碎片) line={line!r}")
                    continue
                # 病句6：句子包含时间戳格式（如"16：29" "2026/7/29"）
                # OCR 常把时间戳和用户消息拼接，如"认管理员密码多少？在嘲多改？"
                if re.search(r'\d{1,2}:\d{1,2}(?::\d{1,2})?|\d{4}[/-]\d{1,2}[/-]\d{1,2}', line):
                    logger.debug(f"[{platform}] OCR 过滤: 病句(含时间戳) line={line!r}")
                    continue
                # 病句7：句子以数字开头且包含问号（如"1屏蔽？不想要的后缀。"）
                # 可能是 OCR 把消息编号和内容拼接
                if re.match(r'^\d+', line) and re.search(r'[？?]', line):
                    logger.debug(f"[{platform}] OCR 过滤: 病句(数字开头+问号) line={line!r}")
                    continue
                # 病句8：句子包含引号包裹的时间戳（如'"2026/7/29"'）
                if re.search(r'["""][^"""]*\d{4}[/-]\d{1,2}[/-]\d{1,2}[^"""]*["""]', line):
                    logger.debug(f"[{platform}] OCR 过滤: 病句(引号包裹时间戳) line={line!r}")
                    continue
                # 病句9：纯问句碎片（如"怎么办？" "好不好？"）无实质内容
                # 只有疑问词+标点，或疑问词+少量无意义字符
                _pure_q = re.match(r'^(怎么办|好不好|行不行|能不能|可以吗|是不是|有没有|是什么|怎么样|在哪里)\s*[？?。！]*\s*$', line)
                if _pure_q:
                    logger.debug(f"[{platform}] OCR 过滤: 病句(纯问句碎片) line={line!r}")
                    continue
                # 病句10：问句+乱码碎片拼接（如"怎么办？/printer玩家名"）
                # 问词开头 + 非自然字符（斜线/英文/数字乱拼）
                if re.match(r'^(怎么办|好不好|行不行|能不能|可以吗|是什么|怎么样)', line):
                    # 检查问词后面是否有乱码特征
                    rest = re.sub(r'^(怎么办|好不好|行不行|能不能|可以吗|是什么|怎么样)\s*[？?。！]*\s*', '', line)
                    if rest and (re.search(r'/[A-Za-z]{2,}', rest) or re.search(r'[a-zA-Z]{3,}', rest) or len(rest) < 3):
                        logger.debug(f"[{platform}] OCR 过滤: 病句(问句+乱码拼接) line={line!r}")
                        continue

            texts.append(line)
        logger.debug(f"[{platform}] OCR -> {len(ocr_lines)} raw, {len(texts)} filtered, "
                     f"last=\"{texts[-1][:50] if texts else ''}\"")
        return texts

    def _read_via_clipboard_once(self, platform: str) -> list:
        """剪贴板法单次执行（安全键盘导航：Enter + Ctrl+End + Ctrl+A/C，无 Esc）。

        去重由 _poll 的 _replied_texts + _seen_messages 负责，本函数只过滤并返回。
        回复回环防御由 _paste_and_send 写入 _replied_texts 承担。
        """
        hwnd = self._cached_hwnd.get(platform)
        if not hwnd or not win32gui.IsWindow(hwnd):
            return []

        import win32clipboard as wc

        old = None
        try:
            wc.OpenClipboard()
            if wc.IsClipboardFormatAvailable(wc.CF_UNICODETEXT):
                old = wc.GetClipboardData(wc.CF_UNICODETEXT)
            wc.CloseClipboard()
        except Exception:
            pass

        texts = []
        raw_lines = []  # 预初始化，防止 content 为空时 UnboundLocalError
        try:
            # 确保窗口在前台（失败则返回空，避免发送到错误窗口）
            # QQ 剪贴板优先路径需要更可靠的前台保证（与发送路径 retries 一致）
            if not self._ensure_foreground(hwnd, max_retries=5):
                return []

            # PostMessage 点击消息区域（设焦点，不全局，不比鼠标移动）
            rect = win32gui.GetWindowRect(hwnd)
            if rect:
                left, top, right, bottom = rect
                w = right - left
                h = bottom - top
                # QQ NT 消息面板在 ~55-95% 宽度区域
                click_x = int(w * 0.72)  # 消息面板中部
                click_y = int(h * 0.60)  # 消息面板中部偏下
                lparam = win32api.MAKELONG(click_x, click_y)
                win32gui.PostMessage(hwnd, win32con.WM_LBUTTONDOWN, win32con.MK_LBUTTON, lparam)
                win32gui.PostMessage(hwnd, win32con.WM_LBUTTONUP, 0, lparam)
                time.sleep(0.2)

            # 滚动到底部（PostMessage 安全，不切焦点，确保新消息可见）
            self._force_scroll_bottom(platform)
            time.sleep(0.2)

            # TIM/QQ NT: 安全键盘导航（无 Esc，不关窗口）
            # 每步前校验目标窗口仍在焦点，防止 keybd_event 泄露到控制台
            VK_CONTROL = 0x11
            variant = self._app_variant.get(platform, "")
            if variant in ("tim", "qq_nt"):
                VK_RETURN = 0x0D
                VK_END = 0x23

                # Enter 激活当前对话
                if self._fg_is_target(hwnd):
                    ctypes.windll.user32.keybd_event(VK_RETURN, 0, 0, 0)
                    time.sleep(0.05)
                    ctypes.windll.user32.keybd_event(VK_RETURN, 0, 2, 0)
                    time.sleep(0.3)

                # Ctrl+End 滚动到底部（双保险：PostMessage + keybd_event）
                if self._fg_is_target(hwnd):
                    ctypes.windll.user32.keybd_event(VK_CONTROL, 0, 0, 0)
                    ctypes.windll.user32.keybd_event(VK_END, 0, 0, 0)
                    time.sleep(0.05)
                    ctypes.windll.user32.keybd_event(VK_END, 0, 2, 0)
                    ctypes.windll.user32.keybd_event(VK_CONTROL, 0, 2, 0)
                    time.sleep(0.3)

            # Ctrl+A (全选) — 仅当目标窗口仍在焦点
            # 先检查发送锁：主线程可能正在 _paste_and_send，避免 Ctrl+C 覆盖其剪贴板
            if self._sending_event.is_set():
                logger.debug(f"[{platform}] 发送中，剪贴板读取跳过防竞争")
                return []
            VK_A = 0x41
            if self._fg_is_target(hwnd):
                ctypes.windll.user32.keybd_event(VK_CONTROL, 0, 0, 0)
                ctypes.windll.user32.keybd_event(VK_A, 0, 0, 0)
                time.sleep(0.05)
                ctypes.windll.user32.keybd_event(VK_A, 0, 2, 0)
                ctypes.windll.user32.keybd_event(VK_CONTROL, 0, 2, 0)
                time.sleep(0.15)
            # Ctrl+C (复制)
            VK_C = 0x43
            if self._fg_is_target(hwnd):
                ctypes.windll.user32.keybd_event(VK_CONTROL, 0, 0, 0)
                ctypes.windll.user32.keybd_event(VK_C, 0, 0, 0)
                time.sleep(0.05)
                ctypes.windll.user32.keybd_event(VK_C, 0, 2, 0)
                ctypes.windll.user32.keybd_event(VK_CONTROL, 0, 2, 0)
                time.sleep(0.3)

            wc.OpenClipboard()
            if wc.IsClipboardFormatAvailable(wc.CF_UNICODETEXT):
                content = wc.GetClipboardData(wc.CF_UNICODETEXT)
                if content:
                    raw_lines = [l.strip() for l in content.strip().split('\n') if l.strip()]
                    self._raw_clipboard[platform] = content
            wc.CloseClipboard()

            logger.debug(f"[{platform}] 剪贴板读取 → {len(raw_lines)} lines")

            # ⭐ 剪贴板 hash：内容没变化 → 跳过（防止跨平台读到过时数据）
            import hashlib
            cur_h = hashlib.md5(content.encode('utf-8') if content else b'').hexdigest()
            last_h = self._last_clipboard_hash.get(platform, '')
            if cur_h == last_h:
                logger.debug(f"[{platform}] 剪贴板内容未变，跳过 stale 数据")
                return []
            self._last_clipboard_hash[platform] = cur_h

            # ── 过滤：只返回"像用户消息"的行 ──
            sender_pattern = re.compile(r'^[\u4e00-\u9fff·A-Za-z0-9_\-]{1,10}$')
            for line in raw_lines:
                # 清理 QQ 消息末尾的状态标记（如 "O~" "C~" "0~O~"），避免污染 KB 匹配
                line = re.sub(r'\s*(?:[A-Za-z0-9]~)+\s*$', '', line).strip()
                if not line:
                    continue
                # 跳过：系统消息、纯时间、纯数字、无意义短行
                if self._is_system_message(line):
                    continue
                # 跳过：控制台/Python 垃圾（剪贴板截错窗口内容）
                if self._is_ocr_console_garbage(line):
                    continue
                # 跳过：单行发送者名（1-10汉字/字母/数字/下划线）
                if sender_pattern.match(line):
                    continue
                # 跳过：纯时间格式（连字符/斜杠分格日期）
                if re.match(r'^\d{1,2}[:：\s]\d{2}', line):
                    continue
                if re.match(r'^\d{4}[/-]\d{1,2}', line):
                    continue
                # 跳过：纯 emoji / 纯标点（短于 6 个字符且只有符号）
                clean = re.sub('[~!@#$%^&*()_+\\-=\\[\\]{};:\\\'",.<>/?·！@#￥%……&*（）—+。，、；：""\'\'【】｛｝「」『』《》【】 \\t\\n\\r\\u2000-\\u206f\\u2190-\\u2bff\\U0001F000-\\U0001FFFF]', '', line)
                if len(clean) == 0 and len(line) <= 6:
                    continue
                # 跳过：游戏UI乱码（CJK+下划线英文、CJK+大写英文组合）
                if re.search(r'[\u4e00-\u9fff]', line) and re.search(r'[A-Za-z]', line) and len(line) > 10:
                    if re.search(r'[a-zA-Z]+_[a-zA-Z]+', line):
                        logger.debug(f"[{platform}] 剪贴板过滤: 游戏UI乱码(下划线英文) line={line!r}")
                        continue
                    if re.search(r'[\u4e00-\u9fff][A-Z][a-z]{1,}', line):
                        cjk_count = len(re.findall(r'[\u4e00-\u9fff]', line))
                        alpha_count = len(re.findall(r'[A-Za-z]', line))
                        if alpha_count > 0 and cjk_count < alpha_count:
                            logger.debug(f"[{platform}] 剪贴板过滤: 游戏UI乱码(CJK+大写英文) line={line!r}")
                            continue
                # 通过全部检查 → 保留
                texts.append(line)

            logger.debug(f"[{platform}] 剪贴板过滤后 → {len(texts)} 条用户消息")
        except Exception as e:
            logger.debug(f"[{platform}] 剪贴板失败: {e}")
        finally:
            if old is not None:
                try:
                    wc.OpenClipboard()
                    wc.EmptyClipboard()
                    wc.SetClipboardText(old, wc.CF_UNICODETEXT)
                    wc.CloseClipboard()
                except Exception:
                    pass

        return texts

    def get_raw_clipboard(self, platform: str) -> str:
        """获取最近一次剪贴板读取的原始文本。"""
        return self._raw_clipboard.get(platform, "")

    @staticmethod
    def _parse_last_sender(raw_text: str) -> Optional[str]:
        """从剪贴板原始文本中提取最后一条消息的发送者。

        TIM/QQ 剪贴板格式通常是:
            [发送者]
            [时间]
            [消息]
            (空行)
            [发送者]
            [时间]
            [消息]
        """
        if not raw_text:
            return None
        blocks = re.split(r'\n\s*\n', raw_text.strip())
        if not blocks:
            return None
        last_block = blocks[-1].strip()
        if not last_block:
            return None
        lines = [l.strip() for l in last_block.split('\n') if l.strip()]
        if not lines:
            return None
        candidate = lines[0]
        # 排除时间格式
        if re.match(r'^\d{1,2}[:：]\d{2}', candidate):
            return None
        if re.match(r'^\d{4}[/-]\d{1,2}', candidate):
            return None
        if len(candidate) > 30:
            return None
        return candidate

    def _search_contact(self, platform: str, contact: str) -> bool:
        """在 TIM/QQ 搜索框中搜索联系人并切换到对应会话。"""
        hwnd = self._cached_hwnd.get(platform)
        if not hwnd:
            return False
        try:
            win = auto.ControlFromHandle(hwnd)
            search = win.EditControl(Name="搜索", maxSearchSeconds=0.5)
            if not search.Exists(maxSearchSeconds=0.3):
                logger.warning(f"[{platform}] 找不到搜索框")
                return False

            # 恢复窗口并前置（失败则放弃搜索）
            if win32gui.IsIconic(hwnd):
                win32gui.ShowWindow(hwnd, win32con.SW_RESTORE)
            if not self._ensure_foreground(hwnd):
                logger.warning(f"[{platform}] 无法前置窗口，放弃搜索联系人")
                return False
            time.sleep(0.2)

            # SetFocus 到搜索框（不移动鼠标）
            search.SetFocus()
            time.sleep(0.2)

            # 全选已有内容并输入联系人名
            auto.SendKeys('{Ctrl}a')
            time.sleep(0.1)
            auto.SendKeys(contact)
            time.sleep(0.5)

            # Enter 打开第一个结果
            auto.SendKeys('{Enter}')
            time.sleep(0.5)

            logger.info(f"[{platform}] 已搜索并切换到联系人: {contact}")
            return True
        except Exception as e:
            logger.error(f"[{platform}] 搜索联系人失败: {e}")
            return False

    # ── SendInput 键盘模拟 ─────────────────────────────────

    @staticmethod
    def _key_down(vk: int):
        """SendInput KEYBDINPUT keydown."""
        ctypes.windll.user32.keybd_event(vk, 0, 0, 0)

    @staticmethod
    def _key_up(vk: int):
        """SendInput KEYBDINPUT keyup (KEYEVENTF_KEYUP=2)."""
        ctypes.windll.user32.keybd_event(vk, 0, 2, 0)

    @staticmethod
    def _send_key_press(vk: int, delay: float = 0.05):
        """SendInput single key press (down + up)."""
        ctypes.windll.user32.keybd_event(vk, 0, 0, 0)
        time.sleep(delay)
        ctypes.windll.user32.keybd_event(vk, 0, 2, 0)

    @staticmethod
    def _send_ctrl_combo(vk: int):
        """Send Ctrl+<key>: Ctrl down → key down → key up → Ctrl up."""
        VK_CONTROL = 0x11
        ctypes.windll.user32.keybd_event(VK_CONTROL, 0, 0, 0)
        ctypes.windll.user32.keybd_event(vk, 0, 0, 0)
        ctypes.windll.user32.keybd_event(vk, 0, 2, 0)
        ctypes.windll.user32.keybd_event(VK_CONTROL, 0, 2, 0)

    @staticmethod
    def _post_key(hwnd, vk, delay=0.05):
        """PostMessage 键盘到指定窗口（不全局，安全）。"""
        win32gui.PostMessage(hwnd, win32con.WM_KEYDOWN, vk, 0)
        time.sleep(delay)
        win32gui.PostMessage(hwnd, win32con.WM_KEYUP, vk, 0)

    @staticmethod
    def _post_ctrl_combo(hwnd, vk, delay=0.05):
        """PostMessage Ctrl+组合键到指定窗口（不泄露到控制台）。"""
        VK_CONTROL = 0x11
        win32gui.PostMessage(hwnd, win32con.WM_KEYDOWN, VK_CONTROL, 0)
        win32gui.PostMessage(hwnd, win32con.WM_KEYDOWN, vk, 0)
        time.sleep(delay)
        win32gui.PostMessage(hwnd, win32con.WM_KEYUP, vk, 0)
        win32gui.PostMessage(hwnd, win32con.WM_KEYUP, VK_CONTROL, 0)

    def _fg_is_target(self, hwnd) -> bool:
        """校验目标窗口仍在焦点，防止 keybd_event 泄露到控制台。"""
        try:
            fg = win32gui.GetForegroundWindow()
            root = win32gui.GetAncestor(hwnd, win32con.GA_ROOT)
            return fg == root or (fg and win32gui.IsChild(root, fg))
        except Exception:
            return False

    @staticmethod
    def _image_hash(im) -> str:
        """感知哈希：缩至 9x8 灰阶 → dHash（差值哈希，对局部变化敏感）。
        
        dHash 比较每行相邻像素的梯度，比 aHash（均值哈希）更能捕捉文字变化。
        9 列 × 8 行 = 72 位 hash，比 8×8=64 位 aHash 信息量更大。
        """
        small = im.convert('L').resize((9, 8), Image.LANCZOS)
        pixels = list(small.getdata())
        # 每行 9 个像素，比较相邻像素：左 > 右 → 1，否则 → 0
        bits = []
        for row in range(8):
            for col in range(8):
                left = pixels[row * 9 + col]
                right = pixels[row * 9 + col + 1]
                bits.append('1' if left > right else '0')
        return ''.join(bits)

    @staticmethod
    def _is_white_bubble_pixel(px, x, y, w, h) -> bool:
        """判定 (x,y) 的纯白像素是否属于"白色气泡"(对方消息)，而非：
           - 聊天浅灰背景（本身不是 >=245 候选）
           - 彩色(绿/蓝)自身气泡上的白色文字（邻域为彩色底色）
        规则：四方向(±4px)邻域中 >=3 个也为 near-white(>=245) 才算气泡。
           白字笔画的邻域多为彩色气泡底色 → 不通过 → 不被误判为对方消息。
        """
        d = 4
        hits = 0
        for dx, dy in ((d, 0), (-d, 0), (0, d), (0, -d)):
            nx, ny = x + dx, y + dy
            if 0 <= nx < w and 0 <= ny < h:
                try:
                    rr, gg, bb = px[nx, ny][:3]
                    if rr >= 245 and gg >= 245 and bb >= 245:
                        hits += 1
                except Exception:
                    pass
        return hits >= 3


    @staticmethod
    def _has_user_colors(im, platform: str) -> bool:
        """区域颜色检测：判断截图中是否有**对方发来的消息**，决定是否需要OCR。

        ⭐ 核心原则：自身消息 = 最顶层门禁，不过则全部取消。
        - QQ: 用户白色气泡左对齐，bot/对方蓝色气泡右对齐
        - WeChat: 对方白色气泡左对齐，自己绿色气泡右对齐

        返回 True=有对方消息需要OCR，False=仅自身消息/无消息 → 跳过
        """
        w, h = im.size
        if w < 10 or h < 10:
            return True

        # 跳过顶部 20%（群名/大标题栏）
        check = im.crop((0, int(h * 0.20), w, h))
        cw, ch = check.size
        if cw < 20 or ch < 20:
            return True

        # 左右半区
        left_half = check.crop((0, 0, cw // 2, ch))
        right_half = check.crop((cw // 2, 0, cw, ch))

        step_x = max(2, cw // 15)
        step_y = max(2, ch // 15)

        if platform == "qq":
            # QQ: 蓝色 = bot/对方气泡（右对齐）
            def is_bot(r, g, b):
                return 110 <= r <= 190 and 170 <= g <= 235 and 220 <= b <= 255
        else:
            # WeChat: 绿色 = 自己发的消息（右对齐）— 不是 bot 色
            def is_self(r, g, b):
                return 135 <= r <= 180 and 205 <= g <= 250 and 75 <= b <= 125
            is_bot = is_self

        def analyze(img):
            p = img.load()
            bot = other = white = total = 0
            iw, ih = img.width, img.height
            for y in range(0, ih, step_y):
                for x in range(0, iw, step_x):
                    total += 1
                    try:
                        r, g, b = p[x, y][:3]
                    except:
                        continue
                    if r >= 245 and g >= 245 and b >= 245:
                        # ⚠️ 纯白像素可能是：①对方白色气泡(背景/白字) ②聊天浅灰背景
                        #   ③绿色/蓝色自身气泡上的白色文字。
                        # ②③ 不能算"对方消息"——否则微信自身绿气泡白字被误判为对方
                        #   → OCR → 自回复循环。必须确认邻域也为大面积白色(气泡)才计入。
                        if MessageMonitor._is_white_bubble_pixel(p, x, y, iw, ih):
                            white += 1
                    elif is_bot(r, g, b):
                        bot += 1
                    else:
                        other += 1
            return bot, other, white, total

        left_bot, left_other, left_white, left_total = analyze(left_half)
        right_bot, right_other, right_white, right_total = analyze(right_half)

        rlogger = logging.getLogger("msgbot.monitor")
        rlogger.debug(f"[{platform}] 像素: 左其它={left_other}/{left_total} "
                      f"{'自身' if platform=='wechat' else 'bot'}={left_bot} 白={left_white} | "
                      f"右其它={right_other}/{right_total} "
                      f"{'自身' if platform=='wechat' else 'bot'}={right_bot} 白={right_white}")

        # ====== 微信专用逻辑 ======
        # 颜色语义：
        #   白色(>225,>225,>225) = 对方消息（左对齐）
        #   绿色(135-180,205-250,75-125) = 自己消息（右对齐）
        #   其它 = 背景/UI元素
        if platform == "wechat":
            # ⭐ 自身消息门禁：右大量绿色(自身) + 左无白色(无对方) → 仅自身，跳过
            if right_bot >= 3 and left_white < 3:
                rlogger.debug(f"[wechat] 像素检测: 仅自身消息(右绿={right_bot},左白={left_white}), 跳过")
                return False

            # 左半区有白色气泡 → 有对方消息，必须OCR
            if left_white >= 3:
                rlogger.debug(f"[wechat] 像素检测: 有对方消息(左白={left_white}), 继续")
                return True

            # 左半区无白色气泡 → 无对方消息，跳过
            # （包括：仅自身消息、空聊天、非聊天界面）
            rlogger.debug(f"[wechat] 像素检测: 无对方白色气泡(左白={left_white}), 跳过")
            return False

        # ====== QQ/TIM 专用逻辑 ======
        # 颜色语义：
        #   白色(>225,>225,>225) = 用户消息（左对齐）
        #   蓝色(110-190,170-235,220-255) = bot/对方消息（右对齐）
        #   其它 = 背景/UI元素
        # ⭐ 核心原则：只要左半区无白色气泡 → 无用户消息 → 跳过

        # ⭐ 跨窗口污染检测：QQ窗口无绿色气泡，若检测到大量绿色像素，说明截到了微信窗口
        def is_wechat_green(r, g, b):
            return 135 <= r <= 180 and 205 <= g <= 250 and 75 <= b <= 125
        left_green = right_green = 0
        for y in range(0, ch, step_y):
            for x in range(0, cw // 2, step_x):
                try:
                    r, g, b = check.load()[x, y][:3]
                    if is_wechat_green(r, g, b):
                        left_green += 1
                except:
                    continue
        for y in range(0, ch, step_y):
            for x in range(cw // 2, cw, step_x):
                try:
                    r, g, b = check.load()[x, y][:3]
                    if is_wechat_green(r, g, b):
                        right_green += 1
                except:
                    continue
        total_green = left_green + right_green
        if total_green >= 3:
            rlogger.debug(f"[qq] 像素检测: 检测到微信绿色像素(绿={total_green}), 判定为微信窗口, 跳过")
            return False

        # 左半区有白色气泡 → 有用户消息，必须OCR
        if left_white >= 3:
            rlogger.debug(f"[qq] 像素检测: 有用户消息(左白={left_white}), 继续")
            return True

        # 左半区无白色气泡 → 无用户消息，跳过
        # （包括：仅bot回复、空聊天、非聊天界面）
        rlogger.debug(f"[qq] 像素检测: 无用户白色气泡(左白={left_white}), 跳过")
        return False

    @staticmethod
    def _split_merged_ocr_text(text: str) -> list:
        """尝试将 OCR 单行合并文本在中文句尾标点处拆分。

        EasyOCR 常把横向相邻的两条消息（用户问句 + 群昵称/UI文字/其他人消息）
        检测为同一行文本，导致"兑换码导入错误时如何处置?游戏专用小筑憩-草一"式合并。

        启发式: 在[。？！?]后紧跟CJK字符的位置拆分，前提是两侧都有足够中文。
        不拆分续接句（第二段以"但/而/并/且/或/还/也/又/就/才/再/变"开头）。
        """
        if len(text) < 10:
            return [text]

        _continuations = {'但', '而', '并', '且', '或', '还', '也', '又',
                          '就', '才', '再', '变', '便', '则', '却', '虽',
                          '因', '为', '与', '和', '同', '跟'}
        result = []
        remaining = text
        max_splits = 2  # 最多拆 2 次（3 段），防过度拆分

        while max_splits > 0:
            # 找[。？！?]后紧跟CJK的位置
            m = re.search(r'([。？！?])([\u4e00-\u9fff])', remaining)
            if not m:
                break
            split_pos = m.start() + 1  # 标点后
            first = remaining[:split_pos]
            second = remaining[split_pos:]

            # 两侧都需有足够 CJK
            first_cjk = sum(1 for c in first if '\u4e00' <= c <= '\u9fff')
            second_cjk = sum(1 for c in second if '\u4e00' <= c <= '\u9fff')
            if first_cjk < 3 or second_cjk < 3:
                break

            # 第二段不以续接词开头
            if second[0] in _continuations:
                break

            # 第二段太短（少于 3 CJK）→ 不拆
            first_part = first
            second_part = second
            result.append(first_part)
            remaining = second_part
            max_splits -= 1

        result.append(remaining)
        if len(result) > 1:
            logger.debug(f"[ocr] 句尾标点拆分: {[r[:60] for r in result]}")
        return result

    def _is_reply_fragment(self, text: str) -> bool:
        """检查文本是否为 bot 回复内容的碎片（OCR 截取的 md 残片/跨行碎片）。"""
        logger.debug(f"[ocr] 过滤器4: _is_reply_fragment 检查: {text[:80]!r}")
        if not self._replied_texts:
            logger.debug(f"[ocr] 过滤器4结果: 无已回复文本，返回False")
            return False
        if len(text) < 4:
            logger.debug(f"[ocr] 过滤器4结果: 文本太短（{len(text)}<4），返回False")
            return False
        import difflib
        # 原始文本匹配（含字母数字）
        for r in self._replied_texts:
            if len(r) < 5:
                continue
            sm = difflib.SequenceMatcher(None, text, r)
            if sm.find_longest_match(0, len(text), 0, len(r)).size >= 6:
                logger.debug(f"[ocr] 过滤器4结果: 原始文本匹配成功，返回True")
                return True
        # CJK-only 降阈值
        cjk_t = ''.join(c for c in text if '\u4e00' <= c <= '\u9fff')
        if len(cjk_t) >= 5:
            for r in self._replied_texts:
                r_cjk = ''.join(c for c in r if '\u4e00' <= c <= '\u9fff')
                if len(r_cjk) < 5:
                    continue
                sm = difflib.SequenceMatcher(None, cjk_t, r_cjk)
                if sm.find_longest_match(0, len(cjk_t), 0, len(r_cjk)).size >= 5:
                    logger.debug(f"[ocr] 过滤器4结果: CJK文本匹配成功，返回True")
                    return True
        logger.debug(f"[ocr] 过滤器4结果: 未匹配到已回复文本，返回False")
        return False

    @staticmethod
    def _looks_fresh_content(text: str) -> bool:
        """判断一段 OCR 文本是否含"新鲜消息"特征。

        只放行明显是用户新发的查询/聊天消息，避免旧历史记录因为含问句被误放行。
        规则严格：短消息 或 明确疑问/请求句（含疑问词+问号/怎么/如何等）。
        """
        if not text or not text.strip():
            return False
        t = text.strip()
        # 超短中文消息（如"好的"、"嗯"）可能无时间戳
        if len(t) <= 4 and re.search(r'[\u4e00-\u9fff]', t):
            return True
        # 明确疑问/请求：含疑问词+问号，或"怎么/如何/怎么办"等
        if re.search(r'(?:怎么办|为什么|能不能|怎么|如何|什么|哪些|哪个|吗|呢)\s*[？?]', t):
            return True
        if re.search(r'^(?:怎么|如何|请问|请教|求助)', t):
            return True
        return False

    def _ocr_text_has_fresh_timestamp(self, text: str, platform: str = "unknown") -> bool:
        """检查 OCR 文本是否可能包含新消息。

        有时间戳且至少一个 ≤300s → True（确定新消息）
        无时间戳 → 保守放行（可能是短句无时间戳的新消息）
        有时间戳但全部过期 → 仅当最新时间戳不太老（≤600s）且文本含明确新鲜特征时放行，
                               否则视为历史消息丢弃
        """
        logger.debug(f"[ocr] === 过滤器1: _ocr_text_has_fresh_timestamp 开始检查 ===")
        logger.debug(f"[ocr] 输入文本: {text[:100]!r}")
        if not text:
            logger.debug(f"[ocr] 过滤器1结果: 空文本，返回False")
            return False
        # 标准化 EasyOCR 时间戳：16.47 → 16:47, 15;39 → 15:39, 16:03.41 → 16:03:41
        normalized = re.sub(r'(\d{1,2})[.;](\d{2})(?:[.;](\d{2}))?', r'\1:\2:\3', text)
        timestamps = re.findall(r'\d{1,2}:\d{1,2}(?::\d{1,2})?', normalized)
        logger.debug(f"[ocr] 提取到时间戳: {timestamps}")
        if not timestamps:
            # ⭐ 无可见时间戳：仅超短中文消息（如"好的""嗯"）视为可能的新消息放行；
            #   较长文本无时间戳 → 无法验证新鲜性，可能是不含时间戳的历史/UI噪声
            #   → 丢弃，防止旧消息因整批无时间戳而绕过 stage splitting 放行
            #   但如果文本包含噪声（HTML/图片路径等），直接丢弃
            logger.debug(f"[ocr] 无可见时间戳")
            if self._is_noise_text(text):
                logger.debug(f"[ocr] 过滤器1结果: 无时间戳且为噪声文本，丢弃: {text[:80]!r}")
                return False
            if len(text.strip()) <= 4 and re.search(r'[\u4e00-\u9fff]', text):
                logger.debug(f"[ocr] 过滤器1结果: 无时间戳但为超短中文消息，放行: {text[:80]!r}")
                self._msg_history.record_user_message(platform, text.strip())
                return True
            # 用户消息挨着bot消息判断：最近一次bot回复在30秒内
            last_bot_time = self._msg_history.last_bot_reply_time(platform)
            if last_bot_time > 0 and time.time() - last_bot_time <= 30:
                # 用户消息挨着bot消息
                if not self._msg_history.is_user_message_replied(platform, text.strip()):
                    # 数据库无记录，无条件放行
                    logger.debug(f"[ocr] 过滤器1结果: 无时间戳但用户消息挨着bot消息且无记录，放行: {text[:80]!r}")
                    self._msg_history.record_user_message(platform, text.strip())
                    return True
                else:
                    # 数据库有记录，整段丢弃
                    logger.debug(f"[ocr] 过滤器1结果: 无时间戳且用户消息挨着bot消息但有记录，丢弃: {text[:80]!r}")
                    return False
            logger.debug(f"[ocr] 过滤器1结果: 无时间戳且非超短消息，丢弃: {text[:80]!r}")
            return False
        # 有新鲜时间戳 → 确定有新消息
        for ts in timestamps:
            try:
                if not self._is_timestamp_old(ts, 300):
                    logger.debug(f"[ocr] 过滤器1结果: 发现新鲜时间戳{ts}（≤300s），放行")
                    return True
            except Exception:
                pass
        # 全部过期：若最新时间戳已 ≥600s，整屏视为历史消息，直接丢弃
        newest_fresh_enough = False
        for ts in timestamps:
            try:
                if not self._is_timestamp_old(ts, 600):
                    newest_fresh_enough = True
                    break
            except Exception:
                pass
        if not newest_fresh_enough:
            logger.debug(f"[ocr] 过滤器1结果: 最新可见时间戳已过期≥600s，丢弃: {text[:80]!r}")
            return False
        # 最新时间戳在 300-600s 之间，且文本含明确新鲜特征 → 放行给 stage splitting
        if self._looks_fresh_content(text):
            logger.debug(f"[ocr] 过滤器1结果: 时间戳全过期但最新≤600s且含新鲜特征，放行: {text[:80]!r}")
            return True
        logger.debug(f"[ocr] 过滤器1结果: 时间戳全过期且无新鲜特征，丢弃: {text[:80]!r}")
        return False

    # 未来时间戳容忍偏差（秒）：同日内时间戳比系统时间晚超过此值 = 未到来，直接丢弃。
    # 容忍小量偏差避免误杀：OCR/聊天服务器时钟与系统时钟存在秒级差异，刚到的消息
    # 时间戳可能比系统时间晚几秒（如 14:41:00 消息在 14:40:58 被捕获）。
    _TS_FUTURE_TOLERANCE_S = 15

    @staticmethod
    def _is_timestamp_old(ts_str: str, max_age: int = 300) -> bool:
        """检查 HH:MM 或 HH:MM:SS 时间戳是否超过 max_age 秒。
        处理跨午夜边界：如果 diff > 12h 说明是昨天的时间戳。
        未来时间戳硬拦截：同日内 diff < -容差 = 时间未到来（系统14:40不可能有16:00），丢弃。
        OCR 误读兜底：15:31→5:31（`1`笔画细被吞），若 h<12，尝试 h+10/h+12
        取 diff 最小者，若 < max_age 则视为 OCR 误读，放行。
        返回 True = 时间戳太老，应跳过。
        """
        ts = ts_str.strip()
        if not ts:
            return False
        m = re.match(r'^(\d{1,2}):(\d{2})(?::(\d{2}))?$', ts)
        if not m:
            return False
        h, mi, s = int(m.group(1)), int(m.group(2)), int(m.group(3) or 0)
        if h > 23 or mi > 59 or s > 59:
            return False
        now = datetime.now()
        try:
            parsed = now.replace(hour=h, minute=mi, second=s, microsecond=0)
        except ValueError:
            return False
        diff = (now - parsed).total_seconds()
        # 跨午夜: diff > 12h 说明时间戳来自昨天
        # ⚠ 用 timedelta 回退而非 replace(day-1)：每月1号 day=1 时 day-1=0 抛
        #   ValueError("day is out of range for month") → 微信 OCR 整轮失败
        if diff > 43200:
            parsed = parsed - timedelta(days=1)
            diff = (now - parsed).total_seconds()
        # 跨午夜反向: diff < -12h 说明是昨天晚些时候（当前 00:05，时间戳 23:55 → 昨天23:55）
        # ⚠ 必须 -1day：之前误用 +1day 得到 -47h 的负 diff → 返回"不旧"=新鲜 → 凌晨误判
        if diff < -43200:
            parsed = parsed - timedelta(days=1)
            diff = (now - parsed).total_seconds()
        # 未来时间戳硬拦截（用户反馈：系统14:40 不能把 16:00 未到来的时间判为新鲜）:
        # 跨午夜调整后仍为负 = 同日内未来时间，必为 OCR 误读/异常，直接丢弃
        if diff < -MessageMonitor._TS_FUTURE_TOLERANCE_S:
            logger.debug(f"[ts] 未来时间戳拦截: {ts} 比系统时间 {now.strftime('%H:%M:%S')} 晚 {-diff:.0f}s，未到来，丢弃")
            return True
        # OCR 误读兜底：h<12 且判定为老 → 尝试 h+10 / h+12（OCR 丢失前导1：15→5）
        if diff > max_age and h < 12:
            best_h, best_diff = h, diff
            for offset in (10, 12):
                try:
                    h2 = h + offset
                    if h2 > 23:
                        continue
                    parsed2 = now.replace(hour=h2, minute=mi, second=s, microsecond=0)
                    diff2 = (now - parsed2).total_seconds()
                    if diff2 < 0:
                        diff2 += 86400
                    if diff2 < best_diff:
                        best_diff = diff2
                        best_h = h2
                except ValueError:
                    pass
            if best_h != h and best_diff < max_age:
                logger.debug(f"[ts] OCR误读兜底: {ts} 可能是 {best_h}:{mi:02d}:{s:02d}, diff={best_diff:.0f}s < {max_age}s, 放行")
                return False
        return diff > max_age

    @staticmethod
    def _is_system_message(text: str) -> bool:
        """过滤机器人/系统消息，不作为用户消息处理。"""
        if not text:
            return True
        # NFKC 标准化：去除 UIA/OCR 夹杂的零宽字符、不可见 Unicode
        text = unicodedata.normalize('NFKC', text)
        # 系统前缀/标记
        system_markers = [
            "✅", "❌", "📝", "🔍", "📄", "➡", "♡", "✿",
            "[WECHAT]", "[QQ]", "[wechat]", "[qq]",
        ]
        for m in system_markers:
            if text.startswith(m):
                return True
        # ⭐ QQ/微信 界面噪声文字（按钮/提示/碎片/导航，非用户消息）
        qq_ui_noise = [
            "查看更多", "可查看在其他设备产生的聊天记录",
            "收藏", "转发", "多选", "引用", "回复",
            "选择会话开始聊天",
            # 微信底部导航
            "通讯录", "发现", "我", "消息", "朋友圈",
            # 微信/QQ 顶部/侧边
            "搜索", "添加到表情", "更多",
            # 微信底部栏 + 附加按钮
            "导航", "视频号",
            # QQ 空间/动态
            "空间", "动态", "说说", "日志", "相册",
            # 通用 UI
            "发送", "接收", "取消", "确认", "确定", "关闭",
        ]
        for n in qq_ui_noise:
            if text == n:
                return True
        # 系统事件模板 — 注意：用 startswith 而非 in，避免混合文本（OCR 多行合一）误杀
        system_patterns = [
            "已自动回复", "知识库中未找到", "找到相关结果",
            "监控已启动", "监控已暂停", "设置已保存",
            "🤖", "找不到联系人", "当前会话回复",
            "自动回复触发", "匹配度",
            # KB 文档内容格式（机器人回复格式），OCR 可能把用户消息+KB 回复混成一行
            # 只有全行以"答："开头才过滤，内含"答："的混合文本不过滤
            "答：",
            # 纯系统命令反馈
            "PS ", "❯ ", "$ ",
        ]
        for p in system_patterns:
            if text.startswith(p):
                return True
        # 纯时间格式（不含消息内容）
        if re.match(r'^\d{1,2}:\d{2}', text):
            return True
        return False

    @staticmethod
    def _strip_json_yaml_blocks(raw_text: str, platform: str = "") -> str:
        """剥离 OCR 截屏中混入的 JSON/YAML 配置块。

        微信 OCR 截屏范围 40%-98%，常把右侧文档/配置面板一起截入。
        JSON 块（"key": value, {, }）和 YAML 块（key: value, - item）
        跟用户消息混在一起，导致 split 后 JSON 碎片污染用户消息行。

        策略：逐行检测，丢弃明显是 JSON/YAML 语法的行。
        用户聊天不会写 "key": value 或 { } 块。
        """
        lines = raw_text.split('\n')
        cleaned = []
        in_json_block = False
        brace_depth = 0

        for line in lines:
            stripped = line.strip()
            if not stripped:
                cleaned.append(line)
                continue

            # 检测 JSON 对象块开始/结束
            if stripped == '{' or stripped.startswith('{') and '"' in stripped:
                in_json_block = True
                brace_depth = stripped.count('{') - stripped.count('}')
                logger.debug(f"[{platform}] JSON块剥离: 开始 {stripped[:60]!r}")
                continue

            if in_json_block:
                brace_depth += stripped.count('{') - stripped.count('}')
                if brace_depth <= 0:
                    in_json_block = False
                    logger.debug(f"[{platform}] JSON块剥离: 结束 {stripped[:60]!r}")
                continue

            # JSON 行特征: "key": value 或 "key": "value"
            if re.match(r'^["\']?[a-zA-Z_][\w]*["\']?\s*:\s*["\d\[\{tfn]', stripped):
                logger.debug(f"[{platform}] JSON块剥离: key-value行 {stripped[:60]!r}")
                continue

            # YAML 行特征: key: value（无引号，非 URL）
            if re.match(r'^[a-zA-Z_][\w]*\s*:\s*["\w\d]', stripped) and \
               not re.match(r'^(https?|ftp)://', stripped) and \
               not re.match(r'^[a-zA-Z_][\w]*\s*:\s*/', stripped):
                logger.debug(f"[{platform}] JSON块剥离: YAML行 {stripped[:60]!r}")
                continue

            # YAML 列表项: - item
            if re.match(r'^-\s+\S', stripped) and \
               not re.match(r'^-\s*[\u4e00-\u9fff]', stripped):
                logger.debug(f"[{platform}] JSON块剥离: YAML列表 {stripped[:60]!r}")
                continue

            # 纯 JSON 数组: [ "item", ... ]
            if stripped.startswith('[') and stripped.endswith(']') and \
               '"' in stripped:
                logger.debug(f"[{platform}] JSON块剥离: 数组 {stripped[:60]!r}")
                continue

            cleaned.append(line)

        return '\n'.join(cleaned)

    @staticmethod
    def _is_markdown_document(text: str) -> bool:
        """检测是否为 Markdown 格式的文档内容。

        Bot 回复用 md 格式（# 标题、[链接](url)、列表等），用户日常对话不用。
        借此区分 bot 旧回复和历史堆积 vs 用户新消息。
        """
        logger.debug(f"[ocr] 过滤器3: _is_markdown_document 检查: {text[:80]!r}")
        if not text:
            logger.debug(f"[ocr] 过滤器3结果: 空文本，返回False")
            return False
        # # 行首标题：短文本也检测（OCR 把 ##协议修 切成 5 字符片段）
        if re.match(r'^#{1,6}(?:\s|\[|[\u4e00-\u9fff])', text):
            logger.debug(f"[ocr] 过滤器3结果: 检测到Markdown标题语法，返回True")
            return True
        # 行首列表项：短文本也检测（- 玩家义务 / * 注意）
        # 必须放 len<10 之前，否则 "- 玩家应尊重他"(8c) 漏网
        if re.match(r'^[\-\*]\s', text):
            logger.debug(f"[ocr] 过滤器3结果: 检测到Markdown列表语法，返回True")
            return True
        # 全角括号退化 md 链接：短文本也检测
        if re.search(r'\]（', text):
            logger.debug(f"[ocr] 过滤器3结果: 检测到全角括号退化链接，返回True")
            return True
        if re.search(r'\[.+?\]（', text):
            logger.debug(f"[ocr] 过滤器3结果: 检测到全角括号退化链接模式2，返回True")
            return True
        # OCR 退化 md checkbox：短文本也检测（[V] / [x]）
        if re.search(r'\[\s*[VXvx√✗]\s*\]', text):
            logger.debug(f"[ocr] 过滤器3结果: 检测到OCR退化checkbox，返回True")
            return True
        # OCR 退化 md 链接缺括号：短文本也检测
        if re.search(r'\[.+?\]\(', text):
            logger.debug(f"[ocr] 过滤器3结果: 检测到OCR退化链接，返回True")
            return True
        # **加粗**语法：短文本也检测（bot md 回复标配，用户日常不用）
        if re.search(r'\*\*.+?\*\*', text):
            logger.debug(f"[ocr] 过滤器3结果: 检测到加粗语法，返回True")
            return True
        # <br> HTML 换行标记 — bot md 回复中用于换行，用户聊天不打
        if re.search(r'<\s*br\s*/?\s*>', text, re.IGNORECASE):
            logger.debug(f"[ocr] 过滤器3结果: 检测到HTML换行标记，返回True")
            return True
        # ###1. / ####数字标题 — 数字直接跟在 # 后（OCR 常见）
        if re.match(r'^#{1,6}\d', text):
            return True
        # 编号列表项：1. 2. 12. / 1) 2) / 1、2、
        if re.match(r'^\d{1,3}[\.\)、]\s', text):
            return True
        # 引用块：> 开头
        if re.match(r'^>\s', text):
            return True
        # 水平分隔线：--- 或 === 连续 3+ 个
        if re.match(r'^[-=]{3,}\s*$', text):
            return True
        # |表格行：| 开头和结尾
        if re.match(r'^\|.+\|$', text):
            return True
        # *斜体* / ***粗斜体* 或任何 ** 裸标记
        # 用户日常对话从不打 **，只可能是 bot md 回复
        if '**' in text:
            return True
        if len(text) < 10:
            logger.debug(f"[ocr] 过滤器3结果: 短文本(<10)无Markdown特征，返回False")
            return False
        # ##直接跟汉字（OCR 丢失 ##后空格时常见：##文档导航）
        if re.match(r'^#{1,6}[\u4e00-\u9fff]', text):
            return True
        # 包含 markdown 链接 [text](url)
        if re.search(r'\[.+?\]\(.+?\)', text):
            return True
        # 包含 .md 文件引用（如 "gin.md)" 分割后断开的链接）
        if re.search(r'\S+\.md\)', text):
            return True
        # 包含代码块标记 ``` 或 `code`
        if re.search(r'`{1,3}', text):
            return True
        # 连续 3+ 行包含 markdown 特征：| 表格、--- 分隔线、> 引用
        pipes = text.count('|')
        if pipes >= 3:
            return True
        # 内联 # # 标题标记（如 "# # 必装依赖" → 分割后 `#  #` 或 `# #`）
        if re.search(r'#\s*#', text):
            return True
        return False

    @staticmethod
    def _is_noise_text(text: str) -> bool:
        """检测是否为OCR噪声文本（HTML标签、图片路径、OCR乱码等）。

        这些文本通常来自QQ消息中的引用/图片附属内容，或OCR识别错误。
        返回 True = 应当丢弃。
        """
        logger.debug(f"[ocr] 过滤器2: _is_noise_text 检查: {text[:80]!r}")
        if not text:
            logger.debug(f"[ocr] 过滤器2结果: 空文本，返回False")
            return False
        # HTML 标签：<br>、<br/>、<p>、</p>、<div>等
        if re.search(r'<\s*(?:br|p|div|span|a|img)\s*/?\s*>', text, re.IGNORECASE):
            logger.debug(f"[ocr] 过滤器2结果: 检测到HTML标签，返回True")
            return True
        # 图片路径引用：![](./img/...)、!0(Jimg/...)、![](...)=等
        if re.search(r'!\s*\[.*?\]\s*\(.*?\)', text):
            logger.debug(f"[ocr] 过滤器2结果: 检测到图片路径引用模式1，返回True")
            return True
        # 简化图片路径：!0(Jimg/...) 或 ![](./img/...)
        if re.search(r'!\s*\[.*?\]\s*\(', text):
            logger.debug(f"[ocr] 过滤器2结果: 检测到图片路径引用模式2，返回True")
            return True
        # 纯图片路径：./img/... 或 img/...
        if re.search(r'(?:^|\s)\.?(?:img|image|pic|photo)/\S+', text, re.IGNORECASE):
            logger.debug(f"[ocr] 过滤器2结果: 检测到纯图片路径，返回True")
            return True
        # OCR 噪声字符模式：!0(J、![](...)= 等
        if re.search(r'![\[\(]\S+[\]\)]', text):
            logger.debug(f"[ocr] 过滤器2结果: 检测到OCR噪声字符模式，返回True")
            return True
        # 编辑权限等UI文本残留（用户截图中出现）
        if re.search(r'编辑权限', text):
            logger.debug(f"[ocr] 过滤器2结果: 检测到UI文本残留，返回True")
            return True
        logger.debug(f"[ocr] 过滤器2结果: 未检测到噪声特征，返回False")
        return False

    def _paste_and_send_safe(self, text: str, hwnd: int, msg_hash: int, platform: str) -> bool:
        """Electron 应用安全发送（TIM/微信）。无 AttachThreadInput、无 SendMessage 同步点击。

        Electron 多线程架构下 AttachThreadInput 会导致死锁，
        SendMessage 同步阻塞在渲染进程 busy 时直接炸进程。
        只用 SwitchToThisWindow + 前台确认后 keybd_event。
        """
        import win32clipboard as wc

        # 保存原始剪贴板
        old = None
        try:
            wc.OpenClipboard()
            if wc.IsClipboardFormatAvailable(wc.CF_UNICODETEXT):
                old = wc.GetClipboardData(wc.CF_UNICODETEXT)
            wc.CloseClipboard()
        except Exception:
            pass

        success = False
        try:
            # 设剪贴板
            try:
                wc.OpenClipboard()
                wc.EmptyClipboard()
                wc.SetClipboardText(text, wc.CF_UNICODETEXT)
                wc.CloseClipboard()
            except Exception as e:
                logger.error(f"[{platform}] 剪贴板设文本失败: {e}")
                return False

            root_hwnd = win32gui.GetAncestor(hwnd, win32con.GA_ROOT)

            # 恢复/显示窗口（仅 SwitchToThisWindow + SetForegroundWindow，无 AttachThreadInput）
            try:
                if win32gui.IsIconic(root_hwnd):
                    win32gui.ShowWindow(root_hwnd, win32con.SW_RESTORE)
                    time.sleep(0.3)
                if not win32gui.IsWindowVisible(root_hwnd):
                    win32gui.ShowWindow(root_hwnd, win32con.SW_SHOWNORMAL)
                    time.sleep(0.3)
                ctypes.windll.user32.AllowSetForegroundWindow(-1)
                ctypes.windll.user32.SwitchToThisWindow(root_hwnd, True)
                time.sleep(0.2)
                win32gui.SetForegroundWindow(root_hwnd)
                time.sleep(0.3)
            except Exception as e:
                logger.debug(f"[{platform}] 窗口唤醒异常: {e}")

            # 验证前台 — 失败则放弃，不做 SendMessage 防崩
            fg_now = win32gui.GetForegroundWindow()
            fg_ok = (fg_now == root_hwnd) or (fg_now and win32gui.IsChild(root_hwnd, fg_now))
            if not fg_ok:
                logger.warning(f"[{platform}] 前台失败，放弃发送（不做 SendMessage 防崩）")
                return False

            # keybd_event 发送（只有在前台确认后才做）
            VK_A = 0x41
            VK_V = 0x56
            VK_BACK = 0x08
            VK_RETURN = 0x0D
            try:
                self._send_ctrl_combo(VK_A)
                time.sleep(0.05)
                self._key_down(VK_BACK)
                self._key_up(VK_BACK)
                time.sleep(0.05)
                self._send_ctrl_combo(VK_V)
                time.sleep(0.3)
                self._key_down(VK_RETURN)
                self._key_up(VK_RETURN)
                time.sleep(0.5)
            except Exception as e:
                logger.error(f"[{platform}] keybd_event 发送失败: {e}")
                return False

            logger.info(f"[{platform}] 已回复(安全路径): {text[:60]}")

            # 记录到消息历史数据库
            self._msg_history.record_bot_reply(platform, text.strip())

            # 记录回复到去重集（与 _paste_and_send 一致）
            reply_text = text.strip()
            self._replied_texts.add(reply_text)
            self._seen_messages.add(reply_text)
            if '\n' in reply_text:
                self._replied_texts.add(reply_text.replace('\n', ' '))
                self._replied_texts.add(reply_text.replace('\n', ' ').rstrip('.'))
                self._seen_messages.add(reply_text.replace('\n', ' '))
                self._seen_messages.add(reply_text.replace('\n', ' ').rstrip('.'))
                for part in reply_text.split('\n'):
                    part = part.strip()
                    if part and len(part) > 3:
                        self._replied_texts.add(part)
                        self._seen_messages.add(part)
                        if part.startswith('#'):
                            no_hash = re.sub(r'^#+\s*', '', part).strip()
                            if no_hash and len(no_hash) > 2:
                                self._replied_texts.add(no_hash)
                                self._seen_messages.add(no_hash)
            self._last_reply_time[platform] = time.time()
            self._self_reply_cooldown_until[platform] = time.time() + 15.0
            flat = reply_text.replace('\n', ' ')
            if len(flat) > 15:
                self._replied_texts.add(flat[:30])
                if len(flat) > 40:
                    self._replied_texts.add(flat[-30:].strip())
            self._foreground_cooldown_until[platform] = time.time() + 30.0
            success = True
            return True
        finally:
            # 恢复原始剪贴板
            if old is not None:
                try:
                    wc.OpenClipboard()
                    wc.EmptyClipboard()
                    wc.SetClipboardText(old, wc.CF_UNICODETEXT)
                    wc.CloseClipboard()
                except Exception:
                    pass
            # 失败时记录冷却
            if not success:
                self._failed_send_cooldown[msg_hash] = time.time()
                self._seen_messages.add(text.strip())
        return True

    def _paste_and_send(self, platform: str, text: str) -> bool:
        """粘贴文本到输入框并发送（剪贴板 + SendInput）。"""
        hwnd = self._cached_hwnd.get(platform)
        if not hwnd:
            return False

        # 失败冷却检查：60 秒内同一消息不重试（防止卡死）
        msg_hash = hash(text) % 100000
        last_fail = self._failed_send_cooldown.get(msg_hash, 0.0)
        if time.time() - last_fail < 60.0:
            logger.debug(f"[{platform}] 发送冷却中({int(60-(time.time()-last_fail))}s)，跳过")
            return False

        import win32clipboard as wc

        # 保存剪贴板
        old = None
        try:
            wc.OpenClipboard()
            if wc.IsClipboardFormatAvailable(wc.CF_UNICODETEXT):
                old = wc.GetClipboardData(wc.CF_UNICODETEXT)
            wc.CloseClipboard()
        except Exception:
            pass

        try:
            # 设置答案到剪贴板
            wc.OpenClipboard()
            wc.EmptyClipboard()
            wc.SetClipboardText(text, wc.CF_UNICODETEXT)
            wc.CloseClipboard()

            # ⛔ 剪贴板回读校验：设完立即读回，确认内容一致才继续
            # 防止 monitor 线程的 _read_via_clipboard_once 在设与用之间 Ctrl+C 覆盖
            try:
                wc.OpenClipboard()
                if wc.IsClipboardFormatAvailable(wc.CF_UNICODETEXT):
                    verify = wc.GetClipboardData(wc.CF_UNICODETEXT)
                else:
                    verify = None
                wc.CloseClipboard()
                if verify != text:
                    logger.error(f"[{platform}] 剪贴板校验失败: 设了{len(text)}c但读回{len(verify or '')}c，可能被其他线程覆盖")
                    raise RuntimeError("clipboard verification failed")
            except RuntimeError:
                raise
            except Exception:
                logger.error(f"[{platform}] 剪贴板校验异常，放弃发送")
                raise

            # ── Electron 安全发送路径：TIM/微信都无 AttachThreadInput、无 SendMessage ──
            if (platform == "qq" and self._app_variant.get("qq") == "tim") or platform == "wechat":
                return self._paste_and_send_safe(text, hwnd, msg_hash, platform)

            # ── 更激进的窗口唤醒 ──
            # 1) 允许任意进程 SetForegroundWindow（移除系统限制）
            try:
                ctypes.windll.user32.AllowSetForegroundWindow(-1)  # ASFW_ANY
            except Exception:
                pass

            # 2) 恢复/显示窗口
            root_hwnd = win32gui.GetAncestor(hwnd, win32con.GA_ROOT)
            if win32gui.IsIconic(root_hwnd):
                win32gui.ShowWindow(root_hwnd, win32con.SW_RESTORE)
                time.sleep(0.3)
            if not win32gui.IsWindowVisible(root_hwnd):
                win32gui.ShowWindow(root_hwnd, win32con.SW_SHOWNORMAL)
                time.sleep(0.3)

            # 3) AttachThreadInput + SetForegroundWindow（不发送全局 Alt 键干扰 QQ 焦点）
            try:
                self._attach_set_foreground(root_hwnd)
            except Exception as e:
                logger.debug(f"[{platform}] _attach_set_foreground 异常: {e}")
            time.sleep(0.2)

            # 4) 再 SetForegroundWindow + SwitchToThisWindow
            try:
                win32gui.SetForegroundWindow(root_hwnd)
                ctypes.windll.user32.SwitchToThisWindow(root_hwnd, True)
            except Exception as e:
                logger.debug(f"[{platform}] SetForegroundWindow/SwitchToThisWindow 异常: {e}")
            time.sleep(0.3)

            # 5) 验证 foreground — 不成功则用 SendMessage 点击 + keybd_event
            VK_A = 0x41
            VK_V = 0x56
            VK_BACK = 0x08
            VK_RETURN = 0x0D

            fg_now = win32gui.GetForegroundWindow()
            fg_ok = (fg_now == root_hwnd) or (fg_now and win32gui.IsChild(root_hwnd, fg_now))
            if not fg_ok:
                logger.warning(f"[{platform}] 前台唤醒失败(fg={fg_now}, target={root_hwnd})，SendMessage 点击+keybd_event 兜底")
                # SendMessage 同步点击设置焦点（Electron 接受 SendMessage 点击）
                rect = win32gui.GetWindowRect(hwnd)
                if rect:
                    left, top, right, bottom = rect
                    w = right - left
                    h = bottom - top
                    click_x = int(w * 0.72)
                    click_y = int(h * 0.92)
                    lparam = win32api.MAKELONG(click_x, click_y)
                    win32gui.SendMessage(hwnd, win32con.WM_LBUTTONDOWN, win32con.MK_LBUTTON, lparam)
                    win32gui.SendMessage(hwnd, win32con.WM_LBUTTONUP, 0, lparam)
                    time.sleep(0.3)
                    # 再试一次 SetForegroundWindow（SendMessage 点击后可能已生效）
                    self._attach_set_foreground(root_hwnd)
                    try:
                        win32gui.SetForegroundWindow(root_hwnd)
                    except Exception:
                        pass
                    time.sleep(0.2)

                # keybd_event 发送（不依赖 PostMessage——Electron 不吃 PostMessage 键盘）
                self._send_ctrl_combo(VK_A)
                time.sleep(0.05)
                self._key_down(VK_BACK)
                self._key_up(VK_BACK)
                time.sleep(0.05)
                self._send_ctrl_combo(VK_V)
                time.sleep(0.3)
                self._key_down(VK_RETURN)
                self._key_up(VK_RETURN)
                time.sleep(0.5)
                logger.info(f"[{platform}] 已回复(SendMessage+keybd): {text[:60]}")
                # 记录到消息历史数据库
                self._msg_history.record_bot_reply(platform, text.strip())
            else:
                # ── 前台成功：SendMessage 点击输入框（同步，确保焦点） + keybd_event ──
                rect = win32gui.GetWindowRect(hwnd)
                if rect:
                    left, top, right, bottom = rect
                    w = right - left
                    h = bottom - top
                    click_x = int(w * 0.72)
                    click_y = int(h * 0.92)
                    lparam = win32api.MAKELONG(click_x, click_y)
                    win32gui.SendMessage(hwnd, win32con.WM_LBUTTONDOWN, win32con.MK_LBUTTON, lparam)
                    win32gui.SendMessage(hwnd, win32con.WM_LBUTTONUP, 0, lparam)
                    time.sleep(0.2)

                # keybd_event 发送（窗口已在前台）
                self._send_ctrl_combo(VK_A)
                time.sleep(0.05)
                self._key_down(VK_BACK)
                self._key_up(VK_BACK)
                time.sleep(0.05)
                self._send_ctrl_combo(VK_V)
                time.sleep(0.3)
                self._key_down(VK_RETURN)
                self._key_up(VK_RETURN)
                time.sleep(0.5)
                logger.info(f"[{platform}] 已回复: {text[:60]}")
                # 记录到消息历史数据库
                self._msg_history.record_bot_reply(platform, text.strip())

            # 记录回复文本到去重集
            # 将回复文本加入 _replied_texts（永久集，永不裁切，必拦）和 seen
            reply_text = text.strip()
            self._replied_texts.add(reply_text)
            self._seen_messages.add(reply_text)
            # 添加换行符归一化变体（跨频道转发时会替换 \n → 空格）
            if '\n' in reply_text:
                self._replied_texts.add(reply_text.replace('\n', ' '))
                self._replied_texts.add(reply_text.replace('\n', ' ').rstrip('.'))
                self._seen_messages.add(reply_text.replace('\n', ' '))
                self._seen_messages.add(reply_text.replace('\n', ' ').rstrip('.'))
                for part in reply_text.split('\n'):
                    part = part.strip()
                    if part and len(part) > 3:
                        self._replied_texts.add(part)
                        self._seen_messages.add(part)
                        # 同时追踪去掉 ## 前缀的标题文本（OCR 常丢失 ## 后的空格）
                        if part.startswith('#'):
                            no_hash = re.sub(r'^#+\s*', '', part).strip()
                            if no_hash and len(no_hash) > 2:
                                self._replied_texts.add(no_hash)
                                self._seen_messages.add(no_hash)
            self._last_reply_time[platform] = time.time()
            # 同平台 15s 冷却：回复回声截到也不触发
            self._self_reply_cooldown_until[platform] = time.time() + 15.0
            # 追加前30字符/后30字符变体（OCR 碎片常截取回复的开头或结尾）
            flat = reply_text.replace('\n', ' ')
            if len(flat) > 15:
                self._replied_texts.add(flat[:30])
                if len(flat) > 40:
                    self._replied_texts.add(flat[-30:].strip())
            # 回复涉及前景切换（QQ Alt+Tab / 微信 SendMessage 点击）
            # → 对端平台冷却 30s，避免另一平台截到相同回复内容又触发自动回复
            other = "qq" if platform == "wechat" else "wechat"
            self._foreground_cooldown_until[other] = time.time() + 30.0
            return True
        except Exception as e:
            logger.error(f"[{platform}] 回复失败: {e}\n{traceback.format_exc()}")
            # 进入冷却期，60 秒内不重试同一条消息
            self._failed_send_cooldown[msg_hash] = time.time()
            # 加入 seen_messages 防止下一轮 OCR 读到相同文本又触发
            self._seen_messages.add(text.strip())
            return False
        finally:
            # 恢复原始剪贴板
            if old is not None:
                try:
                    wc.OpenClipboard()
                    wc.EmptyClipboard()
                    wc.SetClipboardText(old, wc.CF_UNICODETEXT)
                    wc.CloseClipboard()
                except Exception:
                    pass

    # ── 核心：读消息 ──────────────────────────────────────────

    def _read_messages(self, window, platform: str = "") -> list:
        """每轮重新定位 ListControl。"""
        if platform == "qq":
            # QQ NT: OCR 读屏优先（零依赖，不切焦点，不碰剪贴板）
            texts = self._ocr_read_qq()
            if texts:
                logger.debug(f"[qq] 消息来源: OCR → {len(texts)} 条")
                return texts
            # 截图未变→跳过所有 fallback（clipboard/UIA 只会读旧数据）
            if self._ocr_unchanged.get("qq"):
                return []
            # TIM (Electron) 安全：OC R 空时跳过所有 fallback。
            # 剪贴板路径调 _ensure_foreground → AttachThreadInput → 崩 TIM；
            # UIA / Win32 读 Electron 窗口也无意义（结构不稳定）。
            if self._app_variant.get("qq") == "tim":
                return []

            # OCR 空 → 剪贴板兜底（窗口置前→滚底→全选→复制，内部自带重试）
            texts = self._read_via_clipboard_once(platform)
            if texts and len(texts) > 5:
                logger.debug(f"[qq] 消息来源: 剪贴板 → {len(texts)} 条")
                return texts

            # 剪贴板也空 → UIA 最后兜底（可能返回陈旧数据）
            fresh_win = self._find_qq_window_fresh()
            if fresh_win:
                texts = self._read_message_list(fresh_win)
                if texts:
                    logger.debug(f"[qq] 消息来源: UIA消息列表 → {len(texts)} 条")
                    return texts
                texts = self._read_conversation_list(fresh_win)
                if texts:
                    logger.debug(f"[qq] 消息来源: UIA会话列表 → {len(texts)} 条")
                    return texts
                try:
                    rect = fresh_win.BoundingRectangle
                    boundary = rect.left + rect.width() * 0.40
                    for lst in self._list_controls(fresh_win):
                        try:
                            cr = lst.BoundingRectangle
                            if cr.left >= boundary:
                                texts = self._extract_last_line(lst)
                                if texts:
                                    logger.debug(f"[S-C] ListControl(x={cr.left}) → {len(texts)} items")
                                    return texts
                        except Exception:
                            pass
                except Exception:
                    pass
                try:
                    texts = self._collect_filtered_texts(fresh_win, "qq", max_depth=5)
                    if texts:
                        _before = len(texts)
                        texts = [t for t in texts if t not in _UI_EXACT_BLOCKLIST]
                        if texts:
                            logger.debug(f"[S-D] 全窗文本 → {_before} items ({_before - len(texts)} UI过滤)")
                            return texts
                        return []
                except Exception:
                    pass

            # Win32 兜底
            texts = self._read_win32_texts(platform)
            if texts:
                logger.debug(f"[qq] 消息来源: Win32 → {len(texts)} 条")
                return texts
            return []

        # 微信: OCR 读屏优先（同 QQ 策略，UIA 树不暴露消息内容）
        texts = self._ocr_read_wechat()
        if texts:
            return texts
        # 截图未变→跳过 fallback
        if self._ocr_unchanged.get("wechat"):
            return []
        # 未提供 UIA 控件（_poll 跳过了 _fresh_window 避免 Electron 冻结）
        # 此时惰性创建，仅在 OCR 失败后 fallback 时才需要
        if window is None:
            window = self._fresh_window(platform)
        if window is None:
            return []
        # 微信: UIA 兜底（可能读到陈旧数据或 UI 文字）
        texts = self._read_message_list(window)
        if texts:
            return texts
        # 兜底：会话列表
        texts = self._read_conversation_list(window)
        if texts:
            return texts
        try:
            rect = window.BoundingRectangle
            boundary = rect.left + rect.width() * 0.40
            for lst in self._list_controls(window):
                try:
                    cr = lst.BoundingRectangle
                    if cr.left >= boundary:
                        texts = self._extract_last_line(lst)
                        if texts:
                            logger.debug(f"[S-C] ListControl(x={cr.left}) → {len(texts)} items")
                            return texts
                except Exception:
                    pass
        except Exception:
            pass
        try:
            texts = self._collect_filtered_texts(window, "wechat", max_depth=5)
            if texts:
                # Smart-Dump 产出 UI 文本不经过 _process_ocr_output 过滤链
                # → 手动过 UI 块列表
                _before = len(texts)
                texts = [t for t in texts if t not in _UI_EXACT_BLOCKLIST]
                if texts:
                    logger.debug(f"[S-D] 全窗文本 → {_before} items ({_before - len(texts)} UI过滤)")
                    return texts
                return []
        except Exception:
            pass
        return []

    def _read_message_list(self, window) -> list:
        # 只接受窗口右半侧（>45%）的 ListControl，避开侧栏/文件列表用同名控件
        try:
            wr = window.BoundingRectangle
            boundary = wr.left + wr.width() * 0.45
        except Exception:
            boundary = 0
        for name in ["消息", "Message"]:
            try:
                lst = window.ListControl(Name=name)
                if lst.Exists(maxSearchSeconds=0.2):
                    try:
                        cr = lst.BoundingRectangle
                        if cr.left < boundary:
                            continue  # 左侧的"消息"列表（文件/笔记预览）跳过
                    except Exception:
                        pass
                    self._scroll_to_bottom(lst)
                    texts = self._extract_last_line(lst)
                    if texts:
                        logger.debug(f"[S-A] ListControl({name}) → {len(texts)} items, last=\"{texts[-1][:50]}\"")
                        return texts
            except Exception:
                pass
        return []

    def _read_conversation_list(self, window) -> list:
        try:
            wr = window.BoundingRectangle
            boundary = wr.left + wr.width() * 0.45
        except Exception:
            boundary = 0
        for name in ["会话", "聊天", "Chat"]:
            try:
                lst = window.ListControl(Name=name)
                if lst.Exists(maxSearchSeconds=0.2):
                    try:
                        cr = lst.BoundingRectangle
                        if cr.left < boundary:
                            continue
                    except Exception:
                        pass
                    self._scroll_to_bottom(lst)
                    texts = self._extract_second_line(lst)
                    if texts:
                        logger.debug(f"[S-B] 会话({name}) → {len(texts)} items, last=\"{texts[-1][:50]}\"")
                        return texts
            except Exception:
                pass
        return []

    def _scroll_to_bottom(self, lst):
        """滚动 ListControl 到底部，触发应用加载新消息。"""
        try:
            scroll = lst.GetScrollPattern()
            if scroll:
                scroll.SetScrollPercent(100, 0)
        except Exception:
            pass

    @staticmethod
    def _extract_last_line(lst) -> list:
        texts = []
        try:
            for item in lst.GetChildren():
                try:
                    name = item.Name
                    if name and name.strip():
                        lines = [l.strip() for l in name.split("\n") if l.strip()]
                        if not lines:
                            continue
                        # NFKC 标准化（去除零宽字符后比较）
                        norm = unicodedata.normalize('NFKC', lines[-1])
                        # 跳过末尾按钮文字（微信消息项的"关闭"等）和时间戳
                        ui_known = {"关闭", "发送", "接收", "取消", "确定", "更多"}
                        if len(lines) >= 2 and (norm in ui_known or re.match(r'^\d{1,2}:\d{2}', norm)):
                            texts.append(lines[-2])
                        else:
                            texts.append(lines[-1])
                except Exception:
                    pass
        except Exception:
            pass
        return texts

    @staticmethod
    def _extract_deep_text(lst) -> list:
        """深度递归提取 ListControl 内所有控件的 Name 文本（最多3层）。"""
        texts = []

        def walk(ctrl, depth):
            if depth > 3:
                return
            try:
                name = ctrl.Name
                if name and name.strip():
                    texts.append(name.strip())
            except Exception:
                pass
            try:
                for child in ctrl.GetChildren():
                    walk(child, depth + 1)
            except Exception:
                pass

        try:
            for item in lst.GetChildren():
                walk(item, 0)
        except Exception:
            pass
        return texts

    @staticmethod
    def _extract_second_line(lst) -> list:
        texts = []
        try:
            for item in lst.GetChildren():
                try:
                    name = item.Name
                    if name and name.strip():
                        lines = [l.strip() for l in name.split("\n") if l.strip()]
                        if len(lines) >= 2:
                            texts.append(lines[1])
                        elif lines:
                            texts.append(lines[-1])
                except Exception:
                    pass
        except Exception:
            pass
        return texts

    @staticmethod
    def _list_controls(window):
        results = []
        try:
            for ctrl in window.GetChildren():
                results.extend(_walk_list_controls(ctrl, 0))
        except Exception:
            pass
        return results

    @staticmethod
    def _collect_filtered_texts(window, platform: str = "", max_depth=14) -> list:
        """深度遍历 + 位置过滤（排除搜索框/标题栏区域）。"""
        items = []  # [(text, rect_top, rect_left, depth)]

        def walk(ctrl, depth):
            if depth > max_depth:
                return
            try:
                cr = ctrl.BoundingRectangle
                if cr.width() < 20 or cr.height() < 20:
                    return
            except Exception:
                return
            try:
                name = ctrl.Name
                if name and name.strip():
                    t = name.strip()
                    if len(t) >= 2 and not t.isdigit():
                        items.append((t, cr.top, cr.left, depth))
            except Exception:
                pass
            try:
                for child in ctrl.GetChildren():
                    walk(child, depth + 1)
            except Exception:
                pass

        try:
            for child in window.GetChildren():
                walk(child, 1)
        except Exception:
            pass

        if not items:
            return []

        try:
            w_rect = window.BoundingRectangle
            w_width = w_rect.width()
            w_height = w_rect.height()
        except Exception:
            w_width = 1390
            w_height = 953

        if platform == "qq":
            filtered = [
                t for t, top, left, d in items
                if top > w_height * 0.08
            ]
            seen = set()
            deduped = []
            for t in filtered:
                if t not in seen:
                    seen.add(t)
                    deduped.append(t)
            return deduped

        return [t for t, _, _, _ in items]

    # ── 单次轮询 ─────────────────────────────────────────────

    def _poll(self, platform: str):
        # ⚠️ 急停检查：OCR 期间用户可能已按 ESC 急停，必须立即折返
        if not self._running:
            return
        # 自动回复发送中跳过轮询（防止窗口焦点被抢）
        if self._sending_event.is_set():
            return

        # 对端平台冷却：刚切过前台（回复发送），给调试覆盖层消失时间
        cooldown = self._foreground_cooldown_until.get(platform, 0.0)
        if time.time() < cooldown:
            return

        # 冷却期：回复后 5 秒内跳过 poll，防止反馈回环
        last_reply = self._last_reply_time.get(platform, 0.0)
        if time.time() - last_reply < 5.0:
            return

        counter = self._poll_count.get(platform, 0) + 1
        self._poll_count[platform] = counter

        # 1. 确保窗口句柄
        # qq 路径纯 Win32+psutil，直接调用不超时；wechat 用 UIA（可能挂死）才套子线程
        if platform == "qq":
            hwnd = self._ensure_hwnd(platform)
        else:
            hwnd = self._ensure_hwnd_with_timeout(platform, timeout=12.0)
        if not hwnd:
            if counter % 10 == 0 or (counter == 1 and platform == "qq"):
                logger.debug(f"[{platform}] 窗口未找到")
            return

        # QQ 在托盘隐藏（IsWindowVisible=False）时跳过本轮。
        # 任何尝试恢复隐藏窗口的操作（SW_SHOWNORMAL 等）在 QQ NT 上都会触发托盘预览弹窗，
        # 不会恢复主聊天窗口。用户保持 QQ 窗口最小化到任务栏即可。
        if platform == "qq" and hwnd and win32gui.IsWindow(hwnd) and not win32gui.IsWindowVisible(hwnd):
            return

        # 2. 从 HWND 创建全新 Control（绕过缓存）
        #    QQ: 需要 UIA 控件做多种 fallback 读取（ListControl、全窗爬文本等）
        #    微信( Electron ): ControlFromHandle 构建 UIA 控件树冻结 3-5s，
        #    而微信 OCR 读到消息就直接返回，不需要 UIA。只在 OCR 空/fallback 时创建。
        if platform == "qq":
            win = self._fresh_window(platform)
            if not win:
                logger.debug(f"[{platform}] 创建窗口控件失败")
                return
        else:
            win = None  # 惰性创建：OCR 失败后需要 fallback 时再建

        # 3. 读消息（Windows OCR 同步阻塞，可能耗时 2-5s）
        texts = self._read_messages(win, platform)

        # ⚠️ OCR 返回后立即检查急停标志：急停可能在 OCR 阻塞期间触发，
        #    Windows OCR 无法被中断，但后续文本处理可以立即跳过。
        if not self._running:
            return

        if not texts:
            # 截图未变→不计入空读，不触发清缓存
            if self._ocr_unchanged.get(platform):
                return
            empty = self._empty_reads.get(platform, 0) + 1
            self._empty_reads[platform] = empty
            if counter % 5 == 0:
                logger.debug(f"[{platform}] 空读 #{empty}")
            if empty >= 5:
                self._cached_hwnd.pop(platform, None)
                self._cached_pid.pop(platform, None)
                self._empty_reads[platform] = 0
                logger.info(f"[{platform}] 连续空读，清窗口缓存重试")
            return

        self._empty_reads[platform] = 0

        # 冻结计数器（不在 early-return 里定义，保证所有路径都能访问）
        stale = 0

        # 4a. 全文本签名快速跳过 — OCR 输出与上轮完全相同 → 无变化，跳过
        sig = "||".join([t.strip() for t in texts if t.strip()])
        if sig == self._last_sig.get(platform, ""):
            stale = self._stale_count.get(platform, 0) + 1
            self._stale_count[platform] = stale
            logger.debug(f"[{platform}] Poll: 签名相同(#{stale})静默跳过: {sig[:60]!r}")
            return

        # 4. 用全局 _seen_messages 去重（跨平台、跨轮次防回环）
        #    精确匹配 + 模糊匹配（OCR 噪声导致精确匹配失效）
        seen = self._seen_messages
        replied = self._replied_texts
        new_items = []
        for t in texts:
            ts = t.strip()
            if not ts:
                continue
            # === URL-only 兜底：无中文且含 URL → 碎片 ===
            if not re.search(r'[\u4e00-\u9fff]', ts) and re.search(r'https?\S', ts, re.IGNORECASE):
                logger.debug(f"[{platform}] Poll过滤: URL-only碎片 ts={ts!r}")

            # === Bot自身回复过滤：pipe 表格格式（|参数1|参数2|参数3|结果|） ===
            pipe_count = ts.count('|')
            if pipe_count >= 3 and len(ts) > 30:
                logger.debug(f"[{platform}] Poll过滤: bot表格(pipe={pipe_count}) ts={ts!r}")
                continue
            # === Bot回复内容过滤：英文key=value配置格式 ===
            if re.search(r'[a-zA-Z_][\w]*\s*=\s*\S', ts) and not re.search(r'[\u4e00-\u9fff]', ts):
                logger.debug(f"[{platform}] Poll过滤: bot配置(key=value) ts={ts!r}")
                continue
            # === Bot回复内容过滤：配置文件描述片段 ===
            # ⚠️ 要求同时包含配置短语 + 英文关键词 + 配置格式(=或:)，避免误过滤用户讨论配置的消息
            _config_phrases = ('配置此处的文件', '负责展示', '对应一个商品', '使用md文件格式',
                               '配置文件', '该配置', '此配置', '参数配置', '配置项')
            _config_keywords = ('invite', 'referral', 'reward', 'bonus')
            has_config_phrase = any(p in ts for p in _config_phrases)
            has_config_keyword = re.search(r'invite|referral|reward|bonus', ts, re.IGNORECASE)
            has_config_format = re.search(r'[=:]\s*\S', ts)  # 包含 = 或 : 后跟非空白字符
            if has_config_phrase and has_config_keyword and has_config_format:
                logger.debug(f"[{platform}] Poll过滤: bot配置说明(三重匹配) ts={ts!r}")
                continue
            # === KB内容回读过滤：bot旧回复中的KB段落标题/内容 ===
            _kb_markers = ('奖励:', '规则:', '配置:', '说明:', '要求:', '限制:', '条件:', '流程:',
                           '奖励：', '规则：', '配置：', '说明：', '要求：', '限制：', '条件：', '流程：')
            if any(m in ts for m in _kb_markers):
                logger.debug(f"[{platform}] Poll过滤: KB内容回读 ts={ts!r}")
                continue
            # === Bot回复内容过滤：百分比+金额描述 ===
            if re.search(r'\d+\s*%', ts) and re.search(r'(金额|奖励|积分|返利|分成)', ts):
                logger.debug(f"[{platform}] Poll过滤: 奖励金额描述 ts={ts!r}")
                continue
            # === 纯非中文乱码：OCR 阅读到终端 log 或 URL 啃碎，中文群必有中文 ===
            if not re.search(r'[\u4e00-\u9fff]', ts) and len(ts) > 15 and not ts.startswith('/'):
                logger.debug(f"[{platform}] Poll过滤: 无中文乱码 ts={ts!r}")
                continue
            # === CJK 比例过低乱码：EasyOCR 把 URL/代码认成罕见汉字混一堆字母 ===
            if len(ts) > 15 and re.search(r'[A-Za-z]', ts):
                cjk = sum(1 for c in ts if '\u4e00' <= c <= '\u9fff')
                if cjk > 0 and cjk / max(len(ts), 1) < 0.15:
                    logger.debug(f"[{platform}] Poll过滤: CJK比例过低乱码 ts={ts!r}")
                    continue
            # === 英文配置格式+乱码过滤：key=value 或 key: value 后跟乱码 ===
            # 如 "invite referral bonus=5a激<5"、"config=file.txt乱码"
            if re.search(r'[a-zA-Z_]{2,}\s*[=:]\s*\S+', ts):
                # 检查是否包含乱码特征：特殊字符、数字字母混合、非正常英文单词
                乱码特征 = False
                # 特征1：等号或冒号后包含特殊字符（<>!@#$%^&*等）
                if re.search(r'[=:]\s*[a-zA-Z0-9]*[<>!@#$%^&*()\[\]{}|\\/:;\'",.?~`]+', ts):
                    乱码特征 = True
                # 特征2：等号或冒号后包含数字字母混合但无空格（如"5a激<5"）
                if re.search(r'[=:]\s*[a-zA-Z0-9]{3,}[^\s,.;:!?。，；：！？\u4e00-\u9fff]', ts):
                    乱码特征 = True
                if 乱码特征:
                    logger.debug(f"[{platform}] Poll过滤: 英文配置+乱码 ts={ts!r}")
                    continue
            # === 微信专属：气泡上下文验证 ===
            # 微信截图可能混入 Windows 弹窗/通知/非聊天内容
            # 真实用户消息通常含时间戳(14:30格式) 或 冒号分隔符(用户名：消息)
            # 纯粹的碎片文本（无时间戳、无冒号、无标点结尾）→ 高概率是非消息内容
            if platform == "wechat":
                has_timestamp = bool(re.search(r'\d{1,2}:\d{2}', ts))
                has_colon = bool(re.search(r'[:：]', ts))
                has_punct_end = bool(re.search(r'[。！？!?]$', ts))
                # 短句(≤8字)含中文 → 可能是合法短消息（如"好的"、"嗯"），不拦截
                if len(ts) <= 8 and re.search(r'[\u4e00-\u9fff]', ts):
                    pass  # 放行短中文消息
                # 无时间戳 + 无冒号 + 无标点结尾 → 高概率是非消息碎片（弹窗/通知/UI）
                elif not has_timestamp and not has_colon and not has_punct_end:
                    # 再放宽：含问词(怎么办/为什么/能不能)或感叹词 → 可能是真实消息
                    if not re.search(r'怎么办|为什么|能不能|怎么|如何|什么|可以|帮忙|谢谢|好的|嗯|收到|OK|ok', ts):
                        logger.debug(f"[{platform}] Poll过滤: 微信非消息碎片(无上下文) ts={ts!r}")
                        continue

            # === 斜线英文命令碎片："/sdfl undo撤销导入" 命令帮助碎片 ===
            if re.match(r'^/[A-Za-z]', ts):
                logger.debug(f"[{platform}] Poll过滤: 斜线英文命令 ts={ts!r}")
                continue
            # === 消息中段含 /英文命令（如"怎么办？/printer玩家名"）→ 指令碎片拼接 ===
            if re.search(r'(?<=[\s？?。！,，])/[A-Za-z]{2,}', ts):
                logger.debug(f"[{platform}] Poll过滤: 斜线命令碎片(中段) ts={ts!r}")
                continue
            # === 下划线+斜线：OCR 左对齐气泡残影 "_ /sdfl undo" ===
            if re.match(r'^_[ /]', ts):
                logger.debug(f"[{platform}] Poll过滤: 下划线斜线残影 ts={ts!r}")
                continue
            # === OCR 误读斜线为 I/J："/sdfl"→"Isdfl", "_ /sdfl"→下划线前缀 ===
            # 常见变体：/sdfl, _ /sdfl, Isdfl, sdfl undo...
            if 'sdfl' in ts.lower() or 'sdf1' in ts.lower():
                logger.debug(f"[{platform}] Poll过滤: 变形命令(sdfl) ts={ts!r}")
                continue
            # === OCR 斜线→I 变形：/skin→Iskin, /reg→Ireg 等 ===
            # 特征：CJK 上下文中出现 I+小写字母（正常中文聊天不会这样写）
            # 用户不会发"使用指令Iskin"这种文本，安全砍掉不进知识库
            if re.search(r'[\u4e00-\u9fff]I[a-z]{2,}', ts):
                logger.debug(f"[{platform}] Poll过滤: 斜线I变形 ts={ts!r}")
                continue
            if re.match(r'^[A-Z][a-z]{4,}', ts) and re.search(r'[\u4e00-\u9fff]', ts) and len(ts) > 10:
                logger.debug(f"[{platform}] Poll过滤: 变形命令(大写+字母) ts={ts!r}")
                continue
            # === 结构化数据面板：QQ/TIM 指令面板（指令:/rtp 权限类型:玩家 图标:标题:）===
            colon_kv = re.findall(r'[\u4e00-\u9fff]{1,6}[：:](?:[A-Za-z0-9/]|[\u4e00-\u9fff])', ts)
            if len(colon_kv) >= 3:
                logger.debug(f"[{platform}] Poll过滤: 结构化面板 ts={ts!r}")
                continue
            # === 偏旁碎片过滤：包含偏旁字符就丢弃 ===
            # 偏旁字符（U+2E80-U+2FDF）在正常中文聊天中不会出现
            # OCR 拆字碎片如"亻牛""彡"只要出现就是碎片
            if any(_is_radical_char(ch) for ch in ts):
                logger.debug(f"[{platform}] Poll过滤: 包含偏旁字符(丢弃) ts={ts!r}")
                continue
            # === 系统配置内容过滤：SMTP/邮件地址/代码片段不是用户消息 ===
            if re.search(r'@example|smtp|\.py\b|\.bat\b|\.sh\b|//.*\.\w{2,4}\b', ts, re.IGNORECASE):
                logger.debug(f"[{platform}] Poll过滤: 系统配置内容 ts={ts!r}")
                continue
            if re.search(r'@\w+\.\w{2,4}[,.\s]', ts) and re.search(r'[a-zA-Z0-9._%+-]+@[a-zA-Z0-9.-]+\.[a-zA-Z]{2,}', ts):
                logger.debug(f"[{platform}] Poll过滤: 邮件地址格式 ts={ts!r}")
                continue
            # === 游戏UI乱码：CJK+下划线英文、CJK+大写英文组合 → 非聊天文本 ===
            if re.search(r'[\u4e00-\u9fff]', ts) and re.search(r'[A-Za-z]', ts) and len(ts) > 10:
                if re.search(r'[a-zA-Z]+_[a-zA-Z]+', ts):
                    logger.debug(f"[{platform}] Poll过滤: 游戏UI乱码(下划线英文) ts={ts!r}")
                    continue
                if re.search(r'[\u4e00-\u9fff][A-Z][a-z]{1,}', ts):
                    cjk_count = len(re.findall(r'[\u4e00-\u9fff]', ts))
                    alpha_count = len(re.findall(r'[A-Za-z]', ts))
                    if alpha_count > 0 and cjk_count < alpha_count:
                        logger.debug(f"[{platform}] Poll过滤: 游戏UI乱码(CJK+大写英文) ts={ts!r}")
                        continue
            # === 绿色气泡 OCR 乱码：| 管道符混中文（正常聊天从不混用）===
            if '|' in ts and re.search(r'[\u4e00-\u9fff]', ts) and len(ts) > 5:
                logger.debug(f"[{platform}] Poll过滤: 管道符碎片(绿色气泡) ts={ts!r}")
                continue
            # === JSON/YAML 碎片兜底：OCR 截屏混入配置面板 ===
            if re.match(r'^["\']?[a-zA-Z_][\w]*["\']?\s*:\s*["\d\[\{tfn]', ts):
                logger.debug(f"[{platform}] Poll过滤: JSON行 ts={ts!r}")
                continue
            if re.match(r'^[a-zA-Z_][\w]*\s*:\s*["\w\d]', ts) and \
               not re.match(r'^(https?|ftp)://', ts) and \
               not re.match(r'^[a-zA-Z_][\w]*\s*:\s*/', ts):
                logger.debug(f"[{platform}] Poll过滤: YAML行 ts={ts!r}")
                continue
            # === 纯问句碎片（如"怎么办？" "好不好？"）无实质内容 ===
            _pure_q = re.match(r'^(怎么办|好不好|行不行|能不能|可以吗|是不是|有没有|是什么|怎么样|在哪里)\s*[？?。！]*\s*$', ts)
            if _pure_q:
                logger.debug(f"[{platform}] Poll过滤: 纯问句碎片 ts={ts!r}")
                continue
            # === 以特殊符号(~、`等)开头 → OCR把"一键"识别为"~键"等碎片 ===
            if re.match(r'^[~`～]', ts):
                logger.debug(f"[{platform}] Poll过滤: 特殊符号开头碎片 ts={ts!r}")
                continue
            # === 问句+乱码碎片拼接（如"怎么办？/printer玩家名"）===
            if re.match(r'^(怎么办|好不好|行不行|能不能|可以吗|是什么|怎么样)', ts):
                rest = re.sub(r'^(怎么办|好不好|行不行|能不能|可以吗|是什么|怎么样)\s*[？?。！]*\s*', '', ts)
                if rest and (re.search(r'/[A-Za-z]{2,}', rest) or re.search(r'[a-zA-Z]{3,}', rest) or len(rest) < 3):
                    logger.debug(f"[{platform}] Poll过滤: 问句+乱码拼接 ts={ts!r}")
                    continue
            # === 安全阀：UI 子串过滤（兜底，防任何路径漏过）===
            if any(sub in ts for sub in _UI_SUBSTR_BLOCKLIST):
                logger.debug(f"[{platform}] Poll过滤: UI子串 ts={ts!r}")
                continue
            # === 安全阀：UI 块列表过滤（兜底，防任何路径漏过）===
            if ts in _UI_EXACT_BLOCKLIST:
                logger.debug(f"[{platform}] Poll过滤: UI黑名单 line={ts!r}")
                seen.add(ts)
                continue

            # _replied_texts 优先检查（永不裁切，100% 拦住自己的回复）
            if ts in replied:
                continue
            # _replied_texts 模糊匹配：OCR 噪声导致精确匹配失效（长文本尤甚）
            if self._fuzzy_duplicate(ts, replied, threshold=0.75):
                logger.debug(f"[{platform}] 回复模糊跳过: {ts[:50]}")
                continue
            # _replied_texts 子串包含：OCR 提取的 md 表格细胞值（如"依赖插件可选/必选"）
            # 是 bot 回复表的一部分，不是用户提问。长度>5才检查避免误杀短消息。
            # OCR 常把 ，转 , 等标点差异，做双向子串检查（原始+归一化标点）
            if len(ts) > 5:
                if any(ts in r for r in replied):
                    logger.debug(f"[{platform}] 回复子串包含跳过({len(ts)}c): {ts[:50]}")
                    continue
                # 归一化标点后重试（OCR 噪声：，→,  。→. ！→! ？→?）
                norm_ts = ts.replace(',', '，').replace('.', '。').replace('!', '！').replace('?', '？')
                if norm_ts != ts and any(norm_ts in r for r in replied):
                    logger.debug(f"[{platform}] 回复子串包含跳过(归一化,{len(ts)}c): {ts[:50]}")
                    continue
            # _replied_texts 长公共子串检测：OCR 截取的碎片开头/结尾有噪声，精确/子串匹配失效
            # 先试原始文本（含字母数字），再试 CJK-only（进一步降阈值）
            if len(ts) > 8:
                import difflib
                matched_r = False
                # 第一轮：原始文本匹配（阈值 6，OCR 噪声导致连续匹配可能中断）
                for r in replied:
                    if len(r) < 5:
                        continue
                    sm = difflib.SequenceMatcher(None, ts, r)
                    if sm.find_longest_match(0, len(ts), 0, len(r)).size >= 6:
                        matched_r = True
                        break
                # 第二轮：CJK-only 降阈值到 5（去除标点空格干扰后更稳定）
                if not matched_r:
                    cjk_ts = ''.join(c for c in ts if '\u4e00' <= c <= '\u9fff')
                    if len(cjk_ts) >= 5:
                        for r in replied:
                            r_cjk = ''.join(c for c in r if '\u4e00' <= c <= '\u9fff')
                            if len(r_cjk) < 5:
                                continue
                            sm = difflib.SequenceMatcher(None, cjk_ts, r_cjk)
                            if sm.find_longest_match(0, len(cjk_ts), 0, len(r_cjk)).size >= 5:
                                matched_r = True
                                break
                if matched_r:
                    logger.debug(f"[{platform}] 回复公共子串跳过: {ts[:50]}")
                    continue
            if ts in seen:
                continue
            # 模糊匹配：OCR 输出每次微小差异（勖彐碎片、行首数字、尾部截断）
            # 精确匹配命中不了 → 用 difflib 相似度去重
            if self._fuzzy_duplicate(ts, seen, threshold=0.80):
                logger.debug(f"[{platform}] 模糊重复跳过: {ts[:50]}")
                continue
            # 超长文本（>200字符）跳过——大概率是堆积历史或 bot 自己的回复，不是单条新消息
            if len(ts) > 200:
                logger.debug(f"[{platform}] 超长文本跳过({len(ts)}c): {ts[:50]}...")
                continue
            if self._is_system_message(ts):
                continue
            # Markdown 文档过滤：bot 回复以 md 格式为主（#标题、[链接](url)、-列表项），
            # 用户日常对话不用 md 语法。拦截 md 格式文本避免 bot 旧回复被重新处理。
            if self._is_markdown_document(ts):
                logger.debug(f"[{platform}] md文档跳过: {ts[:50]}")
                continue
            # 纯装饰符号（单字符非汉字非字母数字）跳过
            if len(ts) == 1 and not re.match(r'[\u4e00-\u9fff\w]', ts):
                continue
            # 只有符号/空格/emoji 的非消息文本（<3 字符且长度等于标点去掉后长度）
            clean = re.sub(r'[\s\u2000-\u206f\u2190-\u2bff\U0001F000-\U0001FFFF✿♡♥❤★☆]', '', ts)
            if len(ts) <= 3 and len(clean) == 0:
                continue
            seen.add(ts)
            new_items.append(ts)
        # _seen_messages 上限 500 条，超了裁到 300
        # 防止集合无限膨胀 → 新消息模糊匹配时被历史噪声误杀
        if len(seen) > 500:
            # 保留后 300 条（最新）
            self._seen_messages = set(list(seen)[-300:])

        # 单次 poll 最多处理 3 条新消息，防止系统消息海量涌入触发回环
        MAX_NEW_ITEMS = 3
        new_items = new_items[:MAX_NEW_ITEMS]

        # 过滤纯时间/日期文本 → 不应进入 KB 匹配（OCR 时间戳分割遗留的噪音片段）
        # 这些文本在 KB 子串匹配阶段会命中文件内任何含相同数字的内容
        new_items = [
            it for it in new_items
            if not re.match(r'^\d{1,2}[:：]\d{2}(?:[:：]\d{2})?$', it.strip())
            and not re.match(r'^\d{4}[/-]\d{1,2}', it.strip())
        ]

        # ⚠️ 文本处理后再次检查急停：防止急停在过滤阶段触发后仍触发回复
        if not self._running:
            return

        # 更新 last_texts 与签名
        self._last_texts[platform] = list(texts)
        self._last_sig[platform] = sig
        self._stale_count[platform] = 0

        if new_items:
            # 清理过期冷却条目（TTL 60 秒）
            now = time.time()
            self._failed_send_cooldown = {
                k: v for k, v in self._failed_send_cooldown.items()
                if now - v < 60.0
            }

            # ⭐ 取最后一条（屏幕最下方 = 最新消息）
            # OCR 从上到下读屏，旧消息排前面，新消息排后面。
            # 原"只处理第一条"逻辑把旧历史消息当新消息处理，
            # 真正的用户新消息被"同poll第条跳过"挡掉。
            item = new_items[-1]
            if len(new_items) > 1:
                logger.debug(f"[{platform}] 同poll多条({len(new_items)}条)，取最后(最新): {item[:40]}")
                # 其余加入 seen 防止下次重复
                for skipped in new_items[:-1]:
                    seen.add(skipped)

            # ⭐ 首次成功轮询（上次无消息→本次有消息）：拦截历史基线
            is_baseline = self._last_new_msg_time.get(platform, 0) == 0
            if is_baseline:
                # 基线轮：日志标记但不触发回复。
                # ⚠ 三项关键处置，防止"基线吞消息后永不回复"：
                #   1. 从 seen 移除 item（4383 循环已 seen.add）——否则用户重发
                #      相同内容 → ts in seen 永久拦截
                #   2. 清空 _last_sig ——否则下一轮 sig 相同 → 4131 静默跳过，
                #      用户刚发的新消息被基线误吞后永远等不到回复
                #   3. 不 seen.add ——防重复由 sig 静默跳过承担
                logger.info(f"[{platform}] 基线↺(不回复): {item[:60]}")
                seen.discard(item)
                self._last_sig[platform] = ""
                self._last_new_msg_time[platform] = time.time()
            else:
                self._last_new_msg_time[platform] = time.time()
                self._last_msg[platform] = item
                engine_tag = self._last_chosen_engine.get(platform, "")
                logger.info(f"[{platform}] 新消息[{engine_tag}]: {item[:60]}")
                # ⚠️ 急停检查：回复前最后检查，防止急停后仍然发送
                if not self._running:
                    return
                if self._on_message:
                    self._on_message(platform, item)
                if platform == "qq":
                    if stale == 3:
                        logger.debug(f"[QQ] 冻结 #{stale}，强制刷新")
                        self._force_uia_refresh(platform)
                    elif stale == 6:
                        logger.debug(f"[QQ] 冻结 #{stale}，重建窗口引用")
                        self._cached_hwnd.pop(platform, None)
                        self._cached_pid.pop(platform, None)
                else:
                    if stale == 5:
                        logger.debug(f"[{platform}] 冻结 #{stale}，尝试强制刷新")
                        self._force_uia_refresh(platform)
                    elif stale == 10:
                        logger.debug(f"[{platform}] 冻结 #{stale}，重建窗口引用")
                        self._cached_hwnd.pop(platform, None)
                        self._cached_pid.pop(platform, None)

def _get_ocr_raw_dir(platform: str = "") -> str:
    """OCR 原始截图（PNG）保存目录：源码目录下的 img/raw[/platform]。

    统一存源码目录（历史版本即如此，从未被 360 误报），并按 raw / processed
    分目录存放，原图与处理后图片互不混杂，便于排查。
    platform 参数非空时返回对应平台子目录（qq / wechat），便于分类存放、
    解决定时器轮询清理时图片堆积难以寻找的问题。
    """
    try:
        base = os.path.join(os.path.dirname(os.path.abspath(__file__)), "img", "raw")
        if platform:
            base = os.path.join(base, platform)
        os.makedirs(base, exist_ok=True)
    except Exception:
        base = os.path.dirname(os.path.abspath(__file__))
    return base


def _get_ocr_processed_dir(platform: str = "") -> str:
    """OCR 处理后图片（JPG）保存目录：源码目录下的 img/processed[/platform]。"""
    try:
        base = os.path.join(os.path.dirname(os.path.abspath(__file__)), "img", "processed")
        if platform:
            base = os.path.join(base, platform)
        os.makedirs(base, exist_ok=True)
    except Exception:
        base = os.path.dirname(os.path.abspath(__file__))
    return base


def _get_easyocr_crash_log() -> str:
    """返回 easyocr_worker 崩溃日志路径，必须与 easyocr_worker.py 中 CRASH_LOG 保持一致。

    放在源码目录根（easyocr_crash.log），统一管理、便于父进程读取（不写 %LOCALAPPDATA%）。
    """
    try:
        base = os.path.dirname(os.path.abspath(__file__))
    except Exception:
        base = "."
    return os.path.join(base, "easyocr_crash.log")


def _read_easyocr_crash_tail(max_bytes: int = 2000) -> str:
    """读取 easyocr_worker 崩溃日志尾部，供父进程在检测到 worker 崩溃时把原因写进主日志。

    只在文件存在且较新时读取，避免每次都读陈旧历史。
    """
    try:
        path = _get_easyocr_crash_log()
        if not os.path.exists(path):
            return ""
        # 只看最近 60s 内的崩溃（文件可能被很久以前的残留占据）
        if time.time() - os.path.getmtime(path) > 60:
            return ""
        with open(path, "r", encoding="utf-8", errors="ignore") as f:
            data = f.read()
        # 取最后一段（最近一次崩溃通常在末尾）
        if len(data) > max_bytes:
            data = "...(截断)...\n" + data[-max_bytes:]
        return data.strip()
    except Exception:
        return ""


def _walk_list_controls(ctrl, depth):
    if depth > 6:
        return []
    results = []
    try:
        cname = ctrl.ControlTypeName
    except Exception:
        return results
    if cname == "ListControl":
        results.append(ctrl)
        return results
    try:
        for child in ctrl.GetChildren():
            results.extend(_walk_list_controls(child, depth + 1))
    except Exception:
        pass
    return results