fix(sdk+launcher): 图标不渲染真根因(agent-219) — meow_ui_img.c scale_buf cover 采样把乘写成除(÷缩放比→采到源图左上角透明区,全丢); 改乘+居中裁剪偏移修正; 宿主旧测试用纯色图掩盖了该bug。+ main_menu App退出/结构变化重绘时 fb_pan_buf0_force 无条件pan回buffer0(防App翻页留buffer1致菜单残帧)

meow_ui.a→3e0ee8f7 launcher→9d0efc2f hello→9609ea6e files→90f5cf07 ncm→be8be221(均已上卡); 真机截图证据 .tmp/meowbug/fix1.png+fix_b2_after.png

patch_v2/meow_launcherd/app_launcher.c

@@ -63,6 +63,14 @@ static void ams_send(const char *payload, int len)
     close(fd);
 }
 
+/* 公开 amsd 上报通道包装（AMSD_DESIGN §6.2 二期）：util.c 转发运行时 declare / picker
+ * call/result 给 amsd 用。语义与 ams_send 一致：best-effort、单次 connect+write+close、
+ * 失败静默丢（amsd 不在不影响 launcher）。 */
+void meow_ams_send(const char *payload, int len)
+{
+    ams_send(payload, len);
+}
+
 /* launch 上报：pkg/activity/chain/pid。amsd 建表项 + 开 stdout 会话。 */
 static void ams_report_launch(const struct app *a, const char *chain, pid_t pid)
 {
@@ -223,6 +231,54 @@ int meow_ams_kill_pending(const char *pkg)
     return 1;
 }
 
+/* ---- AMSD_DESIGN §6.2 二期：picker 上下文（随 pending-start 置位，launch_app_chain 消费后清）----
+ * amsd `am picker` → MSG_AMS_START 扩载荷（picker=1）→ ipc_dispatch 经 set_ex 置位 + 武装
+ * g_ams_pick_armed；main_menu 消费 pending-start（照旧 launch_app/launch_activity）时，
+ * launch_app_chain 读到武装位 → 注入 MEOW_PICKER_ACTION/REQ_ID/CALLER 到子进程 → 解除武装。
+ * 单一写者（ipc_dispatch / launch_app_chain），且同一时刻仅一个 pending-start 在飞（v1 单前台 App），
+ * 故武装位不会错配到非 picker 启动。 */
+static char     g_ams_pick_action[24];
+static char     g_ams_pick_caller[MEOW_APP_ID_MAX];
+static uint32_t g_ams_pick_req;
+static int      g_ams_pick_armed;
+
+int meow_ams_pending_start_set_ex(const char *pkg, const char *act,
+                                  const char *pick_action, uint32_t pick_req,
+                                  const char *pick_caller)
+{
+    int rc = meow_ams_pending_start_set(pkg, act);
+    if (rc != 0) return rc;                          /* 拒绝（有前台 App / 参数非法） */
+    g_ams_pick_action[0] = 0;
+    g_ams_pick_caller[0] = 0;
+    g_ams_pick_req = 0;
+    g_ams_pick_armed = 0;
+    if (pick_action && pick_action[0]) {
+        snprintf(g_ams_pick_action, sizeof g_ams_pick_action, "%s", pick_action);
+        if (pick_caller) snprintf(g_ams_pick_caller, sizeof g_ams_pick_caller, "%s", pick_caller);
+        g_ams_pick_req = pick_req;
+        g_ams_pick_armed = 1;
+    }
+    return 0;
+}
+
+/* 子进程 exec 前注入 picker env（action/req/caller 已由 launch_app_chain 入口捕获并解除全局武装，
+ * 即使启动失败不再错配到下一次普通启动）。返回注入后的 ne。 */
+static int ams_push_picker_env(char **envp, int ne, const char *action,
+                               uint32_t req, const char *caller)
+{
+    if (!action || !action[0]) return ne;
+    /* envp 容量 48：此处 +3 仍在界内（见 launch_app_chain envp[48] 注释） */
+    static char e_act[40], e_req[40], e_caller[MEOW_APP_ID_MAX + 20];
+    snprintf(e_act, sizeof e_act, "MEOW_PICKER_ACTION=%s", action);
+    snprintf(e_req, sizeof e_req, "MEOW_PICKER_REQ_ID=%u", req);
+    snprintf(e_caller, sizeof e_caller, "MEOW_PICKER_CALLER=%s", caller ? caller : "");
+    envp[ne++] = e_act;
+    envp[ne++] = e_req;
+    envp[ne++] = e_caller;
+    logmsg("launch: picker env action=%s req=%u caller=%s", action, req, caller ? caller : "");
+    return ne;
+}
+
 
 /* ---- 阶段 D · M1：路由注册表辅助（主循环单写者，无锁）---- */
 struct meow_acct *meow_acct_find(const char *app_id)
