@mrrisega/dsh-remote 0.7.0-beta.2 → 0.7.0-beta.3

package/clients/dsh-remote/dsh-bridge.mjs

@@ -254,8 +254,25 @@ function resolveInstallVersion() {
     return JSON.parse(fs.readFileSync(path.join(ROOT, "package.json"), "utf8")).version || "";
   } catch { return ""; }
 }
+/**
+ * 宿主（DeepSeek Harness）版本：**由插件注入**，bridge 自己算不出来。
+ *
+ * 为什么必须是注入：宿主版本要从"宿主进程的 argv / 安装目录"推出来，而 bridge 是插件
+ * **另外拉起的独立进程**（脱离宿主，见 dsh-setup.mjs 的守护），它的 argv 与宿主毫无关系。
+ * 插件跑在宿主进程内，能拿到真实版本（见 packages/dsh-remote-web/lib/index.js 的
+ * harnessVersion()），所以由它经 DSH_BRIDGE_HARNESS_VERSION 传下来。
+ *
+ * 与 INSTALL_VERSION 的区别（曾经把这两个数混为一谈，导致版本问题答不出来）：
+ *   install_version = **本插件**的版本（用户装的 dsh-remote-web 是哪个版本）
+ *   harness_version = **宿主**的版本（用户跑的 DeepSeek Harness 是哪个版本）
+ * 只知其一都定位不了"是不是宿主升级导致的兼容性故障"。
+ */
+function resolveHarnessVersion() {
+  return String(process.env.DSH_BRIDGE_HARNESS_VERSION || "").trim();
+}
 const INSTALL_SOURCE = resolveInstallSource();
 const INSTALL_VERSION = resolveInstallVersion();
+const HARNESS_VERSION = resolveHarnessVersion();
 
 // ---------- 稳定设备身份(.dsh-config.json) ----------
 
@@ -1399,6 +1416,9 @@ async function registerDeviceInAccount(token) {
         //   install_source: npx(安装器注入) | plugin_market(插件拉起/自愈,默认) | unknown(白名单外)
         install_source: INSTALL_SOURCE,
         install_version: INSTALL_VERSION,
+        // v15 宿主版本(由插件注入;老插件不注入 → 空串 = 未上报)。服务端 devices.harness_version。
+        // 与 install_version 是两个不同的数:前者是"插件版本",这个是"DeepSeek Harness 版本"。
+        harness_version: HARNESS_VERSION,
         host_os: process.platform,
         host_arch: process.arch
       })

package/clients/dsh-remote/mobile-adapter.mjs

