feat: SQLCipher + Frida 重构微信自动回复链路

- auto-reply.js 接入 hermes-agent OpenAI-compatible API (:8642) - 新增 android-wechat-tracker-sqlcipher.js 替代 LSPosed 日志 tail - 新增 android-wechat-sender-frida.js 替代 am broadcast 发送 - 更新 keepalive.sh、README、HermesWeChatModule.java - 添加 .gitignore SQLite 变体规则 - 新增 docs: 息屏发送尝试记录与屏幕自动唤醒方案 Co-Authored-By: Claude Opus 4.7 <noreply@anthropic.com>

feat: SQLCipher + Frida 重构微信自动回复链路
- auto-reply.js 接入 hermes-agent OpenAI-compatible API (:8642) - 新增 android-wechat-tracker-sqlcipher.js 替代 LSPosed 日志 tail - 新增 android-wechat-sender-frida.js 替代 am broadcast 发送 - 更新 keepalive.sh、README、HermesWeChatModule.java - 添加 .gitignore SQLite 变体规则 - 新增 docs: 息屏发送尝试记录与屏幕自动唤醒方案 Co-Authored-By: Claude Opus 4.7 <noreply@anthropic.com>
yibo
1 parent 7bd3230b
Showing 9 changed files with 1122 additions and 115 deletions
.gitignore
docs/screen-auto-wake-proposal.md
docs/wechat-screen-off-send-attempts.md
server/services/wechat/android-wechat-sender-frida.js
server/services/wechat/android-wechat-tracker-sqlcipher.js
server/services/wechat/auto-reply.js
wechat_plain/scripts/local-testkit/docs/README.md
wechat_plain/scripts/local-testkit/keepalive.sh
wechat_plain/scripts/lsposed-wechat-sendmsg/app/src/main/java/com/hermes/wechat/xposed/HermesWeChatModule.java
@@ -26,6 +26,11 @@ system/agents/*/memory/
 # SQLite databases
 *.sqlite
+*.sqlite3
+*.db
+*.db-journal
+*.db-shm
+*.db-wal
 server/db/
 # Build output
+# 息屏自动唤醒亮屏方案讨论
+
+> 背景：Pixel 10 Pro Fold (Android 15) 息屏状态下微信消息发送失败
+> 核心问题：息屏是否必然导致发送失败？能否通过"自动亮屏"绕过限制？
+> 时间：2026-05-23
+
+---
+
+## 一、为什么息屏会导致发送失败？（Android 15 限制分析）
+
+### 1.1 息屏 ≠ 只是屏幕变黑
+
+Android 15 在息屏时会同时激活多层限制：
+
+```
+用户按下电源键 / 超时息屏
+    │
+    ├──→ Display OFF（屏幕关闭）
+    │
+    ├──→ Keyguard ON（锁屏界面激活，若有密码需解锁）
+    │
+    ├──→ Doze Mode（浅睡眠，限制网络/闹钟/JobScheduler）
+    │       └── 进入 doze 后：网络批量处理、闹钟延迟、wakelock 忽略
+    │
+    ├──→ App Standby（应用待机桶，限制后台活动）
+    │       └── 微信可能被分到 RARE/RESTRICTED 桶
+    │
+    └──→ Background Activity Launch 限制
+            └── 后台应用（包括通过 su 启动的）禁止启动 Activity
+```
+
+### 1.2 我们遇到的限制层级
+
+| 层级 | 当前是否受影响 | 说明 |
+|------|-------------|------|
+| 屏幕关闭 | ✅ 是 | `am start` 不执行，需要 `input keyevent 26` 点亮 |
+| 锁屏界面 | ⚠️ 未知 | Pixel 是否有密码/指纹？亮屏后是否卡在 Keyguard？ |
+| Doze 模式 | ⚠️ 可能 | 即使亮屏，Doze 可能仍在运行，限制网络调度 |
+| 后台启动限制 | ⚠️ 可能 | Termux 通过 `su` 执行命令，但微信进程本身不是前台 |
+| NetScene 队列冻结 | ⚠️ 可能 | 微信内部可能在息屏时暂停消息发送队列 |
+
+**关键结论**：即使屏幕亮了，如果 Doze 仍在运行、或微信 NetSceneDispatcher 未恢复，发送仍可能失败。
+
+---
+
+## 二、自动唤醒亮屏的技术方案（6 种）
+
+### 方案 A：模拟电源键点亮（已部分实现）
+
+**做法**：
+```bash
+input keyevent 26      # 模拟电源键，Toggle 屏幕开关
+```
+
+**限制**：
+- 只点亮屏幕，**不解锁**锁屏界面
+- 如果手机有 PIN/密码/指纹，会卡在 Keyguard
+- Doze 模式**不会退出**（需要传感器运动或插拔充电）
+
+**适用条件**：手机无密码（Swipe only）或 Smart Lock 已信任当前位置/设备
+
+**可行性**：⭐⭐⭐ 部分可行
+
+---
+
+### 方案 B：模拟滑动手势解锁
+
+**做法**：
+```bash
+# 先点亮
+input keyevent 26
+sleep 300ms
+# 模拟从底部向上滑解锁（无密码时）
+input swipe 500 1200 500 500 300
+```
+
+**限制**：
+- 仅适用于**无密码**的 Swipe 解锁
+- 有 PIN/密码/图案/指纹时完全无效
+- 不同手机分辨率不同，滑动坐标需适配
+
+**适用条件**：手机未设置任何安全锁屏
+
+**可行性**：⭐⭐ 受限极大
+
+---
+
+### 方案 C：发送高优先级通知唤醒
+
+**原理**：Android 允许某些通知唤醒屏幕（如来电、闹钟）
+
+**做法**：
+```bash
+# 通过 termux-notification 发送一个 IMPORTANCE_HIGH 通知
+# 并设置唤醒屏幕标志
+```
+
+**限制**：
+- 需要 `termux-api` 应用及后台服务运行
+- Android 15 对通知唤醒屏幕有严格限制，通常只有电话/闹钟应用可以做到
+- 用户需在设置中允许 Termux "唤醒屏幕"
+
+**适用条件**：用户手动授权 + Termux API 常驻
+
+**可行性**：⭐⭐ 不可靠
+
+---
+
+### 方案 D：通过 AlarmManager / 精确闹钟触发
+
+**原理**：设置一个精确闹钟，闹钟触发时系统会短暂退出 Doze，允许应用执行操作
+
+**做法**：
+```bash
+# 通过 termux 的脚本或 Android 应用设置 AlarmManager
+# 触发时执行发送逻辑
+```
+
+**限制**：
+- 闹钟只能唤醒**自己的应用**，不能直接唤醒微信
+- 闹钟触发时屏幕不一定亮
+- Android 15 需要 `SCHEDULE_EXACT_ALARM` 权限
+
+**适用条件**：仅适用于定时任务，不适用于实时消息回复
+
+**可行性**：⭐ 不适合实时回复场景
+
+---
+
+### 方案 E：保持屏幕常亮（ prevention 而非 cure ）
+
+**原理**：不让手机息屏，从根本上避免问题
+
+**做法**：
+```bash
+# 方法 1：修改系统设置（需要 root）
+su -c "settings put system screen_off_timeout 2147483647"
+
+# 方法 2：使用 WakeLock（需要应用支持）
+# Termux 中运行 termux-wake-lock（但这只保持 CPU，不关屏幕）
+
+# 方法 3：充电时保持亮屏（设置中 Developer Options）
+```
+
+**限制**：
+- 耗电严重
+- OLED 屏幕可能烧屏
+- 用户接受度低
+- 如果手机在口袋里，误触问题
+
+**适用条件**：设备长期插电使用，且用户接受屏幕常亮
+
+**可行性**：⭐⭐⭐ 技术可行，但体验差
+
+---
+
+### 方案 F：利用 Smart Lock / 信任设备自动解锁
+
+**原理**：Android Smart Lock 可以在特定条件下（如连接到信任的蓝牙设备、位于信任的地理位置）自动跳过锁屏。
+
+**做法**：
+1. 用户在手机设置中开启 Smart Lock
+2. 添加信任条件（如连接到家里 Wi-Fi、信任的蓝牙手表/耳机）
+3. 当条件满足时，`input keyevent 26` 点亮屏幕后自动解锁
+
+**限制**：
+- 需要用户手动配置
+- 安全性降低
+- 如果条件不满足，仍然卡在锁屏
+
+**适用条件**：用户愿意配置 Smart Lock，且有稳定的信任条件
+
+**可行性**：⭐⭐⭐ 依赖用户配置
+
+---
+
+## 三、更深层的分析：亮屏后发送就一定成功吗？
+
+### 3.1 当前 Frida 测试结果告诉我们什么？
+
+我们在**亮屏状态**下调用 `u01.m1.a()`，返回 `true`，但 DB 中**没有新消息**。
+
+这说明：
+1. **调用链可能本身就是错的** — `m1.a()` 不是真正发送消息的方法
+2. **或者**，微信内部需要额外的初始化步骤
+
+**关键推论**：即使我们通过某种方式让屏幕亮了，如果调用链不正确，发送仍然失败。
+
+### 3.2 需要先解决"亮屏发送"，再解决"息屏唤醒"
+
+当前问题的优先级应该是：
+
+```
+P0: 亮屏 + 微信前台 → 能否成功发送？（Frida 测试 q1.b() / d()）
+    │
+    ├──→ 如果亮屏也失败：调用链有问题，与息屏无关
+    │
+    └──→ 如果亮屏成功：再解决息屏限制
+            │
+            ├──→ 方案 A/B/F：自动亮屏+解锁
+            └──→ 方案 E：保持常亮
+```
+
+---
+
+## 四、综合方案推荐
+
+### 方案 1：双路径发送（推荐）
+
+```
+消息检测（sqlcipher 轮询 / 通知监听）
+    │
+    ├──→ 检测到微信在前台 ──→ 直接调用发送 API
+    │
+    └──→ 检测到息屏 ────────→ input keyevent 26 唤醒
+                                │
+                                ├──→ 无密码 / Smart Lock ──→ 自动解锁
+                                │                            └──→ 微信前台 → 发送
+                                │
+                                └──→ 有密码且未 Smart Lock ──→ 发送失败，记录待发送队列
+                                                                   │
+                                                                   └──→ 下次用户解锁时批量发送
+```
+
+**优点**：
+- 前台时实时发送
+- 息屏时尝试唤醒，成功则发，失败则缓存
+- 不丢失消息
+
+**缺点**：
+- 息屏时回复有延迟（需等用户下次解锁）
+- 需要维护待发送队列
+
+---
+
+### 方案 2：保持微信前台常驻（激进方案）
+
+```bash
+# 1. 设置屏幕常亮（root）
+su -c "settings put system screen_off_timeout 2147483647"
+
+# 2. 微信保持在 LauncherUI 前台
+# 3. 使用 termux-wake-lock 防止 CPU 休眠
+```
+
+**配合硬件**：
+- 手机长期连接充电器
+- 降低屏幕亮度到最低
+- 使用 OLED 黑色主题减少烧屏
+
+**优点**：
+- 完全绕过息屏限制
+- 发送实时性最好
+
+**缺点**：
+- 耗电
+- 烧屏风险
+- 用户体验差（手机一直亮着）
+
+---
+
+### 方案 3：Termux 前台服务 + 通知监听（折中方案）
+
+**原理**：
+1. Termux 运行在**前台服务**模式（显示一个常驻通知）
+2. 前台服务不受 Doze 限制，可以持续运行
+3. 收到微信通知时，通过 `input keyevent 26` 唤醒屏幕
+4. 如果手机无密码/Smart Lock，微信启动后自动前台
+5. 发送消息
+
+**关键条件**：
+- Termux 需要在前台服务模式下运行
+- 手机不能有密码锁，或已配置 Smart Lock
+
+---
+
+## 五、针对 Pixel 10 Pro Fold 的具体建议
+
+### 5.1 先确认锁屏状态
+
+```bash
+# 检查当前 Keyguard 状态
+adb shell dumpsys window | grep -i "keyguard"
+# 或
+adb shell dumpsys deviceidle | grep -i "screen"
+```
+
+**输出分析**：
+- `mDreamingLockscreen=true` → 有锁屏界面
+- `mInputRestricted=true` → 需要解锁才能操作
+
+### 5.2 如果手机有密码
+
+**路径 1**：建议用户开启 Smart Lock
+- 设置 → 安全 → Smart Lock → 信任的地点/设备
+- 添加家里位置或连接的蓝牙耳机
+
+**路径 2**：使用 ADB + 电脑保持连接
+- 电脑端运行 `adb shell svc power stayon usb`
+- 手机连接电脑时屏幕常亮
+- 但这要求电脑一直在旁边
+
+**路径 3**：接受延迟回复
+- 息屏时缓存回复到队列
+- 用户下次解锁手机时自动发送队列中的消息
+
+### 5.3 如果手机无密码
+
+直接实现方案 A + B：
+```javascript
+async function wakeAndUnlock() {
+    await shell('input keyevent 26', 3000);     // 点亮
+    await sleep(500);
+    await shell('input swipe 500 1200 500 500 300', 3000); // 上滑解锁
+    await sleep(300);
+    await shell('am start -n com.tencent.mm/.ui.LauncherUI', 5000); // 启动微信
+}
+```
+
+---
+
+## 六、结论与下一步
+
+### 核心结论
+
+1. **息屏限制是真实存在的**：Android 15 的 Doze + 后台启动限制确实会阻止消息发送
+2. **但当前更大的问题是调用链**：亮屏状态下 `u01.m1.a()` 也不工作，说明不是单纯的息屏问题
+3. **自动亮屏技术上可行**：`input keyevent 26` 已验证可用，但**解锁**是瓶颈
+4. **优先级应该是**：
+   - **P0**：用 Frida 测试 `q1.b()` 和 `q1.d()`，找到真正发送方法
+   - **P1**：确认亮屏+前台状态下能否稳定发送
+   - **P2**：解决息屏唤醒（根据用户锁屏配置选择方案 A/B/F/E）
+
+### 建议用户决策
+
+| 你的手机状态 | 推荐方案 | 实施难度 |
+|-----------|---------|---------|
+| 无密码 / Swipe only | 方案 A + B：唤醒 + 滑动解锁 | 低 |
+| 有密码，可开 Smart Lock | 方案 F：Smart Lock 自动解锁 | 中（需配置） |
+| 有密码，不能开 Smart Lock | 方案 1（双路径）：前台实时发，息屏缓存延迟发 | 中 |
+| 长期插电放在桌上 | 方案 E：屏幕常亮 | 低（但耗电） |
+
+---
+
+## 七、待确认问题（需要用户回答）
+
+1. **你的 Pixel 10 Fold 有设置锁屏密码/PIN/指纹吗？**
+   - 如果有，能否开启 Smart Lock？
+
+2. **手机通常是放在桌上插电，还是随身携带？**
+   - 这影响"屏幕常亮"方案的可行性
+
+3. **对回复延迟的容忍度如何？**
+   - 是否接受息屏时延迟到下次解锁才发送？
+
+4. **是否愿意安装 Termux:API 并保持其前台服务运行？**
+   - 这可以绕过部分后台限制
+
+根据你的回答，我可以给出最精准的实施方案。
+# WeChat 息屏自动发送方案汇总
+
+> 设备：Pixel 10 Pro Fold (Android 15)
+> 微信：8.0.72
+> 目标：息屏状态下成功发送消息给 yibooo
+> 时间：2026-05-23
+
+---
+
+## 一、整体架构（当前部署）
+
+```
+息屏检测                消息生成               消息发送
+---------->  三种方案并行尝试  ---------->
+
+1. sqlcipher DB 轮询 ←── 检测新消息 ──→ hermes API ←── 生成 AI 回复
+2. termux-notification-list（息屏兜底唤醒）
+3. LSPosed hook（WCDB insert 监控）
+```
+
+**当前部署路径**：`/data/data/com.termux/files/home/hermes-wechat/`
+
+---
+
+## 二、已尝试的发送方案（5 种）
+
+### 方案 1：LSPosed Xposed 模块 + `am broadcast`
+
+**原理**：
+- 安装 LSPosed 模块到 WeChat 进程
+- 模块注册 BroadcastReceiver，监听 `com.hermes.wechat.SEND_MSG`
+- 收到广播后，反射调用微信内部 API：`u01.r1.a(talker) → q1.e(content) → q1.a() → m1.a()`
+- 将 NetScene 提交到主线程执行
+
+**代码位置**：
+- Java 源码：`wechat_plain/scripts/lsposed-wechat-sendmsg/app/src/main/java/com/hermes/wechat/xposed/HermesWeChatModule.java`
+- Smali（已编译）：`/tmp/lsposed-mod/smali/com/hermes/wechat/xposed/HermesWeChatModule.smali`
+- 签名 APK：`/tmp/lsposed-mod/dist/lsposed-wechat-sendmsg.apk`
+
+**已做的 bypass**：
+- `ExtContentProviderBase.h()` → return 1（auth bypass）
+- `ExtContentProviderBase.b()` → return true（login bypass）
+- `AESUtil.b()` / `AESUtil.a()` 跳过加密
+- NetScene submit 改为 `Handler(Looper.getMainLooper()).post()` 主线程执行
+
+**测试结果**：
+- 亮屏：`am broadcast` 可以执行，但消息未成功写入 DB（怀疑模块未正确 hook 或 `m1.a()` 不是真正的发送方法）
+- 息屏：`am broadcast` 可能被系统拦截，未验证
+- **状态：❌ 未成功**
+
+**失败原因分析**：
+1. 模块重新签名安装后，LSPosed 数据库中路径未更新，可能未正确加载
+2. `u01.m1.a()` 返回 true 但无 DB 写入，说明 `a()` 可能不是真正的提交方法
+3. Android 15 后台广播限制可能阻止息屏时的 `am broadcast`
+
+---
+
+### 方案 2：Frida 直接调用微信内部 API
+
+**原理**：
+- Frida attach 到 WeChat 主进程，直接执行 JavaScript 调用微信内部类
+- 调用链：`u01.r1.a("yibooo") → q1.e("content") → q1.a() → m1.a()`
+- 使用 `Java.scheduleOnMainThread()` 确保在主线程执行
+
+**Frida 脚本**：
+- `/tmp/send_msg3.js` — 基本发送脚本（主线程提交）
+- `/tmp/send_msg4.js` — 测试 `q1.b()` 作为替代发送方法（尚未运行）
+- `/tmp/inspect_all.js` — 类方法枚举工具
+
+**已发现的关键类签名**：
+```
+u01.r1.a(java.lang.String) → u01.q1          # 创建 builder
+u01.q1.e(java.lang.String) → u01.q1          # 设置消息内容（链式）
+u01.q1.g(java.lang.String) → u01.q1          # 可能是设置 talker
+u01.q1.h(int) → u01.q1                       # 可能是设置 type
+u01.q1.a() → u01.m1                          # build NetScene
+u01.q1.b() → void                            # ??? 可能是真正发送
+u01.q1.d(u01.q1, qw5.l, int, Object) → void  # 静态方法，可能是 dispatch
+u01.m1.a() → boolean                         # 返回 true 但无实际效果
+```
+
+**测试结果**：
+- `m1.a()` 在主线程执行，返回 `true`，但 DB 中没有新的 `isSend=1` 记录
+- msgId 846 之后无新消息写入
+- **状态：❌ 亮屏也未成功**
+
+**关键疑点**：
+`u01.m1.a()` 可能不是 `doScene()`/`dispatch()`，而是：
+- 预检查/校验方法
+- 状态查询方法
+- 需要配合其他参数才能触发真正的发送
+
+**下一步待验证**：
+1. `u01.q1.b()` — 返回 void，更像执行方法
+2. `u01.q1.d()` — 静态方法，参数 `(q1, l, int, Object)` 可能是 dispatcher
+3. hook `u01.m1.a()` 内部实现，追踪它到底调用了什么
+4. hook WCDB `insert()`，确认调用 API 后是否有任何 DB 写入尝试
+
+---
+
+### 方案 3：`input text` + `input keyevent 66` 模拟键盘输入
+
+**原理**：
+- 使用 Android `input text "消息内容"` 向当前焦点窗口输入文本
+- `input keyevent 66` 模拟回车发送
+
+**测试结果**：
+- 亮屏：简单英文数字可用，某些字符导致 `NullPointerException`
+- 息屏：无法输入到没有焦点的前台窗口
+- **状态：❌ 不适用**
+
+**失败原因**：
+1. 微信聊天窗口需要是前台焦点才能接收 `input text`
+2. 息屏状态下系统不会分发输入事件到应用
+3. 特殊字符（中文、标点）容易崩溃
+
+---
+
+### 方案 4：直接启动 ChattingUI (`am start -n`)
+
+**原理**：
+- `am start -n com.tencent.mm/.ui.chatting.ChattingUI` 直接打开聊天窗口
+- 然后配合 `input text` 发送
+
+**测试结果**：
+- `am start` 抛出 `SecurityException: Not exported`
+- ChattingUI 未在 manifest 中声明 exported=true
+- **状态：❌ 无法启动**
+
+---
+
+### 方案 5：`content insert` → ContentProvider
+
+**原理**：
+- 通过 `content insert --uri content://com.hermes.wechat.xposed.provider/send` 发送
+- 绕过了广播，直接走 ContentProvider
+
+**代码位置**：`android-wechat-sender.js::sendTextMessage()`
+
+**测试结果**：
+- 未实际测试（依赖 LSPosed 模块的 ContentProvider）
+- 模块的 Provider 可能需要同样 bypass auth
+- **状态：❓ 未测试**
+
+---
+
+## 三、消息检测方案（2 种，均可用）
+
+### 检测 1：sqlcipher DB 轮询 ✅
+
+**原理**：
+- 直接用 sqlcipher 打开 `EnMicroMsg.db`（key: `e03ce81`）
+- 轮询 `message` 表，查 `msgId > lastMsgId AND isSend = 0`
+
+**代码位置**：`android-wechat-tracker-sqlcipher.js`
+
+**已修复的问题**：
+- temp 文件路径从 `/tmp/` 改为 `/data/data/com.termux/files/usr/tmp/`（Termux 无 `/tmp` 权限）
+
+**状态**：✅ **工作正常**，可检测新消息
+
+### 检测 2：termux-notification-list 息屏兜底 ✅
+
+**原理**：
+- 每 3 秒执行 `termux-notification-list`
+- 过滤 `packageName === 'com.tencent.mm'` 的通知
+- 检测到通知后 → `input keyevent 26` 点亮屏幕 → `am force-stop` + `am start` 重启微信 → 等待前台确认
+
+**代码位置**：`auto-reply.js::pollNotifications()`
+
+**已修复的问题**：
+- `pkgName` → `packageName` 字段名修正
+- 添加 `input keyevent 26` 唤醒屏幕（息屏时 `am start` 不执行）
+- 添加 `ensureWechatForeground()` 轮询确认前台 + 模拟按键保持活跃
+
+**状态**：✅ **检测+唤醒工作正常**，但发送卡住了
+
+---
+
+## 四、当前代码文件状态
+
+| 文件 | 位置 | 状态 | 说明 |
+|------|------|------|------|
+| `auto-reply.js` | `server/services/wechat/` | ✅ 已部署 | 主逻辑，通知兜底+sqlcipher轮询+hermes调用，但发送调用的是 `sendTextMessageBroadcast()` |
+| `android-wechat-tracker-sqlcipher.js` | `server/services/wechat/` | ✅ 已部署 | sqlcipher DB 轮询，检测新消息正常 |
+| `android-wechat-sender.js` | `server/services/wechat/` | ✅ 已部署 | 提供 `sendTextMessageBroadcast()` 和 `sendTextMessage()`，但底层依赖 LSPosed 模块 |
+| `HermesWeChatModule.java` | `wechat_plain/scripts/lsposed-wechat-sendmsg/...` | ✅ 已修改 | 主线程提交 NetScene，但 APK 重新签名后 LSPosed 可能未正确加载 |
+| `lsposed-wechat-sendmsg.apk` | `/tmp/lsposed-mod/dist/` | ⚠️ 已编译 | 新签名，LSPosed DB 中路径可能未更新 |
+| Frida 脚本 | `/tmp/send_msg*.js` | ✅ 可用 | `send_msg3.js` 亮屏测试未成功，`send_msg4.js` 待测试 `q1.b()` |
+
+---
+
+## 五、核心卡点总结
+
+### 卡点 1：为什么 `u01.m1.a()` 返回 true 但消息没发出去？
+
+**现象**：
+- Frida 调用 `netScene.a()` 返回 `true`
+- DB 中没有新的 `isSend=1` 记录
+- 没有异常抛出
+
+**假设**：
+1. `a()` 不是 `doScene()`，而是其他方法（如 `check()` / `preSend()`）
+2. 真正的发送方法是 `u01.q1.b()` 或 `u01.q1.d()`
+3. NetScene 需要额外的初始化（如 `MsgInfo` 的某些字段未设置）
+4. 微信在息屏/后台时 NetSceneDispatcher 被冻结，即使调用也不执行
+
+**待验证**：
+- [ ] 测试 `u01.q1.b()` 是否能触发 DB 写入
+- [ ] 测试 `u01.q1.d()` 静态方法
+- [ ] hook `u01.m1.a()` 内部，看其调用链
+- [ ] hook WCDB insert，确认 API 调用后是否有任何 DB 操作
+
+### 卡点 2：息屏状态下后台执行限制
+
+**现象**：
+- Android 15 对后台 Activity 启动、后台广播有严格限制
+- `am start` 在息屏锁定时不会立即执行
+- 需要先 `input keyevent 26` 点亮屏幕
+
+**当前 workaround**：
+- 检测到通知 → 唤醒屏幕 → force-stop + start 微信 → 轮询确认前台
+- 这个流程已验证可以工作
+
+**剩余风险**：
+- 即使微信在前台，如果 NetSceneDispatcher 在息屏时被系统挂起，消息仍可能无法发送
+- 需要确认亮屏后微信网络层是否完全恢复
+
+### 卡点 3：LSPosed 模块加载问题
+
+**现象**：
+- 重新编译签名 APK 后安装
+- LSPosed 管理器中显示已启用，但日志中没有模块 hook 的输出
+- 可能原因：新签名导致 LSPosed 数据库中路径/签名不匹配
+
+**已尝试**：
+- 直接修改 `/data/adb/lspd/config/modules_config.db` 更新路径
+- 重启 Zygote (`setprop ctl.restart zygote`) 和 lspd
+
+**状态**：⚠️ 不确定模块是否真正加载
+
+---
+
+## 六、下一步建议（优先级排序）
+
+### P0：确认真正发送方法（Frida 验证）
+
+用 Frida 在亮屏状态下测试以下方法，找到真正能触发 DB 写入的调用：
+
+```javascript
+// 测试 1：q1.b()
+var builder = r1.a("yibooo");
+builder.e("test msg");
+builder.b();  // 返回 void，可能是真正发送
+
+// 测试 2：q1.d() 静态方法
+q1.d(builder, null, 0, null);  // 参数猜测
+
+// 测试 3：hook m1.a() 内部
+// 看 m1.a() 到底调用了什么，追踪其调用链
+```
+
+### P1：验证亮屏发送
+
+只有在亮屏状态下能稳定发送，才有意义测试息屏。
+当前亮屏都无法发送，说明调用链不正确。
+
+### P2：息屏发送验证
+
+亮屏发送成功后：
+1. 息屏
+2. 等待 5 秒
+3. Frida 执行相同脚本
+4. 检查 DB 是否有写入
+
+### P3：修复 LSPosed 模块（备用方案）
+
+如果 Frida 方案因息屏限制不可行，回到 LSPosed 模块：
+1. 确认模块正确加载（查看 LSPosed 日志）
+2. 修正 `m1.a()` 为正确的方法调用
+3. 验证息屏时广播是否能被接收
+
+### P4：集成到 auto-reply.js
+
+发送方法确定后：
+1. 修改 `auto-reply.js` 中的发送调用
+2. 确保息屏唤醒流程与发送流程衔接
+3. 测试完整闭环：收到消息 → AI 回复 → 成功发送
+
+---
+
+## 七、附录：Frida 调试命令速查
+
+```bash
+# 连接设备
+adb connect 192.168.x.x:5555
+
+# 启动微信并 Frida 注入
+frida -U -f com.tencent.mm -l /tmp/send_msg3.js --no-pause
+
+# attach 到已运行的微信
+frida -U -n "com.tencent.mm" -l /tmp/send_msg3.js
+
+# 查看微信进程 PID
+adb shell ps | grep com.tencent.mm
+
+# 息屏/亮屏
+adb shell input keyevent 26
+
+# 查询 DB 最新发送消息
+adb shell su -c "sqlcipher /data/data/.../EnMicroMsg.db 'PRAGMA key=e03ce81; SELECT msgId, talker, content FROM message WHERE isSend=1 ORDER BY msgId DESC LIMIT 3;'"
+```
+
+---
+
+## 八、关键发现记录
+
+| 发现 | 时间 | 影响 |
+|------|------|------|
+| WeChat 8.0.72 使用 u01.r1/q1/m1 作为发送 API | 2026-05-23 | 确认了调用链 |
+| `m1.a()` 返回 true 但无 DB 写入 | 2026-05-23 | 怀疑 `a()` 不是真正发送方法 |
+| `termux-notification-list` 字段是 `packageName` 非 `pkgName` | 2026-05-23 | 修复了息屏检测 |
+| Termux 无法写 `/tmp`，需用 `/data/data/com.termux/files/usr/tmp/` | 2026-05-23 | 修复了 sqlcipher 查询 |
+| `input keyevent 26` 可在息屏时点亮屏幕 | 2026-05-23 | 实现了息屏唤醒 |
+| ChattingUI 未 exported，无法 `am start` | 2026-05-23 | 排除了直接启动聊天窗口方案 |
+| `u01.q1.b()` 和 `d()` 可能是真正发送方法 | 2026-05-23 | 待验证 |
+/**
+ * android-wechat-sender-frida.js — 基于 Frida Daemon 的微信消息发送
+ *
+ * 原理：写入队列文件 /data/local/tmp/frida_daemon/queue.jsonl
+ *       由常驻微信进程的 Frida daemon 读取并发送
+ *
+ * 前提：
+ *   1. frida-server 运行中
+ *   2. frida_daemon.js 已注入微信进程（通过 Mac 端 frida CLI）
+ *   3. 队列目录 /data/local/tmp/frida_daemon/ 存在且可写
+ *
+ * 注意：发送为 fire-and-forget，daemon 会异步处理队列。
+ *       如需确认送达，可通过 sqlcipher 查询 message 表。
+ */
+
+const fs = require('fs');
+
+const QUEUE_DIR = '/data/local/tmp/frida_daemon';
+const QUEUE_FILE = QUEUE_DIR + '/queue.jsonl';
+
+function ensureDir() {
+  try {
+    if (!fs.existsSync(QUEUE_DIR)) {
+      fs.mkdirSync(QUEUE_DIR, { recursive: true });
+      fs.chmodSync(QUEUE_DIR, 0o777);
+    }
+  } catch (e) {
+    // ignore
+  }
+}
+
+/**
+ * 使用 Frida daemon 发送文本消息（fire-and-forget）
+ * @param {string} toUser — wxid / 群聊ID
+ * @param {string} content — 消息内容
+ * @returns {Promise<{ok: boolean, error?: string}>}
+ */
+async function sendTextMessageFrida(toUser, content) {
+  if (!toUser || !content) {
+    return { ok: false, error: 'toUser and content are required' };
+  }
+
+  ensureDir();
+
+  const id = 'msg_' + Date.now() + '_' + Math.random().toString(36).slice(2, 8);
+  const payload = JSON.stringify({ talker: toUser, content, id }) + '\n';
+
+  try {
+    fs.writeFileSync(QUEUE_FILE, payload);
+    fs.chmodSync(QUEUE_FILE, 0o666);
+  } catch (e) {
+    return { ok: false, error: `Failed to write queue: ${e.message}` };
+  }
+
+  // Fire-and-forget: daemon will process asynchronously
+  // 给 daemon 一点时间处理（通常 < 1s）
+  await new Promise(r => setTimeout(r, 500));
+  return { ok: true };
+}
+
+module.exports = { sendTextMessageFrida };
+/**
+ * android-wechat-tracker-sqlcipher.js — 通过 sqlcipher 轮询 WeChat DB 检测新消息
+ *
+ * 不依赖 LSPosed HOOK，直接查询 EnMicroMsg.db 的 message 表。
+ * 需要 root 权限（su -c）。
+ */
+
+const { spawn } = require('child_process');
+const EventEmitter = require('events');
+const fs = require('fs');
+
+const DB_PATH = '/data/data/com.tencent.mm/MicroMsg/653cdc2320abb089e149a3f7a7683fcf/EnMicroMsg.db';
+const SQLCIPHER_KEY = 'e03ce81';
+const SQLCIPHER_BIN = '/data/data/com.termux/files/usr/bin/sqlcipher';
+
+function hasRoot() {
+  return process.getuid && process.getuid() === 0;
+}
+
+function wrapCmd(cmd) {
+  if (hasRoot()) return cmd;
+  return `su -c "${cmd.replace(/"/g, '\\"')}"`;
+}
+
+function shell(cmd, timeoutMs = 15000) {
+  const fullCmd = wrapCmd(cmd);
+  const args = ['-c', fullCmd];
+  const shellBin = process.env.SHELL || '/system/bin/sh';
+
+  return new Promise((resolve, reject) => {
+    const proc = spawn(shellBin, args, { timeout: timeoutMs });
+    let stdout = '';
+    let stderr = '';
+    proc.stdout.on('data', d => stdout += d.toString());
+    proc.stderr.on('data', d => stderr += d.toString());
+    proc.on('close', code => {
+      if (code !== 0) {
+        reject(new Error(`exit ${code}: ${stderr.trim() || stdout.trim()}`));
+      } else {
+        resolve(stdout.trim());
+      }
+    });
+    proc.on('error', reject);
+  });
+}
+
+class AndroidWechatTrackerSQLCipher extends EventEmitter {
+  constructor() {
+    super();
+    this.polling = false;
+    this.lastMsgId = 0;
+    this.dbPath = DB_PATH;
+  }
+
+  async init() {
+    const out = await this._query(`SELECT MAX(msgId) AS max_id FROM message;`, 5000);
+    const val = this._extractValue(out, 'max_id');
+    this.lastMsgId = parseInt(val, 10) || 0;
+    console.log(`[TrackerSQLCipher] DB: ${this.dbPath}, lastMsgId: ${this.lastMsgId}`);
+  }
+
+  async _query(sql, timeoutMs = 10000) {
+    // 使用 .mode line 和 .headers off 获取干净输出
+    const script = `.headers off\n.mode line\nPRAGMA key="${SQLCIPHER_KEY}";\nPRAGMA cipher_compatibility=1;\nPRAGMA cipher_page_size=1024;\n${sql}\n`;
+    // 写入临时文件避免命令行转义问题
+    const tmpFile = `/data/data/com.termux/files/usr/tmp/sqlcipher_query_${Date.now()}.sql`;
+    fs.writeFileSync(tmpFile, script);
+    const cmd = `${SQLCIPHER_BIN} "${this.dbPath}" < ${tmpFile}`;
+    const out = await shell(cmd, timeoutMs);
+    // 清理临时文件
+    try { fs.unlinkSync(tmpFile); } catch (_) {}
+    return out;
+  }
+
+  _extractValue(out, columnName) {
+    if (!out) return '';
+    const lines = out.trim().split('\n');
+    // .mode line 输出格式: columnName = value 或 columnName: value
+    for (const line of lines) {
+      const trimmed = line.trim();
+      const eqPrefix = `${columnName} = `;
+      const colonPrefix = `${columnName}: `;
+      if (trimmed.startsWith(eqPrefix)) {
+        return trimmed.substring(eqPrefix.length);
+      }
+      if (trimmed.startsWith(colonPrefix)) {
+        return trimmed.substring(colonPrefix.length);
+      }
+    }
+    return '';
+  }
+
+  /**
+   * 获取新消息（msgId > lastMsgId）
+   */
+  async fetchNew() {
+    // 只查询文本消息 (type=1) 和撤回通知 (type=10002)，排除自己发送的
+    const sql = `SELECT msgId, type, isSend, talker, content, createTime FROM message WHERE msgId > ${this.lastMsgId} AND isSend = 0 AND type IN (1, 10002) ORDER BY msgId ASC;`;
+    const out = await this._query(sql, 10000);
+    const msgs = this._parseRows(out);
+    if (msgs.length > 0) {
+      this.lastMsgId = Math.max(...msgs.map(m => m.msgId));
+    }
+    return msgs;
+  }
+
+  startPolling(intervalMs = 3000) {
+    if (this.polling) return;
+    this.polling = true;
+
+    const tick = async () => {
+      if (!this.polling) return;
+      try {
+        const msgs = await this.fetchNew();
+        for (const msg of msgs) {
+          this.emit('message', msg);
+        }
+      } catch (e) {
+        // 静默失败，防止日志刷屏
+        if (!e.message.includes('database is locked')) {
+          this.emit('error', e);
+        }
+      }
+      setTimeout(tick, intervalMs);
+    };
+
+    tick();
+  }
+
+  stopPolling() {
+    this.polling = false;
+  }
+
+  _parseRows(text) {
+    const messages = [];
+    if (!text) return messages;
+
+    // .mode line 输出格式：每行一个 "column = value"，记录之间用空行分隔
+    const records = [];
+    let current = {};
+    for (const line of text.split('\n')) {
+      const trimmed = line.trim();
+      if (!trimmed) {
+        if (Object.keys(current).length > 0) {
+          records.push(current);
+          current = {};
+        }
+        continue;
+      }
+      // sqlcipher .mode line 输出格式: "key: value" 或 "key = value"
+      let sepIdx = trimmed.indexOf(': ');
+      if (sepIdx < 0) sepIdx = trimmed.indexOf(' = ');
+      if (sepIdx > 0) {
+        const key = trimmed.substring(0, sepIdx).trim();
+        const val = trimmed.substring(sepIdx + 2).trim();
+        current[key] = val;
+      }
+    }
+    if (Object.keys(current).length > 0) {
+      records.push(current);
+    }
+
+    for (const rec of records) {
+      if (!rec.msgId) continue;
+      const isSendVal = parseInt(rec.isSend, 10);
+      messages.push({
+        msgId: parseInt(rec.msgId, 10),
+        msgType: parseInt(rec.type, 10),
+        isSend: isSendVal,
+        talker: rec.talker || '',
+        content: rec.content || '',
+        createTime: parseInt(rec.createTime, 10),
+        type: isSendVal === 1 ? 'send' : 'recv',
+        timestamp: Date.now(),
+        raw: JSON.stringify(rec),
+      });
+    }
+    return messages;
+  }
+}
+
+module.exports = { AndroidWechatTrackerSQLCipher, shell };
@@ -2,10 +2,10 @@
  * auto-reply.js — Pixel 手机微信自动回复 Plugin（接入 hermes API）
  *
  * 架构：
