dsh-mobile-plugin 0.1.87 → 0.1.89

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/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/history-derive.js

@@ -138,6 +138,10 @@ function parseBlocks(blocks, toolResults) {
       // does not expose chain-of-thought. They are known blocks, not unsupported
       // content; silently omit empty placeholders and avoid leaking their JSON.
       if (typeof b.text === 'string' && b.text) out.push({ type: 'reasoning', text: b.text });
+    } else if (b.type === 'image' && b.dataUnavailable === true) {
+      // The image attachment resolver marked this block as unavailable. Keep it out of
+      // visible text; pushMessage projects its retry metadata onto unavailableImages.
+      continue;
     } else if (b.type === 'image' && typeof b.data === 'string' && typeof b.mediaType === 'string') {
       out.push({ type: 'image', mediaType: b.mediaType, data: b.data, name: typeof b.name === 'string' ? b.name : undefined });
     } else if (b.type === 'tool-call') {
@@ -321,12 +325,35 @@ function deriveMessages(events) {
 
   // 普通消息（user/assistant）沿用原折叠逻辑。
   const pushMessage = (msg, e) => {
-    const blocks = parseBlocks(msg.content, toolResults);
+    const parsed = parseBlocks(msg.content, toolResults);
+    // 工具产出的图挂成这条消息的图片附件：App 把它画在气泡上方（缩略图 + 文件名，点开全屏），
+    // 与用户自己发的图同一种形状。工具卡里不再重复画同一张图 —— 一张图两处画会把字节也翻倍。
+    const toolImages = [];
+    const blocks = parsed.map((block) => {
+      if (block.type !== 'tool-call' || !Array.isArray(block.images) || block.images.length === 0) return block;
+      toolImages.push(...block.images);
+      const { images: _movedToAttachments, ...rest } = block;
+      return rest;
+    });
     const text = blocksToText(blocks);
-    const images = blocks.filter((b) => b.type === 'image').map(({ mediaType, data, name }) => ({ mediaType, data, name }));
+    const images = [
+      ...blocks.filter((b) => b.type === 'image'),
+      ...toolImages,
+    ].map(({ mediaType, data, name }) => ({ mediaType, data, name }));
+    const unavailableImages = (Array.isArray(msg.content) ? msg.content : [])
+      .filter((block) => block && block.type === 'image' && block.dataUnavailable === true)
+      .map((block) => {
+        const attachment = block.attachment && typeof block.attachment === 'object' ? block.attachment : {};
+        return {
+          attachmentId: typeof attachment.attachmentId === 'string' ? attachment.attachmentId : '',
+          ...(typeof block.mediaType === 'string' ? { mediaType: block.mediaType } : {}),
+          ...(typeof block.name === 'string' ? { name: block.name } : {}),
+        };
+      })
+      .filter((image) => image.attachmentId !== '');
     // 只要存在可识别或保留的 block 就入列表；纯推理/工具调用也必须保留，
-    // 否则流式标签在重同步后会消失。
-    const hasContent = blocks.length > 0;
+    // 否则流式标签在重同步时会消失。
+    const hasContent = blocks.length > 0 || unavailableImages.length > 0;
     if (!hasContent) return;
     const clientMessageId = msg.role === 'user' ? clientMessageIdFromSource(msg.source, msg) : undefined;
     const item = {
@@ -335,6 +362,7 @@ function deriveMessages(events) {
       text,
       blocks,
       images: images.length > 0 ? images : undefined,
+      ...(unavailableImages.length > 0 ? { unavailableImages } : {}),
       ...(clientMessageId ? { clientMessageId } : {}),
       seq: e.seq,
       time: e.time,

package/lib/mobile/host-bridge/endpoints.js

@@ -62,8 +62,9 @@ const ENDPOINTS = {
   'sessions.updateQueue': inv('session', 'updateQueue'),
   // 宿主的 fork 请求体只有 sessionId / atSeq，increaseTitle 在 0.2.0 已删除。
   'sessions.fork': inv('session', 'fork', (p) => ({ request: pick(p, ['sessionId', 'atSeq']) })),
-  // 宿主的模型目录是全局的（不再按 session 查），这里翻译成插件/移动端要的形状。
-  'sessions.models': (ctx, payload, signal) => modelCatalog(ctx, signal),
+  // 宿主的模型目录是全局的（不再按 session 查），这里翻译成插件/移动端要的形状；
+  // payload 带 sessionId，供 modelCatalog 叠加会话自己的 modelSelection 投影。
+  'sessions.models': (ctx, payload, signal) => modelCatalog(ctx, payload, signal),
 
   // agentPresets（namespace 是复数 agentPresets）
   'agentPresets.list': inv('agentPresets', 'list', () => ({})),

package/lib/mobile/host-bridge/shims.js

@@ -47,23 +47,49 @@ async function historyViaPage(ctx, payload, signal) {
 }
 
 /**
- * `session.models` → `session.modelCatalog`。
+ * `session.models` → `session.modelCatalog` + 会话自己的 `session/projections`。
  *
  * 宿主改成全局目录了（args 为空），字段也换了名：default → current、
  * routableProviders 变成「能不能用这个 provider」。移动端要的 groups 结构两边一致，
  * 原样带过去即可。
+ *
+ * 但 `default` 是**全局**默认，不是「这个会话实际用的模型」。会话自己的模型记在
+ * `session/projections` 的 `modelSelection` 投影里（`next` 是「下一次请求要用」，
+ * 落到 `lastUsed` 是「最近一次真正跑过的」）；只有会话从没选过模型时，投影里才没有
+ * 这一项，此时才回落到全局默认。桌面端「切到某个对话显示那个对话的模型」读的正是
+ * 这份会话级投影，不是全局默认。移动端这里也要对同一口径，否则 A、B 两个会话各选
+ * 了不同模型，手机却都显示同一个「默认模型」。
+ *
+ * 读不到投影（会话不存在 / 宿主没挂投影能力）时不升级成错误：退回全局默认即可，
+ * 让模型目录照常下发，宁可少一次会话级精修也不让整个模型面板消失。
  */
-async function modelCatalog(ctx, signal) {
-  const result = await invoke(ctx, 'session', 'modelCatalog', {}, signal);
+async function modelCatalog(ctx, payload, signal) {
+  const sessionId = payload && typeof payload.sessionId === 'string' ? payload.sessionId : '';
+  const [result, projection] = await Promise.all([
+    invoke(ctx, 'session', 'modelCatalog', {}, signal),
+    sessionId ? invoke(ctx, 'session', 'projections', { request: { sessionId } }, signal) : Promise.resolve({ error: undefined, value: undefined }),
+  ]);
   if (result.error) return fail(result.error);
   const catalog = result.value && typeof result.value === 'object' ? result.value : {};
   const current = catalog.default && typeof catalog.default === 'object'
     ? pick(catalog.default, ['provider', 'model', 'reasoningEffort'])
     : null;
+  // 会话自己选过模型时，用它覆盖全局默认；读不到或没选过才保留全局默认。
+  const sessionModel = !projection.error && projection.value && typeof projection.value === 'object'
+    ? projection.value.values && typeof projection.value.values === 'object' && projection.value.values.modelSelection
+    : undefined;
+  const sessionSelection = sessionModel && typeof sessionModel === 'object'
+    ? (sessionModel.next && typeof sessionModel.next === 'object'
+      ? pick(sessionModel.next, ['provider', 'model', 'reasoningEffort'])
+      : sessionModel.lastUsed && typeof sessionModel.lastUsed === 'object'
+        ? pick(sessionModel.lastUsed, ['provider', 'model', 'reasoningEffort'])
+        : null)
+    : null;
+  const effective = sessionSelection && sessionSelection.provider && sessionSelection.model ? sessionSelection : current;
   const routable = Array.isArray(catalog.routableProviders) ? catalog.routableProviders : [];
   return ok({
-    ...(current ? { current } : {}),
-    routable: Boolean(current && routable.includes(current.provider)),
+    ...(effective ? { current: effective } : {}),
+    routable: Boolean(effective && routable.includes(effective.provider)),
     groups: Array.isArray(catalog.groups) ? catalog.groups : [],
   });
 }

package/lib/mobile/self-check.cjs

@@ -0,0 +1,254 @@
+'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,
+      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/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),
+  });
 }
 
 /**