@@ -1244,7 +1244,12 @@ const SCRIPT = `(() => {
          旧的 120/300 分档是照"网页首屏"的体感定的，会把大量正常可用的移动网络误报成"较慢"，
          反而让用户以为哪里坏了。 */
       const RTT_KEEP = 8, RTT_MAX_MS = 20000;
-      const rttSamples = [];
+      /* 🔴 样本数组挂在 window 上，**不在 buildRemoteMenu 的闭包里**（2026-10-09 加固）。
+         为什么：fetch 包装只装一次（window.__dshMaSessionWatch 一次性闸门），而菜单/悬浮按钮
+         在官方 SPA 重渲染时可能被**重建**。若样本数组长在 buildRemoteMenu 里，包装就会一直喂给
+         "上一代"渲染器（那个节点已经不在文档里），新界面读自己的空数组 → **永远停在「测速中…」**。
+         挂在 window 上则任何一代渲染器都读同一份样本。 */
+      const rttSamples = (window.__dshMaRttSamples || (window.__dshMaRttSamples = []));
       const rttEl = fab.querySelector('[data-role="rtt"]');
       const netEl = menu.querySelector('[data-role="net"]');
       const rttValue = () => {
@@ -1262,11 +1267,13 @@ const SCRIPT = `(() => {
         try {
           const ms = rttValue();
           const g = ms === null ? "" : rttGrade(ms);
+          // 0ms 是句谎话（不足 1ms 的真实往返会被四舍五入成 0）→ 展示层夹到 ≥1ms。
+          const shown = ms === null ? null : Math.max(1, Math.round(ms));
           if (rttEl) {
-            if (ms === null) { rttEl.hidden = true; rttEl.textContent = ""; rttEl.removeAttribute("data-rtt"); }
+            if (shown === null) { rttEl.hidden = true; rttEl.textContent = ""; rttEl.removeAttribute("data-rtt"); }
             else {
               rttEl.hidden = false;
-              rttEl.textContent = ms + "ms";
+              rttEl.textContent = shown + "ms";
               rttEl.setAttribute("data-rtt", g);
             }
           }
@@ -1274,17 +1281,22 @@ const SCRIPT = `(() => {
             netEl.setAttribute("data-rtt", g || "");
             const ico = netEl.querySelector(".ico");
             const txt = netEl.querySelector(".txt");
-            if (ico) ico.textContent = ms === null ? "📶" : (g === "bad" ? "📵" : "📶");
-            if (txt) txt.textContent = ms === null ? "测速中…（等一次网络请求后显示）" : (ms + " ms · " + rttLabel(g));
+            if (ico) ico.textContent = shown === null ? "📶" : (g === "bad" ? "📵" : "📶");
+            if (txt) txt.textContent = shown === null ? "测速中…（等一次网络请求后显示）" : (shown + " ms · " + rttLabel(g));
           }
-          try { fab.title = ms === null ? FAB_TITLE_BASE : ("远程控制：网络延迟 " + ms + "ms（" + rttLabel(g) + "） / 字号 / 加密状态 / 返回设备列表（可拖动）"); } catch (e) { /* 忽略 */ }
+          try { fab.title = shown === null ? FAB_TITLE_BASE : ("远程控制：网络延迟 " + shown + "ms（" + rttLabel(g) + "） / 字号 / 加密状态 / 返回设备列表（可拖动）"); } catch (e) { /* 忽略 */ }
         } catch (e) { /* 延迟显示失败绝不影响主功能 */ }
       };
       /** 记一个成功样本（由 fetch 包装在**响应到达**时调用；失败/超时不调用）。 */
       const noteRtt = (ms) => {
         if (typeof ms !== "number" || !isFinite(ms)) return;
         const r = Math.round(ms);
-        if (r < 1 || r > RTT_MAX_MS) return;      // 亚毫秒=同帧缓存命中；>20s=卡住/超时 → 都不是"网络延迟"
+        /* 🔴 旧写法是 if (r < 1 || ...) return; ，注释说"亚毫秒=同帧缓存命中"。这个假设是**错的**：
+           本机/回环访问（桌面端自测、在同一台机器上打开镜像页）一次真实往返往往就是 < 1ms，
+           于是**每一个**样本都被丢掉，界面永远停在「测速中…（等一次网络请求后显示）」——
+           业主 2026-10-09 实测反馈的正是这个现象。只拒绝负数与超时；0 → 展示层夹到 1ms。
+           （面板侧 chip 从一开始就是 v <= 0 + Math.max(1, round)，两边口径由此对齐。） */
+        if (r < 0 || r > RTT_MAX_MS) return;
         rttSamples.push(r);
         while (rttSamples.length > RTT_KEEP) rttSamples.shift();
         renderRtt();

package/clients/dsh-remote/test/device-registration-report.test.mjs

@@ -0,0 +1,133 @@
+// 设备登记上报口径回归（2026-10 版本分析需求）。
+//
+// 【为什么必须有】生产反馈只能看到「插件版本」（install_version），从来拿不到
+//   「宿主 DeepSeek Harness 版本」—— 于是「是不是 DSH 升级导致的兼容性故障」这个问题
+//   在后台**答不出来**（数据不能回填，只能从新版开始积累）。
+//   宿主版本由插件在**宿主进程里**问出来（harnessVersion()），经 DSH_BRIDGE_HARNESS_VERSION
+//   传给 bridge；bridge 自己（独立进程）推不出来。本用例走真实 bridge 进程 + 假账号 API，
+//   逐字断言**桥到底往 /api/devices 发了什么**。
+import assert from "node:assert/strict";
+import { spawn } from "node:child_process";
+import http from "node:http";
+import { mkdtemp, rm } from "node:fs/promises";
+import os from "node:os";
+import path from "node:path";
+import test from "node:test";
+import { setTimeout as delay } from "node:timers/promises";
+import { fileURLToPath } from "node:url";
+import { WebSocketServer } from "ws";
+
+const HERE = path.dirname(fileURLToPath(import.meta.url));
+const BRIDGE = path.join(HERE, "..", "dsh-bridge.mjs");
+
+test("设备登记：harness_version（宿主版本）与 install_version（插件版本）必须分别如实上报", async () => {
+  let seen = null;
+  const api = http.createServer((req, res) => {
+    if (req.url === "/api/device-login") {
+      res.writeHead(200, { "content-type": "application/json" });
+      res.end(JSON.stringify({ token: "token-1" }));
+      return;
+    }
+    if (req.url === "/api/devices") {
+      let raw = "";
+      req.on("data", (c) => { raw += c; });
+      req.on("end", () => {
+        try { seen = JSON.parse(raw); } catch { seen = { parseError: raw }; }
+        res.writeHead(201, { "content-type": "application/json" });
+        res.end(JSON.stringify({ device: { id: "dev-000000000002" } }));
+      });
+      return;
+    }
+    res.writeHead(404, { "content-type": "application/json" });
+    res.end(JSON.stringify({ error: "not found" }));
+  });
+  await new Promise((resolve) => api.listen(0, "127.0.0.1", resolve));
+
+  const wss = new WebSocketServer({ host: "127.0.0.1", port: 0 });
+  await new Promise((resolve) => wss.once("listening", resolve));
+
+  const tempDir = await mkdtemp(path.join(os.tmpdir(), "dsh-device-report-"));
+  const child = spawn(process.execPath, [BRIDGE], {
+    env: {
+      ...process.env,
+      DSH_BRIDGE_API: `http://127.0.0.1:${api.address().port}`,
+      DSH_BRIDGE_TUNNEL_URL: `ws://127.0.0.1:${wss.address().port}`,
+      DSH_BRIDGE_PHONE: "test-account",
+      DSH_BRIDGE_PASSWORD: "test-password",
+      DSH_BRIDGE_DEVICE_ID: "dev-000000000002",
+      DSH_BRIDGE_CONFIG: path.join(tempDir, "config.json"),
+      // 插件在宿主进程里探测到的宿主版本 → 经环境变量注入 bridge
+      DSH_BRIDGE_HARNESS_VERSION: "0.2.0-rc.2",
+      DSH_BRIDGE_INSTALL_VERSION: "0.7.0-beta.2",
+      DSH_BRIDGE_INSTALL_SOURCE: "plugin_market",
+    },
+    stdio: "ignore",
+  });
+
+  try {
+    for (let i = 0; i < 60 && !seen; i += 1) await delay(100, null, { ref: false });
+    assert.ok(seen, "bridge 应在 6 秒内完成设备登记（POST /api/devices）");
+    assert.equal(seen.harness_version, "0.2.0-rc.2", "★宿主版本必须进登记请求（这是本次需求的核心）");
+    assert.equal(seen.install_version, "0.7.0-beta.2", "插件版本照旧上报，两个数都要有");
+    assert.equal(seen.install_source, "plugin_market");
+    assert.equal(seen.device_id, "dev-000000000002");
+    assert.ok(seen.host_os && seen.host_arch, "平台/架构照旧");
+  } finally {
+    try { child.kill("SIGKILL"); } catch { /* 已退出 */ }
+    await new Promise((r) => wss.close(r));
+    await new Promise((r) => api.close(r));
+    await rm(tempDir, { recursive: true, force: true });
+  }
+});
+
+test("设备登记：老插件不注入 DSH_BRIDGE_HARNESS_VERSION 时，字段必须是空串（不是缺字段、更不是猜）", async () => {
+  let seen = null;
+  const api = http.createServer((req, res) => {
+    if (req.url === "/api/device-login") {
+      res.writeHead(200, { "content-type": "application/json" });
+      res.end(JSON.stringify({ token: "token-1" }));
+      return;
+    }
+    if (req.url === "/api/devices") {
+      let raw = "";
+      req.on("data", (c) => { raw += c; });
+      req.on("end", () => {
+        try { seen = JSON.parse(raw); } catch { seen = null; }
+        res.writeHead(201, { "content-type": "application/json" });
+        res.end(JSON.stringify({ device: { id: "dev-000000000003" } }));
+      });
+      return;
+    }
+    res.writeHead(404, { "content-type": "application/json" });
+    res.end(JSON.stringify({ error: "not found" }));
+  });
+  await new Promise((resolve) => api.listen(0, "127.0.0.1", resolve));
+  const wss = new WebSocketServer({ host: "127.0.0.1", port: 0 });
+  await new Promise((resolve) => wss.once("listening", resolve));
+
+  const tempDir = await mkdtemp(path.join(os.tmpdir(), "dsh-device-report-"));
+  const env = { ...process.env };
+  delete env.DSH_BRIDGE_HARNESS_VERSION;   // 模拟老插件
+  const child = spawn(process.execPath, [BRIDGE], {
+    env: {
+      ...env,
+      DSH_BRIDGE_API: `http://127.0.0.1:${api.address().port}`,
+      DSH_BRIDGE_TUNNEL_URL: `ws://127.0.0.1:${wss.address().port}`,
+      DSH_BRIDGE_PHONE: "test-account",
+      DSH_BRIDGE_PASSWORD: "test-password",
+      DSH_BRIDGE_DEVICE_ID: "dev-000000000003",
+      DSH_BRIDGE_CONFIG: path.join(tempDir, "config.json"),
+    },
+    stdio: "ignore",
+  });
+  try {
+    for (let i = 0; i < 60 && !seen; i += 1) await delay(100, null, { ref: false });
+    assert.ok(seen, "bridge 仍应完成设备登记");
+    assert.equal(seen.harness_version, "", "取不到就上报空串（= 未上报），绝不猜一个错的版本");
+  } finally {
+    try { child.kill("SIGKILL"); } catch { /* 已退出 */ }
+    await new Promise((r) => wss.close(r));
+    await new Promise((r) => api.close(r));
+    await rm(tempDir, { recursive: true, force: true });
+  }
+});

