dsh-mobile-plugin 0.1.84 → 0.1.86

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,40 @@ function stableEventId(payload, frame) {
   return frame && typeof frame.rpcId === 'string' && frame.rpcId ? frame.rpcId : undefined;
 }
 
+/**
+ * 这条连接上真正「还没发出去」的字节数。
+ *
+ * 只看 `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` 写进去了但底下已经写不动。
+ *
+ * 设备级流的帧全是「有东西变了」的信号，本来就幂等：丢掉一帧的代价是那一次刷新要等
+ * 下一次变更或 60s 兜底轮询；而堆在写缓冲里的代价是宿主 OOM（2026-10-17 现场：466MB
+ * 的 SSE 帧挂在 socket 写队列上，宿主撞 4GB 上限被杀）。所以软水位一律 shed。
+ */
 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 { res.write(`${fields.join('\n')}\n`); return true; } catch { return false; }
+  try {
+    const accepted = res.write(`${fields.join('\n')}\n`);
+    return { ok: true, needDrain: accepted === false };
+  } catch { return { ok: false }; }
 }
 
 async function* mergeHostAndMux(ctx, signal) {
@@ -153,13 +191,17 @@ 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) return false;
+    if (result.shed) return true;
+    framesSent += 1;
+    // 所有调用点都是同步回调（信号总线、心跳），没法在这里 await；写不动就如实回报，
+    // 由调用方 abort —— 这条流本来就是「断了重连、靠补发收敛」的语义。
+    return !result.needDrain;
   };
   /**
    * 自产的「清单变了」帧：镜像推送调度器每 500ms 比一次清单内容哈希，变了就在这里推给手机。
@@ -267,7 +309,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 || sent.needDrain) { clientGone = true; break; }
       framesSent += 1;
     }
     if (!clientGone) loopEnded = true;

package/lib/mobile/history-derive.js

@@ -79,6 +79,26 @@ function normalizeResultDiffs(meta) {
   return out.length > 0 ? out : undefined;
 }
 
+/**
+ * tool/result 的可见内容：两种形状都认。
+ *
+ * - 当前形状：`message.content` 直接就是内容块数组，成败在 `message.isError`；
+ * - 旧形状：`message.content[0]` 是 `{ isError, content: [内容块] }` 信封。
+ *
+ * 曾经只认旧形状，于是真实结果里的图片（`{type:'image', attachment}`）被当成信封剥掉、
+ * 整张图丢失，结果级 isError 也读不到（失败的工具显示成成功）。
+ */
+function toolResultParts(msg) {
+  const direct = Array.isArray(msg.content) ? msg.content : [];
+  const envelope = direct.length === 1 && direct[0] && typeof direct[0] === 'object'
+    && typeof direct[0].type !== 'string' ? direct[0] : null;
+  if (!envelope) return { parts: direct, isError: msg.isError === true };
+  return {
+    parts: Array.isArray(envelope.content) ? envelope.content : [],
+    isError: envelope.isError === true || msg.isError === true,
+  };
+}
+
 /** 预扫描 tool/result 事件，构建 callId → {isError, code} 映射（对接桌面 toolRowModel 状态派生）。 */
 function buildToolResultMap(events) {
   const map = new Map();
@@ -88,10 +108,8 @@ function buildToolResultMap(events) {
     const msg = e.data.message;
     const src = msg.source;
     if (!src || typeof src.callId !== 'string') continue;
-    const content = Array.isArray(msg.content) ? msg.content[0] : null;
-    const isError = content && content.isError === true;
+    const { parts, isError } = toolResultParts(msg);
     const code = e.data.error && typeof e.data.error.code === 'string' ? e.data.error.code : undefined;
-    const parts = content && Array.isArray(content.content) ? content.content : content ? [content] : [];
      const output = parts.map((part) => {
        if (part && typeof part.text === 'string') return part.text;
        if (part && typeof part === 'object' && part.type === 'image') return '';

package/lib/mobile/local-images.js

@@ -18,6 +18,8 @@
  * - 三级体积预算（单图 / 单段文本 / 单次响应，见下方常量）：超预算的图保持字面 markdown，
  *   不截断、不缩水成半张图。
  * - 读不到、不是普通文件、读取失败：原样保留 —— 一条图片取不到不能让整段历史或整帧 SSE 挂掉。
+ * - 围栏代码块与行内代码里的图片语法一律不碰：那是**写法示例**，不是要画的图；换掉会把
+ *   三行代码变成几十万字符的 base64，App 的代码块会铺成很长很长的一块。
  */
 
 const fs = require('node:fs/promises');
@@ -126,17 +128,97 @@ async function dataUriFor(filePath) {
   return uri;
 }
 
+/**
+ * Markdown 里「必须保持字面」的区间：围栏代码块与行内代码。
+ *
+ * 代码块里的 `![](/tmp/a.png)` 是**写法示例**而不是要画的图。旧实现整段正则替换，
+ * 会把三行代码换成几十万字符的 base64——App 把这段按代码文本铺开，就成了很长很长
+ * 的一块（真机现象：图片语法那块刷出几十屏，要划很久）。围栏判定与 App 的
+ * `utils/markdown/parser.ts` 同口径（两边都 trim 后看 3 个以上 ` / ~）。
+ */
+function literalRanges(text) {
+  const ranges = [];
+  const lines = text.split('\n');
+  const lineStarts = [];
+  let offset = 0;
+  for (const line of lines) {
+    lineStarts.push(offset);
+    offset += line.length + 1;
+  }
+  let fence = null;
+  let fenceStart = -1;
+  for (let index = 0; index < lines.length; index += 1) {
+    const line = lines[index];
+    if (fence) {
+      const close = /^(`{3,}|~{3,})[ \t]*$/.exec(line.trim());
+      if (close && close[1][0] === fence.char && close[1].length >= fence.length) {
+        ranges.push([fenceStart, lineStarts[index] + line.length]);
+        fence = null;
+      }
+      continue;
+    }
+    const open = /^(`{3,}|~{3,})/.exec(line.trim());
+    if (!open) continue;
+    fence = { char: open[1][0], length: open[1].length };
+    fenceStart = lineStarts[index];
+  }
+  // 没闭合的围栏按 App 的解析口径一直吃到文末。
+  if (fence) ranges.push([fenceStart, text.length]);
+
+  // 行内代码：同长度的反引号成对（`code`）。围栏内部的反引号已在上面标过。
+  let cursor = 0;
+  while (cursor < text.length) {
+    if (text[cursor] !== '`' || inRanges(cursor, ranges)) {
+      cursor += 1;
+      continue;
+    }
+    let ticks = 1;
+    while (text[cursor + ticks] === '`') ticks += 1;
+    let scan = cursor + ticks;
+    let closed = -1;
+    while (scan < text.length) {
+      if (text[scan] !== '`' || inRanges(scan, ranges)) {
+        scan += 1;
+        continue;
+      }
+      let run = 1;
+      while (text[scan + run] === '`') run += 1;
+      if (run === ticks) {
+        closed = scan + run;
+        break;
+      }
+      scan += run;
+    }
+    if (closed < 0) {
+      cursor += ticks;
+      continue;
+    }
+    ranges.push([cursor, closed]);
+    cursor = closed;
+  }
+  return ranges;
+}
+
+function inRanges(index, ranges) {
+  for (const [start, end] of ranges) {
+    if (index >= start && index < end) return true;
+  }
+  return false;
+}
+
 /**
  * 把一段文本里的本机图片语法换成 data URI。返回原字符串本身（`===`）表示一个字没动，
  * 调用方据此免掉不必要的对象拷贝。
  */
 async function inlineTextImages(text, budget) {
   if (typeof text !== 'string' || text.indexOf('![') < 0) return text;
-  const matches = [...text.matchAll(IMAGE_RE)];
+  const ranges = literalRanges(text);
+  const matches = [...text.matchAll(IMAGE_RE)].filter((m) => !inRanges(m.index, ranges));
   if (!matches.length) return text;
   const pool = budget || createTextImageBudget();
   let textBudget = MAX_TEXT_CHARS;
-  let out = text;
+  let out = '';
+  let cursor = 0;
   for (const m of matches) {
     if (textBudget <= 0 || pool.remaining <= 0) break;
     const filePath = localImagePathOf(m[2]);
@@ -145,9 +227,10 @@ async function inlineTextImages(text, budget) {
     if (!uri || uri.length > textBudget || uri.length > pool.remaining) continue;
     textBudget -= uri.length;
     pool.remaining -= uri.length;
-    out = out.replace(m[0], `![${m[1]}](${uri})`);
+    out += text.slice(cursor, m.index) + `![${m[1]}](${uri})`;
+    cursor = m.index + m[0].length;
   }
-  return out === text ? text : out;
+  return cursor === 0 ? text : out + text.slice(cursor);
 }
 
 module.exports = { inlineTextImages, createTextImageBudget, localImagePathOf };

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: '宿主插件清单返回了意外的结果' } };
 }

package/lib/mobile/references.js

@@ -11,8 +11,8 @@
  * 关键：这两个宿主服务 **不在 apiProxy 上** —— 它们是 Typert Remote 服务
  * （dsh-file-reference 的 fileReferences、dsh-session-reference 的
  * sessionReferenceResolver）。手机侧本来就能到它们：dsh-mobile-plugin 与宿主同进程，
- * lib/mobile/sessions.js 已经用 `ctx.get('typertGateway')` 派发过 commands.execute，
- * lib/mobile/plugins.js 也走同一条路读 pluginInventory，这里照搬。
+ * lib/mobile/sessions.js 已经派发过 commands.execute，lib/mobile/plugins.js 也走同一条路
+ * 读 pluginInventory —— 都经 host-bridge/transport.js 的 `invoke`，这里照搬。
  *
  * 两条接口（都只是转发宿主的发现域，不做任何排序或截断之外的加工）：
  *  - GET /api/mobile/v1/file-references?sessionId=…&query=…     → fileReferences.list
@@ -29,17 +29,13 @@
  */
 
 const { sendJson } = require('../shared/http-util');
+const { invoke, UNAVAILABLE: GATEWAY_UNAVAILABLE } = require('./host-bridge/transport.js');
 
 const REFERENCE_ID_MAX_CHARS = 200;       // sessionId 长度上限
 const REFERENCE_QUERY_MAX_CHARS = 200;    // 查询串长度上限（宿主 schema 只要求 string）
 const REFERENCE_MAX_ITEMS = 50;           // 与宿主 session-reference 的 candidateLimit 默认值一致
 const REFERENCE_KINDS = new Set(['file', 'directory']);
 
-/** 宿主网关；宿主没组合 dsh-api-gateway 时返回 null，调用方回 503。 */
-function gatewayOf(ctx) {
-  return (ctx.get && ctx.get('typertGateway')) || null;
-}
-
 /** 网关缺失/命名空间缺失对客户端是同一件事：宿主这个能力没装。 */
 const UNAVAILABLE = Object.freeze({
   code: 'reference-unavailable',
@@ -54,9 +50,13 @@ function errorText(error) {
 }
 
 /**
- * 经 typertGateway 调一次引用发现。
+ * 经网关调一次引用发现。
+ *
+ * 走 host-bridge/transport.js 的 `invoke`：Peer 身份与「服务/方法不存在」的收敛都在
+ * 那里，本域只做自己的 503/400 翻译。**不要自己直连网关** —— 0.2.1 起
+ * 要求每个请求自带 Peer，绕过去就是对 undefined 读 `.signal`，手机端 @ 补全整块失效。
  *
- * 注意返回值形状：`gateway.invoke()` 返回的是 **decode 后的业务结果本体**
+ * 注意返回值形状：网关回的是 **decode 后的业务结果本体**
  * （dsh-api-gateway/lib/index.js:112 `return decode(descriptor.result, result, …)`），
  * 那层 `{ok:true,value}` 外壳是浏览器传输（connection.rpc.intercept('/api')）加的，
  * invoke 不负责包。所以形状取决于服务声明的 result schema：
@@ -67,28 +67,15 @@ function errorText(error) {
  * @returns {Promise<{value?: unknown, error?: {code: string, message: string}}>}
  */
 async function callReference(ctx, namespace, method, agentId, query) {
-  const gateway = gatewayOf(ctx);
-  if (!gateway) return { error: { ...UNAVAILABLE } };
-  let result;
-  try {
-    // 两个方法的声明参数都是 agent(wire=agentId) + query(wire=query)，args 必须精确匹配；
-    // 末位 signal 是可选的取消边界（gateway 会补 NEVER_ABORTED_SIGNAL），这里给真的，
-    // 客户端断开时能让宿主那次发现提前收工。
-    result = await gateway.invoke({
-      namespace,
-      method,
-      args: { agentId, query },
-      signal: new AbortController().signal,
-    });
-  } 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
-      : 'reference-error';
-    return { error: { code, message: errorText(error) } };
+  // 两个方法的声明参数都是 agent(wire=agentId) + query(wire=query)，args 必须精确匹配；
+  // 末位 signal 是可选的取消边界（gateway 会补 NEVER_ABORTED_SIGNAL），这里给真的，
+  // 客户端断开时能让宿主那次发现提前收工。
+  const called = await invoke(ctx, namespace, method, { agentId, query }, new AbortController().signal);
+  if (called.error) {
+    if (called.error.code === GATEWAY_UNAVAILABLE.code) return { error: { ...UNAVAILABLE } };
+    return { error: { code: 'reference-error', message: errorText(called.error) } };
   }
+  const result = called.value;
   // 正常形状：裸数组（宿主声明的 result 就是数组）
   if (Array.isArray(result)) return { value: result };
   if (result && typeof result === 'object') {

package/lib/mobile/session-send.js

@@ -21,6 +21,7 @@ const {
 } = require('./session-cache.js');
 const { promptErrorObject, MODEL_UNAVAILABLE_ERROR } = require('./history-derive.js');
 const { withIdempotency, requestIdOf } = require('./idempotency.js');
+const { invoke, UNAVAILABLE: GATEWAY_UNAVAILABLE } = require('./host-bridge/transport.js');
 const readReceipt = require('../read-receipt.cjs');
 
 const SEND_MAX_BODY = 8 * 1024 * 1024; // /send 请求体上限（图片 base64）
@@ -34,7 +35,7 @@ function singleTextOf(content) {
 }
 
 /**
- * 经宿主 typertGateway 执行 slash 命令（commands.execute——桌面 Web 端同一条派发路径：
+ * 经网关执行 slash 命令（commands.execute——桌面 Web 端同一条派发路径：
  * 命令注册表命中才执行，绝不经 session.prompt 发给模型；agent 由 agentId 经同一
  * agent 查找器解析，与 session.prompt 的 turnAgentFor 同源，支持冷会话自动 resume）。
  *
@@ -51,18 +52,13 @@ function singleTextOf(content) {
  *   | {error} 查找或派发失败 | {missing} 网关服务未组合（调用方回退普通消息）
  */
 async function executeCommand(ctx, sessionId, line) {
-  const gateway = ctx.get && ctx.get('typertGateway');
-  if (!gateway) return { missing: true };
-  try {
-    const execution = await gateway.invoke({
-      namespace: 'commands',
-      method: 'execute',
-      args: { agentId: sessionId, line, submittedAttachments: [] },
-    });
-    return { execution };
-  } catch (error) {
-    return { error };
+  // 走 host-bridge/transport.js 的 invoke：Peer 身份与「服务/方法不存在」的收敛都在
+  // 那里。这里只把「网关没组合」翻成 {missing}，让调用方回退普通消息。
+  const called = await invoke(ctx, 'commands', 'execute', { agentId: sessionId, line, submittedAttachments: [] });
+  if (called.error) {
+    return called.error.code === GATEWAY_UNAVAILABLE.code ? { missing: true } : { error: called.error };
   }
+  return { execution: called.value };
 }
 
 /**
@@ -172,36 +168,30 @@ async function handleSend(ctx, req, res) {
 }
 
 /** GET /api/mobile/v1/commands?sessionId=…（token）：会话有效命令目录（与桌面 Web 端命令面板
- * 同源——typertGateway commands.list，即服务端命令注册表对该 agent 生效的完整清单）。
+ * 同源——commands.list，即服务端命令注册表对该 agent 生效的完整清单）。
  * 响应：{ ok, items:[{name, description, input?:{hint}}] }；网关未组合或失败时降级为空清单，
- * 客户端菜单据此只展示真实可执行的命令（不再硬编码）。 */
+ * 客户端菜单据此只展示真实可执行的命令（不再硬编码）。
+ *
+ * 失败一律降级成空清单是**刻意设计**：输入区不能因为目录拉不到就报错。代价是这个端点
+ * 出问题时手机上看不出任何提示，「+」菜单静默只剩媒体与文件两行 —— 2026-10 宿主升到
+ * 0.2.1 要求每个请求自带 Peer，这条路径没跟上，用户看到的就是「目标、计划、指令全没了」。 */
 async function handleCommands(ctx, req, res) {
   const sessionId = new URL(req.url, 'http://x').searchParams.get('sessionId');
   if (!sessionId) return sendJson(res, 400, { ok: false, error: { code: 'bad-request', message: '缺少 sessionId' } });
-  const gateway = ctx.get && ctx.get('typertGateway');
-  if (!gateway) return sendJson(res, 200, { ok: true, items: [] });
-  try {
-    const descriptors = await gateway.invoke({
-      namespace: 'commands',
-      method: 'list',
-      args: { agentId: sessionId },
-    });
-    const items = Array.isArray(descriptors)
-      ? descriptors
-          .filter((d) => d && typeof d.name === 'string' && d.name && typeof d.description === 'string')
-          .map((d) => ({
-            name: d.name,
-            description: d.description,
-            ...(d.input && typeof d.input === 'object' && typeof d.input.hint === 'string' && d.input.hint
-              ? { input: { hint: d.input.hint } }
-              : {}),
-          }))
-      : [];
-    sendJson(res, 200, { ok: true, items });
-  } catch (error) {
-    // 目录拉取失败不阻塞输入区：降级为空清单（等价桌面网关缺失）。
-    sendJson(res, 200, { ok: true, items: [] });
-  }
+  const called = await invoke(ctx, 'commands', 'list', { agentId: sessionId });
+  const descriptors = called.error ? null : called.value;
+  const items = Array.isArray(descriptors)
+    ? descriptors
+        .filter((d) => d && typeof d.name === 'string' && d.name && typeof d.description === 'string')
+        .map((d) => ({
+          name: d.name,
+          description: d.description,
+          ...(d.input && typeof d.input === 'object' && typeof d.input.hint === 'string' && d.input.hint
+            ? { input: { hint: d.input.hint } }
+            : {}),
+        }))
+    : [];
+  sendJson(res, 200, { ok: true, items });
 }
 
 /** POST /api/mobile/v1/session/read（token）{sessionId}：清除完成提醒。 */

package/lib/mobile/stream.js

@@ -30,6 +30,25 @@ const SSE_RETRY_MS = 3000;
 // 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; // 断线补偿回放的最大事件数
 
 /**
@@ -74,13 +93,72 @@ function stableEventId(payload, frame) {
   return frame && typeof frame.rpcId === 'string' && frame.rpcId ? frame.rpcId : undefined;
 }
 
+/**
+ * 这条连接上真正「还没发出去」的字节数。
+ *
+ * `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 记录。
+ *
+ * @returns {{ok: boolean, shed?: boolean, needDrain?: boolean}}
+ *   `ok:false` → 这条流该收尾（客户端走了，或积压超过硬水位）；
+ *   `shed:true` → 这条**增量**帧被丢掉、连接还活着（超过软水位且没有 seq）；
+ *   `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 { res.write(`${fields.join('\n')}\n`); return true; } catch { return false; }
+  try {
+    // `write()` 返回 false 才是背压的正信号：数据已经堆到高水位，继续写只会把内存
+    // 堆起来。以前把它当成功吞掉，正是这次 4GB OOM 的直接原因。
+    const accepted = res.write(`${fields.join('\n')}\n`);
+    return { ok: true, needDrain: accepted === false };
+  } catch { return { ok: false }; }
 }
 
 /**
@@ -163,7 +241,7 @@ async function handleStream(ctx, req, res) {
       if (replay.gap && !ac.signal.aborted) {
         const value = { type: 'session/resync-required', sessionId, resumeSeq, oldestSeq: replay.oldestSeq };
         // 旧实现在这里直接 `return`：既不清 keepAlive 也不 end，漏出一条永不收尾的连接。
-        if (!writeSse(res, value, { payload: value })) clientGone = true;
+        if (!writeSse(res, value, { payload: value }).ok) clientGone = true;
       }
     }
 
@@ -172,6 +250,19 @@ async function handleStream(ctx, req, res) {
       // 这一条会话的 follow + 投影 + 任务三条流（见 mobile/host-bridge.js 的 muxFrames）。
       // 不带就是设备级视角，只会给工作区基线与全局投影 —— 这里反正只要单会话。
       const frames = ctx.apiProxy.events.mux({ rpcId: 'mobile-stream', payload: { sessionId } }, ac.signal);
+      // 写一帧并把三种结果统一收口：丢增量、需要等 drain、该收尾。
+      // 「需要等 drain」这一步是这次 OOM 的正解 —— 写不动就停手，等底层消化完再继续，
+      // 而不是把帧继续往内存里塞。
+      const push = async (payload, frameArg) => {
+        const sent = writeSse(res, payload, frameArg);
+        if (sent.shed) return 'shed';
+        if (!sent.ok) return 'closed';
+        if (sent.needDrain) {
+          const drained = await waitForDrain(res, ac.signal);
+          if (!drained) { logStream(sessionId, 'drain timeout', null); return 'closed'; }
+        }
+        return 'sent';
+      };
       for await (const frame of frames) {
         const p = frame.payload;
         if (!p || p.sessionId !== sessionId) continue;
@@ -181,25 +272,31 @@ async function handleStream(ctx, req, res) {
           // 回放已覆盖该 seq（回放与实时交界处）→ 跳过，避免重复交付。
           if (seq !== null && seq <= lastDeliveredSeq) continue;
           const event = await resolveEventAttachments(ctx, sessionId, p.event);
-          if (!writeSse(res, event, { ...frame, payload: { ...p, event } })) { clientGone = true; break; }
+          // 被 shed 的只可能是没有 seq 的增量（见 writeSse 的软水位闸）；它不推进水位，
+          // 同一轮收尾的 assistant/message 会把完整正文补上。
+          const result = await push(event, { ...frame, payload: { ...p, event } });
+          if (result === 'shed') continue;
+          if (result === 'closed') { clientGone = true; break; }
           if (seq !== null) lastDeliveredSeq = seq;
         } else if (p.type === 'session/queue' || p.type === 'session/projection') {
           // 队列/投影整帧转发；不假定存在可重放的宿主 API。
-          if (!writeSse(res, p, frame)) { clientGone = true; break; }
+          const result = await push(p, frame);
+          if (result === 'shed') continue;
+          if (result === 'closed') { clientGone = true; break; }
         } else if (p.type === 'session/jobs') {
           // 后台任务整帧（桌面端会话头部任务面板的数据源）。宿主只在任务有变化时发，
           // 且**空数组也要转发** —— 那是「任务都结束了」的唯一信号，丢掉它就永远清不掉。
           const value = { type: 'session/jobs', sessionId, jobs: normalizeJobs(p.jobs) };
-          if (!writeSse(res, value, frame)) { clientGone = true; break; }
+          if (await push(value, frame) === 'closed') { clientGone = true; break; }
         } else if (p.type === 'question/requested') {
           // 问题是可回答的 mux server-request，而非 session/event；保留 rpcId 供回答关联。
           const value = { ...p, rpcId: frame.rpcId };
-          if (!writeSse(res, value, { ...frame, payload: value })) { clientGone = true; break; }
+          if (await push(value, { ...frame, payload: value }) === 'closed') { clientGone = true; break; }
         } else if (p.type === 'question/resolved' || p.type === 'approval/requested' || p.type === 'approval/asked' || p.type === 'approval/decided' || p.type === 'approval/resolved') {
           // Approval frames are server requests/resolutions, not session/event frames;
           // forward the rpcId and approval identity so the mobile client can answer safely.
           const value = ANSWERABLE_APPROVAL_TYPES.has(p.type) && frame.rpcId ? { ...p, rpcId: frame.rpcId } : p;
-          if (!writeSse(res, value, { ...frame, payload: value })) { clientGone = true; break; }
+          if (await push(value, { ...frame, payload: value }) === 'closed') { clientGone = true; break; }
         }
       }
       if (!clientGone) loopEnded = true;
@@ -255,7 +352,10 @@ async function replaySince(ctx, sessionId, sinceSeq, res, signal, onDelivered) {
       // Keep replay data identical to live SSE data: the client reducer consumes
       // the event's own type (turn/start, assistant/message, etc.).
       const payload = { type: 'session/event', sessionId, event };
-      if (!writeSse(res, event, { payload })) break;
+      const sent = writeSse(res, event, { payload });
+      if (!sent.ok) break;
+      // 回放是「一次性灌几千条」，最容易把写队列撑爆：写不动就在这里等，别一口气塞完。
+      if (sent.needDrain && !(await waitForDrain(res, signal))) break;
       if (Number.isFinite(event.seq)) onDelivered(event.seq);
     }
     return { gap, oldestSeq };

package/lib/session-cleanup.cjs

@@ -16,6 +16,9 @@
  *    （pruneOrphanedArchivedSessionsOnce）。理由写在那个函数上：桌面端的会话列表是
  *    连上宿主时拉的一份快照 + 之后的事件增量，进程里擦集合等于把已经删掉、却还留在
  *    快照里的行放回正常列表。
+ *  - **Windows 上目录删不掉 ≠ 会话没删掉**：宿主对它打开过的会话一直握着 `session.lock`
+ *    的写句柄，日志 unlink 成功后那个名字要等句柄关闭才消失（delete-pending），rmdir
+ *    于是报 ENOTEMPTY。判据改成「目录里还有没有规范名日志」：没有就是删成了。
  */
 'use strict'
 
@@ -90,6 +93,9 @@ async function readHeader(file) {
   } finally {
     stream.destroy()
     source.destroy()
+    // Windows 上句柄没真的关掉之前，这个目录项删不掉（delete-pending → rmdir 报 ENOTEMPTY）。
+    // 删会话目录就紧跟在读 header 之后，所以先等 close 再往下走。
+    if (!source.closed) await new Promise(resolve => source.once('close', resolve))
   }
   return undefined
 }
@@ -116,12 +122,16 @@ async function deleteSessionData(sessionIds) {
   for (const file of sessionFiles(root)) {
     const header = await readHeader(file)
     if (!header || !ids.has(header.id)) continue
+    const directory = path.dirname(file)
     try {
-      fs.rmSync(path.dirname(file), { recursive: true, force: true })
-      removed.push(header.id)
+      fs.rmSync(directory, { recursive: true, force: true })
     } catch (error) {
-      throw new Error(`删除会话 ${header.id} 失败：${error.message}`)
+      // Windows：宿主握着 session.lock，日志 unlink 成功了但名字还在（delete-pending），
+      // rmdir 报 ENOTEMPTY。日志都没了，这条会话对宿主就等于已经删掉，按删成记账、继续清
+      // 下一条；日志还在才算真失败（别把没删掉的说成删掉了）。
+      if (sessionFiles(directory).length > 0) throw new Error(`删除会话 ${header.id} 失败：${error.message}`)
     }
+    removed.push(header.id)
   }
   const cacheRoot = path.join(dshHome(), 'storages', 'session_projcache', 'sessions')
   for (const id of ids) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "dsh-mobile-plugin",
-  "version": "0.1.84",
+  "version": "0.1.86",
   "description": "Mobile API (/api/mobile/v1) and relay client for the DSH mobile app — desktop profile build (0.2.0-rc.2 compatible, peers resolved by the host)",
   "license": "MIT",
   "type": "module",