dsh-mobile-plugin 0.1.88 → 0.1.90

package/lib/impl.js

@@ -353,6 +353,13 @@ function apply(ctx) {
     // 桌面端「我读过了」那条路由（/api/relay/desktop-read）要清掉宿主侧的完成提醒，
     // 需要插件 ctx 才能拿到按设备隔离的状态表。
     ctx,
+    // 内存自检台账（`/api/relay/status` 的 `selfCheck`）的四个取值器：台账本体在
+    // `lib/mobile/self-check.cjs`。侧车内存与两条路的流数都只有 worker 的 `/status`
+    // 快照这一条既有通道（局域网那份由 lan-proxy 的 stats() 经快照带出来）。
+    getSidecarSnapshot: sidecarLifecycle.getSnapshot,
+    getMirrorPush: mirror.getMirrorPush,
+    getMirrorPushFailures: mirror.getPushFailures,
+    getLanProxyStats: () => sidecarLifecycle.getSnapshot()?.streams?.lan ?? null,
   })
 
 

package/lib/index.js

@@ -151,6 +151,8 @@ export function apply(ctx) {
     check,
     apply: applyUpdate,
     reload: version => runtime.reload(version),
+    /** 就地把盘上这一份重新装载一遍：版本身份没变也照换（开发机改完代码用，见 runtime 的 reread）。 */
+    reread: () => runtime.reload(undefined, { reread: true }),
     deviceOta,
     setAutoUpdate: enabled => {
       const value = updater.setAutoUpdate(enabled)

package/lib/mirror/pusher.cjs

@@ -194,6 +194,8 @@ function createMirrorPusher(deps) {
 
   // 镜像推送的唯一出口：所有 pushSync 都必须经此，保证状态与真实推送一致。
   const pushMirrorPayload = async (payload) => {
+    // 每一次推上去的清单都顺手记一下规模（含短路那两条路径：手机侧栏看的就是这份清单）。
+    noteMirrorList(payload && payload.sessions);
     if (!tunnelConnected()) {
       recordMirrorPush(false, '隧道未连接，镜像未推送');
       // 没推成镜像，但「正文长到哪儿了」这件事仍然要说给手机听（见 announceSessionActivity）。
@@ -256,6 +258,28 @@ function createMirrorPusher(deps) {
 
   const isHighPriority = (s) => s && (s.running || (s.updatedAt && Date.now() - s.updatedAt < HIGH_PRIORITY_WINDOW_MS));
 
+  /**
+   * 镜像清单本身的规模（自检台账用）：会话总数、其中活跃的、其中子会话。
+   *
+   * 这是插件侧能**诚实**报出的那部分规模——「宿主内存里挂着多少会话、正文占多少」插件看不到
+   * （它住在宿主进程里，没有独立视角，见 lib/mobile/self-check.cjs 的口径段）。清单每 tick 都
+   * 在重建，顺手记三个计数不额外花销。
+   *
+   * 只在真拿到清单时更新：拿不到时保留上一次的读数（连带 `at`），与「清单突然变成 0」区分开。
+   */
+  let mirrorListSessions = 0;
+  let mirrorListActiveSessions = 0;
+  let mirrorListSubagents = 0;
+  let mirrorListAt = 0;
+  const noteMirrorList = (sessionsBody) => {
+    const items = sessionsBody && Array.isArray(sessionsBody.items) ? sessionsBody.items : null;
+    if (!items) return;
+    mirrorListSessions = items.length;
+    mirrorListActiveSessions = items.filter(isHighPriority).length;
+    mirrorListSubagents = items.filter((s) => s && s.origin === 'subagent').length;
+    mirrorListAt = Date.now();
+  };
+
   // Every session snapshot fans out to three Host RPCs. Bound the number of sessions
   // being built globally; event work gets priority, but batch/cold work gets one slot
   // after at most three consecutive event jobs to prevent starvation.
@@ -323,6 +347,33 @@ function createMirrorPusher(deps) {
     // 清单里没有这一行（比如事件先到、清单还没刷出来）时退回 Date.now()：这个值只参与
     // 缓存指纹，不影响正文内容本身。
     const updatedAt = (summary && summary.updatedAt) || Date.now();
+    /**
+     * 子会话的正文**刻意不建**（2026-10-19）。
+     *
+     * 普通历史接口读子会话会被宿主按 durable parent address 拒掉
+     * （`session/agent-busy: subagent Sessions require their durable parent address`），
+     * 而镜像这份正文手机本来就用不到：手机打开子代理读的是子代理那条专用通道（带父会话
+     * 地址与 mode，见 lib/mobile/subagents.js 的文件头）。以前每次都照读、每次都被拒，
+     * 于是 5 秒一次的冷轮转里固定夹着一次注定失败的读取，`skippedBodies` 一路涨
+     * （真机实测 4 分钟 408 → 451），日志里那条 skip 也永远说不清到底哪坏了。
+     *
+     * 这里提前认出清单行上的 `origin === 'subagent'` 就不发那次请求，且 **skipReason 留空**：
+     * 它不是失败，不该进 `skippedBodies` 那本故障账。清单行本身照旧推给手机（App 靠行上的
+     * origin/parentSessionId 认子代理），stats/models 照旧构建，所以镜像载荷的形状与既有的
+     * 「正文缺席」那条路径完全一致。
+     */
+    if (summary && summary.origin === 'subagent') {
+      const [stats, models] = await Promise.all([
+        sessions.buildStatsSnapshot(ctx, sessionId),
+        sessions.buildModelsSnapshot(ctx, sessionId),
+      ]);
+      return {
+        messages: null,
+        skipReason: null,
+        stats: stats?.ok ? stats : null,
+        models: models?.ok ? models : null,
+      };
+    }
     const [messages, stats, models] = await Promise.all([
       sessions.buildMirrorWarmSnapshots(
         ctx,
@@ -707,6 +758,13 @@ function createMirrorPusher(deps) {
       // 正文缺失而清单照推的次数与最近原因：与 ok/pushedAt 分开，避免再把
       // 「某会话正文读不到」误读成「镜像死了」（见 recordMirrorPushSkipped）。
       skippedBodies: mirrorBodySkipCount, skipReason: mirrorBodySkipReason,
+      // 清单规模（自检台账读它）：会话总数 / 其中活跃 / 其中子会话 / 这份读数的时间。
+      // 这是「手机侧栏那份清单有多大」，**不是**「宿主内存里挂着多少会话、正文占多少」——
+      // 后者插件看不到（见 lib/mobile/self-check.cjs 的口径段）。
+      listSessions: mirrorListSessions,
+      listActiveSessions: mirrorListActiveSessions,
+      listSubagents: mirrorListSubagents,
+      listAt: mirrorListAt,
     }),
     /** 失败会话的定向重试账（诊断 + 守卫用）：失败几次、下次什么时候补推。 */
     getPushFailures: () => [...sessionPushFailures.entries()].map(([sessionId, entry]) => ({

package/lib/mobile/events.js

@@ -17,23 +17,11 @@
  */
 'use strict';
 
-const crypto = require('crypto');
-
 const { listSignal: sharedListSignal } = require('../shared/list-signal.js');
 const { sessionSignal: sharedSessionSignal } = require('../shared/session-signal.js');
+const { writeSse: sharedWriteSse, stableEventId: sharedEventId } = require('../shared/sse-write.js');
 
-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;
 
@@ -51,55 +39,23 @@ function logDeviceStream(message, error) {
   } catch { /* ignore */ }
 }
 
-function stableEventId(payload, frame) {
-  if (payload && typeof payload === 'object') {
-    if (payload.type === 'session/event' && payload.sessionId && payload.event && Number.isFinite(payload.event.seq)) {
-      return `${payload.sessionId}:${payload.event.seq}`;
-    }
-    for (const key of ['eventId', 'rpcId', 'id', 'approvalId']) {
-      if (typeof payload[key] === 'string' && payload[key]) return payload[key];
-    }
-    const sessionId = typeof payload.sessionId === 'string' ? payload.sessionId : 'device';
-    const digest = crypto.createHash('sha256').update(JSON.stringify(payload)).digest('hex').slice(0, 24);
-    return `${sessionId}:${payload.type || 'event'}:${digest}`;
-  }
-  return frame && typeof frame.rpcId === 'string' && frame.rpcId ? frame.rpcId : undefined;
-}
-
 /**
- * 这条连接上真正「还没发出去」的字节数。
+ * 写一条 SSE 记录（策略声明，实现见 `lib/shared/sse-write.js`）。
  *
- * 只看 `res.writableLength` 是错的：它只算响应对象自己那一层，真正的积压在底下的套接字
- * 写队列里（堆快照里那些 `{chunk, encoding, callback}`）。2026-10-18 复测证实：只看
- * 前者时闸门从不触发，内存照涨。所以顺着 socket 一起看，取较大值。
- */
-function bufferedBytesOf(res) {
-  const own = Number(res.writableLength) || 0;
-  const socket = res.socket || res.connection;
-  const queued = socket ? Number(socket.writableLength) || 0 : 0;
-  return Math.max(own, queued);
-}
-
-/**
- * 写一条 SSE 记录。返回值与 `mobile/stream.js` 的同名函数一致：`ok:false` 该收尾，
- * `shed:true` 这条被丢掉，`needDrain:true` 写进去了但底下已经写不动。
+ * 这条流的策略：软水位**一律** shed。设备级流的帧全是「有东西变了」的信号，本来就幂等
+ * —— 丢掉一帧的代价是那一次刷新要等下一次变更或 60s 兜底轮询，而堆在写缓冲里的代价是
+ * 宿主 OOM（2026-10-17 现场：466MB 的 SSE 帧挂在 socket 写队列上，宿主撞 4GB 上限被杀）。
+ * 不补填充：这里的帧少、单帧也小，不需要撑 RN 的缓冲阈值。
  *
- * 设备级流的帧全是「有东西变了」的信号，本来就幂等：丢掉一帧的代价是那一次刷新要等
- * 下一次变更或 60s 兜底轮询；而堆在写缓冲里的代价是宿主 OOM（2026-10-17 现场：466MB
- * 的 SSE 帧挂在 socket 写队列上，宿主撞 4GB 上限被杀）。所以软水位一律 shed。
+ * 返回值与会话流一致：`ok:false` 该收尾，`shed:true` 这条被丢掉，`needDrain:true`
+ * 写进去了但底下已经写不动。
  */
 function writeSse(res, payload, frame) {
-  const buffered = bufferedBytesOf(res);
-  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 {
-    const accepted = res.write(`${fields.join('\n')}\n`);
-    return { ok: true, needDrain: accepted === false };
-  } catch { return { ok: false }; }
+  return sharedWriteSse(res, payload, {
+    frame,
+    namespace: 'device',
+    shedWhenBuffered: () => true,
+  });
 }
 
 async function* mergeHostAndMux(ctx, signal) {
@@ -290,7 +246,7 @@ async function handleDeviceStream(ctx, req, res) {
       const payload = listRelevantPayload(rawPayload);
       if (!payload) continue;
       const sessionId = typeof payload.sessionId === 'string' ? payload.sessionId : undefined;
-      const eventId = stableEventId(rawPayload, frame);
+      const eventId = sharedEventId(rawPayload, frame, 'device');
       if (eventId) {
         if (seenEventIds.has(eventId)) continue;
         seenEventIds.add(eventId);

package/lib/mobile/self-check.cjs

@@ -0,0 +1,262 @@
+'use strict';
+
+/**
+ * 内存自检台账：内存出问题之后，用来回答「当时到底堆在哪儿」。
+ *
+ * 起因：宿主进程内存涨到 3.5～5G，排查时手上只有 Activity Monitor 的一个总数，
+ * 分不出「插件推的镜像在堆」「遗弃的流订阅在堆」还是「宿主自己」。所以这里把三件事
+ * 一次性报出来：两个**进程**的内存、各路**活着的流数**、以及插件自己那几个
+ * 只增不减的容器有多大。
+ *
+ * ## 最重要的一条：口径
+ *
+ * **插件住在宿主进程里，没有独立内存可测。** `hostProcess` 报的是**整个宿主进程**
+ * （DSH host）的 `process.memoryUsage()`——插件、宿主自身、其它插件、V8 的堆外缓冲
+ * 全在这个数里。它不是「插件占了多少」。要判断「插件占多少」只能拿它和流数、镜像
+ * 缓存估算字节一起看趋势（插件侧唯一能量化的是 `mirror.cachedBytes`，那还是估算）。
+ * 字段名与 `caveat` 都按这个口径写死，别把它改名成 pluginMemory 之类。
+ *
+ * 侧车（sidecar facade worker）是**另一个进程**（lib/sidecar-facade.cjs 的 fork），
+ * 它的内存在 `sidecarProcess` 下，与宿主分列——两个数不能相加成「插件内存」。
+ *
+ * ## 数据从哪儿来（全走既有通道，没有新开一条）
+ *
+ * - 宿主进程内存：本进程 `process.memoryUsage()` / `v8.getHeapStatistics()`。
+ * - 侧车进程内存、流数：**worker 的 `/status` 快照**（`sidecarLifecycle.getSnapshot()`，
+ *   与 `tunnel`/`lan` 状态同一个来源）。worker 没上报对应字段时如实报 `null` 并记进
+ *   `unavailable`——**不拿 0 顶替**：0 是「一条流都没有」，与「不知道」是两件事。
+ * - 局域网直连路的流数：由注入的 `getLanProxyStats()` 提供，约定形状
+ *   `() => ({ upstreamOpen, sseOpen }) | null`（`lan-proxy.js` 的 `stats()`）。
+ * - 镜像：`mirror.getMirrorPush()` / `getPushFailures()`（不在本模块重复记账），
+ *   缓存本体走 `session-cache.js` 的 `mirrorHistoryStateOf(ctx)`。
+ * - 凭据库：`credentials.listActive().length`（凭据包只暴露「活跃」这一档）。
+ *
+ * ## 为什么是工厂而不是模块级单例
+ *
+ * `desktop-half-stats.cjs` 是单例：它只记进程级的计数。这份不一样——镜像缓存按
+ * `ctx` 隔离（WeakMap），拿不到 ctx 就读不到。所以做成 `createSelfCheck(deps)`，
+ * 由 control-plane 用注入的 ctx 建一次，而不是往模块级塞一个 ctx。
+ *
+ * ## 字节估算的口径
+ *
+ * `mirror.cachedBytes` 是**估算**，不是精确占用：字符串按 `String.length`（会话正文
+ * 以 ASCII 为主，字符数≈字节）、数字 8 字节、布尔 4、每个对象/数组 24 字节固定开销。
+ * 走查有节点预算（`MAX_WALK_NODES`），用尽时 `cachedBytesComplete` 为 false，
+ * 此时那个数是**下限**而不是总量。
+ */
+
+const v8 = require('node:v8');
+
+const { mirrorHistoryStateOf } = require('./session-cache.js');
+
+/** 字节估算的节点预算：status 每 3s 被面板拉一次，走查必须是有界的。 */
+const MAX_WALK_NODES = 20000;
+/** 每个对象/数组的固定开销估计（V8 里一个空对象约这个量级）。 */
+const OBJECT_OVERHEAD_BYTES = 24;
+
+/** 只认有限数：NaN/Infinity/字符串一律记 null，「不知道」不能写成 0。 */
+function finiteNumber(value) {
+  return typeof value === 'number' && Number.isFinite(value) ? value : null;
+}
+
+/** `process.memoryUsage()` 的白名单副本 + V8 堆上限（超了这个数就是 heap OOM）。 */
+function memoryOf(usage, heapStatistics) {
+  if (!usage || typeof usage !== 'object') return null;
+  return {
+    rss: finiteNumber(usage.rss),
+    heapTotal: finiteNumber(usage.heapTotal),
+    heapUsed: finiteNumber(usage.heapUsed),
+    external: finiteNumber(usage.external),
+    arrayBuffers: finiteNumber(usage.arrayBuffers),
+    heapSizeLimit: heapStatistics && typeof heapStatistics === 'object'
+      ? finiteNumber(heapStatistics.heap_size_limit)
+      : null,
+  };
+}
+
+/**
+ * 估算一棵对象树占的字节（口径见文件头）。节点预算用尽时 `complete:false`，`bytes` 是下限。
+ */
+function estimateBytes(root, budget = MAX_WALK_NODES) {
+  const seen = new Set();
+  const stack = [root];
+  let bytes = 0;
+  let nodes = 0;
+  while (stack.length) {
+    if (nodes >= budget) return { bytes, complete: false };
+    const node = stack.pop();
+    nodes += 1;
+    if (typeof node === 'string') { bytes += node.length; continue; }
+    if (typeof node === 'number') { bytes += 8; continue; }
+    if (typeof node === 'boolean') { bytes += 4; continue; }
+    if (!node || typeof node !== 'object') continue;
+    if (seen.has(node)) continue;
+    seen.add(node);
+    bytes += OBJECT_OVERHEAD_BYTES;
+    if (Array.isArray(node)) {
+      for (const item of node) stack.push(item);
+      continue;
+    }
+    for (const key of Object.keys(node)) {
+      bytes += key.length;
+      stack.push(node[key]);
+    }
+  }
+  return { bytes, complete: true };
+}
+
+/**
+ * 镜像缓存本体：条目数 / 消息条数 / 估算字节。
+ *
+ * ⚠️ `mirrorHistoryStateOf(ctx)` 在 ctx 上还没有这张表时会**建一张空的**——这与第一次
+ * 镜像推送本来就会做的事完全一样，没有额外状态。ctx 为空（本文件被单独 require 时）
+ * 返回 null，不抛。
+ */
+function mirrorCacheOf(ctx) {
+  if (!ctx) return null;
+  const cache = mirrorHistoryStateOf(ctx);
+  if (!cache || typeof cache.size !== 'number') return null;
+  let messages = 0;
+  const bodies = [];
+  for (const entry of cache.values()) {
+    const items = entry && entry.body && Array.isArray(entry.body.items) ? entry.body.items : null;
+    if (items) messages += items.length;
+    bodies.push(entry ? entry.body : null);
+  }
+  const estimate = estimateBytes(bodies);
+  return { entries: cache.size, messages, bytes: estimate.bytes, complete: estimate.complete };
+}
+
+/**
+ * 建一份自检台账。所有依赖都是取值器或只读模块，本模块不持有 ctx 之外的可变状态。
+ *
+ * @param {object} [deps]
+ * @param {object} [deps.ctx] 插件 ctx（读镜像缓存需要；缺省时镜像缓存报 null）
+ * @param {() => object|null} [deps.getSidecarSnapshot] worker 的 `/status` 快照取值器
+ * @param {() => object|null} [deps.getMirrorPush] 镜像推送记账（pusher 提供）
+ * @param {() => Array} [deps.getMirrorPushFailures] 待补推会话账（pusher 提供）
+ * @param {() => ({upstreamOpen: number, sseOpen: number})|null} [deps.getLanProxyStats]
+ *   局域网直连路的活连接数（`lan-proxy.js` 的 `stats()`）
+ * @param {object|null} [deps.credentials] 本机设备凭据库
+ */
+function createSelfCheck(deps = {}) {
+  const {
+    ctx = null,
+    getSidecarSnapshot = () => null,
+    getMirrorPush = () => null,
+    getMirrorPushFailures = () => null,
+    getLanProxyStats = () => null,
+    credentials = null,
+  } = deps;
+  const since = Date.now();
+
+  function hostProcess() {
+    const usage = process.memoryUsage();
+    return {
+      // ⚠️ 口径：整个宿主进程，不是插件自己（见文件头）。
+      scope: 'host-process',
+      caveat: '插件住在宿主里，没有独立内存；这里是整个 DSH 宿主进程，含宿主自身与其它插件',
+      ...memoryOf(usage, v8.getHeapStatistics()),
+      startedAt: since,
+    };
+  }
+
+  function sidecarProcess(snapshot) {
+    const reported = snapshot && snapshot.process && snapshot.process.memoryUsage;
+    const memory = memoryOf(reported);
+    return { memory };
+  }
+
+  function streams(snapshot) {
+    const lan = getLanProxyStats();
+    const relaySseOpen = snapshot && snapshot.streams ? finiteNumber(snapshot.streams.relaySseOpen) : null;
+    return {
+      // 中转路：worker 里 `relay/tunnel.js` 的 sseClients.size。
+      relaySseOpen,
+      // 局域网直连路：`lan-proxy.js` 的 stats()。
+      lanUpstreamOpen: lan ? finiteNumber(lan.upstreamOpen) : null,
+      lanSseOpen: lan ? finiteNumber(lan.sseOpen) : null,
+    };
+  }
+
+  function mirror() {
+    // 拿不到记账时整块报 null 并记进 unavailable：`skippedBodies` 报 0 会被读成
+    // 「一次都没跳过」，而那是「不知道」——两者在排查时结论正好相反。
+    const push = getMirrorPush();
+    const known = Boolean(push) && typeof push === 'object';
+    const failures = getMirrorPushFailures();
+    const cache = mirrorCacheOf(ctx);
+    return {
+      pushedAt: known ? (finiteNumber(push.pushedAt) === null ? 0 : finiteNumber(push.pushedAt)) : null,
+      ok: known && typeof push.ok === 'boolean' ? push.ok : null,
+      error: known && typeof push.error === 'string' ? push.error : null,
+      skippedBodies: known ? (finiteNumber(push.skippedBodies) === null ? 0 : finiteNumber(push.skippedBodies)) : null,
+      skipReason: known && typeof push.skipReason === 'string' ? push.skipReason : null,
+      // 待补推的会话数（pusher 的失败重试账长度）。
+      pushFailures: Array.isArray(failures) ? failures.length : null,
+      // 清单规模：会话总数 / 其中活跃（在跑或 5 分钟内动过）/ 其中子会话 / 这份读数的时间。
+      // 这是插件侧**能诚实报出的**「会话有多少」——手机侧栏读的就是这份清单。
+      // ⚠️ 它**不是**「宿主内存里挂着多少会话、正文占多少」：插件住在宿主进程里，看不到那个
+      // 口径（见文件头）。正文规模只能由 `cachedBytes` 那一格回答「插件自己握着多少」。
+      listSessions: known ? finiteNumber(push.listSessions) : null,
+      listActiveSessions: known ? finiteNumber(push.listActiveSessions) : null,
+      listSubagents: known ? finiteNumber(push.listSubagents) : null,
+      listAt: known ? (finiteNumber(push.listAt) === null ? 0 : finiteNumber(push.listAt)) : null,
+      cachedSessions: cache ? cache.entries : null,
+      cachedMessages: cache ? cache.messages : null,
+      cachedBytes: cache ? cache.bytes : null,
+      cachedBytesComplete: cache ? cache.complete : null,
+    };
+  }
+
+  function credentialsBlock() {
+    const list = credentials && typeof credentials.listActive === 'function'
+      ? credentials.listActive()
+      : null;
+    return { active: Array.isArray(list) ? list.length : null };
+  }
+
+  /** 当前读数副本：每次调用都是新对象，status 视图读它、改它都不影响下一份。 */
+  function snapshot() {
+    const sidecarSnapshot = getSidecarSnapshot();
+    const sidecar = sidecarProcess(sidecarSnapshot);
+    const flow = streams(sidecarSnapshot);
+    const mir = mirror();
+    const creds = credentialsBlock();
+    const unavailable = [];
+    if (!sidecar.memory) {
+      unavailable.push('sidecarProcess.memory: worker 的 /status 未上报 process.memoryUsage');
+    }
+    if (flow.relaySseOpen === null) {
+      unavailable.push('streams.relaySseOpen: worker 的 /status 未上报 streams.relaySseOpen');
+    }
+    if (flow.lanUpstreamOpen === null) {
+      unavailable.push('streams.lanUpstreamOpen: 拿不到局域网 stats()（见 self-check.cjs 文件头）');
+    }
+    if (mir.cachedSessions === null) {
+      unavailable.push('mirror.cachedSessions: 没有 ctx，读不到镜像缓存');
+    }
+    if (mir.pushedAt === null) {
+      unavailable.push('mirror.pushedAt: 拿不到镜像推送记账（getMirrorPush）');
+    }
+    if (mir.pushFailures === null) {
+      unavailable.push('mirror.pushFailures: 拿不到镜像待补推账（getMirrorPushFailures）');
+    }
+    if (creds.active === null) {
+      unavailable.push('credentials.active: 拿不到凭据库');
+    }
+    return {
+      since,
+      hostProcess: hostProcess(),
+      sidecarProcess: sidecar,
+      streams: flow,
+      mirror: mir,
+      credentials: creds,
+      unavailable,
+    };
+  }
+
+  return { snapshot };
+}
+
+module.exports = { createSelfCheck, estimateBytes, memoryOf, MAX_WALK_NODES };

package/lib/mobile/sessions.js

@@ -41,7 +41,7 @@ const {
 } = require('./session-cache.js');
 const { resolveEventAttachments } = require('./attachments.js');
 const { updateCompletionStates, confirmCompletionFromHistory } = require('./completion.js');
-const { buildMessagesSnapshot, buildStatsSnapshot, statsProjections, handleMessages } = require('./session-snapshot.js');
+const { eventSeqOf, buildMessagesSnapshot, buildStatsSnapshot, statsProjections, handleMessages } = require('./session-snapshot.js');
 const { buildModelsSnapshot, handleModels, handleSelectModel } = require('./session-models.js');
 const { buildSingleSessionMirror, buildMirrorWarmSnapshots } = require('./session-mirror.js');
 const { promptOnce, handleSend, handleCommands, handleSessionRead, handleSessionAttachment, handleStop,

package/lib/mobile/stream.js

@@ -17,38 +17,21 @@
  * 要 unref —— 它只是保活，不该把进程退出按在 15s 一拍上。
  */
 
-const crypto = require('crypto');
-
 const { sendJson } = require('../shared/http-util');
+const {
+  writeSse: sharedWriteSse,
+  waitForDrain,
+  ssePadding,
+} = require('../shared/sse-write.js');
 const { resolveEventAttachments } = require('./sessions.js');
 const { callSessions } = require('./rpc.js');
 const { unwrap } = require('./envelope.js');
 const { normalizeJobs } = require('./jobs.js');
 
-const SSE_RETRY_MS = 3000;
 // Android React Native's XHR may buffer tiny chunked responses until its
 // internal progress threshold. Pad each SSE record so onprogress exposes it
 // promptly; the padding is an SSE comment and is ignored by clients.
 const SSE_FLUSH_PADDING_BYTES = 2048;
-/**
- * 写缓冲的两道水位（字节）。`res.write()` 在客户端读得慢时返回 false，字节留在 Node
- * 的写队列里；以前没人看这个返回值，于是「手机停在一个生成中的会话上、网络又慢」时
- * 帧无限堆积 —— 2026-10-17 真机现场：堆快照里 17.6 万条 SSE 帧（466MB）挂在
- * `WriteWrap._chunks` 上，宿主 70 分钟涨到 3.9G 被 OOM 杀掉。
- *
- * 两道闸分开，因为两种帧的「丢了能不能补」不一样：
- *  - 软水位：只丢**没有 seq 的增量帧**（`assistant/chunk`）。它本来就是可丢弃的草稿
- *    增量，同一轮收尾的 `assistant/message` 带完整正文且有 seq，重连回放能补齐；
- *  - 硬水位：连有 seq 的帧也放不下了，就返回 false 让上层收尾。客户端带 `lastSeq`
- *    重连后走 `replaySince` 把缺口补齐 —— 断流可恢复，堆内存不会。
- */
-const SSE_SHED_BUFFERED_BYTES = 4 * 1024 * 1024;
-const SSE_CLOSE_BUFFERED_BYTES = 16 * 1024 * 1024;
-/**
- * 等一次 `drain` 的上限。超过这么久还没排空，说明对面不是慢、是真的不读了（手机切后台、
- * 中转卡住），继续等只是把这条连接挂在那里，不如收尾让客户端重连。
- */
-const SSE_DRAIN_TIMEOUT_MS = 20_000;
 const REPLAY_WINDOW = 3000; // 断线补偿回放的最大事件数
 
 /**
@@ -75,90 +58,23 @@ function logStream(sessionId, message, error) {
   } catch { /* ignore */ }
 }
 
-function stableEventId(payload, frame) {
-  const source = payload && payload.type === 'session/event' ? payload : frame?.payload;
-  if (source && typeof source === 'object') {
-    if (source.type === 'session/event' && source.sessionId && source.event && Number.isFinite(source.event.seq)) {
-      return `${source.sessionId}:${source.event.seq}`;
-    }
-  }
-  if (payload && typeof payload === 'object') {
-    for (const key of ['eventId', 'rpcId', 'id', 'approvalId']) {
-      if (typeof payload[key] === 'string' && payload[key]) return payload[key];
-    }
-    const sessionId = typeof payload.sessionId === 'string' ? payload.sessionId : 'session';
-    const digest = crypto.createHash('sha256').update(JSON.stringify(payload)).digest('hex').slice(0, 24);
-    return `${sessionId}:${payload.type || 'event'}:${digest}`;
-  }
-  return frame && typeof frame.rpcId === 'string' && frame.rpcId ? frame.rpcId : undefined;
-}
-
 /**
- * 这条连接上真正「还没发出去」的字节数。
+ * 写一条 SSE 记录（策略声明，实现见 `lib/shared/sse-write.js`）。
  *
- * `res.writableLength` 只算响应对象自己那一层缓冲，真正堆积的地方在它底下的套接字
- * 写队列（堆快照里那些 `{chunk, encoding, callback}` 就是它）。第一版只看
- * `res.writableLength`，它恒为 0，两道闸一次都没触发 —— 2026-10-18 复测：修完内存
- * 仍从 410MB 涨到 1.4GB。所以要顺着 socket 一起看，取两者较大值。
- */
-function bufferedBytesOf(res) {
-  const own = Number(res.writableLength) || 0;
-  const socket = res.socket || res.connection;
-  const queued = socket ? Number(socket.writableLength) || 0 : 0;
-  return Math.max(own, queued);
-}
-
-/**
- * 等底层把缓冲吐出去（`drain`）。背压的正解：写不动就停手，而不是继续塞。
- *
- * @returns {Promise<boolean>} 真的 drain 了 → true；超时或流被中断 → false（该收尾）。
- */
-function waitForDrain(res, signal, timeoutMs = SSE_DRAIN_TIMEOUT_MS) {
-  return new Promise((resolve) => {
-    if (signal && signal.aborted) return resolve(false);
-    let done = false;
-    const cleanup = () => {
-      clearTimeout(timer);
-      if (typeof res.off === 'function') res.off('drain', onDrain);
-      if (signal && typeof signal.removeEventListener === 'function') signal.removeEventListener('abort', onAbort);
-    };
-    const finish = (value) => { if (done) return; done = true; cleanup(); resolve(value); };
-    const onDrain = () => finish(true);
-    const onAbort = () => finish(false);
-    const timer = setTimeout(() => finish(false), timeoutMs);
-    if (typeof timer.unref === 'function') timer.unref();
-    if (typeof res.once === 'function') res.once('drain', onDrain);
-    if (signal && typeof signal.addEventListener === 'function') signal.addEventListener('abort', onAbort, { once: true });
-  });
-}
-
-/**
- * 写一条 SSE 记录。
+ * 这条流的策略：软水位只丢**没有 seq** 的增量（`assistant/chunk` 是可丢弃草稿，同一轮
+ * 收尾的 `assistant/message` 带完整正文且有 seq，重连回放能补齐）；每条记录补 2048 字节
+ * 注释，让 RN 的 XHR 尽快吐出来。
  *
  * @returns {{ok: boolean, shed?: boolean, needDrain?: boolean}}
  *   `ok:false` → 这条流该收尾（客户端走了，或积压超过硬水位）；
- *   `shed:true` → 这条**增量**帧被丢掉、连接还活着（超过软水位且没有 seq）；
+ *   `shed:true` → 这条**增量**帧被丢掉、连接还活着；
  *   `needDrain:true` → 写成功了，但底下已经写不动，调用方要先 await 一次 drain 再继续。
- *
- * 丢增量只丢没有 seq 的帧：有 seq 的帧是客户端水位的一部分，丢了不回放就在手机上
- * 留一个永久的洞，那比断流更糟。
  */
 function writeSse(res, payload, frame) {
-  const buffered = bufferedBytesOf(res);
-  if (buffered > SSE_CLOSE_BUFFERED_BYTES) return { ok: false };
-  const id = stableEventId(payload, frame);
-  const hasSeq = Number.isFinite(payload && payload.seq);
-  if (buffered > SSE_SHED_BUFFERED_BYTES && !hasSeq) return { ok: true, shed: true };
-  const fields = [`retry: ${SSE_RETRY_MS}`];
-  if (id) fields.push(`id: ${id}`);
-  fields.push(`data: ${JSON.stringify(payload)}`);
-  fields.push(`: ${' '.repeat(SSE_FLUSH_PADDING_BYTES)}`, '', '');
-  try {
-    // `write()` 返回 false 才是背压的正信号：数据已经堆到高水位，继续写只会把内存
-    // 堆起来。以前把它当成功吞掉，正是这次 4GB OOM 的直接原因。
-    const accepted = res.write(`${fields.join('\n')}\n`);
-    return { ok: true, needDrain: accepted === false };
-  } catch { return { ok: false }; }
+  return sharedWriteSse(res, payload, {
+    frame,
+    padding: ssePadding(SSE_FLUSH_PADDING_BYTES),
+  });
 }
 
 /**