feat: M6.44+M6.45 收编 — 真机 0.8.45 现场保全(reader章节/key_router按键路由/WiFi连接修复/ncm bench+IME修复)

脏工作区现场收编：devdocs/local/m6_44_45_dirty_tracked.patch(46 个已跟踪文本文件,
+3090/-585, 已对 M6.43 基线干净适配) + m6_44_45_untracked_src.tar.gz 中 patch_v2/ 下
13 个新增源文件, 合成单个提交, 内容与容器工作树(R3ProII/patch_v2)逐字节一致。

- reader 章节: 新增 core/rdchapter.{h,c} — TXT 章节规范解析器, 扫描 512KB 码位对齐段文件
  逐段流式识别标题行(行首缩进≤4/显示宽≤40/行内标点≤1 三重约束防误判), 输出标题+全书字符
  偏移+段号/段内偏移+阿拉伯章号(中文数字归一), 首章前内容归"卷首"; book/reader/rdenc/
  rdlayout/settings 接入章节跳转与进度锚点, 附 chapter_smoke/turn_repro/build_turn_repro.sh
- key_router 按键路由: 新增 meow_launcherd/key_router.{h,c} — launcher-UI 页物理键统一路由
  (P1 仅音量键), 把读取边沿+防抖+长按 held+ramp 推进从 5 个会话收敛为进程内单开;
  各页每圈 key_router_pump() 取防抖后边沿, 动作(调音量/光标导航)仍由调用页决定,
  保留 run_menu 的 meow_mode 分支; App 前台 volume_page 武装时边沿抑制;
  main_menu/now_playing/notif_center/settings_page/subpage 接入, 附 test_key_router_vol/test_np_keys
- WiFi 连接修复: meow_netmgrd connect 有界等待 wpa_state=COMPLETED(普通 10s/隐藏网络 15s,
  env 可调)修设置页连接无响应; list_networks/scan_results 的 \xNN 转义还原始字节, 修中文 SSID
  永不命中致新建同名 open 记录顶影; launcher netmgr_ipc 配读超时; 附 test_wifi_connect(桩
  wpa_cli 驱动 static wifi_connect_ex), test_netmgrd.sh 补用例; wifi_page 同步
- ncm bench: 新增 bench/lyric_sim.c、bench/plpage_sim.c, vol_sync_sim 与 ncm core/app 同步
- SDK IME 修复: shift 大小写、K_ENTER 只提交不关、阻塞 IME 循环喂 on_tick 不被遮挡、
  IME 打开 ~200ms TAP 冷却窗吞 stray-TAP; 附 sdk/test_ime_fix.c
- 同期: meow_audiod 音量异步 ACK 线程(代际防 fd/槽复用竞态)、watchdog 音量收编(首选 audiod
  权威, settings.conf 覆盖路径)、panel 文件搜索(F1-④)与蓝牙只读详情(F1-③)、各类 build 脚本同步

范围红线: third_party/legado-E-main 原开发者未跟踪, 本次不入库(保留 devdocs/local tar 参考);
二进制不入库(后续重编); devdocs/ 不入库。59 文件全部在 patch_v2/ 下, 无 third_party/devdocs。
验证: git apply --check 干净; 59 文件 md5 与容器 patch_v2 逐一比对 59/59 一致(含
key_router.c/rdchapter.c/meow_ui_ime.c/test_wifi_connect.c 抽查); 可执行位保守
(check_lgpl_release.sh 100755, build_turn_repro.sh 100644 与容器一致)。

patch_v2/meow_launcherd/build_launcher.sh

@@ -26,7 +26,7 @@ SYSROOT="$ROOT/.tools/mipsel-linux-muslsf-cross/mipsel-linux-muslsf"
     main_menu.c statusbar.c fb_compositor.c settings_page.c power_menu.c \
     notif_center.c app_launcher.c audio.c backlight.c net.c about.c \
     subpage.c wifi_page.c bt_page.c netmgr_ipc.c now_playing.c bg_page.c \
-    font_theme.c keys.c util.c meow_dep.c \
+    font_theme.c keys.c util.c meow_dep.c key_router.c \
     meow_touch.c meow_settings.c meow_notif.c meow_media.c meow_bgplay.c \
     meow_bgmgr.c \
     meow_ams_start.c lock_screen.c lock_screen_ui.c lock_settings.c \

patch_v2/meow_launcherd/key_router.c

@@ -0,0 +1,142 @@
+/* key_router.c — launcher-UI 页物理键统一路由（KEY_ROUTER_UNIFY，P1：音量键）。
+ *
+ * 本模块持有一个进程内唯一的音量键防抖/基线：
+ *     kp_keys / kp_power（事件设备 poll 态，key_router_init 单开）
+ *     kd_vold / kd_volu（40ms 防抖态，KEY_DEBOUNCE_MS）
+ *     m_prev_vold / m_prev_volu（音量边沿基线）
+ * 各 launcher-UI 页每圈调 key_router_pump() —— 它只产「音量边沿 + 原始 held + ramp 状态」，
+ * 产出的边沿由「谁在跑循环」天然归属当前页；页据此决定 settings_volume_adj(±step) /
+ * 光标导航 / ramp 推进。这样 run_menu 的 meow_mode 分支（HibyOS overlay 音量=导航）不被破坏，
+ * 其余页（设置/通知中心/Now Playing/子页）用默认「音量=调音量」。
+ *
+ * 边界（§3 P1 / §4）：
+ *   - App 前台 volume_page 武装时（meow_volpage_armed()）音量边沿被抑制（防御闸；launcher-UI
+ *     下 sink 恒空，此闸是「不改变行为」的保险）。
+ *   - 播放键/电源键 P1 不路由（各页现状不动；播放键严禁 cmd=6）。
+ *   - 锁屏（EVIOCGRAB）/App 会话层不调用本模块 —— 边界由「调用栈里当前循环是不是 launcher-UI 页」
+ *     自动强加。
+ */
+#include "meow_launcher_internal.h"
+
+static int g_inited = 0;
+
+/* 进程唯一事件设备 poll 态（key_router_init 单开；各页另自开 kp_* 仅供播放/电源键用）。 */
+static struct keypoll kp_power, kp_keys;
+
+/* 进程唯一音量键防抖态 + 边沿基线。 */
+static struct kd_state kd_vold, kd_volu;
+static int m_prev_vold = 0, m_prev_volu = 0;
+
+/* 当前活动页哨兵（key_router_page_enter/exit 登记；与 sdk meow_ui_activity 交叉校验用）。 */
+static int g_page_sentinel = 0;
+
+
+void key_router_init(void)
+{
+    if (g_inited) return;
+    g_inited = 1;
+    memset(&kp_power, 0, sizeof kp_power);
+    memset(&kp_keys, 0, sizeof kp_keys);
+    memset(&kd_vold, 0, sizeof kd_vold);
+    memset(&kd_volu, 0, sizeof kd_volu);
+    m_prev_vold = 0; m_prev_volu = 0;
+    kp_open(&kp_power, DEV_POWER);
+    kp_open(&kp_keys, DEV_KEYS);
+    /* 基线对齐当前 raw：进入时已按住的音量键不产假边沿。 */
+    key_router_rebase();
+}
+
+
+void key_router_rebase(void)
+{
+    memset(&kd_vold, 0, sizeof kd_vold);
+    memset(&kd_volu, 0, sizeof kd_volu);
+    if (!g_inited) return;
+    kp_poll(&kp_power, NULL, NULL);
+    kp_poll(&kp_keys, NULL, NULL);
+    m_prev_vold = kp_is_down(&kp_keys, KEY_VOLUMEDOWN);
+    m_prev_volu = kp_is_down(&kp_keys, KEY_VOLUMEUP);
+}
+
+
+key_evt_t key_router_pump(void)
+{
+    key_evt_t ev;
+    memset(&ev, 0, sizeof ev);
+    if (!g_inited) key_router_init();
+
+    /* 设备晚就绪兜底：init 时 open 失败则此处每圈重试（open 失败快速返回，无阻塞）。 */
+    if (!kp_keys.ok) kp_open(&kp_keys, DEV_KEYS);
+    if (!kp_power.ok) kp_open(&kp_power, DEV_POWER);
+    kp_poll(&kp_power, NULL, NULL);
+    kp_poll(&kp_keys, NULL, NULL);
+
+    int vold = 0, volu = 0;
+    for (int w = 0; w < KEYBUF_WORDS; w++) {
+        if (kp_keys.cur[w] & (1UL << (KEY_VOLUMEDOWN % 32))) vold = 1;
+        if (kp_keys.cur[w] & (1UL << (KEY_VOLUMEUP % 32)))   volu = 1;
+    }
+    /* 原始（未防抖）值：长按 ramp held 用（松开立即停止；同 run_menu/now_playing 现状）。 */
+    ev.vol_held_dn = vold;
+    ev.vol_held_up = volu;
+    (void)kd_tick(&kd_vold, vold);
+    (void)kd_tick(&kd_volu, volu);
+    vold = kd_vold.stable; volu = kd_volu.stable;
+    ev.vol_st_dn = vold; ev.vol_st_up = volu;
+
+    if (meow_volpage_armed()) {
+        /* 防御闸：App 前台 volume_page 武装时（launcher-UI 下恒空）不放行音量边沿。
+         * 音量键在那态下由 app_launcher 的 meow_volpage_key 消费（翻页），不落系统调音。 */
+        ev.vol_dn_edge = 0;
+        ev.vol_up_edge = 0;
+    } else {
+        ev.vol_dn_edge = (vold && !m_prev_vold);
+        ev.vol_up_edge = (volu && !m_prev_volu);
+    }
+    ev.ramping = (vol_ramp_dir != 0);
+
+    m_prev_vold = vold;
+    m_prev_volu = volu;
+    return ev;
+}
+
+
+void key_router_default_volume(const key_evt_t *ev, unsigned long long *last_input)
+{
+    if (ev->vol_dn_edge) {
+        settings_volume_adj(-settings_volume_step);
+        if (last_input) *last_input = now_ms();
+        logmsg("key_router: volume DOWN <- step=%d", settings_volume_step);
+    }
+    if (ev->vol_up_edge) {
+        settings_volume_adj(+settings_volume_step);
+        if (last_input) *last_input = now_ms();
+        logmsg("key_router: volume UP <- step=%d", settings_volume_step);
+    }
+    /* 在 settings_volume_adj 之后重查 vol_ramp_dir：同圈「起 ramp」即立刻迈第一步（同现状
+     * 各页「settings_volume_adj 后 if(vol_ramp_dir) vol_ramp_tick」），且长按续爬随每圈推进。 */
+    if (vol_ramp_dir != 0) {
+        int held = (vol_ramp_dir > 0) ? ev->vol_held_up : ev->vol_held_dn;
+        (void)vol_ramp_tick(held);
+    }
+}
+
+
+void key_router_page_enter(int sentinel)
+{
+    g_page_sentinel = sentinel;
+    /* 与 sdk 活动栈交叉校验：哨兵非 0 且栈顶不一致 → 记录（不中止，防宿主/真机栈深度差异）。 */
+    if (sentinel) {
+        int act = meow_ui_activity_active();
+        if (act && act != sentinel)
+            logmsg("key_router: page_enter sentinel=%#x but active=%#x", sentinel, act);
+    }
+}
+
+
+void key_router_page_exit(int sentinel)
+{
+    if (g_page_sentinel == sentinel) g_page_sentinel = 0;
+    /* 页退出即重播基线（§6 嵌套返回风险项：返回瞬间不产假边沿）。 */
+    key_router_rebase();
+}

patch_v2/meow_launcherd/key_router.h

@@ -0,0 +1,65 @@
+/* key_router.h — launcher-UI 页物理键统一路由（KEY_ROUTER_UNIFY，P1：音量键）。
+ *
+ * 设计（devdocs/plan/KEY_ROUTER_UNIFY.md §2.5 方案 C / §3 P1）：
+ *   - 进程内**唯一**的 kd_*（防抖态）+ m_prev_*（边沿基线）+ kp_*（事件设备 poll 态），
+ *     把「读边沿 + 防抖 + 长按 held + ramp 推进」这层从 5 个会话（run_menu /
+ *     run_settings_page / run_notif_center / run_now_playing / meow_subpage_run）
+ *     收敛到一处。
+ *   - 每个 launcher-UI 页在其 for(;;) 每圈调一次 key_router_pump()，得到「防抖后的
+ *     音量边沿 + 原始 held + ramp 状态」；**真正的动作**（音量边沿 →
+ *     settings_volume_adj(±step)，还是光标导航）由调用页决定 —— 这样 run_menu 的
+ *     meow_mode 分支（HibyOS overlay：音量=导航；MeowOS：音量=调音量）得以保留。
+ *   - 非导航页可经 key_router_default_volume()（内含 settings_volume_adj + vol_ramp_tick +
+ *     last_input 复位）直接用；run_menu 走自己的 meow_mode 分支。
+ *
+ * 范围与边界（§3 P1，勿越界）：
+ *   - 本模块只收敛**音量键**（KEY_VOLUMEDOWN/KEY_VOLUMEUP）。播放键/电源键 P1 不路由，
+ *     维持各页现状（播放键严禁改成 cmd=6；电源键单击/菜单/8s 状态机不动）。
+ *   - App 前台 volume_page 武装时（meow_volpage_armed()）音量边沿被抑制（防御闸）。
+ *   - 锁屏层（EVIOCGRAB）/App 会话层从不调用 key_router_pump，天然退出本路由。
+ */
+#ifndef MEOW_KEY_ROUTER_H
+#define MEOW_KEY_ROUTER_H
+
+/* 一框音量边沿/held/ramp 输出。P1 只填音量；播放/电源字段后续期（P2/P3）再扩展。
+ * 字段语义：
+ *   vol_dn_edge / vol_up_edge —— 防抖后**稳定按下边沿**（= stable ∧ ¬上一 stable；
+ *       1=本圈新按下）。这是「音量边沿」的唯一权威判定。
+ *   vol_held_dn / vol_held_up —— **原始（未防抖）**按住态，ramp 长按 held 用
+ *       （松开立即停止，同 run_menu/now_playing 现状）。
+ *   vol_st_dn / vol_st_up   —— **防抖稳定**按住态（wake_suppress「全键抬起」判定用）。
+ *   ramping                   —— vol_ramp_dir != 0（线性渐变是否在跑；repaint 用）。
+ */
+typedef struct {
+    int vol_dn_edge;
+    int vol_up_edge;
+    int vol_held_dn;
+    int vol_held_up;
+    int vol_st_dn;
+    int vol_st_up;
+    int ramping;
+} key_evt_t;
+
+/* 进程级单开 kp_*（事件设备）+ 初始化防抖态/基线（幂等，可安全重复调用）。 */
+void key_router_init(void);
+
+/* 每页 for(;;) 每圈调用一次：poll 两设备 → 防抖音量键 → 产边沿/held/ramp。
+ * 不做 settings_volume_adj、不驱动 vol_ramp_tick、不复位 last_input —— 皆由调用页决定
+ * （见 key_router_default_volume 与各页自己的分支）。 */
+key_evt_t key_router_pump(void);
+
+/* 模态/菜单/嵌套会话返回/唤醒后重播基线：kd_* 清零 + m_prev_* 对齐当前 raw
+ * （对齐现状各页「memset(kd_*) + kp_poll + m_prev_*=当前 raw」的语义，防假边沿）。
+ * 各页在原本做该重播处调用。 */
+void key_router_rebase(void);
+
+/* 页进入/退出登记（记录当前哨兵；与 sdk meow_ui_activity_active 交叉校验）。 */
+void key_router_page_enter(int sentinel);
+void key_router_page_exit(int sentinel);
+
+/* 默认「音量键=调音量」页回调（非导航页直接用）：音量边沿 → settings_volume_adj(±step)；
+ * 若有 ramp 在爬 → vol_ramp_tick(held)；边沿 → 复位 *last_input。
+ * run_menu 不走本函数（自行 meow_mode 分支）。 */
+void key_router_default_volume(const key_evt_t *ev, unsigned long long *last_input);
+
+#endif /* MEOW_KEY_ROUTER_H */

patch_v2/meow_launcherd/main_menu.c