package/clients/dsh-remote/test/mobile-adapter-runtime.test.mjs

@@ -535,6 +535,47 @@ test("网络延迟分档：500ms 以内=顺畅、1000ms 以内=正常（远程
   }
 });
 
+test("★ 亚毫秒样本（本机/回环自测）也必须出数 —— 不得永远停在「测速中…」", async () => {
+  // 业主 2026-10-09 实测反馈：「小悬浮窗一直提示『测速中，等待下一次网络请求后开始测速』」。
+  // 根因：旧实现是 `if (r < 1) return;`（注释写"亚毫秒=同帧缓存命中"），但**本机/回环**访问
+  //   （桌面端自测、在同一台机器上打开镜像页）一次真实往返往往就是 < 1ms —— 于是**每一个**样本
+  //   都被丢掉，界面永远停在空态。面板侧 chip 从来没这个毛病（`v <= 0` + `Math.max(1, …)`），
+  //   这条用例把两侧口径钉在一起。
+  const env = harness({ width: 390, fetchImpl: async () => ({ status: 200, ok: true }) }); // 零延迟 = 亚毫秒
+  runAdapter(env);
+  const rtt = findFab(env).querySelector('[data-role="rtt"]');
+  assert.equal(rtt.hidden, true, "前提：还没有样本");
+  await env.win.fetch("/api/session/list");
+  await new Promise((r) => setTimeout(r, 10));
+  assert.equal(rtt.hidden, false, "★亚毫秒的真实往返必须记成样本（否则本机自测永远是「测速中…」）");
+  assert.equal(String(rtt.textContent), "1ms", "展示层夹到 1ms —— 0ms 是谎话");
+  const net = findMenu(env).querySelector(".dsh-ma-menu-net");
+  assert.ok(!/测速中/.test(String(net.textContent)),
+    `菜单行不得再显示空态，实际：${net.textContent}`);
+});
+
+test("★ 悬浮窗被官方 SPA 重渲染重建后，已积累的样本仍要显示（样本不跟着某一代闭包走）", async () => {
+  // fetch 包装只装一次（window.__dshMaSessionWatch 一次性闸门），而悬浮窗可能被重建。
+  // 若样本数组长在 buildRemoteMenu 的闭包里，包装会一直喂"上一代"（节点已不在文档里），
+  // 新界面读自己那份空数组 → 又是永远「测速中…」。样本挂在 window 上才不会这样。
+  const env = harness({
+    width: 390,
+    fetchImpl: async () => { await new Promise((r) => setTimeout(r, 5)); return { status: 200, ok: true }; },
+  });
+  runAdapter(env);
+  await env.win.fetch("/api/session/list");
+  await new Promise((r) => setTimeout(r, 10));
+  assert.equal(findFab(env).querySelector('[data-role="rtt"]').hidden, false, "前提：第一代已有样本");
+
+  // 模拟 SPA 重渲染：官方把 body 子树整片换掉（我们的悬浮窗跟着消失），适配层再建一代。
+  env.body.children = [];
+  runAdapter(env);
+  const fab2 = findFab(env);
+  assert.ok(fab2, "重建后应有新的悬浮按钮");
+  assert.equal(fab2.querySelector('[data-role="rtt"]').hidden, false,
+    "★重建后的悬浮窗必须立刻显示已积累的样本（旧实现读自己那份空数组 → 永远「测速中…」）");
+});
+
 test("网络延迟：无样本 / 失败请求绝不显示 0ms（显示「测速中…」是唯一正确的空态）", async () => {
   const env = harness({
     width: 390,

package/clients/dsh-remote/test/wechat-runtime.test.mjs

@@ -1983,6 +1983,77 @@ test("★ 事故锁：用户主动 /use 切走的会话不能被「最近完成
   }
 });
 
+test("★ 待补发队列：过期的**不发**（丢弃最早的），且只保留最近几条", async () => {
+  // 业主 2026-10-09 口径：「积压超过一定时限后就丢弃掉最早的数据，只保留最近几条」。
+  // 两条理由：① 迟到几小时的"任务跑完了"只会误导用户；② 攒到十几条会在平台恢复时一次连打，
+  // 实测正是这种突发批量触发 `ret=-2 prepare failed` 被限流 → 补发又失败 → 队列再涨（死循环）。
+  const ilink = await fakeIlink();
+  try {
+    const sub = makeFakeSubscriber();
+    const { rt, relayDir } = await boundRuntime(ilink, { subscriber: sub });
+    const statePath = path.join(relayDir, ".wechat-state.json");
+    const stateOf = () => JSON.parse(fs.readFileSync(statePath, "utf8"));
+    const now = Date.now();
+    const H = 60 * 60 * 1000;
+
+    // 手工造一段积压：2 条很旧（>2h）+ 1 条刚失败（刚刚）
+    rt.channel.writeState({
+      pending_outbox: [
+        { text: "很久以前的完成通知A", kind: "stopped", at: now - 5 * H },
+        { text: "很久以前的完成通知B", kind: "stopped", at: now - 3 * H },
+        { text: "刚刚的完成通知C", kind: "stopped", at: now - 1000 },
+      ],
+    });
+    // ① 面板看到的是**有效**条数（过期的不该再显示成"待补发"）
+    assert.equal(rt.status().pending_outbox, 1, "status 必须按保质期报有效条数（否则重启后面板显示永远发不出去的旧条目）");
+
+    // ② 用户随便发一条 → 触发补发：只发那条没过期的
+    await rt.handleInbound({ from_user_id: "u", item_list: [{ type: 1, text_item: { text: "/status" } }] });
+    await waitFor(() => (stateOf().pending_outbox || []).length === 0);
+    const resent = allTexts(ilink.state).filter((t) => t.startsWith("（补发）"));
+    assert.equal(resent.length, 1, `★ 只应补发未过期的那一条，实际补发 ${resent.length} 条`);
+    assert.match(resent[0], /刚刚的完成通知C/, "补发的必须是没过期的那条");
+    assert.ok(!resent.some((t) => /很久以前的完成通知/.test(t)), "★ 过期条目绝不能发出去");
+  } finally {
+    await ilink.close();
+  }
+});
+
+test("★ 待补发队列：超过上限只留最近几条（丢最早，且如实记日志）", async () => {
+  const ilink = await fakeIlink({ onSendMessage: (_s, reply) => reply({ ret: -2, errmsg: "prepare failed" }) });
+  try {
+    const infos = [];
+    const warns = [];
+    const sub = makeFakeSubscriber();
+    sub.sessionsFixture = [{ sessionId: "session-done", title: "跑完的活", running: false, cwd: "/p" }];
+    sub.summaryFixture = "做完了。";
+    const { rt, relayDir } = await boundRuntime(ilink, { subscriber: sub });
+    rt.logger = { info: (m) => infos.push(String(m)), warn: (m) => warns.push(String(m)), error() {}, debug() {}, addSecret() {} };
+    const statePath = path.join(relayDir, ".wechat-state.json");
+    const stateOf = () => JSON.parse(fs.readFileSync(statePath, "utf8"));
+
+    // 连推 9 条（每一条都发不出去 → 全部入队）。每条正文不同，才能断言"留下的是最近的"。
+    for (let i = 1; i <= 9; i += 1) {
+      sub.summaryFixture = `这是第${i}条结论。`;
+      await rt.notify({ kind: NODE_KINDS.TURN_END, sessionId: "session-done", reason: "completed", at: i });
+    }
+    const queued = stateOf().pending_outbox || [];
+    assert.equal(queued.length, 5, `★ 队列上限 = 最近 5 条，实际 ${queued.length}`);
+    const kept = queued.map((q) => String(q.text)).join("\n");
+    for (const i of [5, 6, 7, 8, 9]) {
+      assert.match(kept, new RegExp(`这是第${i}条结论`), `最近的第 ${i} 条必须保留`);
+    }
+    for (const i of [1, 2, 3, 4]) {
+      assert.ok(!kept.includes(`这是第${i}条结论`), `★ 最早的第 ${i} 条必须被丢弃（只留最近几条）`);
+    }
+    assert.ok(warns.some((m) => /待补发队列丢弃 \d+ 条/.test(m)),
+      `丢数据必须如实记日志（不得静默），实际:${JSON.stringify(warns)}`);
+  } finally {
+    await ilink.close();
+  }
+});
+
+
 test("★ 事故锁：订阅 fault 必须落到日志 + 状态（旧实现只 emit、没人接 → 全静默）", async () => {
   // 那次「一条推送都没有、日志里也没有任何报错」的根因就在这类静默里：
   // `#emitFault` 只 emit('fault')，而运行时没接这个事件 —— follow 失败/发现失败/流上限
@@ -1990,9 +2061,10 @@ test("★ 事故锁：订阅 fault 必须落到日志 + 状态（旧实现只 em
   const ilink = await fakeIlink();
   try {
     const warns = [];
+    const infos = [];
     const sub = makeFakeSubscriber();
     const { rt, relayDir } = await boundRuntime(ilink, { subscriber: sub });
-    rt.logger = { info() {}, warn: (m) => warns.push(String(m)), error() {}, debug() {}, addSecret() {} };
+    rt.logger = { info: (m) => infos.push(String(m)), warn: (m) => warns.push(String(m)), error() {}, debug() {}, addSecret() {} };
     await rt.startChannel(); // 真实接线：#startSubscriber() → 给注入的订阅器挂 handler
     try {
       sub.emit("fault", { code: "follow-limit", message: "follow 流已达上限 8", sessionId: "session-x", expected: false });
@@ -2002,9 +2074,23 @@ test("★ 事故锁：订阅 fault 必须落到日志 + 状态（旧实现只 em
       assert.equal(st.last_fault && st.last_fault.code, "follow-limit", "非预期的订阅异常要记进状态供面板显示");
 
       // 预期内的（子代理会话必然被拒 / 会话刚被删）只记日志，不该污染故障状态
+      const warnCountBefore = warns.length;
       sub.emit("fault", { code: "session/agent-busy", message: "busy", sessionId: "sub-1", expected: true });
       const st2 = JSON.parse(fs.readFileSync(path.join(relayDir, ".wechat-state.json"), "utf8"));
       assert.equal(st2.last_fault.code, "follow-limit", "expected 的异常不该覆盖真正的故障");
+      // ★2026-10-09：预期内的拒绝**不能写成 warn** —— 每生成一个子代理就会来一条，
+      // 成片的 `订阅异常 session/agent-busy …` 会把真正的故障淹掉（业主现场看到的就是这个）。
+      assert.equal(warns.length, warnCountBefore, `expected 的拒绝不得写 warn，实际:${JSON.stringify(warns)}`);
+      assert.ok(infos.some((m) => m.includes("订阅跳过(预期") && m.includes("session=sub-1")),
+        `expected 的拒绝要有一条 info 留痕（绝不静默），实际:${JSON.stringify(infos)}`);
+      // 同一对 (code, session) 反复来也只报一次：否则子代理一多照样刷屏
+      const infoCountBefore = infos.length;
+      sub.emit("fault", { code: "session/agent-busy", message: "busy", sessionId: "sub-1", expected: true });
+      sub.emit("fault", { code: "session/agent-busy", message: "busy", sessionId: "sub-1", expected: true });
+      assert.equal(infos.length, infoCountBefore, "同一 (code, session) 的预期拒绝只报一次（防刷屏）");
+      // 但**不同**会话仍各自留痕一次（可诊断，不被去重抹掉）
+      sub.emit("fault", { code: "session/agent-busy", message: "busy", sessionId: "sub-2", expected: true });
+      assert.equal(infos.length, infoCountBefore + 1, "不同子代理会话各留一条");
     } finally {
       await rt.stopChannel();
     }

package/clients/dsh-remote/wechat-runtime.mjs

@@ -199,10 +199,22 @@ const SPECIAL_EVENT_KINDS = Object.freeze([
 const NOTICE_FORMATTER_KINDS = Object.freeze(["quota", "membership"]);
 
 /**
- * 主动推送失败后的**待补发队列**上限（见 `#pushProactive`）。
- * 为什么是 20：够放下"一轮里所有该告诉用户的事"；再多下去，补发就变成刷屏了。
+ * 主动推送失败后的**待补发队列**上限（见 `#pushProactive`）：只留**最近几条**。
+ *
+ * 2026-10-09 业主口径：「积压超过一定时限后就丢弃掉最早的数据，只保留最近几条」。
+ * 从 20 收到 5 的理由：一轮里真正还值得看的就最近那么两三条；攒到 20 条的结果是
+ * 平台一恢复就**一次连打十几条** —— 实测正是这种突发批量触发 `ret=-2 prepare failed`
+ * 被限流，于是补发又失败、队列再涨，越积越多永远还不上（现场观察到的就是这个循环）。
+ */
+const MAX_OUTBOX = 5;
+/**
+ * 待补发条目的**保质期**：超过这个时长还没送达就丢弃（先丢最旧的）。
+ *
+ * 为什么必须有（同一条业主口径）：一条"任务跑完了"的通知迟到几小时就**毫无价值** ——
+ * 补发出去只会让用户以为刚刚才发生；而队列的价值在于"网络抖动期间的短暂失败"，
+ * 那是分钟级的。2 小时足够覆盖抖动与短时离线，又不会把半天前的旧事翻出来刷屏。
  */
-const MAX_OUTBOX = 20;
+const OUTBOX_TTL_MS = 2 * 60 * 60 * 1000;
 /** 补发时的正文前缀（迟到必须如实说，不能让用户以为刚刚才发生）。 */
 const OUTBOX_MARK = "（补发）";
 
@@ -337,6 +349,12 @@ function sendJson(res, status, body) {
 }
 
 export class WeChatRuntime {
+  /**
+   * 「预期内的订阅拒绝」已报过的 (code|sessionId) 集合 —— 见 fault 处理器。
+   * 只是防刷屏：每生成一个**子代理**会话都会被订阅层拒一次，不记集合就是每个子代理刷一行 warn。
+   */
+  #expectedFaultSeen = new Set();
+
   /**
    * @param {{
    *   relayDir: string,
@@ -508,7 +526,9 @@ export class WeChatRuntime {
       followed_sessions: this.subscriber && typeof this.subscriber.sessions === "function"
         ? this.subscriber.sessions()
         : [],
-      pending_outbox: Array.isArray(state.pending_outbox) ? state.pending_outbox.length : 0,
+      // 报**有效**条数（按保质期过滤后）：否则进程重启后，面板会一直显示那几条早已过期、
+      // 永远不会被补发的条目，看起来像"队列卡住了"。真正的清理由 #trimOutbox 落盘。
+      pending_outbox: this.#pruneOutbox(state.pending_outbox).kept.length,
       last_fault: state.last_fault || null,
       last_completed_session_id: state.last_completed_session_id || "",
       last_completed_at: Number(state.last_completed_at || 0),
@@ -1547,14 +1567,44 @@ export class WeChatRuntime {
     return list;
   }
 
+  /**
+   * 丢掉**过期**条目（返回保留的与丢掉的数量）。
+   * `at` 缺失/非法 = 更早的落盘格式（那时还没有 at 字段）→ 一律视为过期：
+   * 留着只会把"最近几条"挤掉，而它们必然比 TTL 更老。
+   */
+  #pruneOutbox(list) {
+    const now = this.clock();
+    const kept = [];
+    let dropped = 0;
+    for (const item of Array.isArray(list) ? list : []) {
+      const at = Number(item && item.at);
+      if (!Number.isFinite(at) || at <= 0 || now - at > OUTBOX_TTL_MS) { dropped += 1; continue; }
+      kept.push(item);
+    }
+    return { kept, dropped };
+  }
+
+  /** 丢弃过期的、并按上限只留最近几条；丢了就**如实记一行日志**（绝不静默丢）。 */
+  #trimOutbox(list) {
+    const { kept, dropped } = this.#pruneOutbox(list);
+    let overflow = 0;
+    while (kept.length > MAX_OUTBOX) { kept.shift(); overflow += 1; }
+    const lost = dropped + overflow;
+    if (lost > 0) {
+      const mins = Math.round(OUTBOX_TTL_MS / 60000);
+      const why = [dropped ? `${dropped} 条超 ${mins} 分钟未送达` : "", overflow ? `${overflow} 条超出最近 ${MAX_OUTBOX} 条上限` : ""]
+        .filter(Boolean).join("、");
+      this.logger.warn(`[wechat] 待补发队列丢弃 ${lost} 条（${why}），保留最近 ${kept.length} 条`);
+    }
+    return kept;
+  }
+
   #enqueueOutbox(text, kind = "") {
     const body = String(text || "");
     if (!body) return 0;
     const list = this.#outbox();
     list.push({ text: body, kind: String(kind || ""), at: this.clock() });
-    // 上限：丢最旧的（用户最需要的是"最近发生了什么"，而无限攒下去只会让补发像刷屏）
-    while (list.length > MAX_OUTBOX) list.shift();
-    return this.#writeOutbox(list).length;
+    return this.#writeOutbox(this.#trimOutbox(list)).length;
   }
 
   /**
@@ -1562,7 +1612,11 @@ export class WeChatRuntime {
    * @returns {Promise<number>} 这次补发成功的条数
    */
   async #flushOutbox(to) {
-    const list = this.#outbox();
+    // 补发前先按保质期清一遍：**过期的不发**（迟到几小时的"任务跑完了"只会误导用户），
+    // 也避免一次性连打十几条把平台打限流（那正是队列越积越多的成因）。
+    const raw = this.#outbox();
+    const list = this.#trimOutbox(raw);              // 只在真丢了东西时才落盘（避免每轮都写状态文件）
+    if (list.length !== raw.length) this.#writeOutbox(list);
     if (!list.length || !to) return 0;
     let sent = 0;
     const rest = [...list];
@@ -1645,10 +1699,20 @@ export class WeChatRuntime {
       const code = String((info && info.code) || "unknown");
       const message = String((info && info.message) || "").slice(0, 160);
       const sessionId = String((info && info.sessionId) || "");
-      this.logger.warn(`[wechat/events] 订阅异常 ${code}${sessionId ? ` session=${sessionId}` : ""}: ${message}`);
-      if (!(info && info.expected === true)) {
-        this.channel.writeState({ last_fault: { code, message, session_id: sessionId, at: this.clock() } });
+      // 预期内的拒绝（子代理会话必然被拒 `session/agent-busy` / 会话刚被删 `session/not-found`）
+      // **不是故障**：每生成一个子代理就会来一条，写成 warn 会把真正的故障淹掉
+      // （2026-10-09 现场：日志里成片 `订阅异常 session/agent-busy … require their durable parent address`）。
+      // 但也不能完全静默（2026-09-25 的教训：fault 以前没人接，全丢）→ 降为 info，且同一对只报一次。
+      if (info && info.expected === true) {
+        const key = `${code}|${sessionId}`;
+        if (this.#expectedFaultSeen.size < 200 && !this.#expectedFaultSeen.has(key)) {
+          this.#expectedFaultSeen.add(key);
+          this.logger.info(`[wechat/events] 订阅跳过(预期，不重试) ${code}${sessionId ? ` session=${sessionId}` : ""}: ${message}`);
+        }
+        return;
       }
+      this.logger.warn(`[wechat/events] 订阅异常 ${code}${sessionId ? ` session=${sessionId}` : ""}: ${message}`);
+      this.channel.writeState({ last_fault: { code, message, session_id: sessionId, at: this.clock() } });
     });
   }
 

package/dsh-setup.mjs

@@ -362,9 +362,13 @@ const SERVICE_PATH = "/usr/local/bin:/opt/homebrew/bin:/usr/bin:/bin:/usr/sbin:/
  * 插件市场那条路径由插件半自愈补装：插件 spawn 本安装器时显式传入
  * DSH_BRIDGE_INSTALL_SOURCE=plugin_market，这里原样透传（外部注入 > 硬编码默认）。
  * install_version：优先取外部注入（插件/在线更新器），否则取本包 package.json 版本。
+ * harness_version：**只能由外部注入** —— 宿主（DeepSeek Harness）版本要从宿主进程的 argv /
+ *   安装目录推出来，而安装器是独立进程，推不出来。插件会在宿主进程内问出来再传进来；
+ *   用户直接跑 `npx @mrrisega/dsh-remote` 时没有这个值 → 留空（= 未上报，绝不猜一个错的）。
  */
 const INSTALL_SOURCE = String(process.env.DSH_BRIDGE_INSTALL_SOURCE || "").trim() || "npx";
 const INSTALL_VERSION = String(process.env.DSH_BRIDGE_INSTALL_VERSION || "").trim() || pkgVersion();
+const HARNESS_VERSION = String(process.env.DSH_BRIDGE_HARNESS_VERSION || "").trim();
 
 /**
  * 把文件权限收紧到「只有本人可读写」。
@@ -708,7 +712,7 @@ function writeAutostartFile() {
   <key>LimitLoadToSessionType</key><array><string>Aqua</string><string>Background</string></array>
   <key>StandardOutPath</key><string>${path.join(CONFIG_DIR, ".dsh-bridge.log")}</string>
   <key>StandardErrorPath</key><string>${path.join(CONFIG_DIR, ".dsh-bridge.log")}</string>
-  <key>EnvironmentVariables</key><dict><key>PATH</key><string>${SERVICE_PATH}</string>${SERVICE_NODE_ENV_PLIST}<key>DSH_BRIDGE_INSTALL_SOURCE</key><string>${INSTALL_SOURCE}</string><key>DSH_BRIDGE_INSTALL_VERSION</key><string>${INSTALL_VERSION}</string></dict>
+  <key>EnvironmentVariables</key><dict><key>PATH</key><string>${SERVICE_PATH}</string>${SERVICE_NODE_ENV_PLIST}<key>DSH_BRIDGE_INSTALL_SOURCE</key><string>${INSTALL_SOURCE}</string><key>DSH_BRIDGE_INSTALL_VERSION</key><string>${INSTALL_VERSION}</string><key>DSH_BRIDGE_HARNESS_VERSION</key><string>${HARNESS_VERSION}</string></dict>
 </dict></plist>`;
     // ~/Library/LaunchAgents 在全新账户/精简系统上可能不存在,必须先建目录,
     // 否则 writeFileSync 抛 ENOENT 直接把安装流程打断(用户反馈里也踩过类似的路径问题)。
@@ -724,7 +728,7 @@ function writeAutostartFile() {
   if (process.platform === "linux") {
     const dir = path.join(os.homedir(), ".config/systemd/user");
     fs.mkdirSync(dir, { recursive: true });
-    const unit = `[Unit]\nDescription=dsh-remote bridge (auto-starts with dsh web)\n\n[Service]\nExecStart=${runCmd}\nRestart=on-failure\nRestartSec=5\nEnvironment=PATH=${SERVICE_PATH}\n${SERVICE_NODE_ENV_UNIT}Environment=DSH_BRIDGE_INSTALL_SOURCE=${INSTALL_SOURCE}\nEnvironment=DSH_BRIDGE_INSTALL_VERSION=${INSTALL_VERSION}\n\n[Install]\nWantedBy=default.target\n`;
+    const unit = `[Unit]\nDescription=dsh-remote bridge (auto-starts with dsh web)\n\n[Service]\nExecStart=${runCmd}\nRestart=on-failure\nRestartSec=5\nEnvironment=PATH=${SERVICE_PATH}\n${SERVICE_NODE_ENV_UNIT}Environment=DSH_BRIDGE_INSTALL_SOURCE=${INSTALL_SOURCE}\nEnvironment=DSH_BRIDGE_INSTALL_VERSION=${INSTALL_VERSION}\nEnvironment=DSH_BRIDGE_HARNESS_VERSION=${HARNESS_VERSION}\n\n[Install]\nWantedBy=default.target\n`;
     const unitPath = autostartFilePath();
     fs.writeFileSync(unitPath, unit);
     return unitPath; // 路径在最终汇总里统一展示
@@ -1505,6 +1509,8 @@ async function runBridge() {
         // 安装口径透传给 bridge（bridge 把它随设备登记请求一起上报给账号 API）
         DSH_BRIDGE_INSTALL_SOURCE: INSTALL_SOURCE,
         DSH_BRIDGE_INSTALL_VERSION: INSTALL_VERSION,
+        // 宿主版本：外部注入（插件在宿主进程内问出来的），安装器只是搬运工；没有就是空串
+        DSH_BRIDGE_HARNESS_VERSION: HARNESS_VERSION,
         ...(saas ? { DSH_BRIDGE_PHONE: (cfg.phone || cfg.email || ""), DSH_BRIDGE_PASSWORD: cfg.password, DSH_BRIDGE_API: apiUrl, DSH_BRIDGE_SECRET: cfg.bridge_secret || "" } : {}),
         ...(local ? { DSH_BRIDGE_LOCAL_KEY: cfg.local_key } : {})
       };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@mrrisega/dsh-remote",
-  "version": "0.7.0-beta.2",
+  "version": "0.7.0-beta.3",
   "description": "手机远程控制 DeepSeek Harness · Remote control DeepSeek Harness (dsh web) from any phone browser — 100% 全功能 App 级体验：发消息、看工具执行、审批权限、改设置、管凭据，含特权操作，免内网穿透。一条命令安装 npx @mrrisega/dsh-remote。Mobile remote control for DSH, self-host or SaaS, no server needed on LAN.",
   "keywords": [
     "deepseek-harness",