dsh-mobile-plugin 0.1.82 → 0.1.85

package/README.md

@@ -74,16 +74,19 @@ pnpm add dsh-mobile-plugin@<版本>
 
 新版插件的管理面板提供「本机调试 OTA」卡片，可手动检查并安装中转发布的紧急完整包。入口仅限宿主本机访问，不会由手机或公网触发；安装后通过实现代切换生效，切换失败会恢复上一代。npm 仍是正式发布源；后续 npm 正式版本达到 OTA 版本时会接管该版本。首次发布带此功能的 npm 包需要重启一次 DSH，让稳定外壳加载 OTA 能力。
 
-发布一个紧急完整包：在插件仓库根目录 `npm pack`，把打出来的 tgz 原样 POST 给中转（包本身就是 tar.gz，不用再解包重打）：
+发布一个紧急完整包：用仓库里的打包脚本，不要手工 `tar`。
 
 ```sh
-curl -X POST -H "authorization: Bearer <中转的 OTA 发布 token>" --data-binary @dsh-mobile-plugin-0.1.61.tgz \
-  "https://你的中转/api/desktop-plugins/ota/publish?platform=darwin&channel=stable&version=0.1.61"
+# 只打包（产物在当前目录）
+node scripts/pack-ota.mjs
+
+# 打包并发布，发布后会下载回来核对哈希
+node scripts/pack-ota.mjs --publish https://你的中转 --token <中转的 OTA 发布 token>
 ```
 
-`platform` 填 `process.platform`（`darwin` / `linux` / `win32`），`channel` 一般 `stable`。发布接口没配 token 时是关闭的，下载不受影响；版本按号比，最后发的那个才是「最新」。
+脚本做四件事：文件清单问 `npm pack --dry-run --json` 要（**不碰系统 tar**，三个平台同一份逻辑）、往包里写一份 `lib/ota-manifest.json`（版本 + 每个文件的路径与字节数）、用客户端的真解包器自检、发布后再下载回来比 sha256。中转那边也记哈希，客户端装之前会核对——半个包、被中间层改过的包都装不上去。
 
-打包时**别用 macOS 默认的 tar 参数**——带 PAX 扩展头，宿主那边的解析器不认，会报「OTA 包结构不完整」。要 `COPYFILE_DISABLE=1 tar --no-xattrs --no-mac-metadata -czf …`，且条目以 `package/` 打头。
+`--platform` 默认 `process.platform`（`darwin` / `linux` / `win32`）；这个插件是纯 JS，也可以 `--platform any` 发一份三个系统通用，客户端在自己平台没有包时会回落去问 `any`。`channel` 一般 `stable`。发布接口没配 token 时是关闭的，下载不受影响；版本按号比，最后发的那个才是「最新」。
 
 ## 开发
 

package/lib/client.js