@@ -1179,6 +1235,17 @@ static int run_app_notif_overlay(struct app *a, pid_t pid)
 static int launch_app_chain(struct app *a, const char *chain)
 {
     logmsg("launch: %s (%s) chain=\"%s\"", a->name, a->exec, chain ? chain : "");
+    /* §6.2 二期：入口即捕获 picker 上下文并解除全局武装——即便后续 exec 失败（!a->ok）返回，
+     * 武装位也已清，不会错配到下一次普通启动（单飞不泄漏）。 */
+    char pick_action[24] = "";
+    char pick_caller[MEOW_APP_ID_MAX] = "";
+    uint32_t pick_req = 0;
+    if (g_ams_pick_armed) {
+        snprintf(pick_action, sizeof pick_action, "%s", g_ams_pick_action);
+        snprintf(pick_caller, sizeof pick_caller, "%s", g_ams_pick_caller);
+        pick_req = g_ams_pick_req;
+        g_ams_pick_armed = 0;
+    }
     if (!a->ok) { logmsg("launch blocked: exec not ok"); return -1; }
     meow_nav_begin(a->id, chain);   /* M3：冷启动/裸启动都以当前链深初始化导航栈（chain 空→depth 0） */
 
@@ -1369,6 +1436,8 @@ static int launch_app_chain(struct app *a, const char *chain)
             envp[ne++] = env_chain;
             logmsg("launch: M3 env %s / %s", env_act, env_chain);
         }
+        /* AMSD_DESIGN §6.2 二期：picker handler 启动注入（捕获值来自 launch_app_chain 入口）。 */
+        ne = ams_push_picker_env(envp, ne, pick_action, pick_req, pick_caller);
         envp[ne] = NULL;
         execve(a->exec, argv, envp);
         int e = errno;

patch_v2/meow_launcherd/main_menu.c

@@ -339,6 +339,7 @@ static meow_img *menu_app_icon_load(const struct app *a)
         snprintf(p, sizeof p, "/usr/data/mnt/sd_0/%s", a->icon);
         img = meow_img_load_file(p);
     }
+    logmsg("icon: %s -> %s %s", a->id[0] ? a->id : a->name, p, img ? "OK" : "FAIL");   /* M2.87 排查 */
     return img;
 }
 
@@ -1574,14 +1575,23 @@ static void run_menu(struct app apps[MAX_APPS], int napps, int state,
             need_menu_paint = 1;
             dirty = 0;
         }
+        /* Bug2 残帧防护 (agent-x)：App 退出/结构变化触发全帧重画时，用 fb_pan_buf0_force()
+         * 无条件把 LCDC pan 回 buffer0（菜单/所有 app 都画 buffer0 且从不自己 pan）。仅
+         * fb_norm_buf0() 会在缓存的 fb_active_yoffset==0 时短路——若 App 运行期把物理
+         * yoffset 留到了 buffer1（如其内部双缓冲翻页），缓存仍为 0 导致真正的 re-pan 从未
+         * 发出，重画后的菜单落在 buffer0 而 LCDC 仍显示 buffer1 的 App 残帧（=菜单区残帧）。
+         * 只在真重画（need_menu_paint）时 force-pan，不每圈 ioctl；重复 pan 到同一 yoffset
+         * 是硬件 no-op，无频闪（fb_pan_buf0_force 注释）。 */
         if (need_menu_paint) {
             draw_menu(apps, napps, state, cursor, toast_ms, toast);   /* 全画 SDK back_buf（RAM，快） */
+            fb_pan_buf0_force();   /* 真重画 → 无条件 pan 回 buffer0（防 App 残留 buffer1） */
             need_menu_paint = 0;
+        } else {
+            fb_norm_buf0();   /* 无重画 → 短路；yoffset 非 0 才 pan */
         }
         /* A-1/A-2：呈现统一走 SDK meow_ui_flush()（内含帧率门控；无脏返回，门控未达期保留脏
          * 待下一轮）。fb_norm_buf0 确保 LCDC 显示 buffer0（yoffset 非 0 才 pan，短路无开销）。
          * 不再用 launcher 的 g_ndirty/g_dirty_full 做呈现门——SDK present 自会 no-op 于空脏。 */