@@ -1214,10 +1214,11 @@ static void run_menu(struct app apps[MAX_APPS], int napps, int state,
     struct keypoll kp_power, kp_keys;
     kp_open(&kp_power, DEV_POWER);
     kp_open(&kp_keys, DEV_KEYS);
-    /* M2.16 按键防抖状态（每键独立）；kd_tick 40ms 稳定后才认，抗 ADC 抖动 */
-    struct kd_state kd_vold, kd_volu, kd_play, kd_pwr;
-    memset(&kd_vold, 0, sizeof kd_vold); memset(&kd_volu, 0, sizeof kd_volu);
+    /* M2.16 按键防抖状态（每键独立）；kd_tick 40ms 稳定后才认，抗 ADC 抖动。
+     * 音量键防抖/基线已上收 key_router（进程唯一）；本页只保留播放/电源键自家防抖。 */
+    struct kd_state kd_play, kd_pwr;
     memset(&kd_play, 0, sizeof kd_play); memset(&kd_pwr, 0, sizeof kd_pwr);
+    key_router_rebase();   /* 进入主菜单：音量基线对齐当前 raw（防残留边沿） */
 
     logmsg("menu open: napps=%d state=%d cursor=%d",
            napps, state, cursor);
@@ -1226,10 +1227,8 @@ static void run_menu(struct app apps[MAX_APPS], int napps, int state,
      * when the menu opens (e.g. the hotkey release tail) do not fire
      * edges; kp.prev cannot be used for this because kp_poll() syncs it
      * to cur before we compare */
-    int m_prev_vold = 0, m_prev_volu = 0, m_prev_play = 0, m_prev_pwr = 0;
+    int m_prev_play = 0, m_prev_pwr = 0;
     for (int w = 0; w < KEYBUF_WORDS; w++) {
-        if (kp_keys.cur[w] & (1UL << (KEY_VOLUMEDOWN % 32))) m_prev_vold = 1;
-        if (kp_keys.cur[w] & (1UL << (KEY_VOLUMEUP % 32))) m_prev_volu = 1;
         if (kp_keys.cur[w] & (1UL << (KEY_PLAYPAUSE % 32))) m_prev_play = 1;
         if (kp_power.cur[w] & (1UL << (KEY_POWER % 32))) m_prev_pwr = 1;
     }
@@ -1433,26 +1432,20 @@ static void run_menu(struct app apps[MAX_APPS], int napps, int state,
          * does not affect it) — the launcher must NOT touch brightness/panel
          * or exit the menu on it. Exit is only via the BACK TO PLAYER touch
          * row (below) or sim-exit. */
+        /* 音量键走 key_router（进程唯一防抖/基线，产边沿/held/ramp）；播放/电源键仍本页自理。 */
+        key_evt_t kev = key_router_pump();
         kp_poll(&kp_power, NULL, NULL);
         kp_poll(&kp_keys, NULL, NULL);
-        int vold = 0, volu = 0, play = 0, pwr = 0;
+        int play = 0, pwr = 0;
         for (int w = 0; w < KEYBUF_WORDS; w++) {
-            if (kp_keys.cur[w] & (1UL << (KEY_VOLUMEDOWN % 32))) vold = 1;
-            if (kp_keys.cur[w] & (1UL << (KEY_VOLUMEUP % 32))) volu = 1;
             if (kp_keys.cur[w] & (1UL << (KEY_PLAYPAUSE % 32))) play = 1;
             if (kp_power.cur[w] & (1UL << (KEY_POWER % 32))) pwr = 1;
         }
         if (sim_power_hold_ms > 0 && el >= sim_power_hold_ms) pwr = 1;  /* sim：按住电源 */
-        /* 原始（未防抖）键值：长按连续（vol_ramp held）用，避免防抖延迟让单击仍连爬多档。 */
-        int rvold = vold, rvolu = volu, rplay = play, rpwr = pwr;   /* 原始值：长按连续用 rvolu/rvold */
-        (void)rplay; (void)rpwr;   /* play/pwr 只用稳定边沿，不需原始 held */
         /* M2.16 防抖：每键值须稳定 KEY_DEBOUNCE_MS(40ms) 才认可，抗 ADC 抖动（"点一下跳5-6下"）。
-         * 稳定态 vold/volu/play/pwr 与 m_prev_*（上一稳定值）比较得稳定边沿；长按(连续)用 .down。 */
-        (void)kd_tick(&kd_vold, vold);
-        (void)kd_tick(&kd_volu, volu);
+         * 稳定态 play/pwr 与 m_prev_*（上一稳定值）比较得稳定边沿；长按(连续)用 .down。 */
         (void)kd_tick(&kd_play, play);
         (void)kd_tick(&kd_pwr,  pwr);
-        vold = kd_vold.stable; volu = kd_volu.stable;
         play = kd_play.stable; pwr = kd_pwr.stable;
         /* M2.6 电源语义（MeowOS 自持面板，无播放器拔河）：
          *   单击（短按松开 <2s）= 息屏/亮屏；2s = 电源菜单；8s = 强制关机。 */
@@ -1497,15 +1490,13 @@ static void run_menu(struct app apps[MAX_APPS], int napps, int state,
                      * 难唤醒：launcher 以为屏开着，电源唤醒逻辑不触发）。电源键确认取消时 raw
                      * 仍=按住=1，无此错配，所以只有触摸路径黑屏。此处重播 kd_* 并以当前 raw
                      * 对齐 m_prev_*，杜绝该假边沿（真实新按键仍正常防抖/单击）。 */
+                    /* 重播音量基线（key_router）+ 本页播放/电源基线 */
+                    key_router_rebase();
                     memset(&kd_pwr, 0, sizeof kd_pwr);
-                    memset(&kd_vold, 0, sizeof kd_vold);
-                    memset(&kd_volu, 0, sizeof kd_volu);
                     memset(&kd_play, 0, sizeof kd_play);
                     kp_poll(&kp_power, NULL, NULL);
                     kp_poll(&kp_keys, NULL, NULL);
                     m_prev_pwr = kp_is_down(&kp_power, KEY_POWER);
-                    m_prev_vold = kp_is_down(&kp_keys, KEY_VOLUMEDOWN);
-                    m_prev_volu = kp_is_down(&kp_keys, KEY_VOLUMEUP);
                     m_prev_play = kp_is_down(&kp_keys, KEY_PLAYPAUSE);
                     continue;
                 }
@@ -1530,15 +1521,13 @@ static void run_menu(struct app apps[MAX_APPS], int napps, int state,
                         if (lck_wake_should_lock()) {
                             int lr = run_lock_screen();
                             /* 重播按键防抖基线（阻塞期间按键可能已变化，防误判新边沿） */
+                            /* 重播音量基线（key_router）+ 本页播放/电源基线 */
+                            key_router_rebase();
                             memset(&kd_pwr, 0, sizeof kd_pwr);
-                            memset(&kd_vold, 0, sizeof kd_vold);
-                            memset(&kd_volu, 0, sizeof kd_volu);
                             memset(&kd_play, 0, sizeof kd_play);
                             kp_poll(&kp_power, NULL, NULL);
                             kp_poll(&kp_keys, NULL, NULL);
-                            m_prev_pwr  = kp_is_down(&kp_power, KEY_POWER);
-                            m_prev_vold = kp_is_down(&kp_keys, KEY_VOLUMEDOWN);
-                            m_prev_volu = kp_is_down(&kp_keys, KEY_VOLUMEUP);
+                            m_prev_pwr = kp_is_down(&kp_power, KEY_POWER);
                             m_prev_play = kp_is_down(&kp_keys, KEY_PLAYPAUSE);
                             if (lr == 1)
                                 meow_repaint_surface(apps, napps, state, cursor);  /* 已解锁重绘主屏 */
@@ -1567,11 +1556,11 @@ static void run_menu(struct app apps[MAX_APPS], int napps, int state,
          * M2.11 E：MeowOS 下音量键 = 调系统软件音量（settings audio.volume，步进5 clamp），
          * 状态栏即时显示、持久化。有播放器的覆盖态才保留音量键=菜单光标导航。 */
         if (meow_mode) {
-            if (vold && !m_prev_vold) {
+            if (kev.vol_dn_edge) {
                 any_input = 1;
                 settings_volume_adj(-settings_volume_step);   /* 起线性渐变（1% 爬） */
                 logmsg("volume DOWN <- ramp step=%d", settings_volume_step);
-            } else if (volu && !m_prev_volu) {
+            } else if (kev.vol_up_edge) {
                 any_input = 1;
                 settings_volume_adj(+settings_volume_step);
                 logmsg("volume UP <- ramp step=%d", settings_volume_step);
@@ -1579,22 +1568,23 @@ static void run_menu(struct app apps[MAX_APPS], int napps, int state,
         } else {
             /* M2.36 B2b：光标范围扩展为 [0..napps]（napps=「系统设置」行，位于 Exit 行上方）。
              * 音量下移越过最后应用 → 设置行；设置行再下移 → 回 0。应用行仍 0..napps-1。 */
-            if (vold && !m_prev_vold && napps > 0 && state == 0) {
+            if (kev.vol_dn_edge && napps > 0 && state == 0) {
                 any_input = 1;
                 cursor++;
                 if (cursor > napps) cursor = 0;      /* napps=设置行 */
                 logmsg("menu cursor -> %d", cursor);
             }
-            if (volu && !m_prev_volu && napps > 0 && state == 0) {
+            if (kev.vol_up_edge && napps > 0 && state == 0) {
                 any_input = 1;
                 cursor--;
                 if (cursor < 0) cursor = napps;      /* 回绕到设置行 */
                 logmsg("menu cursor -> %d", cursor);
             }
         }
-        /* M2.14 线性渐变：每 tick 推进 1% 并刷新状态栏（显示爬升中的值或最终值） */
+        /* M2.14 线性渐变：每 tick 推进 1% 并刷新状态栏（显示爬升中的值或最终值）。
+         * 长按 raw held 取自 key_router（kev.vol_held_*，同现状 rvolu/rvold），松开立即停止。 */
         if (meow_mode && vol_ramp_dir != 0) {
-            int held = (vol_ramp_dir > 0) ? rvolu : rvold;   /* 长按=该方向键仍按住（用原始值：松开立即停止） */
+            int held = (vol_ramp_dir > 0) ? kev.vol_held_up : kev.vol_held_dn;
             int going = vol_ramp_tick(held);
             g_sys.vol = settings_volume_get();
             paint_sb_right();          /* M2.16：只重画右侧信息格（VOL 变化），不动列表/时钟 */
@@ -1618,7 +1608,7 @@ static void run_menu(struct app apps[MAX_APPS], int napps, int state,
                 logmsg("play key: media-reserved (no media source)");
             }
         }
-        m_prev_vold = vold; m_prev_volu = volu; m_prev_play = play;
+        m_prev_play = play;
 
         /* touch (event reads) */
         if (touch_fd >= 0 && meow_screen_on) {   /* 息屏时不处理触摸（goodix 已被 FBIOBLANK(4) 挂起） */
@@ -1683,15 +1673,13 @@ static void run_menu(struct app apps[MAX_APPS], int napps, int state,
                             click.status = NOTIF_CLICK_STATUS_NONE;
                             run_notif_center(apps, napps, &click, 1, t_down_x, loy);
                             /* 重播按键防抖基线（同原 top-swipe 路径），防面板内电源/音量边沿被 run_menu 误判 */
+                            /* 重播音量基线（key_router）+ 本页播放/电源基线 */
+                            key_router_rebase();
                             memset(&kd_pwr, 0, sizeof kd_pwr);
-                            memset(&kd_vold, 0, sizeof kd_vold);
-                            memset(&kd_volu, 0, sizeof kd_volu);
                             memset(&kd_play, 0, sizeof kd_play);
                             kp_poll(&kp_power, NULL, NULL);
                             kp_poll(&kp_keys, NULL, NULL);
                             m_prev_pwr = kp_is_down(&kp_power, KEY_POWER);
-                            m_prev_vold = kp_is_down(&kp_keys, KEY_VOLUMEDOWN);
-                            m_prev_volu = kp_is_down(&kp_keys, KEY_VOLUMEUP);
                             m_prev_play = kp_is_down(&kp_keys, KEY_PLAYPAUSE);
                             last_input_ms = now_ms();
                             menu_arm_touch(800);
@@ -1783,15 +1771,13 @@ static void run_menu(struct app apps[MAX_APPS], int napps, int state,
                                     click.status = NOTIF_CLICK_STATUS_NONE;
                                     run_notif_center(apps, napps, &click, 0, 0, 0);   /* ⑨ live_open=0 → 触发式自动展开（防御） */
                                     /* 重播按键防抖基线，防面板内电源/音量边沿被 run_menu 误判（M2.25 同款）。 */
+                                    /* 重播音量基线（key_router）+ 本页播放/电源基线 */
+                                    key_router_rebase();
                                     memset(&kd_pwr, 0, sizeof kd_pwr);
-                                    memset(&kd_vold, 0, sizeof kd_vold);
-                                    memset(&kd_volu, 0, sizeof kd_volu);
                                     memset(&kd_play, 0, sizeof kd_play);
                                     kp_poll(&kp_power, NULL, NULL);
                                     kp_poll(&kp_keys, NULL, NULL);
                                     m_prev_pwr = kp_is_down(&kp_power, KEY_POWER);
-                                    m_prev_vold = kp_is_down(&kp_keys, KEY_VOLUMEDOWN);
-                                    m_prev_volu = kp_is_down(&kp_keys, KEY_VOLUMEUP);
                                     m_prev_play = kp_is_down(&kp_keys, KEY_PLAYPAUSE);
                                     last_input_ms = now_ms();
                                     menu_arm_touch(800);
@@ -1835,15 +1821,13 @@ static void run_menu(struct app apps[MAX_APPS], int napps, int state,
                                     menu_arm_touch(TAP_ARM_DELAY_MS);
                                     run_now_playing(apps, napps);
                                     /* 重播按键防抖基线，防播放页内电源/音量边沿被 run_menu 误判 */
+                                    /* 重播音量基线（key_router）+ 本页播放/电源基线 */
+                                    key_router_rebase();
                                     memset(&kd_pwr, 0, sizeof kd_pwr);
-                                    memset(&kd_vold, 0, sizeof kd_vold);
-                                    memset(&kd_volu, 0, sizeof kd_volu);
                                     memset(&kd_play, 0, sizeof kd_play);
                                     kp_poll(&kp_power, NULL, NULL);
                                     kp_poll(&kp_keys, NULL, NULL);
                                     m_prev_pwr = kp_is_down(&kp_power, KEY_POWER);
-                                    m_prev_vold = kp_is_down(&kp_keys, KEY_VOLUMEDOWN);
-                                    m_prev_volu = kp_is_down(&kp_keys, KEY_VOLUMEUP);
                                     m_prev_play = kp_is_down(&kp_keys, KEY_PLAYPAUSE);
                                     last_input_ms = now_ms();
                                     menu_arm_touch(800);
@@ -1858,15 +1842,13 @@ static void run_menu(struct app apps[MAX_APPS], int napps, int state,
                                         logmsg("menu: touch topbar bg-manager button");
                                         menu_arm_touch(TAP_ARM_DELAY_MS);   /* 幽灵触摸防护 */
                                         run_bg_page(apps, napps);
+                                        /* 重播音量基线（key_router）+ 本页播放/电源基线 */
+                                        key_router_rebase();
                                         memset(&kd_pwr, 0, sizeof kd_pwr);
-                                        memset(&kd_vold, 0, sizeof kd_vold);
-                                        memset(&kd_volu, 0, sizeof kd_volu);
                                         memset(&kd_play, 0, sizeof kd_play);
                                         kp_poll(&kp_power, NULL, NULL);
                                         kp_poll(&kp_keys, NULL, NULL);
                                         m_prev_pwr = kp_is_down(&kp_power, KEY_POWER);
-                                        m_prev_vold = kp_is_down(&kp_keys, KEY_VOLUMEDOWN);
-                                        m_prev_volu = kp_is_down(&kp_keys, KEY_VOLUMEUP);
                                         m_prev_play = kp_is_down(&kp_keys, KEY_PLAYPAUSE);
                                         last_input_ms = now_ms();
                                         menu_arm_touch(800);
@@ -1898,15 +1880,13 @@ static void run_menu(struct app apps[MAX_APPS], int napps, int state,
                                         logmsg("menu: touch settings row -> settings page");
                                         menu_arm_touch(TAP_ARM_DELAY_MS);   /* 幽灵触摸防护：吃掉打开此行的那次触摸 */
                                         run_settings_page();
+                                        /* 重播音量基线（key_router）+ 本页播放/电源基线 */
+                                        key_router_rebase();
                                         memset(&kd_pwr, 0, sizeof kd_pwr);
-                                        memset(&kd_vold, 0, sizeof kd_vold);
-                                        memset(&kd_volu, 0, sizeof kd_volu);
                                         memset(&kd_play, 0, sizeof kd_play);
                                         kp_poll(&kp_power, NULL, NULL);
                                         kp_poll(&kp_keys, NULL, NULL);
                                         m_prev_pwr = kp_is_down(&kp_power, KEY_POWER);
-                                        m_prev_vold = kp_is_down(&kp_keys, KEY_VOLUMEDOWN);
-                                        m_prev_volu = kp_is_down(&kp_keys, KEY_VOLUMEUP);
                                         m_prev_play = kp_is_down(&kp_keys, KEY_PLAYPAUSE);
                                         last_input_ms = now_ms();          /* 回主界面即视为输入 */
                                         menu_arm_touch(800);                /* 设置页返回后再忽略近期触摸 */
@@ -1975,15 +1955,13 @@ static void run_menu(struct app apps[MAX_APPS], int napps, int state,
             /* M2.x 锁屏：自动息屏唤醒后若需锁屏 → 弹阻塞式锁屏页；解锁才重绘，息屏留 dirty */
             if (lck_wake_should_lock()) {
                 int lr = run_lock_screen();
+                /* 重播音量基线（key_router）+ 本页播放/电源基线 */
+                key_router_rebase();
                 memset(&kd_pwr, 0, sizeof kd_pwr);
-                memset(&kd_vold, 0, sizeof kd_vold);
-                memset(&kd_volu, 0, sizeof kd_volu);
                 memset(&kd_play, 0, sizeof kd_play);
                 kp_poll(&kp_power, NULL, NULL);
                 kp_poll(&kp_keys, NULL, NULL);
-                m_prev_pwr  = kp_is_down(&kp_power, KEY_POWER);
-                m_prev_vold = kp_is_down(&kp_keys, KEY_VOLUMEDOWN);
-                m_prev_volu = kp_is_down(&kp_keys, KEY_VOLUMEUP);
+                m_prev_pwr = kp_is_down(&kp_power, KEY_POWER);
                 m_prev_play = kp_is_down(&kp_keys, KEY_PLAYPAUSE);
                 if (lr == 1)
                     meow_repaint_surface(apps, napps, state, cursor);   /* 已解锁重绘主屏 */
@@ -2219,6 +2197,7 @@ int main(int argc, char **argv)
     load_config();   /* hotkey_seq / hotkey_seq_gap / bg_color (also run per
                       * menu open so edits apply without a daemon restart) */
     settings_load();   /* M2.11：读系统设置（audio.volume 等），供音量/状态栏使用 */
+    key_router_init();   /* M6.x：launcher-UI 页物理键统一路由（KEY_ROUTER_UNIFY P1）单开 kp_*/
 
     /* M2.6：启动扫描一次 TF 卡 MeowOS/fonts/<family>/<weight>/，填充「字体文件」下拉 preset。
      * 无卡/无字库目录 → 仅默认字体（等价现状）。进设置页时 run_settings_page 会再扫一次（verify=0）。 */

patch_v2/meow_launcherd/meow_launcher_internal.h

@@ -28,6 +28,7 @@ extern "C" {
 #include <sys/stat.h>
 #include <sys/syscall.h>   /* Bug 2：直连 reboot(2) syscall 用 */
 #include <pthread.h>       /* M0：IPC 线程 */
+#include "key_router.h"    /* M6.x：launcher-UI 页物理键统一路由（KEY_ROUTER_UNIFY P1） */
 #include <sys/eventfd.h>   /* M0：IPC→主循环唤醒（EFD_NONBLOCK） */
 #include <sys/socket.h>    /* M0：AF_UNIX IPC */
 #include <sys/un.h>        /* M0：sockaddr_un */
@@ -847,6 +848,9 @@ int  nm_wifi_saved(meow_net_t *out, int max);
 int  nm_wifi_scan(meow_net_t *out, int max);
 void nm_wifi_scan_trigger(void);
 int  nm_wifi_connect(const char *ssid, const char *psk, char *err, int elen); /* MEOW_OK=成功 */
+/* WiFi 设置页 bug2（2026-09-15）：hidden=1 走 netmgrd connecth（scan_ssid=1 + 更长 COMPLETED 等待），
+ * 回退直连同步对齐；err 回填 netmgrd/直连的诚实结果文本（成功含 ip / 失败含原因）。 */
+int  nm_wifi_connect_ex(const char *ssid, const char *psk, int hidden, char *err, int elen);
 int  nm_wifi_disconnect(char *err, int elen);
 int  nm_wifi_toggle(int on);
 

patch_v2/meow_launcherd/netmgr_ipc.c

@@ -15,6 +15,14 @@
 #define NETMGR_SOCK_DEFAULT "/usr/data/meow_net.sock"
 /* NETMGR_UNREACH 定义在 meow_launcher_internal.h（测试/调用方共用） */
 
+/* IPC 读超时（ms）。netmgrd 单线程 poll，connect/connecth 会阻塞 ~10s/~15s 有界等待
+ * wpa_state=COMPLETED（bug1），scan 内含 1.5s 触发等待（P3）——客户端 per-command 超时需
+ * 覆盖这些同步等待，其余读级子命令维持 1.5s 不被卡死。 */
+#define NM_TMO_DFL      1500
+#define NM_TMO_SCAN     5000
+#define NM_TMO_CONNECT  12000
+#define NM_TMO_CONNECTH 17000
+
 /* 可达性缓存：netmgrd 不可达时每次 connect 都秒回 ECONNREFUSED，无成本；缓存约 1s 防热循环。 */
 static int    g_nm_ok = -1;           /* -1 未知 / 0 down / 1 up */
 static time_t g_nm_ok_ts = 0;
@@ -50,7 +58,7 @@ static int nm_r_all(int fd, uint8_t *b, size_t n)
     return 0;
 }
 static int nm_xchg(int fd, uint16_t type, uint32_t req, const void *pl, uint32_t len,
-                   uint8_t *rbuf, uint32_t rcap, uint16_t *rtype)
+                   uint8_t *rbuf, uint32_t rcap, uint16_t *rtype, int tmo_ms)
 {
     uint8_t hdr[MEOW_IPC_HDR_LEN];
     uint32_t magic = MEOW_IPC_MAGIC, rlen = len;
@@ -60,7 +68,7 @@ static int nm_xchg(int fd, uint16_t type, uint32_t req, const void *pl, uint32_t
     if (nm_w_all(fd, hdr, sizeof hdr) < 0) return -1;
     if (len && pl && nm_w_all(fd, pl, len) < 0) return -1;
     struct pollfd pf = { fd, POLLIN, 0 };
-    int pr = poll(&pf, 1, 1500);
+    int pr = poll(&pf, 1, tmo_ms);
     if (pr <= 0) return -1;
     uint8_t rhdr[MEOW_IPC_HDR_LEN];
     if (nm_r_all(fd, rhdr, sizeof rhdr) < 0) return -1;
@@ -81,15 +89,16 @@ static int nm_hello(int fd)
     snprintf(h.app_id, sizeof h.app_id, "%s", "os.meow.launcher");
     h.version = 1;
     uint8_t rbuf[256]; uint16_t rtype = 0;
-    if (nm_xchg(fd, MSG_HELLO, 0x100, &h, sizeof h, rbuf, sizeof rbuf, &rtype) < 0 || rtype != MSG_ACK)
+    if (nm_xchg(fd, MSG_HELLO, 0x100, &h, sizeof h, rbuf, sizeof rbuf, &rtype, NM_TMO_DFL) < 0 || rtype != MSG_ACK)
         return -1;
     m_ack_t ak; memcpy(&ak, rbuf, sizeof ak);
     return (ak.code == MEOW_OK) ? 0 : -1;
 }
 
-/* 发一条 WIFI_CTL/BT_CTL 子命令，收 RESULT。返回 netmgrd 业务 code；NETMGR_UNREACH=不可达。 */
+/* 发一条 WIFI_CTL/BT_CTL 子命令，收 RESULT。返回 netmgrd 业务 code；NETMGR_UNREACH=不可达。
+ * tmo_ms：读超时（connect/connecth/scan 需覆盖 netmgrd 同步等待，见 NM_TMO_*）。 */
 static int nm_cmd(uint16_t ctl_type, uint16_t res_type, const char *cmd, const char *arg,
-                  char *text, int tlen)
+                  char *text, int tlen, int tmo_ms)
 {
     m_net_cmd_t q;
     memset(&q, 0, sizeof q);
@@ -100,7 +109,7 @@ static int nm_cmd(uint16_t ctl_type, uint16_t res_type, const char *cmd, const c
     if (nm_hello(fd) < 0) { close(fd); nm_cache(0); return NETMGR_UNREACH; }
     uint8_t rbuf[MEOW_IPC_MAX]; uint16_t rtype = 0;
     memset(rbuf, 0, sizeof rbuf);
-    if (nm_xchg(fd, ctl_type, 0x101, &q, sizeof q, rbuf, sizeof rbuf, &rtype) < 0 || rtype != res_type) {
+    if (nm_xchg(fd, ctl_type, 0x101, &q, sizeof q, rbuf, sizeof rbuf, &rtype, tmo_ms) < 0 || rtype != res_type) {
         close(fd); nm_cache(0); return NETMGR_UNREACH;
     }
     m_net_cmd_result_t res; memcpy(&res, rbuf, sizeof res);
@@ -112,11 +121,14 @@ static int nm_cmd(uint16_t ctl_type, uint16_t res_type, const char *cmd, const c
     return (int)res.code;
 }
 
+int netmgr_wifi_tmo(const char *cmd, const char *arg, char *text, int tlen, int tmo_ms)
+{ return nm_cmd(MSG_NET_WIFI_CTL, MSG_NET_WIFI_RESULT, cmd, arg, text, tlen, tmo_ms); }
+
 int netmgr_wifi(const char *cmd, const char *arg, char *text, int tlen)
-{ return nm_cmd(MSG_NET_WIFI_CTL, MSG_NET_WIFI_RESULT, cmd, arg, text, tlen); }
+{ return netmgr_wifi_tmo(cmd, arg, text, tlen, NM_TMO_DFL); }
 
 int netmgr_bt(const char *cmd, const char *arg, char *text, int tlen)
-{ return nm_cmd(MSG_NET_BT_CTL, MSG_NET_BT_RESULT, cmd, arg, text, tlen); }
+{ return nm_cmd(MSG_NET_BT_CTL, MSG_NET_BT_RESULT, cmd, arg, text, tlen, NM_TMO_DFL); }
 
 int netmgr_ok(void)
 {
@@ -361,7 +373,7 @@ int nm_wifi_saved(meow_net_t *out, int max)
 int nm_wifi_scan(meow_net_t *out, int max)
 {
     char text[MEOW_IPC_MAX - 32];
-    int rc = netmgr_wifi("scan", NULL, text, sizeof text);       /* netmgrd 内含触发+有界等待+读结果 */
+    int rc = netmgr_wifi_tmo("scan", NULL, text, sizeof text, NM_TMO_SCAN); /* netmgrd 内含触发+有界等待+读结果 */
     if (rc == NETMGR_UNREACH) return net_wifi_scan(out, max);
     if (rc != MEOW_OK) return 0;
     return nm_parse_scan(text, out, max);
@@ -374,49 +386,133 @@ void nm_wifi_scan_trigger(void)
     if (!netmgr_ok()) net_wifi_scan_trigger();
 }
 
-/* —— 直连回退：wpa_cli add/set/enable/select 新网络（复刻 netmgrd wifi_connect 逻辑）—— */
-static int nm_direct_connect(const char *ssid, const char *psk, char *err, int elen)
+/* —— 直连回退：与 netmgrd wifi_connect/connecth 对齐（bug1/bug2/bug4）。
+ * 匹配既有（\xNN 还原同表示）→ 新建或（命中且带新 psk）更新凭据 → hidden 补 scan_ssid=1 →
+ * enable+select → 有界等待 wpa_state=COMPLETED → 成功 enable_network all + save_config（校验重试）；
+ * 失败时本次新建的网络回收，报文明示原因。仅在 netmgrd 不可达时走此路径。 */
+static const char NM_WPA_PREFIX[] = "PATH=/bin:/sbin:/usr/bin:/usr/sbin wpa_cli -i wlan0";
+
+static int nm_direct_wpa(char *out, int cap, const char *args, int tmo)
 {
-    const char *wpa = "PATH=/bin:/sbin:/usr/bin:/usr/sbin wpa_cli -i wlan0";
-    char cmd[256];
-    snprintf(cmd, sizeof cmd, "%s add_network 2>/dev/null", wpa);
-    char *o = popen_read_tmo(1200, cmd);
-    int id = o ? atoi(o) : -1;
-    if (o) free(o);
-    if (id < 0) { if (err) snprintf(err, elen, "add_network 无 id"); return MEOW_ERR_INVAL; }
-    {
-        char *r;
-        snprintf(cmd, sizeof cmd, "%s set_network %d ssid '\"%s\"' 2>/dev/null", wpa, id, ssid);
-        if ((r = popen_read_tmo(1200, cmd))) free(r);
-        if (psk && psk[0]) {
-            snprintf(cmd, sizeof cmd, "%s set_network %d psk '\"%s\"' 2>/dev/null", wpa, id, psk);
-            if ((r = popen_read_tmo(1200, cmd))) free(r);
-        } else {
-            snprintf(cmd, sizeof cmd, "%s set_network %d key_mgmt NONE 2>/dev/null", wpa, id);
-            if ((r = popen_read_tmo(1200, cmd))) free(r);
+    char cmd[384];
+    snprintf(cmd, sizeof cmd, "%s %s 2>/dev/null", NM_WPA_PREFIX, args);
+    char *o = popen_read_tmo(tmo, cmd);
+    if (!o) { out[0] = 0; return -1; }
+    int l = (int)strlen(o);
+    if (l >= cap) l = cap - 1;
+    memcpy(out, o, (size_t)l); out[l] = 0;
+    free(o);
+    return l;
+}
+
+static int nm_direct_save_config(void)
+{
+    char out[128];
+    if (nm_direct_wpa(out, sizeof out, "save_config", 1500) > 0 && strstr(out, "OK")) return 1;
+    nm_direct_wpa(out, sizeof out, "set update_config 1", 1500);
+    if (nm_direct_wpa(out, sizeof out, "save_config", 1500) > 0 && strstr(out, "OK")) return 1;
+    return 0;
+}
+
+static int nm_direct_connect_ex(const char *ssid, const char *psk, int hidden, char *err, int elen)
+{
+    char out[1024]; char args[256];
+    int id = -1;
+    if (nm_direct_wpa(out, sizeof out, "list_networks", 1500) > 0) {
+        char *ln = strtok(out, "\n");
+        while (ln) {
+            char *tab0 = strchr(ln, '\t');
+            if (tab0) {
+                int this_id = atoi(ln);
+                char *ss = tab0 + 1;
+                char *tab1 = strchr(ss, '\t');
+                if (tab1) *tab1 = 0;
+                char clean[128], unesc[160], norm[128];
+                size_t cl = strlen(ss);
+                if (cl >= 2 && ss[0] == '"' && ss[cl - 1] == '"') {
+                    memcpy(clean, ss + 1, cl - 2); clean[cl - 2] = 0;
+                } else {
+                    snprintf(clean, sizeof clean, "%s", ss);
+                }
+                nm_decode_ssid(clean, unesc, sizeof unesc);
+                char *p = unesc; while (*p == ' ' || *p == '\t') p++;
+                snprintf(norm, sizeof norm, "%s", p);
+                size_t nl = strlen(norm);
+                while (nl > 0 && (norm[nl - 1] == ' ' || norm[nl - 1] == '\t')) norm[--nl] = 0;
+                if (strcmp(norm, ssid) == 0) { id = this_id; break; }
+            }
+            ln = strtok(NULL, "\n");
         }
-        snprintf(cmd, sizeof cmd, "%s enable_network %d 2>/dev/null", wpa, id);
-        if ((r = popen_read_tmo(1200, cmd))) free(r);
-        snprintf(cmd, sizeof cmd, "%s select_network %d 2>/dev/null", wpa, id);
-        if ((r = popen_read_tmo(1200, cmd))) free(r);
     }
-    if (err) snprintf(err, elen, "connect: ssid=%s network_id=%d", ssid, id);
-    logmsg("netmgr_ipc: [direct-fallback] wifi connect ssid=%s id=%d", ssid, id);
+    int created = 0;
+    if (id < 0) {
+        if (nm_direct_wpa(out, sizeof out, "add_network", 1500) <= 0) {
+            if (err) snprintf(err, elen, "add_network 无 id");
+            return MEOW_ERR_INVAL;
+        }
+        id = atoi(out);
+        if (id < 0) { if (err) snprintf(err, elen, "add_network 无 id"); return MEOW_ERR_INVAL; }
+        created = 1;
+        snprintf(args, sizeof args, "set_network %d ssid '\"%s\"'", id, ssid);
+        nm_direct_wpa(out, sizeof out, args, 1500);
+        if (psk && psk[0]) { snprintf(args, sizeof args, "set_network %d psk '\"%s\"'", id, psk); nm_direct_wpa(out, sizeof out, args, 1500); }
+        else { snprintf(args, sizeof args, "set_network %d key_mgmt NONE", id); nm_direct_wpa(out, sizeof out, args, 1500); }
+    } else if (psk && psk[0]) {
+        snprintf(args, sizeof args, "set_network %d psk '\"%s\"'", id, psk);
+        nm_direct_wpa(out, sizeof out, args, 1500);
+    }
+    if (hidden) { snprintf(args, sizeof args, "set_network %d scan_ssid 1", id); nm_direct_wpa(out, sizeof out, args, 1500); }
+    snprintf(args, sizeof args, "enable_network %d", id); nm_direct_wpa(out, sizeof out, args, 1500);
+    snprintf(args, sizeof args, "select_network %d", id); nm_direct_wpa(out, sizeof out, args, 1500);
+
+    int wait_ms = hidden ? 15000 : 10000;
+    int waited = 0, ok = 0; char ip[40] = "";
+    for (;;) {
+        char st[512];
+        if (nm_direct_wpa(st, sizeof st, "status", 1500) > 0) {
+            char *ws = strstr(st, "wpa_state=");
+            if (ws && !strncmp(ws + 10, "COMPLETED", 9)) {
+                ok = 1;
+                char *ib = strstr(st, "ip_address=");
+                if (ib) { ib += 11; char *ie = ib; while (*ie && *ie != '\n' && *ie != '\r') ie++;
+                          int il = (int)(ie - ib); if (il >= (int)sizeof ip) il = (int)sizeof ip - 1;
+                          memcpy(ip, ib, (size_t)il); ip[il] = 0; }
+                break;
+            }
+        }
+        if (waited >= wait_ms) break;
+        usleep(200000);
+        waited += 200;
+    }
+    if (!ok) {
+        if (created) { snprintf(args, sizeof args, "remove_network %d", id); nm_direct_wpa(out, sizeof out, args, 1500); nm_direct_save_config(); }
+        if (err) snprintf(err, elen, "连接失败：密码错误或信号不佳（超时未关联）");
+        logmsg("netmgr_ipc: [direct-fallback] wifi connect ssid=%s hidden=%d id=%d timeout", ssid, hidden, id);
+        return MEOW_ERR_NODEV;
+    }
+    nm_direct_wpa(out, sizeof out, "enable_network all", 1500);
+    int persisted = nm_direct_save_config();
+    if (err) snprintf(err, elen, "已连接：%s ip=%s%s", ssid, ip[0] ? ip : "-", persisted ? "" : "（记录未持久化）");
+    logmsg("netmgr_ipc: [direct-fallback] wifi connect ssid=%s hidden=%d id=%d ip=%s", ssid, hidden, id, ip[0] ? ip : "-");
     return MEOW_OK;
 }
 
-int nm_wifi_connect(const char *ssid, const char *psk, char *err, int elen)
+int nm_wifi_connect_ex(const char *ssid, const char *psk, int hidden, char *err, int elen)
 {
     if (!ssid || !ssid[0]) { if (err) snprintf(err, elen, "ssid 缺失"); return MEOW_ERR_INVAL; }
     char arg[132];
-    snprintf(arg, sizeof arg, "%s,%s", ssid, psk ? psk : "");   /* connect 带空 psk → netmgrd 复用既有网络 */
+    snprintf(arg, sizeof arg, "%s,%s", ssid, psk ? psk : "");   /* 带空 psk → netmgrd 复用既有网络 */
     char text[192];
-    int rc = netmgr_wifi("connect", arg, text, sizeof text);
-    if (rc == NETMGR_UNREACH) return nm_direct_connect(ssid, psk, err, elen);
+    int rc = netmgr_wifi_tmo(hidden ? "connecth" : "connect", arg, text, sizeof text,
+                             hidden ? NM_TMO_CONNECTH : NM_TMO_CONNECT);
+    if (rc == NETMGR_UNREACH) return nm_direct_connect_ex(ssid, psk, hidden, err, elen);
     if (err && elen > 0) snprintf(err, elen, "%s", text);
     return rc;
 }
 
+int nm_wifi_connect(const char *ssid, const char *psk, char *err, int elen)
+{ return nm_wifi_connect_ex(ssid, psk, 0, err, elen); }
+
 int nm_wifi_disconnect(char *err, int elen)
 {
     char text[128];

patch_v2/meow_launcherd/notif_center.c

@@ -1168,16 +1168,15 @@ void run_notif_center(struct app *apps, int napps, notif_click_t *click,
 
     struct keypoll kp_power, kp_keys;
     kp_open(&kp_power, DEV_POWER); kp_open(&kp_keys, DEV_KEYS);
-    struct kd_state kd_vold, kd_volu, kd_play, kd_pwr;
-    memset(&kd_vold, 0, sizeof kd_vold); memset(&kd_volu, 0, sizeof kd_volu);
+    /* 音量键防抖/基线已上收 key_router（进程唯一）——本页只保留播放/电源键自家防抖。 */
+    struct kd_state kd_play, kd_pwr;
     memset(&kd_play, 0, sizeof kd_play); memset(&kd_pwr, 0, sizeof kd_pwr);
-    int m_prev_vold = 0, m_prev_volu = 0, m_prev_play = 0, m_prev_pwr = 0;
+    int m_prev_play = 0, m_prev_pwr = 0;
     for (int w = 0; w < KEYBUF_WORDS; w++) {
-        if (kp_keys.cur[w] & (1UL << (KEY_VOLUMEDOWN % 32))) m_prev_vold = 1;
-        if (kp_keys.cur[w] & (1UL << (KEY_VOLUMEUP % 32))) m_prev_volu = 1;
         if (kp_keys.cur[w] & (1UL << (KEY_PLAYPAUSE % 32))) m_prev_play = 1;
         if (kp_power.cur[w] & (1UL << (KEY_POWER % 32))) m_prev_pwr = 1;
     }
+    key_router_rebase();   /* 进入通知中心：音量基线对齐当前 raw（防残留边沿） */
     int tfd = open(DEV_TOUCH, O_RDONLY | O_NONBLOCK);
     if (tfd >= 0) { unsigned char ev[16]; while (read(tfd, ev, sizeof ev) == 16) {} }
     unsigned long long touch_cooldown_until = now_ms() + 300;
@@ -1304,12 +1303,11 @@ void run_notif_center(struct app *apps, int napps, notif_click_t *click,
             }
             if (wak) {
                 meow_panel_on(); meow_auto_slept = 0; wake_suppress = 1; last_act = now_ms();
-                memset(&kd_pwr, 0, sizeof kd_pwr); memset(&kd_vold, 0, sizeof kd_vold);
-                memset(&kd_volu, 0, sizeof kd_volu); memset(&kd_play, 0, sizeof kd_play);
+                /* 唤醒：音量基线重播（key_router）+ 本页播放/电源基线 */
+                key_router_rebase();
+                memset(&kd_pwr, 0, sizeof kd_pwr); memset(&kd_play, 0, sizeof kd_play);
                 kp_poll(&kp_power, NULL, NULL); kp_poll(&kp_keys, NULL, NULL);
                 m_prev_pwr = kp_is_down(&kp_power, KEY_POWER);
-                m_prev_vold = kp_is_down(&kp_keys, KEY_VOLUMEDOWN);
-                m_prev_volu = kp_is_down(&kp_keys, KEY_VOLUMEUP);
                 m_prev_play = kp_is_down(&kp_keys, KEY_PLAYPAUSE);
                 touch_cooldown_until = now_ms() + 300;
                 td = 0; td_ok = 0; drag_slider = 0; tlx = tly = -1;
@@ -1331,23 +1329,20 @@ void run_notif_center(struct app *apps, int napps, notif_click_t *click,
         }
 
         /* 按键：系统语义（APP §3.4.1 红线——不映射返回/确认） */
+        key_evt_t ev = key_router_pump();   /* 音量边沿/held/ramp（进程唯一防抖基线） */
         kp_poll(&kp_power, NULL, NULL); kp_poll(&kp_keys, NULL, NULL);
-        int vold = 0, volu = 0, play = 0, pwr = 0;
+        int play = 0, pwr = 0;
         for (int w = 0; w < KEYBUF_WORDS; w++) {
-            if (kp_keys.cur[w] & (1UL << (KEY_VOLUMEDOWN % 32))) vold = 1;
-            if (kp_keys.cur[w] & (1UL << (KEY_VOLUMEUP % 32))) volu = 1;
             if (kp_keys.cur[w] & (1UL << (KEY_PLAYPAUSE % 32))) play = 1;
             if (kp_power.cur[w] & (1UL << (KEY_POWER % 32))) pwr = 1;
         }
-        (void)kd_tick(&kd_vold, vold); (void)kd_tick(&kd_volu, volu);
         (void)kd_tick(&kd_play, play); (void)kd_tick(&kd_pwr, pwr);
-        vold = kd_vold.stable; volu = kd_volu.stable;
         play = kd_play.stable; pwr = kd_pwr.stable;
         if (wake_suppress) {
-            if (!pwr && !vold && !volu && !play) wake_suppress = 0;
+            if (!pwr && !ev.vol_st_dn && !ev.vol_st_up && !play) wake_suppress = 0;
         } else {
-            if (vold && !m_prev_vold) { settings_volume_adj(-settings_volume_step); need_paint = 1; }
-            if (volu && !m_prev_volu) { settings_volume_adj(+settings_volume_step); need_paint = 1; }
+            if (ev.vol_dn_edge) { settings_volume_adj(-settings_volume_step); need_paint = 1; }
+            if (ev.vol_up_edge) { settings_volume_adj(+settings_volume_step); need_paint = 1; }
             if (play && !m_prev_play) {
                 logmsg("notif-center: play key caught (media-reserved, no exit)");
                 last_act = now;
@@ -1366,12 +1361,11 @@ void run_notif_center(struct app *apps, int napps, notif_click_t *click,
                     show_power_menu();
                     last_act = now_ms();
                     pwr_hold_at = 0; pwr_menu_state = 0; pwr_woke = 0; pwr_suppress_click = 1;
-                    memset(&kd_pwr, 0, sizeof kd_pwr); memset(&kd_vold, 0, sizeof kd_vold);
-                    memset(&kd_volu, 0, sizeof kd_volu); memset(&kd_play, 0, sizeof kd_play);
+                    /* 电源菜单返回：音量基线重播（key_router）+ 本页播放/电源基线 */
+                    key_router_rebase();
+                    memset(&kd_pwr, 0, sizeof kd_pwr); memset(&kd_play, 0, sizeof kd_play);
                     kp_poll(&kp_power, NULL, NULL); kp_poll(&kp_keys, NULL, NULL);
                     m_prev_pwr = kp_is_down(&kp_power, KEY_POWER);
-                    m_prev_vold = kp_is_down(&kp_keys, KEY_VOLUMEDOWN);
-                    m_prev_volu = kp_is_down(&kp_keys, KEY_VOLUMEUP);
                     m_prev_play = kp_is_down(&kp_keys, KEY_PLAYPAUSE);
                     after_modal = 1; need_paint = 1;
                     goto ncp_keys_seeded;
@@ -1390,14 +1384,14 @@ void run_notif_center(struct app *apps, int napps, notif_click_t *click,
             }
         }
         if (vol_ramp_dir != 0) {
-            int held = (vol_ramp_dir > 0) ? volu : vold;
+            int held = (vol_ramp_dir > 0) ? ev.vol_held_up : ev.vol_held_dn;
             int going = vol_ramp_tick(held);
             g_sys.vol = settings_volume_get();
             paint_sb_right();
             need_paint = 1;
             if (!going) logmsg("notif-center vol ramp end -> %d", g_sys.vol);
         }
-        m_prev_vold = vold; m_prev_volu = volu; m_prev_play = play; m_prev_pwr = pwr;
+        m_prev_play = play; m_prev_pwr = pwr;
     ncp_keys_seeded:
         ;
 
@@ -1562,15 +1556,13 @@ void run_notif_center(struct app *apps, int napps, notif_click_t *click,
                                                 after_modal = 1;             /* 电源菜单已弹 → 整帧重绘还原 */
                                                 /* 电源菜单返回：菜单期间用户可能按电源确认/取消，键边沿可能错配，
                                                  * 同电源键长按路径（line 7480-7488）重 poll + 重采 m_prev_*，防误判「单击」→ 误切 panel。 */
+                                                /* 菜单返回：音量基线重播（key_router）+ 本页播放/电源基线 */
+                                                key_router_rebase();
                                                 memset(&kd_pwr, 0, sizeof kd_pwr);
-                                                memset(&kd_vold, 0, sizeof kd_vold);
-                                                memset(&kd_volu, 0, sizeof kd_volu);
                                                 memset(&kd_play, 0, sizeof kd_play);
                                                 kp_poll(&kp_power, NULL, NULL);
                                                 kp_poll(&kp_keys, NULL, NULL);
                                                 m_prev_pwr = kp_is_down(&kp_power, KEY_POWER);
-                                                m_prev_vold = kp_is_down(&kp_keys, KEY_VOLUMEDOWN);
-                                                m_prev_volu = kp_is_down(&kp_keys, KEY_VOLUMEUP);
                                                 m_prev_play = kp_is_down(&kp_keys, KEY_PLAYPAUSE);
                                                 /* 菜单期间用户的触摸经 evdev 广播也会进本 panel 的 tfd → 立即排空，
                                                  * 防返回后把「菜单里的点击」误判为 panel 内 tap/滑动。 */

patch_v2/meow_launcherd/now_playing.c

@@ -198,6 +198,54 @@ static void np_center_text(int y, const char *s, int size, uint32_t color, int m
     ui_draw((W - ui_width(buf, size)) / 2, y, buf, color, size);
 }
 
+/* 左对齐 + 超宽截断（UTF-8 安全，近似按字节比例切；歌词页顶部元信息用）。 */
+static void np_left_text(int x, int y, const char *s, int size, uint32_t color, int maxw)
+{
+    if (!s) s = "";
+    if (ui_width(s, size) <= maxw) {
+        ui_draw(x, y, s, color, size);
+        return;
+    }
+    char buf[160];
+    int keep = (int)(strlen(s) * maxw / (ui_width(s, size) + 1));
+    if (keep < 0) keep = 0;
+    if (keep > (int)sizeof buf - 4) keep = (int)sizeof buf - 4;
+    memcpy(buf, s, (size_t)keep); buf[keep] = 0;
+    strcat(buf, "...");
+    ui_draw(x, y, buf, color, size);
+}
+
+/* 歌词页顶部元信息（两行居左，复刻 ncm 歌词页）：第一行歌名（大字白）、第二行歌手（小字灰）。
+ * 多歌手已由源侧拼串（ncm art_name 即「A / B」），此处原样显示 + 超宽截断。
+ * 左边距与歌词正文一致（LYR_PAD=24）；离状态栏留边距（SB_BAR_H + 20）；右缘同距截断。 */
+static void np_draw_lyric_title(const meow_media_session_t *s)
+{
+    if (!s) return;
+    if (!s->title[0] && !s->artist[0]) return;
+    int pad = 24;
+    int y = SB_BAR_H + 20;
+    int maxw = fb_xres - 2 * pad;
+    if (s->title[0])
+        np_left_text(pad, y, s->title, 28, 0xFFFFFF, maxw);
+    if (s->artist[0])
+        np_left_text(pad, y + meow_font_line_height(28) + 6, s->artist, 20, 0xBBBBBB, maxw);
+}
+
+/* 歌词页强制 ncm 配色：活动行恒纯白 + 上下逐级灰阶（对齐 ncm lyr_gray_tbl
+ * {FFFFFF,BBBBBB,929292,808080,6A6A6A,555555}——gray[0]=0 按 cur=0xFFFFFF 自动递减即为该表）。
+ * 背景恒为 np_draw_lyric_page 铺的黑色半透明叠加层，故关掉 lyric_view 自带 scrim
+ * （scrim_alpha=0）避免双重压暗；当前行/灰阶不随主题/封面取色（保黑底对比度，夜间可读）。 */
+static void np_set_lyric_ncm_colors(void)
+{
+    if (!g_np_lyric) return;
+    meow_lyric_view_colors c;
+    memset(&c, 0, sizeof c);
+    c.scrim = 0x000000;
+    c.cur = 0xFFFFFF;
+    c.scrim_alpha = 0;   /* 不画 scrim：由 launcher 黑底铺（单一叠加层） */
+    meow_lyric_view_set_colors(g_np_lyric, &c);
+}
+
 /* ==================================================================
  * M7.0b Now Playing 控件化（launcher 无 meow_ui_run，手动驱动 SDK 控件）：
  *   - 进度条 → meow_progress（线性，SDK 主题 track/fill）；
@@ -346,28 +394,49 @@ static void np_draw_home_bar(void)
                         NP_HOME_BAR_H / 2, th->on_surface_variant);
 }
 
-/* 歌词页整页绘制：背景统一黑色半透明叠加层（用户 2026-09-04，弃封面取色/封面图半透明底，
- * 保证高亮封面下歌词对比度）→ lyric_view（自绘 scrim + 歌词/空态）。 */
+/* 网易云式歌词页封面背景（用户 2026-09-05）：有封面 → 等比居中放大铺满内容区（cover-fit，
+ * 超出部分由画布裁剪，镜像 ncm plr_draw_lyrics 的 meow_ui_img_scaled 算法）；无封面 → 纯黑底
+ * （现状回退）。本函数只铺底；压暗由调用方随后叠黑色半透明叠加层（alpha176）完成。 */
+static void np_draw_lyric_cover_bg(int W, int H)
+{
+    int x = 0, y = SB_BAR_H, cw = W, ch = H - SB_BAR_H;   /* 只盖内容区（状态栏下），与播放页一致 */
+    if (!g_np_cover || meow_img_w(g_np_cover) <= 0 || meow_img_h(g_np_cover) <= 0) {
+        fill_rect(x, y, cw, ch, 0x000000);                /* 无封面 → 纯黑底（回退现状） */
+        return;
+    }
+    int iw = meow_img_w(g_np_cover), ih = meow_img_h(g_np_cover);
+    long dw = cw, dh = (long)ih * cw / iw;                /* cover-fit：铺满宽度，高按等比 */
+    if (dh < ch) { dh = ch; dw = (long)iw * ch / ih; }    /* 宽度不足再铺满高度（超出裁剪） */
+    meow_ui_img_scaled(x + (cw - (int)dw) / 2, y + (ch - (int)dh) / 2, (int)dw, (int)dh, g_np_cover);
+}
+
+/* 歌词页整页绘制：网易云式封面背景（封面图当底 + 黑色半透明叠加层压暗，保证歌词对比度）→
+ * lyric_view（自绘 scrim 关闭，仅歌词/空态）→ 顶部元信息（歌名/歌手）。 */
 static void np_draw_lyric_page(int redraw_sb)
 {
     const meow_ui_theme_t *th = s_ui_theme();
     int W = fb_xres, H = fb_yres;
     if (!g_np_init) np_widgets_create();
     if (redraw_sb) fill_rect(0, 0, W, SB_BAR_H, th->surface);
-    /* 批5：封面取色背景（主→次渐变）或主题面；并注入歌词页 set_colors。
-     * 批6：有封面时以封面作整页背景（衬在 lyric_view 半透明 scrim 之下），取色只做附加；
-     * 无封面回退渐变/主题面。
+    /* 批5：np_cover_theme_update 取色（仅为播放页文字/按钮主题；歌词页背景不走取色，恒 ncm 白/灰）。
+     * 批6：有封面时以封面作整页背景（网易云式 cover-fit 铺满，见 np_draw_lyric_cover_bg），
+     * 无封面回退纯黑底；压暗由下方黑色半透明叠加层（alpha176）统一完成，lyric_view 关内置 scrim。
      * M6.33：先 np_cover_load（artwork 空→复原/换源时重载封面）再取色——顺序不能反，
      * 取色读 g_np_cover，须在封面载入后（否则歌词页在 artwork 复原后仍无封面）。 */
     np_cover_load(meow_media_current());
     np_cover_theme_update();
-    np_apply_lyric_colors();
-    /* 用户 2026-09-04：歌词页背景统一黑色半透明叠加层（弃封面取色/封面图半透明底）——
-     * 部分高亮度封面对歌词显示不友好，黑底保证对比度。歌词行颜色/布局/滚动不变。 */
+    /* 网易云式封面背景（用户 2026-09-05）：先铺封面底（cover-fit 原图铺满），无封面回退纯黑底；
+     * 随后统一叠黑色半透明叠加层（alpha176）压暗，保证歌词对比度。歌词配色仍恒 ncm 白/灰
+     * （不随封面取色——取色仅服务播放页文字/按钮）。歌词行布局/滚动逻辑不变，只换背景。 */
+    np_draw_lyric_cover_bg(W, H);
+    np_set_lyric_ncm_colors();
+    /* 用户 2026-09-04：黑色半透明叠加层（alpha176）——压暗封面底，保证歌词可读；无封面时叠于
+     * 纯黑底之上（仍纯黑，即现状回退）。 */
     meow_ui_fill_rect_alpha(0, SB_BAR_H, W, H - SB_BAR_H, 0x000000, 176);
     np_lyric_refresh(meow_media_current());
     if (g_np_lyric)
         meow_widget_draw(meow_lyric_view_widget(g_np_lyric));
+    np_draw_lyric_title(meow_media_current());   /* 顶部元信息（歌名/歌手，居左，避状态栏） */
     np_draw_home_bar();                     /* 批②：歌词页也示 home 指示（底部上滑可回桌面） */
     if (redraw_sb) draw_statusbar();
 }
@@ -486,6 +555,31 @@ static int64_t np_progress_seek(int tx, int ty)
     return 0;
 }
 
+/* 播放页按键动作应用（音量 + 播放切换）。语义与主界面/子页一致：
+ *   - 音量键 = 系统音量（settings_volume_adj 内含插孔消抖 + 线性渐变）；
+ *   - 播放键 = 媒体播放/暂停切换（路由最近活跃媒体会话，与主界面同判）；
+ *   边沿由调用方按防抖后稳定值计算（vold_edge = 稳定按下 ∧ 上一稳定为抬起）。
+ *   抽成独立小函数供宿主单测（np_apply_key_actions 仅依赖 settings_volume_adj/
+ *   meow_media_playctl/now_ms/logmsg，可 -ffunction-sections 链接隔离）。 */
+static void np_apply_key_actions(int vold_edge, int volu_edge, int play_edge,
+                                 const meow_media_session_t *s,
+                                 unsigned long long *last_input)
+{
+    if (vold_edge) {
+        settings_volume_adj(-settings_volume_step);
+        if (last_input) *last_input = now_ms();
+        logmsg("np: volume DOWN <- ramp step=%d", settings_volume_step);
+    } else if (volu_edge) {
+        settings_volume_adj(+settings_volume_step);
+        if (last_input) *last_input = now_ms();
+        logmsg("np: volume UP <- ramp step=%d", settings_volume_step);
+    }
+    if (play_edge) {
+        if (s) meow_media_playctl((s->state == MEOW_MEDIA_PLAYING) ? 2u : 1u, 0);
+        if (last_input) *last_input = now_ms();
+    }
+}
+
 void run_now_playing(struct app *apps, int napps)
 {
     int tfd = open(DEV_TOUCH, O_RDONLY | O_NONBLOCK);
@@ -495,15 +589,17 @@ void run_now_playing(struct app *apps, int napps)
     kp_open(&kp_keys, DEV_KEYS);
     struct keypoll kp_power;                 /* M2.92：NP 页接管电源键（修「页内电源键无反应」） */
     kp_open(&kp_power, DEV_POWER);
-    struct kd_state kd_play;
+    struct kd_state kd_play;                 /* 音量键防抖/基线上收 key_router（进程唯一） */
     memset(&kd_play, 0, sizeof kd_play);
     /* 读播放键按住态（用于边沿） */
     int m_prev_play = 0;
-    for (int w = 0; w < KEYBUF_WORDS; w++)
-        if (kp_keys.cur[w] & (1UL << (KEY_PLAYPAUSE % 32))) m_prev_play = 1;
+    for (int w = 0; w < KEYBUF_WORDS; w++) {
+        if (kp_keys.cur[w] & (1UL << (KEY_PLAYPAUSE % 32)))    m_prev_play = 1;
+    }
     int np_prev_power = 0;                   /* 电源键边沿跟踪 */
     for (int w = 0; w < KEYBUF_WORDS; w++)
         if (kp_power.cur[w] & (1UL << (KEY_POWER % 32))) np_prev_power = 1;
+    key_router_rebase();   /* 进入 Now Playing：音量基线对齐当前 raw（防残留边沿） */
     unsigned long long np_last_input = now_ms();   /* 自动息屏计时（M2.92：NP 页也遵守 display.screen_off_timeout） */
 
     int td = 0, td_ok = 0, tdx = -1, tdy = -1, tlx = -1, tly = -1;
@@ -521,6 +617,7 @@ void run_now_playing(struct app *apps, int napps)
                                                * 控件 owner 一直钉哨兵，命中要走 meow_widget_hit 的
                                                * owner==active 闸门——漏 push 则 active()!=0x51，
                                                * 三钮 meow_widget_hit 恒 false（「播放页三键无效」根因）。 */
+    key_router_page_enter(NP_SENTINEL_ACT);   /* 路由登记活动页（与 activity 栈交叉校验） */
     g_np_page = NP_PAGE_PLAY;                  /* 批4：每次进入 Now Playing 从播放页起（上次退出页不残留） */
     g_np_lyric_last_valid = -1;                /* 批4：重置歌词「是否有词」过渡态，防首帧多清一次 */
     g_np_lyric_seq = 0xFFFFFFFFu;              /* 批4：强制首次进歌词页重解析（防跨进入残留缓存） */
@@ -631,17 +728,30 @@ void run_now_playing(struct app *apps, int napps)
             }
         }
 
-        /* 播放键边沿 → 播放/暂停切换 */
+        /* 播放键/音量键边沿 → 媒体播放/暂停切换 + 系统音量（与主界面/子页一致）。
+         * 修复：run_now_playing 原先只接播放/电源键，未接音量键 → 播放页/歌词页（同一循环，
+         * 与页无关）音量键无反应。 */
+        key_evt_t kev = key_router_pump();   /* 音量边沿/held/ramp（进程唯一防抖基线） */
         kp_poll(&kp_keys, NULL, NULL);
         int play = 0;
-        for (int w = 0; w < KEYBUF_WORDS; w++)
+        for (int w = 0; w < KEYBUF_WORDS; w++) {
             if (kp_keys.cur[w] & (1UL << (KEY_PLAYPAUSE % 32))) play = 1;
-        if (play && !m_prev_play) {
-            const meow_media_session_t *s = meow_media_current();
-            if (s) meow_media_playctl((s->state == MEOW_MEDIA_PLAYING) ? 2u : 1u, 0);
-            np_last_input = now_ms();
         }
+        (void)kd_tick(&kd_play, play);
+        play = kd_play.stable;
+        /* 音量键/播放键边沿 → 动作（与主界面/子页同语义；见 np_apply_key_actions） */
+        np_apply_key_actions(kev.vol_dn_edge, kev.vol_up_edge,
+                             play && !m_prev_play, meow_media_current(), &np_last_input);
         m_prev_play = play;
+        /* 音量线性渐变（按住长爬；与主界面/子页同语义，状态栏即时刷新）。
+         * Now Playing 用 raw held（kev.vol_held_*，同现状 rvold/rvolu）。 */
+        if (vol_ramp_dir != 0) {
+            int held = (vol_ramp_dir > 0) ? kev.vol_held_up : kev.vol_held_dn;
+            int going = vol_ramp_tick(held);
+            g_sys.vol = settings_volume_get();
+            paint_sb_right();
+            if (!going) logmsg("np: volume ramp end -> %d", g_sys.vol);
+        }
 
         /* M2.92：NP 页电源键接管——单击边沿 = 息屏/亮屏（与主界面语义一致；
          * 修「NP 页电源键无反应」。3s 电源菜单仍由 watchdog→/tmp 标记→主循环消费，
@@ -714,6 +824,7 @@ void run_now_playing(struct app *apps, int napps)
         usleep(10000);
     }
     meow_ui_activity_pop();   /* M7.0b：退出 Now Playing，回主 activity（控件 owner 仍钉哨兵，复用） */
+    key_router_page_exit(NP_SENTINEL_ACT);   /* 路由：退出登记 + 重播音量基线 */
     if (tfd >= 0) close(tfd);
     kp_close(&kp_keys);
     kp_close(&kp_power);

patch_v2/meow_launcherd/settings_page.c

@@ -1315,16 +1315,15 @@ void run_settings_page(void)
 
     struct keypoll kp_power, kp_keys;
     kp_open(&kp_power, DEV_POWER); kp_open(&kp_keys, DEV_KEYS);
-    struct kd_state kd_vold, kd_volu, kd_play, kd_pwr;
-    memset(&kd_vold, 0, sizeof kd_vold); memset(&kd_volu, 0, sizeof kd_volu);
+    /* 音量键防抖/基线已上收 key_router（进程唯一）——本页只保留播放/电源键自家防抖。 */
+    struct kd_state kd_play, kd_pwr;
     memset(&kd_play, 0, sizeof kd_play); memset(&kd_pwr, 0, sizeof kd_pwr);
-    int m_prev_vold = 0, m_prev_volu = 0, m_prev_play = 0, m_prev_pwr = 0;
+    int m_prev_play = 0, m_prev_pwr = 0;
     for (int w = 0; w < KEYBUF_WORDS; w++) {
-        if (kp_keys.cur[w] & (1UL << (KEY_VOLUMEDOWN % 32))) m_prev_vold = 1;
-        if (kp_keys.cur[w] & (1UL << (KEY_VOLUMEUP % 32))) m_prev_volu = 1;
         if (kp_keys.cur[w] & (1UL << (KEY_PLAYPAUSE % 32))) m_prev_play = 1;
         if (kp_power.cur[w] & (1UL << (KEY_POWER % 32))) m_prev_pwr = 1;
     }
+    key_router_rebase();   /* 进入设置页：音量基线对齐当前 raw（防残留边沿） */
     int tfd = open(DEV_TOUCH, O_RDONLY | O_NONBLOCK);
     if (tfd >= 0) { unsigned char ev[16]; while (read(tfd, ev, sizeof ev) == 16) {} }
     unsigned long long touch_cooldown_until = now_ms() + 300;
@@ -1358,6 +1357,7 @@ void run_settings_page(void)
     logmsg("settings entry: net toggle-sync+kick %llums", now_ms() - t_sets);
     if (!g_set_init) set_widgets_create();   /* M7.2：lazy 建 SDK 控件集（一次，跨次进入复用） */
     meow_ui_activity_push(SET_SENTINEL_ACT); /* 控件 owner 闸门打开（hit/按压态生效） */
+    key_router_page_enter(SET_SENTINEL_ACT); /* 路由登记活动页（与 activity 栈交叉校验） */
     set_paint_page(sel);
     meow_dirty_full(); meow_ui_flush();
     logmsg("settings entry: page shown in %llums", now_ms() - t_sets);
@@ -1396,13 +1396,12 @@ void run_settings_page(void)
                 meow_auto_slept = 0;
                 wake_suppress = 1;
                 last_act = now_ms();
-                /* 重置按键防抖与 m_prev_*（含唤醒键原始态对齐），并丢唤醒的这次触摸 */
-                memset(&kd_pwr, 0, sizeof kd_pwr);  memset(&kd_vold, 0, sizeof kd_vold);
-                memset(&kd_volu, 0, sizeof kd_volu); memset(&kd_play, 0, sizeof kd_play);
+                /* 重置按键防抖与 m_prev_*（含唤醒键原始态对齐），并丢唤醒的这次触摸。
+                 * 音量防抖/基线上收 key_router：唤醒时重播音量基线；播放/电源仍本页自理。 */
+                key_router_rebase();   /* 音量：kd_vold/volu 清零 + m_prev_vold/volu=当前 raw */
+                memset(&kd_pwr, 0, sizeof kd_pwr); memset(&kd_play, 0, sizeof kd_play);
                 kp_poll(&kp_power, NULL, NULL); kp_poll(&kp_keys, NULL, NULL);
                 m_prev_pwr = kp_is_down(&kp_power, KEY_POWER);
-                m_prev_vold = kp_is_down(&kp_keys, KEY_VOLUMEDOWN);
-                m_prev_volu = kp_is_down(&kp_keys, KEY_VOLUMEUP);
                 m_prev_play = kp_is_down(&kp_keys, KEY_PLAYPAUSE);
                 touch_cooldown_until = now_ms() + 300;
                 td = 0; td_ok = 0; drag = -1; scroll_drag = 0; tlx = tly = -1;
@@ -1423,28 +1422,25 @@ void run_settings_page(void)
         }
 
         /* ---- 按键 ---- */
+        key_evt_t ev = key_router_pump();   /* 音量边沿/held/ramp（进程唯一防抖基线） */
         kp_poll(&kp_power, NULL, NULL); kp_poll(&kp_keys, NULL, NULL);
-        int vold = 0, volu = 0, play = 0, pwr = 0;
+        int play = 0, pwr = 0;
         for (int w = 0; w < KEYBUF_WORDS; w++) {
-            if (kp_keys.cur[w] & (1UL << (KEY_VOLUMEDOWN % 32))) vold = 1;
-            if (kp_keys.cur[w] & (1UL << (KEY_VOLUMEUP % 32))) volu = 1;
             if (kp_keys.cur[w] & (1UL << (KEY_PLAYPAUSE % 32))) play = 1;
             if (kp_power.cur[w] & (1UL << (KEY_POWER % 32))) pwr = 1;
         }
-        (void)kd_tick(&kd_vold, vold); (void)kd_tick(&kd_volu, volu);
         (void)kd_tick(&kd_play, play); (void)kd_tick(&kd_pwr, pwr);
-        vold = kd_vold.stable; volu = kd_volu.stable;
         play = kd_play.stable; pwr = kd_pwr.stable;
         if (wake_suppress) {
             /* 刚被唤醒：吸收唤醒键的边沿，等所有按键完全抬起后再接管动作，
              * 避免「电源唤醒→抬起→被当成电源单击返回」或音量唤醒→误导航。 */
-            if (!pwr && !vold && !volu && !play) wake_suppress = 0;
+            if (!pwr && !ev.vol_st_dn && !ev.vol_st_up && !play) wake_suppress = 0;
         } else {
             /* M2.39：设置页音量键 = 调系统音量（写 DAC），不做光标移动（用户约束：
              * 设置页仅触摸导航；音量键在电菜单/应用列表的系统级导航保持不动）。
              * 按下边沿即起线性渐变（vol_ramp_begin），下方 vol_ramp_tick 逐 1% 爬 + 刷状态栏。 */
-            if (vold && !m_prev_vold) { settings_volume_adj(-settings_volume_step); need_paint = 1; }
-            if (volu && !m_prev_volu) { settings_volume_adj(+settings_volume_step); need_paint = 1; }
+            if (ev.vol_dn_edge) { settings_volume_adj(-settings_volume_step); need_paint = 1; }
+            if (ev.vol_up_edge) { settings_volume_adj(+settings_volume_step); need_paint = 1; }
             /* M2.x（KEY_CONTROL_DESIGN §2/§3）播放键在设置页同样被系统「抓住」：
              * 捕获+日志+消费，不再映射为「返回/确认」（原 play 边沿=break 已删，播放键不再退出设置页）。
              * 仍视为输入（重置自动息屏计时，与主界面 play 的媒体预留/any_input 一致）。 */
@@ -1480,14 +1476,11 @@ void run_settings_page(void)
                     pwr_suppress_click = 1;     /* M2.34：菜单返回后抑制本次电源松开被误判单击息屏 */
                     /* M2.25 同款：阻塞式 show_power_menu() 期间 kd_* 冻结，m_prev_* 与稳定值可能错配，
                      * 重播 kd_* 并以当前 raw 对齐 m_prev_*，杜绝「菜单内触摸点取消->返回后被误判单击息屏」。 */
-                    memset(&kd_pwr, 0, sizeof kd_pwr);
-                    memset(&kd_vold, 0, sizeof kd_vold);
-                    memset(&kd_volu, 0, sizeof kd_volu);
-                    memset(&kd_play, 0, sizeof kd_play);
+                    /* 重播音量基线（key_router）+ 本页播放/电源基线 */
+                    key_router_rebase();   /* 音量：kd_vold/volu 清零 + m_prev_vold/volu=当前 raw */
+                    memset(&kd_pwr, 0, sizeof kd_pwr); memset(&kd_play, 0, sizeof kd_play);
                     kp_poll(&kp_power, NULL, NULL); kp_poll(&kp_keys, NULL, NULL);
                     m_prev_pwr = kp_is_down(&kp_power, KEY_POWER);
-                    m_prev_vold = kp_is_down(&kp_keys, KEY_VOLUMEDOWN);
-                    m_prev_volu = kp_is_down(&kp_keys, KEY_VOLUMEUP);
                     m_prev_play = kp_is_down(&kp_keys, KEY_PLAYPAUSE);
                     after_modal = 1;            /* 全屏 dim 覆盖过状态栏，需整帧重绘还原 */
                     need_paint = 1;
@@ -1514,14 +1507,14 @@ void run_settings_page(void)
         }
         /* M2.39：驱动音量线性渐变（长按续爬/松开即止）+ 刷新状态栏 VOL；「音量」行随 need_paint 更新 */
         if (vol_ramp_dir != 0) {
-            int held = (vol_ramp_dir > 0) ? volu : vold;
+            int held = (vol_ramp_dir > 0) ? ev.vol_held_up : ev.vol_held_dn;
             int going = vol_ramp_tick(held);
             g_sys.vol = settings_volume_get();
             paint_sb_right();
             need_paint = 1;
             if (!going) logmsg("settings vol ramp end -> %d", g_sys.vol);
         }
-        m_prev_vold = vold; m_prev_volu = volu; m_prev_play = play; m_prev_pwr = pwr;
+        m_prev_play = play; m_prev_pwr = pwr;
     settings_keys_seeded:
         ;
 
@@ -1658,14 +1651,10 @@ void run_settings_page(void)
                                             scroll_y0 = 0;
                                             tdx = tdy = tlx = tly = -1;
                                             touch_cooldown_until = now_ms() + 300;
-                                            memset(&kd_pwr, 0, sizeof kd_pwr);
-                                            memset(&kd_vold, 0, sizeof kd_vold);
-                                            memset(&kd_volu, 0, sizeof kd_volu);
-                                            memset(&kd_play, 0, sizeof kd_play);
+                                            key_router_rebase();   /* 音量基线重播 */
+                                            memset(&kd_pwr, 0, sizeof kd_pwr); memset(&kd_play, 0, sizeof kd_play);
                                             kp_poll(&kp_power, NULL, NULL); kp_poll(&kp_keys, NULL, NULL);
                                             m_prev_pwr = kp_is_down(&kp_power, KEY_POWER);
-                                            m_prev_vold = kp_is_down(&kp_keys, KEY_VOLUMEDOWN);
-                                            m_prev_volu = kp_is_down(&kp_keys, KEY_VOLUMEUP);
                                             m_prev_play = kp_is_down(&kp_keys, KEY_PLAYPAUSE);
                                             need_paint = 1;
                                         } else if (r->ctrl == SC_ENUM || r->ctrl == SC_PRESET) {
@@ -1703,14 +1692,10 @@ void run_settings_page(void)
                                             tdx = tdy = tlx = tly = -1;
                                             touch_cooldown_until = now_ms() + 300;
                                             /* 重置设置页按键防抖基线，防残边 */
-                                            memset(&kd_pwr, 0, sizeof kd_pwr);
-                                            memset(&kd_vold, 0, sizeof kd_vold);
-                                            memset(&kd_volu, 0, sizeof kd_volu);
-                                            memset(&kd_play, 0, sizeof kd_play);
+                                            key_router_rebase();   /* 音量基线重播 */
+                                            memset(&kd_pwr, 0, sizeof kd_pwr); memset(&kd_play, 0, sizeof kd_play);
                                             kp_poll(&kp_power, NULL, NULL); kp_poll(&kp_keys, NULL, NULL);
                                             m_prev_pwr = kp_is_down(&kp_power, KEY_POWER);
-                                            m_prev_vold = kp_is_down(&kp_keys, KEY_VOLUMEDOWN);
-                                            m_prev_volu = kp_is_down(&kp_keys, KEY_VOLUMEUP);
                                             m_prev_play = kp_is_down(&kp_keys, KEY_PLAYPAUSE);
                                             need_paint = 1;
                                         } else if (r->ctrl == SC_SLIDER && tlx >= 0) {
@@ -1768,6 +1753,7 @@ void run_settings_page(void)
 done:
     meow_input_touch_set(0, 0, 0, 0);   /* M7.2 防残留按压态 */
     meow_ui_activity_pop();              /* 关 owner 闸门（控件 owner 仍钉哨兵，复用） */
+    key_router_page_exit(SET_SENTINEL_ACT);   /* 路由：退出登记 + 重播音量基线 */
     if (tfd >= 0) close(tfd);
     kp_close(&kp_power); kp_close(&kp_keys);
     logmsg("settings page closed");

patch_v2/meow_launcherd/subpage.c

@@ -247,12 +247,11 @@ int meow_subpage_run(sub_page_t *p)
                 meow_auto_slept = 0;
                 wake_suppress = 1;
                 last_act = now;
-                memset(&kd_pwr, 0, sizeof kd_pwr); memset(&kd_vold, 0, sizeof kd_vold);
-                memset(&kd_volu, 0, sizeof kd_volu); memset(&kd_play, 0, sizeof kd_play);
+                /* 唤醒：音量基线重播（key_router）+ 本页播放/电源基线 */
+                key_router_rebase();
+                memset(&kd_pwr, 0, sizeof kd_pwr); memset(&kd_play, 0, sizeof kd_play);
                 kp_poll(&kp_power, NULL, NULL); kp_poll(&kp_keys, NULL, NULL);
                 m_prev_pwr = kp_is_down(&kp_power, KEY_POWER);
-                m_prev_vold = kp_is_down(&kp_keys, KEY_VOLUMEDOWN);
-                m_prev_volu = kp_is_down(&kp_keys, KEY_VOLUMEUP);
                 m_prev_play = kp_is_down(&kp_keys, KEY_PLAYPAUSE);
                 touch_cooldown_until = now_ms() + 300;
                 td = 0; td_ok = 0; scroll_drag = 0; tlx = tly = -1;
@@ -302,14 +301,12 @@ int meow_subpage_run(sub_page_t *p)
                     last_act = now_ms();
                     pwr_hold_at = 0; pwr_menu_state = 0; pwr_woke = 0;
                     pwr_suppress_click = 1;
+                    /* 电源菜单返回：音量基线重播（key_router）+ 本页播放/电源基线 */
+                    key_router_rebase();
                     memset(&kd_pwr, 0, sizeof kd_pwr);
-                    memset(&kd_vold, 0, sizeof kd_vold);
-                    memset(&kd_volu, 0, sizeof kd_volu);
                     memset(&kd_play, 0, sizeof kd_play);
                     kp_poll(&kp_power, NULL, NULL); kp_poll(&kp_keys, NULL, NULL);
                     m_prev_pwr = kp_is_down(&kp_power, KEY_POWER);
-                    m_prev_vold = kp_is_down(&kp_keys, KEY_VOLUMEDOWN);
-                    m_prev_volu = kp_is_down(&kp_keys, KEY_VOLUMEUP);
                     m_prev_play = kp_is_down(&kp_keys, KEY_PLAYPAUSE);
                     after_modal = 1;
                     need_paint = 1;
@@ -456,14 +453,12 @@ int meow_subpage_run(sub_page_t *p)
                                         scroll_base = 0; scroll_y0 = 0;
                                         tdx = tdy = tlx = tly = -1;
                                         touch_cooldown_until = now_ms() + 300;
+                                        /* 返回重播：音量基线（key_router）+ 本页播放/电源基线 */
+                                        key_router_rebase();
                                         memset(&kd_pwr, 0, sizeof kd_pwr);
-                                        memset(&kd_vold, 0, sizeof kd_vold);
-                                        memset(&kd_volu, 0, sizeof kd_volu);
                                         memset(&kd_play, 0, sizeof kd_play);
                                         kp_poll(&kp_power, NULL, NULL); kp_poll(&kp_keys, NULL, NULL);
                                         m_prev_pwr = kp_is_down(&kp_power, KEY_POWER);
-                                        m_prev_vold = kp_is_down(&kp_keys, KEY_VOLUMEDOWN);
-                                        m_prev_volu = kp_is_down(&kp_keys, KEY_VOLUMEUP);
                                         m_prev_play = kp_is_down(&kp_keys, KEY_PLAYPAUSE);
                                         after_modal = 1;
                                         need_paint = 1;
@@ -746,16 +741,15 @@ int meow_subpage_run(sub_page_t *p)
 {
     struct keypoll kp_power, kp_keys;
     kp_open(&kp_power, DEV_POWER); kp_open(&kp_keys, DEV_KEYS);
-    struct kd_state kd_vold, kd_volu, kd_play, kd_pwr;
-    memset(&kd_vold, 0, sizeof kd_vold); memset(&kd_volu, 0, sizeof kd_volu);
+    /* 音量键防抖/基线已上收 key_router（进程唯一）——本页只保留播放/电源键自家防抖。 */
+    struct kd_state kd_play, kd_pwr;
     memset(&kd_play, 0, sizeof kd_play); memset(&kd_pwr, 0, sizeof kd_pwr);
-    int m_prev_vold = 0, m_prev_volu = 0, m_prev_play = 0, m_prev_pwr = 0;
+    int m_prev_play = 0, m_prev_pwr = 0;
     for (int w = 0; w < KEYBUF_WORDS; w++) {
-        if (kp_keys.cur[w] & (1UL << (KEY_VOLUMEDOWN % 32))) m_prev_vold = 1;
-        if (kp_keys.cur[w] & (1UL << (KEY_VOLUMEUP % 32))) m_prev_volu = 1;
         if (kp_keys.cur[w] & (1UL << (KEY_PLAYPAUSE % 32))) m_prev_play = 1;
         if (kp_power.cur[w] & (1UL << (KEY_POWER % 32))) m_prev_pwr = 1;
     }
+    key_router_rebase();   /* 进入子页：音量基线对齐当前 raw（防残留边沿） */
     int tfd = open(DEV_TOUCH, O_RDONLY | O_NONBLOCK);
     if (tfd >= 0) { unsigned char ev[16]; while (read(tfd, ev, sizeof ev) == 16) {} }
     unsigned long long touch_cooldown_until = now_ms() + 300;
@@ -783,6 +777,7 @@ int meow_subpage_run(sub_page_t *p)
     sp_configure_page(p, top_sw_en, top_on);
 
     meow_ui_activity_push(SUB_SENTINEL_ACT);   /* 控件 owner 闸门打开（hit 生效） */
+    key_router_page_enter(SUB_SENTINEL_ACT);   /* 路由登记活动页（与 activity 栈交叉校验） */
     sp_paint_page();
     meow_dirty_full(); meow_ui_flush();
 
@@ -817,12 +812,11 @@ int meow_subpage_run(sub_page_t *p)
                 meow_auto_slept = 0;
                 wake_suppress = 1;
                 last_act = now;
-                memset(&kd_pwr, 0, sizeof kd_pwr); memset(&kd_vold, 0, sizeof kd_vold);
-                memset(&kd_volu, 0, sizeof kd_volu); memset(&kd_play, 0, sizeof kd_play);
+                /* 唤醒：音量基线重播（key_router）+ 本页播放/电源基线 */
+                key_router_rebase();
+                memset(&kd_pwr, 0, sizeof kd_pwr); memset(&kd_play, 0, sizeof kd_play);
                 kp_poll(&kp_power, NULL, NULL); kp_poll(&kp_keys, NULL, NULL);
                 m_prev_pwr = kp_is_down(&kp_power, KEY_POWER);
-                m_prev_vold = kp_is_down(&kp_keys, KEY_VOLUMEDOWN);
-                m_prev_volu = kp_is_down(&kp_keys, KEY_VOLUMEUP);
                 m_prev_play = kp_is_down(&kp_keys, KEY_PLAYPAUSE);
                 touch_cooldown_until = now_ms() + 300;
                 td = 0; td_ok = 0; scroll_drag = 0; drag_last_y = 0; tlx = tly = -1;
@@ -835,23 +829,20 @@ int meow_subpage_run(sub_page_t *p)
         }
 
         /* ---- 按键（与旧版逐字一致：音量=系统音量/播放=媒体预留/电源=系统级语义）---- */
+        key_evt_t ev = key_router_pump();   /* 音量边沿/held/ramp（进程唯一防抖基线） */
         kp_poll(&kp_power, NULL, NULL); kp_poll(&kp_keys, NULL, NULL);
-        int vold = 0, volu = 0, play = 0, pwr = 0;
+        int play = 0, pwr = 0;
         for (int w = 0; w < KEYBUF_WORDS; w++) {
-            if (kp_keys.cur[w] & (1UL << (KEY_VOLUMEDOWN % 32))) vold = 1;
-            if (kp_keys.cur[w] & (1UL << (KEY_VOLUMEUP % 32))) volu = 1;
             if (kp_keys.cur[w] & (1UL << (KEY_PLAYPAUSE % 32))) play = 1;
             if (kp_power.cur[w] & (1UL << (KEY_POWER % 32))) pwr = 1;
         }
-        (void)kd_tick(&kd_vold, vold); (void)kd_tick(&kd_volu, volu);
         (void)kd_tick(&kd_play, play); (void)kd_tick(&kd_pwr, pwr);
-        vold = kd_vold.stable; volu = kd_volu.stable;
         play = kd_play.stable; pwr = kd_pwr.stable;
         if (wake_suppress) {
-            if (!pwr && !vold && !volu && !play) wake_suppress = 0;
+            if (!pwr && !ev.vol_st_dn && !ev.vol_st_up && !play) wake_suppress = 0;
         } else {
-            if (vold && !m_prev_vold) { settings_volume_adj(-settings_volume_step); need_paint = 1; }
-            if (volu && !m_prev_volu) { settings_volume_adj(+settings_volume_step); need_paint = 1; }
+            if (ev.vol_dn_edge) { settings_volume_adj(-settings_volume_step); need_paint = 1; }
+            if (ev.vol_up_edge) { settings_volume_adj(+settings_volume_step); need_paint = 1; }
             if (play && !m_prev_play) { logmsg("subpage: play key caught (media-reserved)"); last_act = now; }
             if (pwr && !m_prev_pwr) {
                 pwr_hold_at = now; pwr_menu_state = 0;
@@ -870,14 +861,12 @@ int meow_subpage_run(sub_page_t *p)
                     last_act = now_ms();
                     pwr_hold_at = 0; pwr_menu_state = 0; pwr_woke = 0;
                     pwr_suppress_click = 1;
+                    /* 电源菜单返回：音量基线重播（key_router）+ 本页播放/电源基线 */
+                    key_router_rebase();
                     memset(&kd_pwr, 0, sizeof kd_pwr);
-                    memset(&kd_vold, 0, sizeof kd_vold);
-                    memset(&kd_volu, 0, sizeof kd_volu);
                     memset(&kd_play, 0, sizeof kd_play);
                     kp_poll(&kp_power, NULL, NULL); kp_poll(&kp_keys, NULL, NULL);
                     m_prev_pwr = kp_is_down(&kp_power, KEY_POWER);
-                    m_prev_vold = kp_is_down(&kp_keys, KEY_VOLUMEDOWN);
-                    m_prev_volu = kp_is_down(&kp_keys, KEY_VOLUMEUP);
                     m_prev_play = kp_is_down(&kp_keys, KEY_PLAYPAUSE);
                     after_modal = 1;
                     need_paint = 1;
@@ -902,13 +891,13 @@ int meow_subpage_run(sub_page_t *p)
             }
         }
         if (vol_ramp_dir != 0) {
-            int held = (vol_ramp_dir > 0) ? volu : vold;
+            int held = (vol_ramp_dir > 0) ? ev.vol_held_up : ev.vol_held_dn;
             (void)vol_ramp_tick(held);
             g_sys.vol = settings_volume_get();
             paint_sb_right();
             need_paint = 1;
         }
-        m_prev_vold = vold; m_prev_volu = volu; m_prev_play = play; m_prev_pwr = pwr;
+        m_prev_play = play; m_prev_pwr = pwr;
     sub_keys_seeded:
         ;
 
@@ -1024,14 +1013,12 @@ int meow_subpage_run(sub_page_t *p)
                                         drag_last_y = 0;
                                         tdx = tdy = tlx = tly = -1;
                                         touch_cooldown_until = now_ms() + 300;
+                                        /* 返回重播：音量基线（key_router）+ 本页播放/电源基线 */
+                                        key_router_rebase();
                                         memset(&kd_pwr, 0, sizeof kd_pwr);
-                                        memset(&kd_vold, 0, sizeof kd_vold);
-                                        memset(&kd_volu, 0, sizeof kd_volu);
                                         memset(&kd_play, 0, sizeof kd_play);
                                         kp_poll(&kp_power, NULL, NULL); kp_poll(&kp_keys, NULL, NULL);
                                         m_prev_pwr = kp_is_down(&kp_power, KEY_POWER);
-                                        m_prev_vold = kp_is_down(&kp_keys, KEY_VOLUMEDOWN);
-                                        m_prev_volu = kp_is_down(&kp_keys, KEY_VOLUMEUP);
                                         m_prev_play = kp_is_down(&kp_keys, KEY_PLAYPAUSE);
                                         after_modal = 1;
                                         need_paint = 1;
@@ -1090,6 +1077,7 @@ int meow_subpage_run(sub_page_t *p)
 subdone:
     meow_input_touch_set(0, 0, 0, 0);   /* 防残留按压态 */
     meow_ui_activity_pop();              /* 关 owner 闸门（控件 owner 仍钉哨兵，复用） */
+    key_router_page_exit(SUB_SENTINEL_ACT);   /* 路由：退出登记 + 重播音量基线 */
     if (tfd >= 0) close(tfd);
     kp_close(&kp_power); kp_close(&kp_keys);
     logmsg("subpage '%s' closed", p->title ? p->title : "");

patch_v2/meow_launcherd/test_key_router_vol.c

@@ -0,0 +1,229 @@
+/* test_key_router_vol.c — 宿主单测：launcher-UI 页物理键统一路由（KEY_ROUTER_UNIFY P1）。
+ *
+ * 测「key_router 自身的音量编排」——它只产「音量边沿 + 原始 held + ramp 状态」，
+ * 由调用页决定 settings_volume_adj(±step) / 光标导航 / ramp 推进。本测用内存桩：
+ *   - kp_poll/kp_open/kp_is_down → 注入 raw 键位矩阵到 key_router 的静态 kp_keys.cur[]；
+ *   - kd_tick → 用 keys.c 的真实现（40ms 防抖，V4 依赖）；keys.c 内 kp_open/kp_poll/
+ *     kp_is_down/meow_volpage_armed 用宏重命名避开真实 ioctl 与桩冲突；
+ *   - settings_volume_adj/settings_volume_step/vol_ramp_dir/vol_ramp_tick → 内存桩；
+ *   - now_ms → 假时钟（手动推进，40ms 防抖可瞬时测）；
+ *   - meow_ui_activity_* → 内存桩（V5 嵌套：真语义=纯静态数组，桩复刻）。
+ *
+ * 断言：
+ *   V1 音量减边沿 → settings_volume_adj(-step) 恰一次 + last_input 复位；
+ *   V2 同会话重复（同 raw 仍按住）→ 不再触发 settings_volume_adj；
+ *   V3 长按 held → vol_ramp_tick 被驱动（vol_ramp_dir!=0，held=正确方向 raw）；松开 → dir=0；
+ *   V4 40ms 防抖：raw 在 40ms 内抖动 → 不产边沿；稳定按下 ≥40ms → 才产边沿；
+ *   V5 嵌套返回：page_enter(0x53)→page_exit(0x53)→page_enter(0x55)，基线重播后 held 键不产假边沿；
+ *   V6 meow_volpage_armed() → 音量边沿被抑制（不下发，不调 settings_volume_adj）。
+ *
+ * 编译（在 patch_v2/meow_launcherd 下）：
+ *   gcc -Wall -Wextra -I../sdk -I. -ffunction-sections -fdata-sections \
+ *       -Wl,--gc-sections test_key_router_vol.c -o test_key_router_vol
+ *   ./test_key_router_vol
+ */
+#include <stdio.h>
+#include <string.h>
+#include <stdarg.h>
+#include <stdint.h>
+
+/* ---- 假时钟 ---- */
+static unsigned long long g_now = 100000;
+unsigned long long now_ms(void) { return g_now; }
+static void advance_ms(unsigned long long d) { g_now += d; }
+
+/* ---- 音量机外部符号桩（key_router 依赖）---- */
+int settings_volume_step = 5;
+static int g_adj_count = 0, g_adj_delta = 0;
+int vol_ramp_dir = 0;                       /* 桩全局：模拟 audio.c 的 ramp 状态 */
+static int g_tick_count = 0, g_tick_held = -1;
+
+void settings_volume_adj(int delta)
+{
+    g_adj_count++; g_adj_delta = delta;
+    if (delta > 0) vol_ramp_dir = 1; else if (delta < 0) vol_ramp_dir = -1;
+}
+
+int vol_ramp_tick(int key_held)
+{
+    g_tick_count++; g_tick_held = key_held;
+    if (!key_held) vol_ramp_dir = 0;
+    return vol_ramp_dir != 0;
+}
+
+static int g_volpage = 0;                   /* 桩：meow_volpage_armed */
+
+/* ---- keys.c 内 kp_open/kp_poll/kp_is_down/meow_volpage_armed 用宏重命名，避开真实 ioctl ----
+ *     （宏在 #include keys.c 前生效，仅重命名 keys.c 体内的调用/定义） ---- */
+#define kp_open          kp_open_rt_
+#define kp_poll          kp_poll_rt_
+#define kp_is_down       kp_is_down_rt_
+#define meow_volpage_armed meow_volpage_armed_rt_
+#include "keys.c"   /* 真 kd_tick（40ms 防抖素材） */
+#undef kp_open
+#undef kp_poll
+#undef kp_is_down
+#undef meow_volpage_armed
+
+/* host 桩声明（key_router.c 需要；恢复到正常名，与 keys.c 被更名后的定义不冲突） */
+struct keypoll;
+int kp_open(struct keypoll *kp, const char *dev);
+int kp_poll(struct keypoll *kp, int (*cb)(int code, int down, void *ctx), void *ctx);
+int kp_is_down(const struct keypoll *k, int code);
+int meow_volpage_armed(void);
+
+#include "key_router.c"   /* 同 TU #include：拿到静态 kp_keys/kp_power/kd_vold/kd_volu + 全部函数 */
+#include "key_router.h"
+
+/* ---- meow_ui_activity_* 桩（复刻 sdk/meow_ui_activity.c：纯静态数组，真语义）---- */
+static int g_act[32]; static int g_act_n = 0;
+void meow_ui_activity_push(int id) { if (g_act_n < 32) g_act[g_act_n++] = id; }
+void meow_ui_activity_pop(void)    { if (g_act_n > 0) g_act_n--; }
+int  meow_ui_activity_active(void) { return g_act_n > 0 ? g_act[g_act_n - 1] : 0; }
+
+/* ---- 注入 raw 到 key_router 静态 kp_keys ---- */
+static void set_vol(int vold, int volu)
+{
+    for (int w = 0; w < KEYBUF_WORDS; w++) kp_keys.cur[w] = 0;
+    if (vold) kp_keys.cur[KEY_VOLUMEDOWN / 32] |= (1UL << (KEY_VOLUMEDOWN % 32));
+    if (volu) kp_keys.cur[KEY_VOLUMEUP / 32]   |= (1UL << (KEY_VOLUMEUP % 32));
+}
+
+/* ---- host 桩：kp_*（prev=cur 模拟真实 poll 的键位更新）+ meow_volpage_armed ---- */
+int kp_open(struct keypoll *kp, const char *dev)
+{ (void)dev; memset(kp, 0, sizeof *kp); kp->ok = 1; return 0; }
+int kp_poll(struct keypoll *kp, int (*cb)(int, int, void *), void *ctx)
+{
+    (void)cb; (void)ctx;
+    for (int w = 0; w < KEYBUF_WORDS; w++) kp->prev[w] = kp->cur[w];
+    return 0;
+}
+int kp_is_down(const struct keypoll *k, int code)
+{ return (k->cur[code / 32] >> (code % 32)) & 1; }
+int meow_volpage_armed(void) { return g_volpage; }
+
+/* 其它全局桩（keys.c 内被更名函数引用；本测 GC 后不保留，仅满足声明一致性） */
+uint32_t menu_bg = 0;
+int screen_off_timeout = 0, screen_off_mode = 0, power_longpress_menu_ms = 0;
+int power_forceoff_ms = 0, refresh_rate_cfg = 60, refresh_always_max = 0;
+
+void logmsg(const char *fmt, ...) { (void)fmt; }
+
+static int g_fails = 0;
+#define CHECK(cond, name) do { \
+    if (cond) printf("  PASS %s\n", name); \
+    else { printf("  FAIL %s (%s:%d)\n", name, __FILE__, __LINE__); g_fails++; } } while (0)
+
+static void reset_router(void)
+{
+    set_vol(0, 0);
+    key_router_rebase();
+    g_adj_count = 0; g_adj_delta = 0; g_tick_count = 0; g_tick_held = -1;
+    vol_ramp_dir = 0; g_volpage = 0;
+    g_act_n = 0;
+}
+
+/* 按下并稳定：register(pump) → hold ≥40ms → pump(stable=1, 边沿)。 */
+static key_evt_t press_settle(int vold, int volu)
+{
+    set_vol(vold, volu);
+    key_router_pump();          /* 登记 raw 跳变（防抖窗口起点） */
+    advance_ms(50);             /* ≥KEY_DEBOUNCE_MS(40) */
+    return key_router_pump();   /* stable→1，边沿 */
+}
+
+/* 抬起并稳定：register(pump) → → pump(stable=0)。 */
+static key_evt_t release_settle(void)
+{
+    set_vol(0, 0);
+    key_router_pump();          /* 登记 release */
+    advance_ms(50);
+    return key_router_pump();   /* stable→0 */
+}
+
+int main(void)
+{
+    unsigned long long last_input = 0;
+
+    /* ---- V1 音量减边沿 → settings_volume_adj(-step) 恰一次 + last_input 复位 ---- */
+    reset_router();
+    set_vol(0, 0); advance_ms(10); key_router_pump();   /* 全抬起基线 */
+    last_input = 0;
+    key_evt_t ev = press_settle(1, 0);
+    CHECK(ev.vol_dn_edge == 1, "V1 vol-down edge fires");
+    key_router_default_volume(&ev, &last_input);
+    CHECK(g_adj_count == 1 && g_adj_delta == -settings_volume_step,
+          "V1 vol-down -> settings_volume_adj(-step) exactly once");
+    CHECK(last_input == g_now, "V1 last_input reset on edge");
+
+    /* ---- V2 同会话重复（同 raw 仍按住）→ 不再触发 ---- */
+    reset_router();
+    set_vol(0, 0); advance_ms(10); key_router_pump();
+    ev = press_settle(1, 0);
+    CHECK(ev.vol_dn_edge == 1, "V2a press edge fires");
+    ev = key_router_pump();          /* 同 raw 仍按住，无新边沿 */
+    CHECK(ev.vol_dn_edge == 0, "V2 held: no re-trigger edge");
+    key_router_default_volume(&ev, &last_input);
+    CHECK(g_adj_count == 0, "V2 held: no double settings_volume_adj");
+
+    /* ---- V3 长按 held → vol_ramp_tick 被驱动（held=正确方向 raw）；松开 → dir=0 ---- */
+    reset_router();
+    set_vol(0, 0); advance_ms(10); key_router_pump(); last_input = 0;
+    ev = press_settle(1, 0);         /* 按下（vol down）并转稳定 */
+    key_router_default_volume(&ev, &last_input);
+    CHECK(g_tick_count == 1 && g_tick_held == ev.vol_held_dn && vol_ramp_dir != 0,
+          "V3 hold vol-down -> ramp driven with held=raw down");
+    advance_ms(50);
+    ev = key_router_pump();          /* 继续长按（raw=1 仍按住） */
+    key_router_default_volume(&ev, &last_input);
+    CHECK(g_tick_count == 2 && g_tick_held == 1, "V3 long-press continues ramp");
+    ev = release_settle();           /* 松开：raw held 立即为 0 */
+    key_router_default_volume(&ev, &last_input);
+    CHECK(vol_ramp_dir == 0, "V3 release -> ramp dir 0 (stops)");
+
+    /* ---- V4 40ms 防抖：raw 在 40ms 内抖动不产边沿；稳定 ≥40ms 才产 ---- */
+    reset_router();
+    set_vol(0, 0); advance_ms(10); key_router_pump();
+    set_vol(1, 0); advance_ms(20); key_router_pump();   /* 按下未满 40ms */
+    set_vol(0, 0); advance_ms(20); key_router_pump();   /* 40ms 内又抬起 */
+    ev = key_router_pump();
+    CHECK(ev.vol_dn_edge == 0, "V4 <40ms jitter -> no edge");
+    ev = press_settle(1, 0);                             /* 稳定按下 ≥40ms */
+    CHECK(ev.vol_dn_edge == 1, "V4 stable >=40ms press -> edge");
+    ev = release_settle();                               /* 抬起稳定 */
+    CHECK(ev.vol_dn_edge == 0 && ev.vol_up_edge == 0, "V4 released -> no residual edge");
+    ev = press_settle(0, 1);                             /* 稳定按音量加 */
+    CHECK(ev.vol_up_edge == 1, "V4 vol-up stable press -> up edge");
+
+    /* ---- V5 嵌套返回：page_enter/exit 重播基线，held 键不产假边沿 ---- */
+    reset_router();
+    meow_ui_activity_push(0x55); key_router_page_enter(0x55);   /* 主菜单 */
+    set_vol(0, 0); advance_ms(10); key_router_pump();
+    ev = press_settle(1, 0);
+    CHECK(ev.vol_dn_edge == 1, "V5a press edge in menu");
+    /* 嵌套进设置页：压栈 + 登记 */
+    meow_ui_activity_push(0x53); key_router_page_enter(0x53);
+    CHECK(meow_ui_activity_active() == 0x53, "V5b settings active sentinel");
+    ev = release_settle();                               /* 设置页内把键抬起 */
+    CHECK(ev.vol_dn_edge == 0, "V5c settings-up: no fresh edge (consumer)");
+    /* 设置页返回（模拟 run_settings_page 结束）：弹栈 + 重播基线 → m_prev=当前 raw(0) */
+    key_router_page_exit(0x53); meow_ui_activity_pop();
+    key_router_page_enter(0x55);
+    CHECK(meow_ui_activity_active() == 0x55, "V5d menu active again");
+    /* 主菜单基线已重播；再次按下应为新边沿，而非残留/双发 */
+    ev = press_settle(1, 0);
+    CHECK(ev.vol_dn_edge == 1, "V5e fresh press after nest return -> single edge");
+
+    /* ---- V6 meow_volpage_armed() → 音量边沿被抑制（不下发）---- */
+    reset_router();
+    set_vol(0, 0); advance_ms(10); key_router_pump();
+    g_volpage = 1;
+    ev = press_settle(1, 0);
+    CHECK(ev.vol_dn_edge == 0, "V6 volpage armed -> edge suppressed");
+    key_router_default_volume(&ev, &last_input);
+    CHECK(g_adj_count == 0, "V6 volpage armed -> settings_volume_adj NOT called");
+    g_volpage = 0;
+
+    printf("\nRESULT: %s (%d fails)\n", g_fails ? "FAIL" : "ALL PASS", g_fails);
+    return g_fails ? 1 : 0;
+}

patch_v2/meow_launcherd/test_np_keys.c

@@ -0,0 +1,114 @@
+/* test_np_keys.c — 宿主单测：Now Playing 播放页/歌词页物理键分发（Task C）。
+ *
+ * 背景（真机现象）：桌面播放页与歌词页上，音量键 + 播放键「完全无反应」。
+ * 根因（now_playing.c）：run_now_playing() 原先只接播放键(164)与电源键，未接音量键
+ * (114/115)，导致播放页/歌词页（同一循环，与页无关）调不了音量。
+ *
+ * 本测复现 run_now_playing() 的按键动作应用（np_apply_key_actions）：音量键走
+ * settings_volume_adj(±step)、播放键走 meow_media_playctl（按会话当前态 1=播放 2=暂停）。
+ * 断言：
+ *   K1 音量减边沿 → settings_volume_adj(-step)；
+ *   K2 音量加边沿 → settings_volume_adj(+step)；
+ *   K3 播放键边沿 + 会话正在播放 → meow_media_playctl(2,0)（暂停）；
+ *   K4 播放键边沿 + 会话已暂停 → meow_media_playctl(1,0)（播放）；
+ *   K5 播放键边沿 + 无会话 → 不下发（空态不误报）；
+ *   K6 无任何边沿 → 两个回调都不触发；
+ *   K7 音量/播放边沿都会更新 last_input（自动息屏计时复位）。
+ *
+ * 编译（在 patch_v2/meow_launcherd 下）：
+ *   gcc -Wall -Wextra -I../sdk -I. -ffunction-sections -fdata-sections \
+ *       -Wl,--gc-sections -DMEOW_NP_KEYS_TEST \
+ *       test_np_keys.c -o test_np_keys
+ *   ./test_np_keys
+ * 说明：now_playing.c 用 #include 同 TU 平移（惯例同 test_vol_ramp_jack）；-ffunction-sections
+ *       + --gc-sections 只保留 np_apply_key_actions 及其依赖，其余（渲染/控件/绘制）被回收，
+ *       故仅需桩 settings_volume_adj/settings_volume_step/meow_media_playctl/now_ms/logmsg。
+ */
+#include "now_playing.c"   /* 同 TU #include：拿到 static np_apply_key_actions */
+#include <stdio.h>
+#include <string.h>
+
+static int g_fails = 0;
+#define CHECK(cond, name) do { \
+    if (cond) printf("  PASS %s\n", name); \
+    else { printf("  FAIL %s (%s:%d)\n", name, __FILE__, __LINE__); g_fails++; } } while (0)
+
+/* ---- 桩：np_apply_key_actions 依赖的 launcher 外部符号 ---- */
+int settings_volume_step = 5;
+static int g_adj_count = 0, g_adj_delta = 0;
+void settings_volume_adj(int delta) { g_adj_count++; g_adj_delta = delta; }
+
+static int g_playctl_count = 0;
+static uint32_t g_playctl_cmd = 0;
+static int64_t g_playctl_seek = 0;
+int meow_media_playctl(uint32_t cmd, int64_t seek_ms)
+{ g_playctl_count++; g_playctl_cmd = cmd; g_playctl_seek = seek_ms; return 0; }
+
+static unsigned long long g_now = 100000;
+unsigned long long now_ms(void) { return g_now; }
+
+void logmsg(const char *fmt, ...) { (void)fmt; }
+
+/* 会话（meow_media_session_t 来自 meow_media.h，含 state 字段） */
+static meow_media_session_t g_s;
+
+static void reset_callbacks(void)
+{
+    g_adj_count = 0; g_adj_delta = 0;
+    g_playctl_count = 0; g_playctl_cmd = 0; g_playctl_seek = 0;
+}
+
+int main(void)
+{
+    memset(&g_s, 0, sizeof g_s);
+    unsigned long long last_input = 0;
+
+    /* K1 音量减边沿 → settings_volume_adj(-step) */
+    reset_callbacks(); last_input = 0; g_now = 100000;
+    np_apply_key_actions(1, 0, 0, &g_s, &last_input);
+    CHECK(g_adj_count == 1 && g_adj_delta == -settings_volume_step,
+          "K1 vol-down edge -> settings_volume_adj(-step)");
+    CHECK(last_input == g_now, "K7a vol-down updates last_input");
+
+    /* K2 音量加边沿 → settings_volume_adj(+step) */
+    reset_callbacks(); last_input = 0; g_now = 100050;
+    np_apply_key_actions(0, 1, 0, &g_s, &last_input);
+    CHECK(g_adj_count == 1 && g_adj_delta == +settings_volume_step,
+          "K2 vol-up edge -> settings_volume_adj(+step)");
+    CHECK(last_input == g_now, "K7b vol-up updates last_input");
+
+    /* K3 播放键边沿 + 正在播放 → MSG_PLAYCTL(2,0) 暂停 */
+    g_s.state = MEOW_MEDIA_PLAYING;
+    reset_callbacks();
+    np_apply_key_actions(0, 0, 1, &g_s, &last_input);
+    CHECK(g_playctl_count == 1 && g_playctl_cmd == 2 && g_playctl_seek == 0,
+          "K3 play edge (playing) -> playctl pause(2)");
+
+    /* K4 播放键边沿 + 已暂停 → MSG_PLAYCTL(1,0) 播放 */
+    g_s.state = MEOW_MEDIA_PAUSED;
+    reset_callbacks();
+    np_apply_key_actions(0, 0, 1, &g_s, &last_input);
+    CHECK(g_playctl_count == 1 && g_playctl_cmd == 1 && g_playctl_seek == 0,
+          "K4 play edge (paused) -> playctl play(1)");
+
+    /* K5 播放键边沿 + 无会话 → 不下发（并仍复位 last_input） */
+    reset_callbacks(); last_input = 0; g_now = 100100;
+    np_apply_key_actions(0, 0, 1, NULL, &last_input);
+    CHECK(g_playctl_count == 0, "K5 play edge (no session) -> no playctl");
+    CHECK(last_input == g_now, "K7c play edge updates last_input (no session)");
+
+    /* K6 无任何边沿 → 两个回调都不触发 */
+    reset_callbacks(); last_input = 0;
+    np_apply_key_actions(0, 0, 0, &g_s, &last_input);
+    CHECK(g_adj_count == 0 && g_playctl_count == 0, "K6 no edge -> no callbacks");
+
+    /* K7 音量递减时播放键不同时触发（音量边沿优先，播放单独判） */
+    g_s.state = MEOW_MEDIA_PLAYING;
+    reset_callbacks();
+    np_apply_key_actions(1, 0, 1, &g_s, &last_input);
+    CHECK(g_adj_count == 1 && g_playctl_count == 1,
+          "K8 vol-down + play_edge both fire (independent)");
+
+    printf("\nRESULT: %s (%d fails)\n", g_fails ? "FAIL" : "ALL PASS", g_fails);
+    return g_fails ? 1 : 0;
+}

patch_v2/meow_launcherd/test_settings_widgets.c

@@ -186,23 +186,29 @@ static void lv_draw(int idx, int x, int y, int w, int h, int state, void *ctx)
     uint32_t textcol = sel ? mt->onPrimaryContainer : mt->onSurface;
     uint32_t subcol  = sel ? mt->onPrimaryContainer : mt->onSurfaceVariant;
 
+    /* MD3 容器化（P0）：行=surface 上 surfaceContainer 圆角卡；段头=surface 上的 primary 段标签（无卡
+     * 无分隔线）；与 settings_page.c set_lv_draw 同构造。 */
+    int cx = x + SET_CARD_X;
+    int cw = w - 2 * SET_CARD_X;
+    int cy = y + 8 / 2;
+    int ch = SET_ITEM_H - 8;
     if (r->ctrl == SC_HEADER) {
-        meow_ui_fill_rect(x, y, w, SET_ITEM_H, mt->surfaceContainerHigh);
         int ty = y + (SET_ITEM_H - thh) / 2;
-        if (ty >= 0) meow_ui_text(x + 16, ty, r->label, mt->font_body, mt->primary);
-        meow_ui_fill_rect(x, y + SET_ITEM_H - 1, w, 1, mt->outlineVariant);
+        if (ty >= 0) meow_ui_text(cx + 16, ty, r->label, mt->font_body, mt->primary);
         return;
     }
-    if (sel) meow_ui_fill_rect(x, y, w, SET_ITEM_H, mt->primaryContainer);
-    else if (press) meow_ui_fill_rect_alpha(x, y, w, SET_ITEM_H, mt->primary, 26);
+    meow_gfx_fill_round(cx, cy, cw, ch, 12, mt->surfaceContainer);
+    if (sel) meow_gfx_fill_round(cx, cy, cw, ch, 12, mt->primaryContainer);
+    else if (press) meow_gfx_fill_round_alpha(cx, cy, cw, ch, 12, mt->primary, 26);
     int ly = y + (SET_ITEM_H - thh) / 2;
+    int rgt = cx + cw - 16;
     switch (r->ctrl) {
     case SC_SWITCH: {
-        meow_ui_text(x + 16, ly, r->label, mt->font_body, textcol);
+        meow_ui_text(cx + 16, ly, r->label, mt->font_body, textcol);
         meow_widget *sw = set_sw_take();
         if (sw) {
             int on = 0; meow_settings_get_switch(r->key, &on);
-            meow_widget_set_rect(sw, x + w - 16 - 56, y + (SET_ITEM_H - 32) / 2, 56, 32);
+            meow_widget_set_rect(sw, rgt - 56, y + (SET_ITEM_H - 32) / 2, 56, 32);
             meow_switch_set(sw, on);
             meow_widget_draw(sw);
         }
@@ -211,26 +217,25 @@ static void lv_draw(int idx, int x, int y, int w, int h, int state, void *ctx)
     case SC_SLIDER: {
         /* 宿主测试不引入 launcher s_draw_slider/s_ui_theme：只验证行文字渲染 + 命中，track 视觉由
          * 真机 s_draw_slider 呈现（settings_page.c set_lv_draw 已复用）。 */
-        meow_ui_text(x + 16, ly, r->label, mt->font_body, textcol);
+        meow_ui_text(cx + 16, ly, r->label, mt->font_body, textcol);
         char vb[32]; s_fmt_value(r, vb, sizeof vb);
-        meow_ui_text(x + w - 16 - meow_ui_text_width(vb, mt->font_body), ly, vb, mt->font_body, subcol);
+        meow_ui_text(rgt - meow_ui_text_width(vb, mt->font_body), ly, vb, mt->font_body, subcol);
         break;
     }
     case SC_LIST: {
-        meow_ui_text(x + 16, ly, r->label, mt->font_body, textcol);
-        meow_ui_text(x + w - 16 - meow_ui_text_width("已连接", mt->font_body), ly, "已连接", mt->font_body, subcol);
+        meow_ui_text(cx + 16, ly, r->label, mt->font_body, textcol);
+        meow_ui_text(rgt - meow_ui_text_width("已连接", mt->font_body), ly, "已连接", mt->font_body, subcol);
         break;
     }
     default: {  /* SC_ENUM / SC_PRESET */
-        meow_ui_text(x + 16, ly, r->label, mt->font_body, textcol);
+        meow_ui_text(cx + 16, ly, r->label, mt->font_body, textcol);
         char vb[40]; s_display_value(r, vb, sizeof vb);
-        int vx = x + w - 16 - meow_ui_text_width(vb, mt->font_body);
+        int vx = rgt - meow_ui_text_width(vb, mt->font_body);
         meow_ui_text(vx, ly, vb, mt->font_body, subcol);
         break;
     }
     }
-    meow_ui_fill_rect(x, y + SET_ITEM_H - 1, w, 1, mt->outlineVariant);
-    if (state & MEOW_LISTVIEW_ST_DISABLED) meow_ui_fill_rect_alpha(x, y, w, SET_ITEM_H, mt->onSurface, 90);
+    if (state & MEOW_LISTVIEW_ST_DISABLED) meow_gfx_fill_round_alpha(cx, cy, cw, ch, 12, mt->onSurface, 90);
 }
 
 static void mk_widgets(void)
@@ -247,7 +252,7 @@ static void draw_all(void)
 {
     const meow_theme *th = meow_theme_get();
     meow_ui_fill_rect(0, 0, XRES, YRES, th->surface);
-    meow_ui_fill_rect(0, SET_LIST_Y, XRES, LV_H, th->surfaceVariant);
+    meow_ui_fill_rect(0, SET_LIST_Y, XRES, LV_H, th->surface);   /* P0：内容底 surface（卡在其上抬升） */
     if (lv) { g_set_sw_use = 0; meow_widget_draw(lv); }
 }
 
@@ -305,16 +310,17 @@ int main(void)
     meow_ui_activity_push(SET_SENTINEL);
     const meow_theme *th = meow_theme_get();
     draw_all();
-    /* 段头行整体填 surfaceContainerHigh（覆盖列表底 surfaceVariant）→ 对列表底背景即非背景；
-     * 注意宿主无 mfont 时 CJK 标题回退点阵不显形，故以「段头底 vs 列表底」判渲染而非文字像素。 */
-    int hdrcnt = region_nonbg(2, SET_LIST_Y + 4, XRES - 4, SET_ITEM_H - 8, th->surfaceVariant);
-    int rowcnt = region_nonbg(2, SET_LIST_Y + SET_ITEM_H + 4, XRES - 4, SET_ITEM_H - 8, th->surfaceVariant);
-    CHECK(hdrcnt > 0, "section header band renders (hdr=%d)", hdrcnt);
-    CHECK(rowcnt > 40, "row band renders (title/value/switch) cnt=%d", rowcnt);
-    /* P1b：开关行（ROWS[2]=最高刷新率 right switch）中心右缘区非背景 */
+    /* MD3 容器化（P0）：段头=surface 上的 primary 段标签（无满幅 band/卡，宿主文本为 no-op →
+     * 段头区应回 surface）；普通行=surfaceContainer 圆角卡（region_nonbg 应见大量非 surface 像素）。
+     * 注意宿主无 mfont 时 CJK 标题回退点阵不显形，故以「卡/段头 vs 列表底」判渲染而非文字像素。 */
+    int hdrcnt = region_nonbg(2, SET_LIST_Y + 4, XRES - 4, SET_ITEM_H - 8, th->surface);
+    int rowcnt = region_nonbg(2, SET_LIST_Y + SET_ITEM_H + 4, XRES - 4, SET_ITEM_H - 8, th->surface);
+    CHECK(hdrcnt == 0, "section header no-band(label-on-surface) nb=%d", hdrcnt);
+    CHECK(rowcnt > 40, "row card renders (title/value/switch) cnt=%d", rowcnt);
+    /* P1b：开关行（ROWS[2]=最高刷新率 right switch）中心右缘区非背景（卡内 switch） */
     {
         int swy = SET_LIST_Y + 2 * SET_ITEM_H + SET_ITEM_H / 2;
-        int swc = region_nonbg(XRES - 16 - 56, swy - 4, 56, 8, th->surfaceVariant);
+        int swc = region_nonbg(XRES - 16 - 56, swy - 4, 56, 8, th->surface);
         CHECK(swc > 0, "switch row right tail (meow_switch) renders swc=%d", swc);
     }
 

patch_v2/meow_launcherd/test_subpage_widgets.c

@@ -125,6 +125,7 @@ static void mk_widgets(void)
     meow_listview_set_vsource(lv, sp_lv_count, sp_lv_bind, NULL);
     meow_listview_set_item_renderer(lv, 2, 0, 1);
     meow_listview_set_item_h(lv, SUB_ITEM_H);
+    meow_listview_set_container(lv, 1);   /* MD3 容器模式（M7.1a P0）：圆角卡+空隙+去分隔线 */
     sw = meow_switch_create(XRES - 16 - 56, SUB_TB_Y + (SUB_TB_H - 32) / 2, 1);
     meow_ui_activity_pop();
 }
@@ -153,12 +154,14 @@ int main(void)
     meow_ui_activity_push(SUB_SENTINEL);
     const meow_theme *th = meow_theme_get();
     draw_all();
+    /* MD3 容器模式：段头=surface 上的 primary 段标签（无满幅 band/卡，宿主文本为 no-op →
+     * 段头区应回 surface）；普通行=surfaceContainer 圆角卡（region_nonbg 应见大量非 surface 像素）。 */
     int hdrcnt = region_nonbg(2, SUB_CONT_TOP + 4, XRES - 4, SUB_ITEM_H - 8, th->surface);
     int rowcnt = region_nonbg(2, SUB_CONT_TOP + SUB_ITEM_H + 4, XRES - 4, SUB_ITEM_H - 8, th->surface);
     char nm[80];
-    snprintf(nm, sizeof nm, "section header renders (band=%d)", hdrcnt);
-    CHECK(hdrcnt > 0, "%s", nm);
-    snprintf(nm, sizeof nm, "row renders (title hdr/switch/arrow) cnt=%d", rowcnt);
+    snprintf(nm, sizeof nm, "section header no-band(label-on-surface) nb=%d", hdrcnt);
+    CHECK(hdrcnt == 0, "%s", nm);
+    snprintf(nm, sizeof nm, "row renders (card) cnt=%d", rowcnt);
     CHECK(rowcnt > 40, "%s", nm);
 
     /* ============ P2 listview 命中（行号 + right 操作区） ============ */
@@ -190,6 +193,7 @@ int main(void)
     meow_listview_set_vsource(scroll_lv, big_count, big_bind, NULL);
     meow_listview_set_item_renderer(scroll_lv, 2, 0, 1);
     meow_listview_set_item_h(scroll_lv, SUB_ITEM_H);
+    meow_listview_set_container(scroll_lv, 1);   /* 与子页一致：MD3 容器模式 */
     meow_scroll *s = meow_scroll_wrap(scroll_lv, 1);   /* 1=W_LISTVIEW */
     CHECK(s != NULL, "meow_scroll_wrap(listview)");
     int maxs = meow_listview_max_scroll(scroll_lv);

patch_v2/meow_launcherd/wifi_page.c

@@ -19,6 +19,7 @@
 #define WF_ACT_CURR     (-1)        /* 当前连接（SUB_ROW，detail） */
 #define WF_ACT_SAVED    0           /* 已保存网络 idx（SUB_ACT，connect） */
 #define WF_ACT_SCAN_BASE 1000       /* 附近网络 1000+idx（SUB_ROW，连接） */
+#define WF_ACT_MANUAL   2000        /* 「手动添加隐藏网络」动作行（SUB_ACT，connecth） */
 
 typedef struct {
     meow_net_t saved[S_NET_MAX];
@@ -122,13 +123,22 @@ static int wifi_rows(void *ctx, sub_row_t *rbuf, int max)
         rbuf[n].on = 0; rbuf[n].act = WF_ACT_SCAN_BASE + i;
         n++;
     }
+    /* bug2：附近网络末尾的「手动添加隐藏网络」入口（SUB_ACT → wifi_act）。 */
+    if (n < max) {
+        rbuf[n].kind = SUB_ACT;
+        rbuf[n].label = "手动添加隐藏网络";
+        rbuf[n].sub = "";
+        rbuf[n].on = 0;
+        rbuf[n].act = WF_ACT_MANUAL;
+        n++;
+    }
     return n;
 }
 
 
-/* SDK IME 输密码（PW 模式=ASCII 软键盘输入，现有输入法复用；回车提交/ESC或点背景取消）。
+/* SDK IME 通用文本输入（MEOW_IME_ASCII：QWERTY，顶条「中」可切拼音输中文 SSID）。
  * 返回 1=已输入；0=取消。 */
-static int wifi_ask_psk(char *psk, int maxlen)
+static int wifi_ask_text(char *out, int maxlen)
 {
     meow_ime_ctx ic;
     memset(&ic, 0, sizeof ic);
@@ -136,36 +146,72 @@ static int wifi_ask_psk(char *psk, int maxlen)
     ic.maxlen = maxlen;
     ic.buf[0] = 0;
     int res = meow_ui_text_input(&ic);      /* 阻塞：提交后 ctx.buf 回填最终文本 */
-    if (res && ic.buf[0]) { snprintf(psk, maxlen, "%s", ic.buf); return 1; }
+    if (res && ic.buf[0]) { snprintf(out, maxlen, "%s", ic.buf); return 1; }
     return 0;
 }
 
 
+/* bug1：connect 阻塞前画非模态「正在连接…」横幅。子页单线程，阻塞期间画面停在此横幅。 */
+static void wifi_connecting_banner(const char *ssid)
+{
+    const meow_ui_theme_t *th = s_ui_theme();
+    int W = meow_ui_width();
+    int y = 108, h = 44;
+    char line[160];
+    snprintf(line, sizeof line, "正在连接 %s ...", ssid && ssid[0] ? ssid : "网络");
+    meow_ui_fill_rect(0, y, W, h, th->surface_container);
+    meow_ui_text_center(W / 2, y + h / 2 - meow_ui_text_height(20) / 2, line, 20, th->on_surface);
+    meow_dirty_full();
+    meow_ui_flush();
+}
+
+
+/* bug2：手动添加隐藏网络（附近网络占位行点击 / 「手动添加隐藏网络」动作行共用）。 */
+static void wifi_manual_add(wifi_ctx_t *c)
+{
+    char ssid[96] = "";
+    if (!wifi_ask_text(ssid, sizeof ssid)) return;
+    const char *items[2];
+    items[0] = "加密网络（WPA/WPA2/WPA3）";
+    items[1] = "开放网络";
+    int pick = s_dd_modal("网络加密方式", items, 2, -1);
+    if (pick < 0) return;
+    int open = (pick == 1);
+    char psk[96] = "";
+    if (!open && !wifi_ask_text(psk, sizeof psk)) return;
+    char err[160]; err[0] = 0;
+    wifi_connecting_banner(ssid);
+    int rc = nm_wifi_connect_ex(ssid, open ? NULL : psk, 1, err, sizeof err);
+    char line[192]; const char *txt[1]; txt[0] = line;
+    snprintf(line, sizeof line, "%s", err[0] ? err : (rc == MEOW_OK ? "已连接" : "连接失败"));
+    logmsg("wifi_page: manual connect ssid=%s hidden=1 open=%d rc=%d err=%s", ssid, open, rc, err);
+    s_dd_modal(ssid, txt, 1, -1);
+    nm_wifi_scan_trigger();
+    c->last_scan_ms = now_ms();
+}
+
+
 /* 附近网络点选 →【WiFi 新网络录入】连接流程。返回 1=重绘。 */
 static int wifi_connect_scan(wifi_ctx_t *c, int scan_idx)
 {
     if (scan_idx < 0 || scan_idx >= c->scan_n) return 0;
     meow_net_t *s = &c->scan[scan_idx];
     if (!s->name[0] || !strcmp(s->name, "(隐藏网络)")) {
-        const char *txt[1]; txt[0] = "隐藏网络无法直接连接";
-        s_dd_modal("附近网络", txt, 1, -1);
+        wifi_manual_add(c);            /* bug2：占位隐藏网络 → 手动录入（SSID 待输） */
         return 1;
     }
     int open = (s->sec[0] == 0 || !strcmp(s->sec, "Open"));
     char psk[96] = "";
     if (!open) {
-        if (!wifi_ask_psk(psk, sizeof psk)) return 1;    /* 用户取消输密码 */
+        if (!wifi_ask_text(psk, sizeof psk)) return 1;    /* 用户取消输密码 */
     }
     char err[160]; err[0] = 0;
+    wifi_connecting_banner(s->name);   /* bug1：阻塞前横幅，避免「点完无反馈」 */
     int rc = nm_wifi_connect(s->name, open ? NULL : psk, err, sizeof err);
     char line[192];
     const char *txt[1]; txt[0] = line;
-    if (rc == MEOW_OK) {
-        snprintf(line, sizeof line, "连接成功：%s%s", s->name,
-                 err[0] ? "" : "（已启用）");
-    } else {
-        snprintf(line, sizeof line, "连接失败：%s", err[0] ? err : "netmgr 返回错误");
-    }
+    /* bug1：结果文案直接采用 netmgrd/直连回填的诚实文本（成功含 ip / 失败含原因）。 */
+    snprintf(line, sizeof line, "%s", err[0] ? err : (rc == MEOW_OK ? "已连接" : "连接失败"));
     logmsg("wifi_page: scan connect ssid=%s open=%d rc=%d err=%s", s->name, open, rc, err);
     /* 连接结果反馈（成功后进已保存网络列表由 rows() 重扫刷新） */
     s_dd_modal(s->name, txt, 1, -1);
@@ -208,20 +254,23 @@ static int wifi_detail(void *ctx, int idx, int act)
 }
 
 
-/* 动作行（SUB_ACT）点击：已保存网络 → netmgr connect（ssid；复用既有网络） */
+/* 动作行（SUB_ACT）点击：已保存网络 → netmgr connect（ssid；复用既有网络）。
+ * 另承接「手动添加隐藏网络」入口（bug2）。 */
 static int wifi_act(void *ctx, int idx, int act)
 {
     (void)idx;
     wifi_ctx_t *c = ctx;
+    if (act == WF_ACT_MANUAL) { wifi_manual_add(c); return 1; }
     if (act >= WF_ACT_SCAN_BASE) return 0;      /* 附近是 SUB_ROW(detail)，不走这里 */
     int sidx = act - WF_ACT_SAVED;
     if (sidx < 0 || sidx >= c->saved_n) return 0;
     if (c->saved[sidx].id < 0) return 0;
     char err[160]; err[0] = 0;
+    wifi_connecting_banner(c->saved[sidx].name);   /* bug1：阻塞前横幅 */
     int rc = nm_wifi_connect(c->saved[sidx].name, NULL, err, sizeof err);
     char line[192]; const char *txt[1]; txt[0] = line;
-    if (rc == MEOW_OK) snprintf(line, sizeof line, "已连接：%s", c->saved[sidx].name);
-    else               snprintf(line, sizeof line, "连接失败：%s", err[0] ? err : "netmgr 返回错误");
+    /* bug1：结果文案直接采用 netmgrd/直连回填的诚实文本（成功含 ip / 失败含原因）。 */
+    snprintf(line, sizeof line, "%s", err[0] ? err : (rc == MEOW_OK ? "已连接" : "连接失败"));
     logmsg("wifi_page: saved connect ssid=%s rc=%d err=%s", c->saved[sidx].name, rc, err);
     s_dd_modal(c->saved[sidx].name, txt, 1, -1);
     nm_wifi_scan_trigger();