@@ -271,27 +271,39 @@ window.__ModuleLoader__.load({
     /**
      * 方向一：桌面端读过了 → 告诉宿主，手机端侧栏灭灯。
      *
-     * 两类会话都算「桌面读过了」：
-     *  1. **未读绿点刚掉出去**的（用户点了那一行）—— 只报 true → false 的边沿，首帧的
-     *     全量未读集合一律不上报（那些还没读，照报会把全部绿点一次清空）；会话从快照里
-     *     消失（列表还没加载完、会话被删）同样不算读过。
-     *  2. **此刻正开在桌面主视图里的那个**（`retainedBy.mainView > 0`）。这类会话在桌面侧
-     *     永远不会进未读集合（`observeRunning` 对 mainView 直接跳过、`reconcileStatus`
-     *     还会主动删），所以第 1 条那个边沿对它**一次都不会发生** —— 用户盯着它读完，
-     *     手机上却一直亮着绿点。2026-10-10 真机截图就是这一格：手机有绿点、桌面没有。
-     *     用户明摆着在看它，就该算读过；会话重新跑起来时把标记摘掉，下一轮结束再报一次。
+     * 三种情形算「桌面读过了」，每种只报一次（变回未读或重新跑起来时摘掉标记、可以再报）：
+     *   - 本次打开页面之后**看见它从别的状态变成未读、又掉出去**（普通的点开）；
+     *   - 此刻**正开在主视图里**（`retainedBy.mainView > 0`：用户盯着它读完，它压根不进未读集合）；
+     *   - 本次打开页面之后**它变过、而且现在不是未读**（补掉漏采的那一瞬间）。
+     *
+     * **首帧一条都不报**：桌面页面刚加载时 `sessionStatus` 里全是 `completionUnread: false`
+     * （`completionUnread` 只在浏览器内存里，重开页面就没了），照单全收会把手机上真的
+     * 未读全灭掉。所以「页面打开之后变过」这条要求 `updatedAt > 页面打开时刻`，
+     * 没拿到会话清单时宁可不报。
      */
     function startDesktopReadSync(ctx) {
       withClientServices(ctx, ['uiSession'], 'uiSession', 'mobile-plugin: 桌面端已读上报', (scope, isDisposed) => {
-        let primed = false;
+        /** 页面打开的时刻：只有这之后动过的会话才敢当成「看见过」。 */
+        const openedAt = Date.now();
         let sending = false;
-        /** sessionId → 上一轮是否在未读集合里。 */
-        const seen = new Map();
-        /** 已经替「正开着」的会话报过读的标记；它重新跑起来就摘掉。 */
-        const reportedOpen = new Set();
+        /** 已经替它报过「读过」的会话；变回未读 / 运行中就摘掉。 */
+        const reported = new Set();
+        /** 本次页面里见过它处于未读的（普通的「点开」边沿就靠这个）。 */
+        const everUnread = new Set();
         /** 待上报的会话 id；POST 失败就留着下一轮再发。 */
         const pending = new Set();
 
+        /** 会话清单里每行的 `updatedAt` / `retainedBy`（拿不到就是空表，方向一退化成边沿判定）。 */
+        const retainedRows = () => {
+          try {
+            const list = currentSessions && currentSessions.list;
+            const snapshot = list && typeof list.getSnapshot === 'function' ? list.getSnapshot() : null;
+            return (snapshot && snapshot.byId) || {};
+          } catch {
+            return {};
+          }
+        };
+
         const flush = async () => {
           if (sending || !pending.size) return;
           const ids = [];
@@ -310,22 +322,6 @@ window.__ModuleLoader__.load({
           }
         };
 
-        /**
-         * 清单里每行的 `retainedBy`：「谁正开着它」只在这里。
-         *
-         * 读的是上面 `captureSessions` 抓回来的那份服务（可选依赖）：拿不到就只少
-         * 「正开着」这一项增强，第 1 类边沿上报照常工作 —— 所以它不该是硬门禁。
-         */
-        const retainedRows = () => {
-          try {
-            const list = currentSessions && currentSessions.list;
-            const snapshot = list && typeof list.getSnapshot === 'function' ? list.getSnapshot() : null;
-            return (snapshot && snapshot.byId) || {};
-          } catch {
-            return {};
-          }
-        };
-
         const scan = () => {
           if (isDisposed()) return;
           const uiSession = scope.uiSession;
@@ -338,28 +334,25 @@ window.__ModuleLoader__.load({
             return;
           }
           const rows = retainedRows();
-          const next = new Map();
           for (const [id, status] of statusEntries(snapshot)) {
             const unread = !!(status && status.completionUnread === true);
-            next.set(id, unread);
-            if (primed && seen.get(id) === true && !unread) pending.add(id);
-            // 第 2 类：正开着的，且不是运行中 —— 报一次就够了，跑起来就重新排队。
-            const row = rows[id];
-            const open = !!(row && row.retainedBy && Number(row.retainedBy.mainView) > 0);
-            if (!open || (status && status.running === true)) {
-              reportedOpen.delete(id);
+            const running = !!(status && status.running === true);
+            // 未读 = 还没读；运行中 = 这一轮的结局还没出来。两者都不是「读过了」。
+            if (unread || running) {
+              if (unread) everUnread.add(id);
+              reported.delete(id);
               continue;
             }
-            if (reportedOpen.has(id)) continue;
-            reportedOpen.add(id);
+            if (reported.has(id)) continue;
+            const row = rows[id];
+            const open = !!(row && Number(row.retainedBy && row.retainedBy.mainView) > 0);
+            const changedWhileOpen = !!(row && typeof row.updatedAt === 'number' && row.updatedAt > openedAt);
+            // 既没看见它掉出未读、也没见它这次变过、更没开着：多半只是页面刚加载，
+            // 全是不带未读标记的空快照。一个都不许报。
+            if (!everUnread.has(id) && !open && !changedWhileOpen) continue;
+            reported.add(id);
             pending.add(id);
           }
-          seen.clear();
-          for (const [id, unread] of next) seen.set(id, unread);
-          if (!primed) {
-            primed = true;
-            return;
-          }
           if (pending.size) void flush();
         };
 
@@ -413,9 +406,9 @@ window.__ModuleLoader__.load({
     }
 
     /**
-     * 把 sessions 服务抓进一个可变引用，供方向一的可选增强（「正开着」判定）使用。
-     * 它缺席时宿主侧看不到这条 effect 的标签，自检上报里 `sessions` 那一格也正是 false ——
-     * 排查时能一眼看出「不是没读到，是服务没拿到」。
+     * 把 sessions 服务抓进一个可变引用，供方向一判断「正开着」与「这次变过」。
+     * 它缺席时少这一路增强（方向一仍有边沿与主视图两条判据），宿主侧自检里
+     * `sessions` 那一格正是 false，排查时能一眼看出是服务没拿到。
      */
     let currentSessions = null;
     function captureSessions(ctx) {
@@ -726,8 +719,8 @@ window.__ModuleLoader__.load({
         ctx.effect(() => ctx.locale.register(NS, DICT), 'mobile-plugin: settings dictionaries');
         const t = ctx.locale.bind(NS);
         startDesktopViewSync(ctx);
-        startDesktopReadSync(ctx);
         captureSessions(ctx);
+        startDesktopReadSync(ctx);
         startReadReceiptSync(ctx);
         startClientHalfReport(ctx);
         // 插槽是「先声明后注册」：宿主可能比我们晚一步声明 settings.section，

package/lib/impl.js

@@ -35,7 +35,7 @@ const { createApiProxy } = require('./mobile/host-bridge.js')
 // 「手机上最近来过没有」：守卫记、控制面状态读。单独一个模块，装配层只转交。
 const activity = require('./mobile/activity.cjs')
 const { installAutoArchive } = require('./auto-archive.cjs')
-const { registerSessionCleanupTool } = require('./session-cleanup.cjs')
+const { installSessionCleanup } = require('./session-cleanup.cjs')
 const { activeGuard } = require('./host-guard.cjs')
 // 桌面端侧栏展开态的快照存储。桌面把这份状态只记在浏览器 localStorage 里，宿主必须
 // 有一个落盘处：客户端半边（lib/client.js）上报 → 这里 → 移动端读取。
@@ -299,7 +299,7 @@ function apply(ctx) {
   ctx.effect(() => installAutoArchive(ctx), `${name}: automatic session archive`)
   ctx.effect(() => {
     // Profiles without the optional tools injection still support core remote control.
-    try { registerSessionCleanupTool(ctx) } catch (error) {
+    try { installSessionCleanup(ctx) } catch (error) {
       if (!String(error).includes('without inject')) throw error
     }
     return undefined

package/lib/mirror/pusher.cjs

@@ -34,6 +34,7 @@ const { dshHome } = require('../shared/paths.js');
 const { listSignal: sharedListSignal } = require('../shared/list-signal.js');
 const { sessionSignal: sharedSessionSignal } = require('../shared/session-signal.js');
 const { dropSessionListCache } = require('../mobile/session-cache.js');
+const { observeCompletionEvent } = require('../mobile/completion.js');
 
 /** 后台循环每个 tick 补推一个冷会话，保证没人动的会话镜像也不长期不更新。 */
 const HIGH_PRIORITY_WINDOW_MS = 5 * 60 * 1000;
@@ -683,6 +684,7 @@ function createMirrorPusher(deps) {
           // 同一轮收尾时的 assistant/message 会把完整消息带进来，手机侧的实时文本由
           // session/stream 的 SSE 负责。不跳的话每条增量都要重建五份全量快照并推一次
           // sidecar，形成推送风暴（配合 pushSessionImmediately 的单飞才有稳定上界）。
+          observeCompletionEvent(ctx, sessionId, p?.event);
           if (p?.event?.type === 'assistant/chunk') continue;
           void pushSessionImmediately(sessionId);
         }

package/lib/mobile/archive-clean.js

@@ -1,30 +1,30 @@
 'use strict';
 
 /**
- * 移动端「清理所有已归档的对话」：按宿主归档集合确定清理范围，并交由落地函数删除。
+ * 移动端「清理所有已归档的对话」：按宿主归档集合确定清理范围，并删掉它们的日志。
  *
  * 以 workspace.list 的 archivedSessionIds 为清理范围，不用可能过时的列表状态缩小范围；
  * 请求必须显式带 confirm: true —— 磁盘删除不可恢复，手机端「少点一次」不值得把它变成滑一下就没了的动作。
  *
- * 删除动作不重写：读日志 header.id → 删会话目录 + 投影缓存 → 擦归档集合这套只在 session-cleanup.cjs
- * 里存在（见地图 A3-17），这里只是把它的触发面从 agent 工具扩到移动端路由。
+ * 删除动作不重写：读日志 header.id → 删会话目录 + 投影缓存只在 session-cleanup.cjs 里存在
+ * （见地图 A3-17），这里只是把它的触发面从 agent 工具扩到移动端路由。
+ *
+ * **这里不擦宿主的归档集合**（只把删掉的 id 记进本进程的删除集，挡住手机端列表里可能
+ * 还没失效的旧快照）。进程里擦集合会把桌面端那份会话列表快照里、其实已经删掉的行放回
+ * 正常列表——桌面端用户看到的就是「清理完它们又回来了，重启 DSH 才真的消失」。归档集合
+ * 的收尾放在宿主启动时做，见 session-cleanup.cjs 的 pruneOrphanedArchivedSessionsOnce。
  */
 
 const { sendJson, readJsonBody } = require('../shared/http-util');
 const { withIdempotency, requestIdOf } = require('./idempotency.js');
-const {
-  canonicalDeviceKey,
-  rememberDeletedSessionIds,
-  pendingUnarchiveSessionIdsOf,
-  clearPendingUnarchiveSessionIds,
-} = require('./session-cache.js');
+const { canonicalDeviceKey, rememberDeletedSessionIds } = require('./session-cache.js');
 const { invalidateSessionList } = require('./sessions.js');
 const { unwrap } = require('./envelope.js');
-const { deleteSessionData, forgetArchivedSessions } = require('../session-cleanup.cjs');
+const { deleteSessionData } = require('../session-cleanup.cjs');
 
 /**
  * POST /api/mobile/v1/workspace/clear-archived（token）
- * body: { confirm: true } → { ok: true, deleted: N, unarchiveFailedSessionIds }。confirm 不为 true 一律 400。
+ * body: { confirm: true } → { ok: true, deleted: N }。confirm 不为 true 一律 400。
  */
 async function handleClearArchived(ctx, req, res) {
   const body = await readJsonBody(req, 64 * 1024);
@@ -40,36 +40,13 @@ async function handleClearArchived(ctx, req, res) {
     }
     const archivedIds = Array.isArray(workspaceResponse.value?.archivedSessionIds) ? workspaceResponse.value.archivedSessionIds : [];
     const selected = archivedIds.filter((id) => typeof id === 'string' && id);
-    if (selected.length === 0) return { status: 200, body: { ok: true, deleted: 0, archivedSessionIds: archivedIds } };
-    // 顺序是**先删日志、再擦归档集合**。删日志才是用户要的那件事，擦集合只是收尾。
-    //
-    // 反过来（先擦后删）曾导致用户报的现象：擦归档是逐条 RPC，中途任何一条失败或链路超时，
-    // 日志一份没删、名字却已经从归档集合里消失——会话退回普通列表，看着像「清理只是把它
-    // 移出了归档」，必须重启桌面端才恢复。先删就没这个窗口：日志没了就是**真的清理掉了**，
-    // 立刻生效、不必等桌面端重启；擦集合失败最多在「已归档」里留一行点不开的死行，
-    // 重试一次即可，不会让操作白做。
-    //
-    // 擦集合是 best-effort：它失败**不**让整条清理报错（日志已经删成功，报错等于骗用户）。
+    if (selected.length === 0) return { status: 200, body: { ok: true, deleted: 0 } };
     const removed = await deleteSessionData(selected);
+    // 删的是列表里可见的行：手机端正开着列表，宿主那份快照可能还带着它们，先在本进程压住。
     rememberDeletedSessionIds(ctx, removed);
-    const pendingUnarchive = pendingUnarchiveSessionIdsOf(ctx);
-    const retryable = [...new Set(selected)].filter((id) => pendingUnarchive.has(id));
-    const failedToUnarchive = await forgetArchivedSessions(ctx, retryable, 'mobile');
-    const failed = new Set(failedToUnarchive);
-    clearPendingUnarchiveSessionIds(ctx, retryable.filter((id) => !failed.has(id)));
-    // 删的是列表里可见的行：手机端正开着列表，不立刻失效最长 10 秒还能点到死行。
+    // 不立刻失效的话，最长 10 秒还能点到已删的行。
     invalidateSessionList(ctx);
-    // 只从返回的归档集合中移除宿主确认已取消归档的 ID；失败项保留为重试候选。
-    const cleared = new Set(retryable.filter((id) => !failed.has(id)));
-    return {
-      status: 200,
-      body: {
-        ok: true,
-        deleted: removed.length,
-        archivedSessionIds: archivedIds.filter((id) => !cleared.has(id)),
-        unarchiveFailedSessionIds: failedToUnarchive,
-      },
-    };
+    return { status: 200, body: { ok: true, deleted: removed.length } };
   });
   sendJson(res, outcome.status, outcome.body);
 }

package/lib/mobile/completion.js

@@ -1,22 +1,47 @@
 'use strict';
 
 /**
- * 完成提醒状态机：从宿主会话列表快照与 history 事件日志里确认「跑完了」。
+ * 完成提醒状态机：一轮怎么结束以 history 为准（turn/end 的 reason.kind），实时 turn
+ * 事件只是让结论早一步到达。提醒算不算数看两个水位：读过的时刻之前不算，本进程启动
+ * 之前结束的轮次也不重播 —— 不再要求「先看见 running」。
  *
- * 三条铁律写在代码注释里，这里也复述一遍，因为它们各自都防过一次误报：
- *  1. **不**从 running→idle 的状态边沿推断完成。agent-loop 是先 append 最终
- *     assistant/message 再 append turn/end，所以必须由 history 折出同一轮的这两个事件
- *     才算完成；
- *  2. `wasRunning` 是进程内边沿标记，只有本次 Host 存活期间观察到的轮次才有资格报完成，
- *     否则冷启动的一份旧列表会把上次开机前的轮次当成新完成弹一遍通知；
- *  3. 一轮的结局由 `turn/end` 的 `reason.kind` 说了算：`error` 记失败（宿主会话列表里
- *     没有任何失败字段，App 侧栏的红点全靠这里折出来），`completed` 才算完成，其余
- *     kind（max-tokens / aborted）既不算完成也不算失败。
+ * 旧要求的后果（2026-10-17 真机）：宿主没采到那一瞬间的轮次永远不亮，桌面亮着绿点 /
+ * 红点，手机上什么都没有。
  */
 
-const { completionStateOf } = require('./session-cache.js');
+const { completionStateOf, completionStateMapsOf } = require('./session-cache.js');
+
+/** 本进程起点：比它更早结束的轮次不重播。 */
+const PROCESS_STARTED_AT = Date.now();
+
+/** 「不算数」水位：读过按读过时刻；没读过时，本进程见过它跑就放开（0）。 */
+function baselineOf(state) {
+  if (!state) return PROCESS_STARTED_AT;
+  if (typeof state.clearedAt === 'number') return state.clearedAt;
+  return state.wasRunning === true ? 0 : PROCESS_STARTED_AT;
+}
+
+/** Consume one live Host turn event for every device with an initialized completion state. */
+function observeCompletionEvent(ctx, sessionId, event) {
+  if (!sessionId || !event || !event.data || typeof event.data.turn !== 'number') return;
+  const turn = event.data.turn;
+  for (const states of completionStateMapsOf(ctx)) {
+    const previous = states.get(sessionId);
+    if (!previous) continue;
+    if (event.type === 'turn/start') {
+      states.set(sessionId, { ...previous, running: true, completed: false, wasRunning: true, turn, completionEvents: [event] });
+      continue;
+    }
+    if ((event.type !== 'assistant/message' && event.type !== 'turn/end')
+      || previous.turn !== turn || previous.wasRunning !== true) continue;
+    const priorEvents = Array.isArray(previous.completionEvents) ? previous.completionEvents : [];
+    const events = [...priorEvents.filter((item) => item.type !== event.type), event];
+    const next = { ...previous, running: event.type === 'turn/end' ? false : previous.running, completionEvents: events };
+    if (event.type === 'turn/end') confirmCompletionFromHistory(next, events, false);
+    states.set(sessionId, next);
+  }
+}
 
-/** Update shared completion reminders from one Host session-list snapshot. */
 function updateCompletionStates(ctx, items, deviceKey = 'legacy') {
   const states = completionStateOf(ctx, deviceKey);
   const seen = new Set();
@@ -25,37 +50,30 @@ function updateCompletionStates(ctx, items, deviceKey = 'legacy') {
     seen.add(summary.sessionId);
     const running = !!summary.running;
     const previous = states.get(summary.sessionId);
-    // Do not infer completion from the status edge. The history fold below
-    // must prove the matching turn/end plus its final assistant message.
+    // 不靠状态边沿猜完成：下面的 history 折叠必须自己找到同轮的 turn/end。
     const completed = previous?.completed === true;
-    // `wasRunning` is an internal edge marker.  A completed notification is
-    // only eligible for a turn observed while this Host was alive; a cold
-    // list snapshot must not replay an old turn as a new completion.
     states.set(summary.sessionId, {
       running,
       completed: running ? false : completed,
       turn: previous?.turn,
-      wasRunning: previous?.running === true,
-      // 「上一轮失败」是历史事实：宿主列表摘要里没有这个信息，唯一来源是下面的 history
-      // 折叠。它必须跨快照、跨下一轮延续 —— 否则「失败之后用户又发一句话」会让
-      // state.turn 前进，红点还没被看见就没了。
+      // 只决定「允许追到多久以前」（见 baselineOf），不再是确认完成的前提。
+      wasRunning: previous?.running === true || previous?.wasRunning === true,
+      completionEvents: previous?.completionEvents,
+      clearedAt: previous?.clearedAt, // 已读水位跨快照延续，读过的轮次不许再亮回来
+      // 「上一轮失败」只能由 history 折出，必须跨快照、跨下一轮延续：否则用户失败后
+      // 又发一句话，state.turn 前进，红点还没被看见就没了。
       failure: previous?.failure,
     });
   }
-  // The Host list is canonical for this device scope; discard detached
-  // sessions so completion state cannot leak across reused session IDs.
+  // 列表是本设备作用的权威：不在列表里的条目要丢（防止复用 id 串状态）。带已读水位的
+  // 留着 —— 丢了水位，会话离开列表再回来时旧轮次会重新点亮。
   for (const sessionId of states.keys()) {
-    if (!seen.has(sessionId)) states.delete(sessionId);
+    if (!seen.has(sessionId) && typeof states.get(sessionId)?.clearedAt !== 'number') states.delete(sessionId);
   }
   return states;
 }
 
-/**
- * Confirm the running -> idle edge against the event log.  Agent status is a
- * coarse activity signal: the agent-loop appends the final assistant/message
- * and only then appends turn/end.  Keep the edge tied to that exact turn so a
- * late/stale list response cannot complete a newer (or an older) turn.
- */
+/** 把 history 最后一轮的结局折到 state 上：结束时刻越过 baselineOf 才算提醒。 */
 function confirmCompletionFromHistory(state, events, running) {
   if (!state || !Array.isArray(events)) return;
   let latestTurn;
@@ -76,15 +94,19 @@ function confirmCompletionFromHistory(state, events, running) {
     }
   }
   if (latestTurn !== undefined) state.turn = latestTurn;
-  if (running || !state.wasRunning || state.turn === undefined) return;
+  if (running || state.turn === undefined) return;
   const end = ends.get(state.turn);
+  if (!end) return;
+  const baseline = baselineOf(state);
+  const endedAt = typeof end.time === 'number' ? end.time : baseline + 1;
+  if (endedAt <= baseline) return; // 读过的 / 冷启动之前结束的那一轮
   const assistant = assistants.get(state.turn);
-  const reason = end && end.data ? end.data.reason : undefined;
+  const reason = end.data ? end.data.reason : undefined;
   const kind = reason && typeof reason.kind === 'string' ? reason.kind : undefined;
   // 本轮以错误收尾：宿主不会再补一条最终消息，但它刚刚追加过 turn/end —— 下面那条
   // 「assistant 早于 turn/end 就算完成」的规则会把这种轮次判成「已完成待读」，侧栏于是
   // 把一次失败显示成绿点。失败是宿主列表摘要里没有的信息，只能在这里折出来交给 App。
-  if (end && kind === 'error') {
+  if (kind === 'error') {
     const error = reason && reason.error && typeof reason.error === 'object' ? reason.error : {};
     state.completed = false;
     state.failure = {
@@ -97,18 +119,18 @@ function confirmCompletionFromHistory(state, events, running) {
   }
   // max-tokens / aborted 等：这一轮没跑完，同样不能报完成；但它没有错误码可显示，
   // 所以只清完成标记，不产生红点。
-  if (end && kind !== undefined && kind !== 'completed') {
+  if (kind !== undefined && kind !== 'completed') {
     state.completed = false;
     state.failure = undefined;
     return;
   }
   // The assistant message must be the settled message for this turn, not an
   // interrupted partial and not merely a preceding turn's message.
-  if (end && assistant && assistant.seq <= end.seq && assistant.data.interrupted !== true) {
+  if (assistant && assistant.seq <= end.seq && assistant.data.interrupted !== true) {
     state.completed = true;
     // 成功收尾的轮次覆盖旧失败：标记必须跟着最新一次运行走。
     state.failure = undefined;
   }
 }
 
-module.exports = { updateCompletionStates, confirmCompletionFromHistory };
+module.exports = { observeCompletionEvent, updateCompletionStates, confirmCompletionFromHistory };

package/lib/mobile/events.js

@@ -24,6 +24,16 @@ const { sessionSignal: sharedSessionSignal } = require('../shared/session-signal
 
 const SSE_RETRY_MS = 3000;
 const DEDUP_WINDOW = 2048;
+/**
+ * 写缓冲的两道水位（字节），与 `mobile/stream.js` 同一口径。
+ *
+ * `res.write()` 在客户端读得慢时返回 false，字节留在 Node 的写队列里。设备级流以前
+ * 完全不看这个信号，于是「手机挂着一条流、网又慢」时帧无限堆积 —— 2026-10-17 真机
+ * 现场：堆快照里 17.6 万条 SSE 帧（466MB）挂在 `WriteWrap._chunks` 上，宿主 70 分钟
+ * 涨到 3.9G 被 OOM 杀掉。软水位只丢信号帧（幂等、下一条变更会再补），硬水位才收尾。
+ */
+const SSE_SHED_BUFFERED_BYTES = 4 * 1024 * 1024;
+const SSE_CLOSE_BUFFERED_BYTES = 16 * 1024 * 1024;
 /** 心跳帧间隔。App 用它判定「这条流真的还活着」，必须与 app 侧的 SIGNAL_HEARTBEAT_MS 一致。 */
 const HEARTBEAT_MS = 15_000;
 
@@ -56,12 +66,23 @@ function stableEventId(payload, frame) {
   return frame && typeof frame.rpcId === 'string' && frame.rpcId ? frame.rpcId : undefined;
 }
 
+/**
+ * 写一条 SSE 记录。返回值与 `mobile/stream.js` 的同名函数一致：`ok:false` 表示该收尾，
+ * `shed:true` 表示这条帧被主动丢掉（写缓冲超过软水位）。
+ *
+ * 设备级流的帧全是「有东西变了」的信号，本来就幂等：丢掉一帧的代价是那一次刷新要等
+ * 下一次变更或 60s 兜底轮询；而堆在写缓冲里的代价是宿主 OOM（2026-10-17 现场：466MB
+ * 的 SSE 帧挂在 socket 写队列上，宿主撞 4GB 上限被杀）。所以软水位一律 shed。
+ */
 function writeSse(res, payload, frame) {
+  const buffered = Number(res.writableLength) || 0;
+  if (buffered > SSE_CLOSE_BUFFERED_BYTES) return { ok: false };
+  if (buffered > SSE_SHED_BUFFERED_BYTES) return { ok: true, shed: true };
   const id = stableEventId(payload, frame);
   const fields = [`retry: ${SSE_RETRY_MS}`];
   if (id) fields.push(`id: ${id}`);
   fields.push(`data: ${JSON.stringify(payload)}`, '', '');
-  try { res.write(`${fields.join('\n')}\n`); return true; } catch { return false; }
+  try { res.write(`${fields.join('\n')}\n`); return { ok: true }; } catch { return { ok: false }; }
 }
 
 async function* mergeHostAndMux(ctx, signal) {
@@ -153,13 +174,13 @@ async function handleDeviceStream(ctx, req, res) {
   /** 这条连接上真正写出去的帧数，只用于收尾日志（诊断「连着却一帧不发」）。 */
   let framesSent = 0;
   const writeFrame = (devicePayload) => {
-    const written = writeSse(res, {
+    const result = writeSse(res, {
       type: 'device/event',
       version: 1,
       payload: devicePayload,
     }, null);
-    if (written) framesSent += 1;
-    return written;
+    if (result.ok && !result.shed) framesSent += 1;
+    return result.ok;
   };
   /**
    * 自产的「清单变了」帧：镜像推送调度器每 500ms 比一次清单内容哈希，变了就在这里推给手机。
@@ -267,7 +288,9 @@ async function handleDeviceStream(ctx, req, res) {
         payload,
       };
       // Keep the existing device/event JSON envelope unchanged; SSE metadata is additive.
-      if (!writeSse(res, envelope, frame)) { clientGone = true; break; }
+      const sent = writeSse(res, envelope, frame);
+      if (sent.shed) continue;
+      if (!sent.ok) { clientGone = true; break; }
       framesSent += 1;
     }
     if (!clientGone) loopEnded = true;

package/lib/mobile/plugins.js

@@ -10,9 +10,9 @@
  *
  * 关键：这个宿主服务 **不在 apiProxy 上** —— 它是 Typert Remote 服务
  * （dsh-host-plugin-inventory 的 pluginInventory）。手机侧本来就能到它：
- * lib/mobile/sessions.js 早已用 `ctx.get('typertGateway')` 派发 commands.execute，
- * lib/mobile/references.js 通了 fileReferences / sessionReferenceResolver，
- * 这里照搬同一条路。
+ * lib/mobile/sessions.js 早已派发 commands.execute，lib/mobile/references.js 通了
+ * fileReferences / sessionReferenceResolver，这里照搬同一条路 —— 都经
+ * host-bridge/transport.js 的 `invoke`，由它统一补 Peer 身份与网关错误收敛。
  *
  * 接口（只转发宿主的部署快照，不做任何加工）：
  *  - GET /api/mobile/v1/plugins → pluginInventory.list
@@ -32,17 +32,13 @@
  */
 
 const { sendJson } = require('../shared/http-util');
+const { invoke, UNAVAILABLE: GATEWAY_UNAVAILABLE } = require('./host-bridge/transport.js');
 
 const PLUGIN_ID_MAX_CHARS = 200;      // entryId 长度上限
 const PLUGIN_NAME_MAX_CHARS = 300;    // moduleName 长度上限
 const PLUGIN_MAX_ITEMS = 500;         // 手机侧兜底上限（真实宿主是几十条）
 const PLUGIN_PHASES = new Set(['failed', 'pending', 'active', 'loading', 'unloading']);
 
-/** 宿主网关；宿主没组合 dsh-api-gateway 时返回 null，调用方回 503。 */
-function gatewayOf(ctx) {
-  return (ctx.get && ctx.get('typertGateway')) || null;
-}
-
 /** 网关缺失/命名空间缺失对客户端是同一件事：宿主这个能力没装。 */
 const UNAVAILABLE = Object.freeze({
   code: 'plugin-inventory-unavailable',
@@ -57,35 +53,33 @@ function errorText(error) {
 }
 
 /**
- * 经 typertGateway 取一次插件清单快照。
+ * 经网关取一次插件清单快照。
+ *
+ * 走 host-bridge/transport.js 的 `invoke`：Peer 身份、`gateway/` 前缀的缺失类错误
+ * 都在那里统一处理，这里只做本域的错误码翻译。**不能直接 `gateway.invoke`** ——
+ * 0.2.1 起网关要求每个请求自带 Peer，绕过去就是对 undefined 读 `.signal`，
+ * 手机端看到的是「插件清单加载失败」。
  *
  * @returns {Promise<{value?: unknown, error?: {code: string, message: string}}>}
  */
 async function callInventory(ctx) {
-  const gateway = gatewayOf(ctx);
-  if (!gateway) return { error: { ...UNAVAILABLE } };
-  let result;
-  try {
-    // 没有声明参数 → args 必须是空对象；这个方法也没声明 cancellation，不能多塞 signal。
-    result = await gateway.invoke({ namespace: 'pluginInventory', method: 'list', args: {} });
-  } catch (error) {
-    // 0.2.0 的网关错误码带 `gateway/` 前缀（dsh-api-gateway/src/types.ts:117-136）；
-    // 0.1.x 时期是不带前缀的。两种都认，否则「宿主没装这个服务」的降级分支形同虚设。
-    const raw = error && typeof error.code === 'string' ? error.code.replace(/^gateway\//, '') : ''
-    const code = raw === 'invocation-unavailable' || raw === 'service-unavailable' || raw === 'method-unavailable'
-      ? UNAVAILABLE.code
-      : 'plugin-inventory-error';
-    return { error: { code, message: errorText(error) } };
+  // 没有声明参数 → args 必须是空对象；这个方法也没声明 cancellation，不能多塞 signal。
+  const result = await invoke(ctx, 'pluginInventory', 'list', {});
+  if (result.error) {
+    // 宿主的服务/方法缺失由传输层收敛成同一个码：对客户端就是「这个能力没装」。
+    if (result.error.code === GATEWAY_UNAVAILABLE.code) return { error: { ...UNAVAILABLE } };
+    return { error: { code: 'plugin-inventory-error', message: errorText(result.error) } };
   }
+  const value = result.value;
   // decode 本体就是 { entries: […] }；另外两种形状只是容错，防宿主以后改成联合。
-  if (result && typeof result === 'object') {
-    if (result.ok === true) return { value: result.value };
-    if (result.ok === false) {
-      const raw = result.error && typeof result.error === 'object' ? result.error : {};
+  if (value && typeof value === 'object') {
+    if (value.ok === true) return { value: value.value };
+    if (value.ok === false) {
+      const raw = value.error && typeof value.error === 'object' ? value.error : {};
       const code = typeof raw.code === 'string' && raw.code ? raw.code : 'plugin-inventory-error';
       return { error: { code, message: errorText(raw) } };
     }
-    return { value: result };
+    return { value };
   }
   return { error: { code: 'plugin-inventory-error', message: '宿主插件清单返回了意外的结果' } };
 }