-        fb_norm_buf0();   /* Bug 3：确保 LCDC 显示 buffer0 */
         meow_ui_flush();  /* M2.16 无闪烁 + M2.16 帧率门控归口 SDK */
         if (toast_ms > 0) {
             toast_ms -= POLL_MS;

patch_v2/meow_launcherd/meow_ipc.h

@@ -64,12 +64,14 @@ enum {
     MSG_PERF_RESULT  = 0x0051,   /* ↓ 聚合 JSON（perf/system 子集） */
     MSG_POWER_ACTION = 0x0060,   /* ↑ 电源/系统动作信号（专项服务 meow_svc_power） */
     MSG_POWER_STATUS = 0x0061,   /* ↓ 动作受理/结果 + 状态文本 */
-    /* ---- 【预留 · 本批不实现】picker：带返回值的跨 App 调用（M3 延伸，只留协议位）----
-     * 语义：App A 经 MSG_PICKER_CALL 请求 App B 弹一个 selector 并返回所选值（如文件/音轨
-     * 选择器）。属「跨 App 带返回值」调用，与单向业务通知（MSG_NOTIFY）不同；负载/应答结构
-     * 待 M3 延伸阶段定义（m_picker_call_t / m_picker_result_t），此处仅固定消息号与方向。 */
-    MSG_PICKER_CALL   = 0x0070,   /* ↑ 请求跨 App picker 调用（发起方 A → 持有方 B） */
-    MSG_PICKER_RESULT = 0x0071,   /* ↓ picker 返回值（候选结果回 A） */
+    /* ---- picker：带返回值的跨 App 调用（M3 延伸，AMSD_DESIGN §6.2 二期已落地）----
+     * 语义：App A 经 MSG_PICKER_CALL 请求 App B 弹一个 selector 并返回所选值（如文件选择器）。
+     * amsd 为路由/决策者：它查 picker 表（app.json `picker.<action>=<chain>`）决定 handler App，
+     * 经 MSG_AMS_START（扩载荷含 picker 上下文）拉起 handler；handler 结果经 MSG_PICKER_RESULT
+     * 回传，launcher 转发 amsd 记录。属「跨 App 带返回值」调用。负载结构见下方
+     * m_picker_call_t / m_picker_result_t。 */
+    MSG_PICKER_CALL   = 0x0070,   /* ↑ 请求跨 App picker 调用（发起方 A → 持有方 B；→launcher→amsd） */
+    MSG_PICKER_RESULT = 0x0071,   /* ↑ picker 返回值（候选结果回 A；→launcher→amsd） */
     MSG_META          = 0x0072,   /* ↑ 媒体会话上报元数据/进度/状态（阶段 D 附录 B） */
     MSG_PLAYCTL       = 0x0073,   /* ↓ 播放控制下发/↑ 控制器转发到最近活跃媒体会话 */
     /* ---- amsd 控制（AMSD_DESIGN §4.2）：amsd→launcher，申请拉起/终止某 App ----
@@ -326,15 +328,45 @@ typedef struct m_power_status {
 /* ---- amsd 控制（AMSD_DESIGN §4.2）---- */
 
 /* MSG_AMS_START →：请求 launcher 拉起某 App。app_id=包名（权威）；activity 空=裸启动
- *   （launcher launch_app），非空=resolve_chain+launch_activity。 */
+ *   （launcher launch_app），非空=resolve_chain+launch_activity。
+ *   picker 上下文（二期）：picker=1 时本次启动为「picker handler 调用」——launcher 注入 env
+ *   MEOW_PICKER_ACTION/MEOW_PICKER_REQ_ID/MEOW_PICKER_CALLER 到子进程；handler App 据此进入
+ *   picker 模式，选完后经 MSG_PICKER_RESULT 回传。 */
 typedef struct m_ams_start {
     char     app_id[MEOW_APP_ID_MAX];   /* 32 */
     char     activity[MEOW_ACT_MAX];    /* 64；空=裸启动 */
-} m_ams_start_t;                        /* 96 B */
+    uint32_t picker;                    /* 1=带 picker 上下文（注入 MEOW_PICKER_*） */
+    uint32_t picker_req_id;             /* picker 请求号（回显到结果） */
+    char     picker_action[24];         /* picker action（如 "pick_file"）；picker=0 忽略 */
+    char     picker_caller[MEOW_APP_ID_MAX]; /* 32：发起方 app_id（""=系统/CLI） */
+} m_ams_start_t;                        /* 160 B */
 
 /* MSG_AMS_KILL →：请求 launcher 终止某 App（SIGTERM 语义，执行器=launcher）。 */
 typedef struct m_ams_kill {
     char     app_id[MEOW_APP_ID_MAX];   /* 32 */
 } m_ams_kill_t;                         /* 32 B */
 
+/* ---- picker 负载（二期）---- */
+
+/* MSG_PICKER_CALL ↑：发起跨 App picker 调用（App A → launcher → amsd 路由；或 amsd 内部）。
+ *   caller=发起方 app_id（""=系统/CLI）；req_id=调用方自填（结果/PICKER_RESULT 回显）；
+ *   action=要调用的 picker 类型（如 "pick_file"）；hint=初始目录等提示（空=缺省）。 */
+typedef struct m_picker_call {
+    char     caller[MEOW_APP_ID_MAX];   /* 32 */
+    uint32_t req_id;                    /* 调用方请求号 */
+    char     action[24];                /* picker action */
+    char     hint[128];                 /* 提示（初始目录等）；空=缺省 */
+    uint32_t flags;                     /* 预留 */
+} m_picker_call_t;                      /* 192 B */
+
+/* MSG_PICKER_RESULT ↑：picker 返回值（handler App → launcher → amsd）。caller/req_id/action
+ *   回显调用方；code=MEOW_OK/MEOW_ERR_*；value=返回项（路径/文本；空=用户取消）。 */
+typedef struct m_picker_result {
+    char     caller[MEOW_APP_ID_MAX];   /* 32：回显发起方（""=系统/CLI） */
+    uint32_t req_id;                    /* 回显请求号 */
+    char     action[24];                /* 回显 action */
+    uint32_t code;                      /* MEOW_OK / MEOW_ERR_* */
+    char     value[256];                /* 返回项（路径/文本）；空=cancel */
+} m_picker_result_t;                    /* 320 B */
+
 #endif /* MEOW_IPC_H */

patch_v2/meow_launcherd/meow_launcher_internal.h

@@ -644,12 +644,20 @@ void meow_nav_report(const char *app_id, uint32_t depth, const char *current);
 void meow_nav_exit(void);                 /* 清栈（应用退出/EXIT） */
 void meow_nav_request_exit(void);         /* MSG_NAV{EXIT}：置位让前台 waitpid 循环终止 app */
 int  meow_nav_exit_pending(void);         /* 读取并清除退出请求（前台 launch_* 循环轮询） */
-/* ---- amsd 控制挂点（AMSD_DESIGN §4.3）：主循环单写者，跨模块声明 ----
+/* ---- amsd 控制挂点（AMSD_DESIGN §4.3 / §6.2 二期）：主循环单写者，跨模块声明 ----
  * pending-start/kill 仅在主循环上下文写入与消费（ipc_dispatch 写、run_menu 前台循环/菜单循环读）。 */
 int  meow_ams_pending_start_set(const char *pkg, const char *act); /* 有前台 App 时拒绝(返回 -MEOW_ERR_BUSY) */
 int  meow_ams_take_start(char *pkg, int pn, char *act, int an);    /* 1=取到待拉起 App（清位）；0=无 */
 void meow_ams_pending_kill_set(const char *pkg);                   /* 请求终止某 pkg */
 int  meow_ams_kill_pending(const char *pkg);                       /* 匹配则清除并返回 1（前台循环轮询） */
+/* §6.2 二期：带 picker 上下文的 pending-start（amsd `am picker` 经 MSG_AMS_START 扩载荷）。
+ * pick_action 非空 → launch_app_chain 注入 MEOW_PICKER_ACTION/REQ_ID/CALLER 到子进程。 */
+int  meow_ams_pending_start_set_ex(const char *pkg, const char *act,
+                                   const char *pick_action, uint32_t pick_req,
+                                   const char *pick_caller);
+/* §6.2 二期：amsd 上报通道（best-effort，app_launcher.c 的 ams_send 公开包装）。
+ * util.c 转发运行时 declare 与 picker call/result 给 amsd 用。 */
+void meow_ams_send(const char *payload, int len);
 
 void meow_dac_vol_write(int pct);
 void meow_dac_vol_write_throttled(void);

patch_v2/meow_launcherd/util.c

@@ -1097,6 +1097,32 @@ void meow_ipc_process(void)
 }
 
 