- *   AndroidWechatTracker (tail -f LSPosed 日志) ──→ 实时消息检测
+ *   AndroidWechatTrackerSQLCipher (sqlcipher DB 轮询) ──→ 消息检测
  *   termux-notification-list (兜底) ──→ 息屏时检测通知并唤醒微信
  *   hermes API (POST /api/master/chat) ──→ AI 回复生成
- *   android-wechat-sender (am broadcast) ──→ 发送回复
+ *   android-wechat-sender-frida (frida-inject 调用微信内部 API) ──→ 发送回复
  *
  * 运行方式：
  *   cd /data/data/com.termux/files/home/hermes-wechat
@@ -17,7 +17,9 @@
  */
 const { AndroidWechatTracker } = require('./android-wechat-tracker');
+const { AndroidWechatTrackerSQLCipher } = require('./android-wechat-tracker-sqlcipher');
 const { sendTextMessageBroadcast } = require('./android-wechat-sender');
+const { sendTextMessageFrida } = require('./android-wechat-sender-frida');
 const { shell } = require('./android-wechat-sender');
 const fs = require('fs');
 const path = require('path');
@@ -32,9 +34,9 @@ const CONFIG = {
   myWxid: process.env.MY_WXID || '',
   myNickname: process.env.MY_NICKNAME || '',
-  // hermes API
-  hermesHost: process.env.HERMES_HOST || 'localhost',
-  hermesPort: parseInt(process.env.HERMES_PORT, 10) || 3010,
+  // hermes-agent API (OpenAI-compatible, localhost:8642)
+  hermesHost: process.env.HERMES_HOST || '127.0.0.1',
+  hermesPort: parseInt(process.env.HERMES_PORT, 10) || 8642,
   hermesTimeoutMs: parseInt(process.env.HERMES_TIMEOUT, 10) || 120000,
   // 回复行为
@@ -127,19 +129,23 @@ function log(...args) {
 // ═══════════════════════════════════════════════════════════════
 /**
- * 调用 hermes /api/master/chat 生成回复
+ * 调用 hermes-agent API (OpenAI-compatible) 生成回复
  *
- * @param {string} message - 构造好的 prompt（包含上下文、系统提示）
- * @param {string} sessionId - 会话 ID（每个 talker 独立）
+ * @param {Array<{role:string,content:string}>} messages - OpenAI messages 格式
+ * @param {string} sessionId - 会话 ID（每个 talker 独立，作为 X-Hermes-Session-Id）
  * @returns {Promise<string|null>} 回复文本
  */
-async function callHermesApi(message, sessionId) {
-  return new Promise((resolve, reject) => {
-    const payload = JSON.stringify({ message, sessionId });
+async function callHermesApi(messages, sessionId) {
+  return new Promise((resolve) => {
+    const payload = JSON.stringify({
+      model: 'hermes-agent',
+      messages,
+      stream: false,
+    });
     const req = http.request({
       hostname: CONFIG.hermesHost,
       port: CONFIG.hermesPort,
-      path: '/api/master/chat',
+      path: '/v1/chat/completions',
       method: 'POST',
       headers: {
         'Content-Type': 'application/json',
@@ -150,11 +156,18 @@ async function callHermesApi(message, sessionId) {
       let buffer = '';
       res.on('data', chunk => { buffer += chunk; });
       res.on('end', () => {
+        log('[HERMES] HTTP status:', res.statusCode, 'body:', buffer.substring(0, 300));
         try {
-          const result = parseSSE(buffer);
-          resolve(result);
+          const data = JSON.parse(buffer);
+          if (data.error) {
+            log('[HERMES] API error:', JSON.stringify(data.error));
+            resolve(null);
+            return;
+          }
+          const content = data.choices?.[0]?.message?.content;
+          resolve(content || null);
         } catch (e) {
-          log('[HERMES] SSE parse error:', e.message);
+          log('[HERMES] JSON parse error:', e.message);
           resolve(null);
         }
       });
@@ -175,85 +188,43 @@ async function callHermesApi(message, sessionId) {
   });
 }
-/**
- * 解析 SSE 响应，提取 result.output
- */
-function parseSSE(buffer) {
-  const lines = buffer.split('\n');
-  const events = [];
-  let currentEvent = null;
-  let currentData = '';
-
-  for (const line of lines) {
-    const trimmed = line.trim();
-    if (trimmed.startsWith('event:')) {
-      if (currentEvent !== null) {
-        events.push({ event: currentEvent, data: currentData });
-      }
-      currentEvent = trimmed.slice(6).trim();
-      currentData = '';
-    } else if (trimmed.startsWith('data:')) {
-      currentData += trimmed.slice(5).trim();
-    } else if (trimmed === '' && currentEvent !== null) {
-      events.push({ event: currentEvent, data: currentData });
-      currentEvent = null;
-      currentData = '';
-    }
-  }
-  if (currentEvent !== null) {
-    events.push({ event: currentEvent, data: currentData });
-  }
-
-  // 找 result 事件
-  for (const ev of events) {
-    if (ev.event === 'result') {
-      try {
-        const data = JSON.parse(ev.data);
-        return data.output || null;
-      } catch {
-        return ev.data || null;
-      }
-    }
-  }
-
-  return null;
-}
-
 // ═══════════════════════════════════════════════════════════════
 //  回复生成器 — 接入 hermes
 // ═══════════════════════════════════════════════════════════════
 /**
- * 构造发给 hermes 的 prompt
+ * 构造 OpenAI messages 数组发给 hermes-agent
  */
-function buildHermesPrompt(ctx) {
+function buildHermesMessages(ctx) {
   const { type, talker, content, senderName } = ctx;
-  let prompt = '';
-
+  let userContent = '';
   if (type === 'private') {
-    prompt = `收到微信私聊消息（来自 ${talker}）：\n${content}\n\n请给出自然、简短、得体的中文回复。只输出回复内容，不要加任何解释。`;
+    userContent = `收到微信私聊消息（来自 ${talker}）：\n${content}\n\n请给出自然、简短、得体的中文回复。只输出回复内容，不要加任何解释。`;
   } else if (type === 'group-at') {
-    prompt = `收到微信群聊消息，有人 @ 我（来自群 ${talker}，发送者 ${senderName}）：\n${content}\n\n请给出自然、简短、得体的中文回复。只输出回复内容，不要加任何解释。`;
+    userContent = `收到微信群聊消息，有人 @ 我（来自群 ${talker}，发送者 ${senderName}）：\n${content}\n\n请给出自然、简短、得体的中文回复。只输出回复内容，不要加任何解释。`;
   } else if (type === 'group-quote') {
-    prompt = `收到微信群聊消息，有人引用了我的消息（来自群 ${talker}，发送者 ${senderName}）：\n${content}\n\n请给出自然、简短、得体的中文回复。只输出回复内容，不要加任何解释。`;
+    userContent = `收到微信群聊消息，有人引用了我的消息（来自群 ${talker}，发送者 ${senderName}）：\n${content}\n\n请给出自然、简短、得体的中文回复。只输出回复内容，不要加任何解释。`;
   } else {
-    prompt = `收到微信消息（来自 ${talker}）：\n${content}\n\n请给出自然、简短、得体的中文回复。只输出回复内容，不要加任何解释。`;
+    userContent = `收到微信消息（来自 ${talker}）：\n${content}\n\n请给出自然、简短、得体的中文回复。只输出回复内容，不要加任何解释。`;
   }
-  return prompt;
+  return [
+    { role: 'system', content: '你是 lemonAI 助手，一个智能、友好、简短的 AI 助手。' },
+    { role: 'user', content: userContent },
+  ];
 }
 /**
- * 接入 hermes 的回复生成器
+ * 接入 hermes-agent 的回复生成器
  */
 async function hermesReplyGenerator(ctx) {
   const { talker } = ctx;
   const sessionId = `wx-${talker}`;
-  const prompt = buildHermesPrompt(ctx);
+  const messages = buildHermesMessages(ctx);
   log('[HERMES] Calling API for', talker, 'session:', sessionId);
-  const reply = await callHermesApi(prompt, sessionId);
+  const reply = await callHermesApi(messages, sessionId);
   if (reply) {
     log('[HERMES] Reply:', reply.substring(0, 80));
@@ -291,29 +262,105 @@ function escapeRegex(str) {
 }
 // ═══════════════════════════════════════════════════════════════
-//  微信前台检测与唤醒
+//  屏幕状态检测与微信唤醒（息屏专用）
 // ═══════════════════════════════════════════════════════════════
+async function isScreenOn() {
+  try {
+    const out = await shell('dumpsys power | grep "mWakefulness"', 3000);
+    return out.includes('mWakefulness=Awake');
+  } catch {
+    return false;
+  }
+}
+
+async function isKeyguardLocked() {
+  try {
+    const out = await shell('dumpsys window | grep "mInputRestricted"', 3000);
+    return out.includes('mInputRestricted=true');
+  } catch {
+    return false;
+  }
+}
+
 async function isWechatForeground() {
   try {
-    const out = await shell('dumpsys activity activities | grep "mResumedActivity"', 5000);
+    // Android 15 上 mCurrentFocus 已废弃，改用 mFocusedApp
+    const out = await shell('dumpsys activity activities | grep "mFocusedApp"', 5000);
     return out.includes('com.tencent.mm');
   } catch {
     return false;
   }
 }
+/**
+ * 息屏唤醒完整流程：点亮 → 解锁（无密码时滑动） → 启动微信 → 确认前台
+ */
 async function wakeWechat() {
   try {
+    // 1. 如果屏幕是黑的，用 KEYCODE_WAKEUP(224) 点亮，不会 toggle
+    const screenOn = await isScreenOn();
+    if (!screenOn) {
+      await shell('input keyevent 224', 3000);
+      log('[WAKE] Screen woke up');
+      await sleep(800);
+    }
+
+    // 2. 无密码时，wm dismiss-keyguard 可直接解除锁屏，比滑动更可靠
+    try {
+      await shell('wm dismiss-keyguard', 3000);
+      log('[WAKE] Keyguard dismissed');
+    } catch (e) {
+      log('[WAKE] dismiss-keyguard failed (may already unlocked):', e.message);
+    }
+    await sleep(500);
+
+    // 3. 启动微信到前台
     await shell('/system/bin/am start -n com.tencent.mm/.ui.LauncherUI', 5000);
-    log('[WECHAT] Woken up');
+    log('[WAKE] WeChat LauncherUI started');
+    await sleep(1000);
+
     return true;
   } catch (e) {
-    log('[WECHAT] Failed to wake:', e.message);
+    log('[WAKE] Failed:', e.message);
     return false;
   }
 }
+/**
+ * 确保微信在前台且屏幕已解锁，轮询最多 20 秒
+ */
+async function ensureWechatForeground(maxWaitMs = 20000) {
+  const start = Date.now();
+  while (Date.now() - start < maxWaitMs) {
+    const screenOn = await isScreenOn();
+    const locked = await isKeyguardLocked();
+    const fg = await isWechatForeground();
+
+    if (screenOn && !locked && fg) {
+      // 模拟一次点击保持活跃
+      try { await shell('input keyevent 62', 1000); } catch (_) {}
+      log('[WAKE] Confirmed: screen on + unlocked + WeChat foreground');
+      return true;
+    }
+
+    if (!screenOn) {
+      log('[WAKE] Screen still off, retrying keyevent 224...');
+      try { await shell('input keyevent 224', 3000); } catch (_) {}
+    } else if (locked) {
+      log('[WAKE] Still locked, retrying dismiss-keyguard...');
+      try { await shell('wm dismiss-keyguard', 3000); } catch (_) {}
+    } else if (!fg) {
+      log('[WAKE] WeChat not foreground, retrying start...');
+      try { await shell('am start -n com.tencent.mm/.ui.LauncherUI', 5000); } catch (_) {}
+    }
+
+    await sleep(1500);
+  }
+  log('[WAKE] Foreground check timeout');
+  return false;
+}
+
 // ═══════════════════════════════════════════════════════════════
 //  通知监听（息屏兜底）
 // ═══════════════════════════════════════════════════════════════
@@ -333,7 +380,7 @@ async function pollNotifications(bot) {
     try {
       const out = await shell(termuxBin, 10000);
       const notifs = JSON.parse(out);
-      const wechatNotifs = notifs.filter(n => n.pkgName === 'com.tencent.mm');
+      const wechatNotifs = notifs.filter(n => n.packageName === 'com.tencent.mm');
       for (const n of wechatNotifs) {
         const key = `${n.title}:${n.content}`;
@@ -349,15 +396,17 @@ async function pollNotifications(bot) {
         log('[NOTIF] WeChat notification:', n.title, n.content.substring(0, 60));
-        // 息屏时微信可能不在前台，先唤醒
-        const fg = await isWechatForeground();
-        if (!fg) {
-          await wakeWechat();
-          await sleep(3000); // 等待微信同步 DB、LSPosed 写日志
+        // 息屏时微信可能不在前台，先点亮+启动微信
+        // 剩下的检测和发送交给 sqlcipher 轮询 + handleMessage
+        const screenOn = await isScreenOn();
+        if (!screenOn) {
+          log('[NOTIF] Screen off, waking WeChat...');
+          const ok = await wakeWechat();
+          if (ok) {
+            await ensureWechatForeground(20000);
+            log('[NOTIF] WeChat woken up, tracker will catch the message');
+          }
         }
-
-        // 通知 tracker 立即检查（tracker 的 tail -f 会捕获新日志）
-        // 如果 tracker 已经停止，这里无法恢复它
       }
     } catch (e) {
       // notification-list 可能返回空或失败，忽略
@@ -377,7 +426,8 @@ function sleep(ms) {
 class AutoReplyBot {
   constructor(replyGenerator = hermesReplyGenerator) {
-    this.tracker = new AndroidWechatTracker();
+    // 优先使用 sqlcipher DB 轮询（LSPosed hook 在 WeChat 8.0.72 上不稳定）
+    this.tracker = new AndroidWechatTrackerSQLCipher();
     this.state = new ReplyState(CONFIG.stateFile);
     this.replyGenerator = replyGenerator;
     this.running = false;
@@ -416,11 +466,17 @@ class AutoReplyBot {
     log(`[${replyType.toUpperCase()}] ${talker}: ${content.substring(0, 80)}`);
-    // 发送前检查微信前台
+    // 发送前确保微信在前台（息屏时通知监听会先唤醒）
     const fg = await isWechatForeground();
     if (!fg) {
+      log('[WECHAT] Not foreground, waking...');
       await wakeWechat();
-      await sleep(2000);
+      const ok = await ensureWechatForeground();
+      if (!ok) {
+        log('[WECHAT] Could not bring WeChat to foreground, skip sending');
+        return;
+      }
+      await sleep(2000); // 额外等待网络初始化
     }
     let replyText;
@@ -447,7 +503,7 @@ class AutoReplyBot {
     }
     try {
-      const result = await sendTextMessageBroadcast(talker, replyText);
+      const result = await sendTextMessageFrida(talker, replyText);
       if (result.ok) {
         log('[SENT]', talker, replyText.substring(0, 60));
         this.state.markReplied(msgId, talker);
@@ -474,13 +530,14 @@ class AutoReplyBot {
       notificationEnabled: CONFIG.notificationEnabled,
     }));
-    // 启动 tracker（流式 tail -f，最实时）
+    // 启动 tracker（sqlcipher DB 轮询，比 LSPosed hook 更可靠）
     this.tracker.on('message', msg => this.handleMessage(msg));
     this.tracker.on('error', err => log('[TRACKER ERROR]', err.message));
-    this.tracker.startStream();
-    log('[TRACKER] Stream started (tail -f)');
+    await this.tracker.init();
+    this.tracker.startPolling(3000);
+    log('[TRACKER] DB polling started (sqlcipher)');
-    // 启动通知监听（息屏兜底）
+    // 启动通知监听（息屏兜底：检测到通知时点亮屏幕+启动微信）
     if (CONFIG.notificationEnabled) {
       this.notifLoop = pollNotifications(this);
     }
@@ -492,7 +549,6 @@ class AutoReplyBot {
   stop() {
     if (!this.running) return;
     this.running = false;
-    this.tracker.stopStream();
     this.tracker.stopPolling();
     log('=== Auto-Reply Bot Stopped ===');
     process.exit(0);
@@ -158,9 +158,18 @@ cd ~/local-testkit
 ### 3. 启动 hermes server（如果还没运行）
+**必须在 proot Ubuntu 内以 ubuntu 用户运行**（Claude CLI 安全机制拒绝 root + `--dangerously-skip-permissions`）：
+
+```bash
+proot-distro login ubuntu --user ubuntu -- bash -c \
+  "cd /data/data/com.termux/files/home/hermes-wechat && . .env && node server/index.js"
+```
+
+或后台运行：
 ```bash
-cd ~/hermes-wechat
-node server/index.js
+nohup proot-distro login ubuntu --user ubuntu -- bash -c \
+  "cd /data/data/com.termux/files/home/hermes-wechat && . .env && node server/index.js" \
+  > hermes-server.log 2>&1 &
 ```
 ### 4. 启动 auto-reply plugin（推荐主流程）
@@ -240,6 +249,7 @@ python3 hermes_wechat_daemon.py --daemon
 | 息屏后完全失效 | 确认电池优化已关闭；检查 `keepalive.sh` 是否运行 |
 | 发送失败 | 检查微信是否在前台；检查 LSPosed 模块是否启用 |
 | Python daemon 查询不到新消息 | 检查微信是否在前台；检查 `sqlcipher_key`；确认 WAL 已复制 |
+| Claude CLI 报错 `root/sudo privileges` | hermes server 必须以 proot 内 **ubuntu 用户** 运行，不能是 root |
 ---
@@ -20,6 +20,9 @@
 set -e
+# 确保 Termux 工具在 PATH 中（su 环境下可能缺失）
+export PATH="/data/data/com.termux/files/usr/bin:$PATH"
+
 HERMES_DIR="${HERMES_DIR:-/data/data/com.termux/files/home/hermes-wechat}"
 HERMES_HOST="${HERMES_HOST:-localhost}"
 HERMES_PORT="${HERMES_PORT:-3010}"
@@ -37,26 +40,26 @@ log &quot;Wake lock acquired&quot;
 # ── 2. 检查前置条件 ──────────────────────────────────────────────
 check_prerequisites() {
-    local ok=true
+    _ok=0
     if ! command -v termux-notification-list >/dev/null 2>&1; then
         log "[WARN] termux-notification-list not found. Install: pkg install termux-api"
-        ok=false
+        _ok=1
     fi
     if [ ! -d "$HERMES_DIR" ]; then
         log "[WARN] HERMES_DIR not found: $HERMES_DIR"
-        ok=false
+        _ok=1
     fi
     if [ -z "$MY_WXID" ] || [ -z "$MY_NICKNAME" ]; then
         log "[WARN] MY_WXID or MY_NICKNAME not set"
         log "       export MY_WXID=wxid_xxxxxx"
         log "       export MY_NICKNAME=你的昵称"
-        ok=false
+        _ok=1
     fi
-    $ok
+    return $_ok
 }
 # ── 3. 检查 hermes server 是否运行 ───────────────────────────────
@@ -65,15 +68,18 @@ is_hermes_running() {
 }
 # ── 4. 启动 hermes server ────────────────────────────────────────
+# 必须在 proot Ubuntu 内以 ubuntu 用户运行（Claude CLI 拒绝 root + --dangerously-skip-permissions）
 start_hermes() {
-    log "Starting hermes server..."
+    log "Starting hermes server in proot Ubuntu user=ubuntu..."
     cd "$HERMES_DIR"
-    nohup node server/index.js > hermes-server.log 2>&1 &
-    sleep 3
+    nohup proot-distro login ubuntu --user ubuntu -- bash -c \
+        "cd $HERMES_DIR && . .env && node server/index.js" \
+        > hermes-server.log 2>&1 &
+    sleep 5
     if is_hermes_running; then
-        log "Hermes server started (PID=$!)"
+        log "Hermes server started PID=$!"
     else
-        log "[WARN] Hermes server may have failed to start"
+        log "[WARN] Hermes server may have failed to start, check hermes-server.log"
     fi
 }
@@ -88,14 +94,14 @@ start_auto_reply() {
     cd "$HERMES_DIR/server/services/wechat"
     env MY_WXID="$MY_WXID" MY_NICKNAME="$MY_NICKNAME" \
         nohup node auto-reply.js > auto-reply.log 2>&1 &
-    log "Auto-reply started (PID=$!)"
+    log "Auto-reply started PID=$!"
 }
 # ── 7. 主循环 ────────────────────────────────────────────────────
 log "=== Keepalive started ==="
 log "HERMES_DIR=$HERMES_DIR"
-log "MY_WXID=${MY_WXID:-(not set)}"
-log "MY_NICKNAME=${MY_NICKNAME:-(not set)}"
+log "MY_WXID=${MY_WXID:-not-set}"
+log "MY_NICKNAME=${MY_NICKNAME:-not-set}"
 if ! check_prerequisites; then
     log "[ERROR] Prerequisites check failed, exiting"
@@ -337,18 +337,20 @@ public class HermesWeChatModule implements IXposedHookLoadPackage {
                 return false;
             }
-            // Submit to NetScene queue on a background thread.
-            // u01.m1.a() may throw a non-fatal NPE during internal cleanup after the
-            // message has already been queued; we swallow it and treat as success.
+            // Submit to NetScene queue on the MAIN thread.
+            // WeChat's NetScene dispatcher requires main-looper execution; calling from
+            // a background thread silently drops the message on some devices / ROMs.
             final java.lang.reflect.Method submit = result.getClass().getMethod("a");
             final Object m1Result = result;
-            new Thread(() -> {
+            new android.os.Handler(android.os.Looper.getMainLooper()).post(() -> {
                 try {
                     submit.invoke(m1Result);
-                } catch (Exception ignored) {
-                    // NPE here is harmless; message was already submitted.
+                    XposedBridge.log("[" + TAG + "] NetScene submitted on main thread");
+                } catch (Exception e) {
+                    XposedBridge.log("[" + TAG + "] NetScene submit on main thread failed: " + e.getMessage());
+                    XposedBridge.log(e);
                 }
-            }).start();
+            });
             XposedBridge.log("[" + TAG + "] Message submitted to NetScene queue");
             return true;