+/* ---- AMSD_DESIGN §6.2 二期：launcher → amsd 转发工具（best-effort）---- */
+
+/* hex 编码二进制/字符串到 out（小写 2 字符/字节）。返回编码字节数。 */
+static int ams_hex_encode(const unsigned char *src, int slen, char *out, int outsz)
+{
+    static const char *hx = "0123456789abcdef";
+    int n = 0;
+    for (int i = 0; i < slen && n + 2 < outsz; i++) {
+        out[n++] = hx[src[i] >> 4];
+        out[n++] = hx[src[i] & 15];
+    }
+    out[n] = 0;
+    return n;
+}
+
+/* m_act_declare_t.entries 为 count 个 NUL 结尾 "id=chain" 串的拼接；返回其字节长（含 NUL）。 */
+static int declare_entries_len(const m_act_declare_t *d)
+{
+    const char *p = d->entries;
+    for (int k = 0; k < d->count && *p; k++) {
+        while (*p) p++;
+        p++;
+    }
+    return (int)(p - d->entries);
+}
+
 /* 处理一条入队帧：HELLO→ACK、ACT_QUERY→ACT_RESULT/ERR、ACT_DECLARE→ACK、其他→ERR。 */
 static void ipc_dispatch(struct meow_ipc_msg *m)
 {
@@ -1125,6 +1151,18 @@ static void ipc_dispatch(struct meow_ipc_msg *m)
         a.status = (uint32_t)g_naccts;
         ipc_send(m->fd, MSG_ACK, m->req_id, &a, sizeof a);
         logmsg("ipc: ACT_DECLARE app=%s n=%u -> ACK", d.app_id, d.count);
+        /* AMSD_DESIGN §6.2 二期：运行时 declare 转发 amsd（权威表增量；amsd 不在→静默丢）。
+         * entries 载荷 hex 编码（含 NUL 分隔），amsd 解码后并集覆盖。 */
+        {
+            int elen = declare_entries_len(&d);
+            if (elen > 0) {
+                char hex[2 * MEOW_IPC_CARGO + 8];
+                (void)ams_hex_encode((const unsigned char *)d.entries, elen, hex, sizeof hex);
+                char fwd[2 * MEOW_IPC_CARGO + 80];
+                int fl = snprintf(fwd, sizeof fwd, "DECLARE %s %d %s\n", d.app_id, (int)d.count, hex);
+                if (fl > 0) meow_ams_send(fwd, fl);
+            }
+        }
         break;
     }
     case MSG_ACT_QUERY: {
@@ -1214,12 +1252,21 @@ static void ipc_dispatch(struct meow_ipc_msg *m)
         memcpy(&s, m->payload, m->plen < (uint16_t)sizeof s ? m->plen : (uint16_t)sizeof s);
         s.app_id[MEOW_APP_ID_MAX - 1] = 0;
         s.activity[MEOW_ACT_MAX - 1] = 0;
-        int rc = meow_ams_pending_start_set(s.app_id, s.activity);
+        s.picker_action[23] = 0;
+        s.picker_caller[MEOW_APP_ID_MAX - 1] = 0;
+        /* §6.2 二期：Picker 上下文（picker=1 且 action 非空）→ 置位武装位，launch_app_chain 注入 env */
+        int rc;
+        if (s.picker)
+            rc = meow_ams_pending_start_set_ex(s.app_id, s.activity,
+                                               s.picker_action, s.picker_req_id, s.picker_caller);
+        else
+            rc = meow_ams_pending_start_set(s.app_id, s.activity);
         m_ack_t a;
         a.code = (uint32_t)(rc < 0 ? -rc : MEOW_OK);   /* 0=OK；MEOW_ERR_BUSY=有前台 App */
         a.status = 0;
         ipc_send(m->fd, MSG_ACK, m->req_id, &a, sizeof a);
-        logmsg("ipc: AMS_START app=%s act=\"%s\" -> ACK code=%u", s.app_id, s.activity, a.code);
+        logmsg("ipc: AMS_START app=%s act=\"%s\" picker=%u req=%u -> ACK code=%u",
+               s.app_id, s.activity, s.picker, s.picker_req_id, a.code);
         break;
     }
     case MSG_AMS_KILL: {
@@ -1239,6 +1286,47 @@ static void ipc_dispatch(struct meow_ipc_msg *m)
         logmsg("ipc: AMS_KILL app=%s -> ACK code=%u", k.app_id, a.code);
         break;
     }
+    /* AMSD_DESIGN §6.2 二期：picker 跨 App 调用（App A → launcher → amsd 路由）。
+     * launcher 仅转发 amsd + ACK 发起方（best-effort；结果经 MSG_PICKER_RESULT 回路记录）。
+     * 诚实出入：A 发送后即断开，amsd 结果暂时落记录（picker-status 可查），push 回 A 需
+     * 将来 MSG_REGISTER 会话通道（M4）。 */
+    case MSG_PICKER_CALL: {
+        m_picker_call_t p;
+        memset(&p, 0, sizeof p);
+        memcpy(&p, m->payload, m->plen < (uint16_t)sizeof p ? m->plen : (uint16_t)sizeof p);
+        p.caller[MEOW_APP_ID_MAX - 1] = 0;
+        p.action[23] = 0;
+        m_ack_t a;
+        a.code = MEOW_OK;
+        a.status = 0;
+        ipc_send(m->fd, MSG_ACK, m->req_id, &a, sizeof a);
+        char fwd[96];
+        int fl = snprintf(fwd, sizeof fwd, "PICKER_CALL %s %u %s\n", p.caller, p.req_id, p.action);
+        if (fl > 0) meow_ams_send(fwd, fl);
+        logmsg("ipc: PICKER_CALL caller=%s req=%u act=%s -> ACK", p.caller, p.req_id, p.action);
+        break;
+    }
+    /* AMSD_DESIGN §6.2 二期：picker 结果回传（handler App → launcher → amsd 记录）。
+     * value 可能含空格 → hex 编码，amsd 解码。 */
+    case MSG_PICKER_RESULT: {
+        m_picker_result_t r;
+        memset(&r, 0, sizeof r);
+        memcpy(&r, m->payload, m->plen < (uint16_t)sizeof r ? m->plen : (uint16_t)sizeof r);
+        r.caller[MEOW_APP_ID_MAX - 1] = 0;
+        r.action[23] = 0;
+        m_ack_t a;
+        a.code = MEOW_OK;
+        a.status = 0;
+        ipc_send(m->fd, MSG_ACK, m->req_id, &a, sizeof a);
+        char hex[512 + 8];
+        (void)ams_hex_encode((const unsigned char *)r.value, (int)strlen(r.value), hex, sizeof hex);
+        char fwd[96 + 512 + 8];
+        int fl = snprintf(fwd, sizeof fwd, "PICKER_RESULT %u %s %u %s\n",
+                          r.req_id, r.action, r.code, hex);
+        if (fl > 0) meow_ams_send(fwd, fl);
+        logmsg("ipc: PICKER_RESULT req=%u act=%s code=%u value=\"%s\"", r.req_id, r.action, r.code, r.value);
+        break;
+    }
     /* M2a：通知存储（NOTIFICATION_SYSTEM.md §4/§7/§8）。IPC 线程只入队，此处在主循环
      * 单写者落存储 + 回 ACK（与 HELLO/QUERY 同一线程模型，绝不在 socket IO 阻塞）。 */
     case MSG_NOTIFY: {