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

package/packages/dsh-remote-web/runtime/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/packages/dsh-remote-web/runtime/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; // 路径在最终汇总里统一展示
@@ -803,6 +807,28 @@ function spawnDetachedBridge() {
  *      但实测 kickstart 只解决"这一次"，进程被杀后不会重建（KeepAlive 已被系统绕过）→ 如实告知
  *   ③ 后台进程  ← 连 launchd 都托管不了时保证可用
  */
+/**
+ * 🔴 标签占用保护（2026-10-10 事故）：`com.dshremote.bridge` 这个 launchd label 是**全局唯一**的，
+ *   谁 bootstrap 谁就接管它。当天跑测试时，某个用例用**假 HOME + 真 launchctl** 把测试临时目录的
+ *   plist 登记到了同一个 label 上 → **真桥被顶掉**、远程访问中断，而日志里看不出任何异常。
+ *
+ *   所以 bootstrap 之前先问一句：这个 label 现在登记的 plist 是**本 relayDir 的**那份吗？
+ *   · 不是（别人家的）→ **拒绝接管**并明确报错。要强行接管得显式设
+ *     `DSH_BRIDGE_ALLOW_LABEL_TAKEOVER=1`（给人留后门，但默认安全）。
+ *   · 查不出来（launchctl 不可用/未登记）→ 照旧继续，不误伤正常安装。
+ */
+function labelOwnedByOtherDir(plistPath, domain) {
+  try {
+    const r = sh(`launchctl print ${domain}/${BRIDGE_LABEL}`);
+    if (!r.ok) return null;                       // 未登记 → 不是"别人家的"
+    const cur = String(r.stdout || "").match(/^\s*path = (.+)$/m);
+    if (!cur) return null;                        // 读不出路径 → 不拦
+    const a = cur[1].trim();
+    const b = String(plistPath).trim();
+    return a === b ? false : a;                   // 返回"占用者的 plist 路径"= 别人家的
+  } catch { return null; }
+}
+
 function startBridgeDarwin(plistPath) {
   const uid = process.getuid();
   const q = (s) => "'" + String(s).replace(/'/g, `'\\''`) + "'";
@@ -813,6 +839,16 @@ function startBridgeDarwin(plistPath) {
     for (const d of [`user/${uid}`, `gui/${uid}`]) {
       if (d !== domain) sh(`launchctl bootout ${d}/${BRIDGE_LABEL}`);
     }
+    // 先确认这个 label 不是别人（别的 relayDir）的，否则**拒绝接管**——见 labelOwnedByOtherDir
+    const foreign = labelOwnedByOtherDir(plistPath, domain);
+    if (foreign && String(process.env.DSH_BRIDGE_ALLOW_LABEL_TAKEOVER || "") !== "1") {
+      return {
+        ok: false,
+        status: "label-owned-by-other",
+        detail: `${domain}/${BRIDGE_LABEL} 已被另一个 relayDir 占用（${foreign}）—— 拒绝接管。`
+          + `真要用本目录接管，请先停掉那边的桥，或显式设 DSH_BRIDGE_ALLOW_LABEL_TAKEOVER=1。`,
+      };
+    }
     sh(`launchctl bootout ${target}`);
     let boot = sh(`launchctl bootstrap ${domain} ${q(plistPath)}`);
     if (!boot.ok) {
@@ -1505,6 +1541,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 } : {})
       };
@@ -2191,10 +2229,21 @@ function copyPluginIntoProfile(profileDir, pluginDir) {
     // 注意：插件源(npx 缓存 / npm 全局)本身就位于某个 node_modules 之下，
     // 过滤必须基于“相对插件目录”的路径片段，绝不能整条 src 路径包含判断，
     // 否则会把插件文件全过滤掉、拷出空目录(此前反复“插件入口缺失”的总根因)。
+    //
+    // 🔴 2026-10-10 修：**插件自带的 runtime/node_modules 不能被剔掉**。
+    //   旧规则是"任何一段叫 node_modules 就过滤"，这条原本只想剔掉插件自己的依赖目录
+    //   （那些由 profile 的包管理器管），却把 `runtime/node_modules/ws` 一起剔了 ——
+    //   而那份运行时正是"只有插件半"的机器**自愈补装时的来源**。剔掉它 = 自愈出来的运行环境
+    //   缺 ws（bridge 顶层 `import WebSocket from "ws"`）→ 一启动就崩，还"自检通过"。
+    //   现在：`runtime/` 之内一律保留；只过滤 runtime 之外的 node_modules。
     filter: (src) => {
       if (src === pluginDir) return true;
-      const rel = path.relative(pluginDir, src);
-      return !String(rel).split(path.sep).some((seg) => seg === "node_modules" || seg === ".git" || seg === ".DS_Store");
+      const rel = String(path.relative(pluginDir, src));
+      const segs = rel.split(path.sep);
+      if (segs.some((seg) => seg === ".git" || seg === ".DS_Store")) return false;
+      const inBundledRuntime = segs[0] === "runtime";
+      if (!inBundledRuntime && segs.some((seg) => seg === "node_modules")) return false;
+      return true;
     }
   };
 

package/packages/dsh-remote-web/test/settings-entry-placement.test.mjs

@@ -0,0 +1,185 @@
+// dsh-remote-web 侧栏快捷入口「落点」回归（2026-10-09 桌面端事故）。
+//
+// 【事故】桌面端（DSH 0.2）设置面板本身就是 `role="dialog" aria-modal="true"` 的弹层，
+//   它左侧栏目列表的第一项叫 **「通用设置」**。旧代码用「文本包含『设置』」（`indexOf !== -1`）
+//   去找侧栏那颗齿轮按钮 → **命中的是弹层里的「通用设置」**，于是我们的「📱 远程访问」
+//   快捷按钮被插进了设置面板栏目列表的最上面。业主截图反馈：「植入错了地方」。
+//
+// 本用例把 client.js 里的导航注入辅助函数**原样切出来**，喂一个最小 DOM，逐条锁住：
+//   ① 官方「设置」触发器只按**语义锚点**（aria-haspopup="dialog"）识别，且必须在弹层之外；
+//   ② 弹层内的「通用设置」**永远不能**被当成落点；
+//   ③ 精确相等优先于子串匹配；
+//   ④ 栏目项（在弹层内）仍能被找到 —— 修好落点不能把「点开栏目」这条路径弄坏。
+import assert from "node:assert/strict";
+import { readFileSync } from "node:fs";
+import test from "node:test";
+
+const SOURCE = readFileSync(new URL("../lib/client.js", import.meta.url), "utf8");
+
+/** 把 `var NAV_ENTRY_ID` 到 `openRemoteSettings` 之前的那段辅助函数切出来（含依赖的常量）。 */
+function navHelpersSource() {
+  const start = SOURCE.indexOf('var NAV_ENTRY_ID = "dru-nav-remote";');
+  // 末端锚点用**函数声明**而不是注释（注释会被重写，2026-10-10 就因此失效过一次）
+  const end = SOURCE.indexOf("function openRemoteSettings()");
+  assert.ok(start > 0 && end > start, "切片锚点失效：侧栏入口辅助函数结构变了");
+  return SOURCE.slice(start, end);
+}
+
+// ───────────────────────── 最小 DOM ─────────────────────────
+// 只实现被测代码真正用到的那几个能力：属性/类名/文本、closest、querySelectorAll。
+class El {
+  constructor(tag, opts = {}) {
+    this.tagName = String(tag).toUpperCase();
+    this.id = opts.id || "";
+    this.className = opts.cls || "";
+    this.attrs = opts.attrs || {};
+    this.ownText = opts.text || "";
+    this.parentNode = null;
+    this.children = [];
+  }
+  get textContent() {
+    return this.ownText + this.children.map((c) => c.textContent).join("");
+  }
+  getAttribute(name) {
+    if (name === "class") return this.className;
+    if (name === "id") return this.id;
+    return Object.prototype.hasOwnProperty.call(this.attrs, name) ? String(this.attrs[name]) : null;
+  }
+  append(...nodes) {
+    for (const n of nodes) { n.parentNode = this; this.children.push(n); }
+    return this;
+  }
+  /** 冒泡查最近的祖先（含自身）是否匹配选择器。 */
+  closest(selector) {
+    let cur = this;
+    while (cur) {
+      if (matches(cur, selector)) return cur;
+      cur = cur.parentNode;
+    }
+    return null;
+  }
+}
+function descendants(root, out = []) {
+  for (const c of root.children) { out.push(c); descendants(c, out); }
+  return out;
+}
+/** 单条复合选择器：tag + [attr] / [attr="v"] / [class*="x" i]。够用即可，不求完整 CSS。 */
+function matchesSimple(el, sel) {
+  const m = /^([a-zA-Z]*)((?:\[[^\]]*\])*)$/.exec(sel.trim());
+  if (!m) return false;
+  const [, tag, attrPart] = m;
+  if (tag && el.tagName !== tag.toUpperCase()) return false;
+  const attrs = attrPart.match(/\[[^\]]*\]/g) || [];
+  for (const a of attrs) {
+    const inner = a.slice(1, -1);
+    const eq = /^([^=*^$|~]+)(?:([*^$|~]?=)"?([^"]*)"?)?(?:\s+i)?$/.exec(inner);
+    if (!eq) return false;
+    const [, name, op, val] = eq;
+    const caseInsensitive = /\si$/.test(inner);
+    const actual = el.getAttribute(name.trim());
+    if (op === undefined) { if (actual === null) return false; continue; }
+    const hay = String(actual ?? "");
+    const needle = String(val ?? "");
+    const [H, N] = caseInsensitive ? [hay.toLowerCase(), needle.toLowerCase()] : [hay, needle];
+    if (op === "=" && H !== N) return false;
+    if (op === "*=" && H.indexOf(N) === -1) return false;
+    if (op === "^=" && H.indexOf(N) !== 0) return false;
+    if (op === "$=" && !H.endsWith(N)) return false;
+  }
+  return true;
+}
+function matches(el, selector) {
+  return String(selector).split(",").some((one) => matchesSimple(el, one));
+}
+function makeDocument(roots) {
+  const all = roots.flatMap((r) => [r, ...descendants(r)]);
+  return {
+    _all: all,
+    getElementById: (id) => all.find((e) => e.id === id) || null,
+    querySelectorAll: (selector) => all.filter((e) => matches(e, selector)),
+  };
+}
+function loadNavHelpers(doc) {
+  const src = navHelpersSource() + "\nreturn { pickSettingsTrigger, pickNavByToken, navInDialog };";
+  // eslint-disable-next-line no-new-func
+  return new Function("document", "window", src)(doc, {});
+}
+
+/** 复刻桌面端 0.2 的真实结构：侧栏一颗齿轮 + 设置弹层（首项「通用设置」）。 */
+function desktopFixture() {
+  const sidebar = new El("div", { cls: "sidebar" });
+  const trigger = new El("button", {
+    cls: "Dws9Sa_trigger",
+    attrs: { "aria-label": "设置", "aria-haspopup": "dialog", "aria-expanded": "false" },
+    text: "设置"
+  });
+  sidebar.append(trigger);
+
+  const dialog = new El("div", { attrs: { role: "dialog", "aria-modal": "true" } });
+  const nav = new El("nav", { cls: "Dws9Sa_nav" });
+  const general = new El("button", { cls: "Dws9Sa_navCell", text: "通用设置" });
+  const remote = new El("button", { cls: "Dws9Sa_navCell", text: "📱 远程访问" });
+  const models = new El("button", { cls: "Dws9Sa_navCell", text: "模型" });
+  nav.append(general, models, remote);
+  dialog.append(nav);
+
+  const doc = makeDocument([sidebar, dialog]);
+  return { doc, trigger, dialog, general, remote };
+}
+
+// ───────────────────────── 用例 ─────────────────────────
+
+test("★ 事故锁：官方「设置」触发器只认语义锚点，且必须落在**设置弹层之外**", () => {
+  const { doc, trigger } = desktopFixture();
+  const { pickSettingsTrigger } = loadNavHelpers(doc);
+  assert.equal(pickSettingsTrigger(), trigger, "必须命中侧栏那颗 aria-haspopup=dialog 的齿轮按钮");
+});
+
+test("★ 事故锁：弹层里的「通用设置」永远不能成为落点", () => {
+  const { doc, general } = desktopFixture();
+  const { pickSettingsTrigger, pickNavByToken } = loadNavHelpers(doc);
+  assert.notEqual(pickSettingsTrigger(), general, "「通用设置」在弹层内，绝不能被当成侧栏设置按钮");
+  // 严格等值 + 只要弹层外：结果只能是侧栏触发器，不能是「通用设置」
+  assert.notEqual(pickNavByToken("设置", { exactOnly: true, insideDialog: false }), general);
+  // 老写法（子串匹配）现在只能作为**兜底**，精确命中优先 —— 先保证不误伤
+  assert.notEqual(pickNavByToken("设置"), general, "子串匹配不得再压过精确匹配");
+});
+
+test("弹层内没有 aria-haspopup 的栏目项，不能被当成「设置」触发器", () => {
+  const dialogOnly = new El("div", { attrs: { role: "dialog", "aria-modal": "true" } });
+  const nav = new El("nav");
+  nav.append(new El("button", { cls: "navCell", text: "通用设置" }));
+  dialogOnly.append(nav);
+  const { pickSettingsTrigger } = loadNavHelpers(makeDocument([dialogOnly]));
+  assert.equal(pickSettingsTrigger(), null, "找不到可信锚点时必须**不注入**，绝不将就一个错落点");
+});
+
+test("栏目项仍在弹层内被找到（修落点不能把「打开远程访问栏目」这条路弄坏）", () => {
+  const { doc, remote } = desktopFixture();
+  const { pickNavByToken } = loadNavHelpers(doc);
+  assert.equal(pickNavByToken("远程访问", { insideDialog: true }), remote);
+});
+
+test("精确相等优先于子串：给了 exactOnly 时子串一律不算", () => {
+  const root = new El("div", { cls: "sidebar" });
+  const general = new El("button", { cls: "navCell", text: "通用设置" });
+  const settings = new El("button", { cls: "navCell", text: "设置" });
+  root.append(general, settings);
+  const { pickNavByToken } = loadNavHelpers(makeDocument([root]));
+  assert.equal(pickNavByToken("设置", { exactOnly: true, insideDialog: false }), settings);
+});
+
+test("源码约束：入口不再自己找 DOM 落点，而是注册官方槽位（2026-10-10 三修后的事实）", () => {
+  // 一修/二修都是"自己找落点"，先后落错到设置面板顶部、以及"找不到锚点干脆不注入"。
+  // 三修起改用官方槽位 sidebar.footer.action —— 本用例把这条设计锁住，防止有人再退回 DOM 注入。
+  assert.match(SOURCE, /ctx\.slots\.inject\("sidebar\.footer\.action"/,
+    "侧栏入口必须注册进官方槽位 sidebar.footer.action");
+  assert.match(SOURCE, /id:\s*"dsh-remote-nav"/, "槽位条目 id 应为 dsh-remote-nav");
+  assert.ok(!/var host = pickSettingsTrigger\(\)/.test(SOURCE),
+    "不得再出现「每 2s 找锚点注入」的老写法（那正是两次落错位置的来源）");
+  assert.ok(!/if \(navInDialog\(host\)\) return;/.test(SOURCE),
+    "老的 DOM 注入兜底应已删除（入口改由槽位渲染）");
+  // 仍保留的：打开栏目的点击路径必须还能工作，且不会把「通用设置」当成设置触发器
+  assert.match(SOURCE, /aria-haspopup="dialog"/, "打开栏目时仍按 aria-haspopup=dialog 认官方设置触发器");
+  assert.match(SOURCE, /\[role="dialog"\], \[aria-modal="true"\]/, "必须保留「在设置弹层内」的判据");
+});

package/packages/dsh-remote-web/test/settings-entry.test.mjs

@@ -162,11 +162,22 @@ function loadPlugin(opts = {}) {
   };
 }
 
-test("入口迁移：注册 settings.section 栏目（id/order/label），移除侧边栏入口与浮动面板", () => {
+test("入口：settings.section 栏目（id/order/label）+ 侧栏底部官方槽 sidebar.footer.action", () => {
   const plugin = loadPlugin();
 
-  // 不再注入侧边栏入口槽
-  assert.equal(plugin.injects.has("sidebar.footer.action"), false, "侧边栏入口槽不应再注入");
+  // 2026-10-10 三修（业主口径「就要放侧栏底部那个位置」）：入口改注册进**官方列表槽**
+  // `sidebar.footer.action`（宿主为侧栏底部区域提供的扩展点；0.2 实测该槽当前为空）。
+  // 不再自己注入 DOM —— 前两次都是"自己找落点"找错的。
+  assert.ok(plugin.injects.has("sidebar.footer.action"), "应注入官方侧栏底部槽");
+  const disposeNav = plugin.injects.get("sidebar.footer.action")();
+  assert.equal(typeof disposeNav, "function", "register 应返回 disposer");
+  const navMeta = plugin.metas.get("dsh-remote-nav");
+  assert.ok(navMeta, "侧栏入口应以 id=dsh-remote-nav 注册");
+  assert.equal(navMeta.name, "sidebar.footer.action");
+  assert.equal(typeof navMeta.label, "function");
+  assert.ok(String(navMeta.label()).includes("远程访问"), `槽位 label 应为「远程访问」，实际 ${navMeta.label()}`);
+  // 按钮 id 必须仍复用 NAV_ENTRY_ID(=dru-nav-remote)：公告徽标/首次红点按 id 取节点的逻辑依赖它
+  assert.match(SOURCE, /id:\s*NAV_ENTRY_ID/, "入口按钮的 id 必须复用 NAV_ENTRY_ID(=dru-nav-remote)");
 
   // settings.section 官方扩展点：id=dsh-remote、order=30（> Agent 预设 20，位于其下方）、label=📱 远程访问
   assert.ok(plugin.injects.has("settings.section"), "应注入 settings.section 扩展点");
@@ -202,8 +213,9 @@ test("入口迁移：settings.section 里**只有一个**栏目（id=dsh-remote
   // 搬进去之后仍然存在：面板 tab 条里的第三个 tab + 微信绿泡泡图标（行为断言见 wechat-bot-ui.test.mjs）
   assert.match(SOURCE, /"微信机器人通道"/, "微信机器人 tab 必须在面板里");
   assert.match(SOURCE, /dru-wx-ico/, "微信 tab 必须带绿泡泡图标 class");
-  // 槽注入次数仍是两次（settings.section + shell.overlay），没有偷偷加第三个 inject
-  assert.equal(plugin.injects.size, 2, `inject 的槽名应仍是 settings.section + shell.overlay，实际：${[...plugin.injects.keys()].join(",")}`);
+  // 槽注入次数：settings.section + shell.overlay + sidebar.footer.action（2026-10-10 加的侧栏入口）
+  assert.equal(plugin.injects.size, 3,
+    `inject 的槽名应是 settings.section + shell.overlay + sidebar.footer.action，实际：${[...plugin.injects.keys()].join(",")}`);
 });
 
 test("登录态账号区：无「切换账号」，有「退出登录」，头部/关于卡文案为「远程访问」", () => {
@@ -345,9 +357,11 @@ test("源码约束：侧栏注入「远程访问」按钮与官方「设置」
   assert.match(SOURCE, /dsh-remote-seen-dot/);
 });
 
-test("源码约束：无侧边栏入口/浮动面板/切换账号；命名统一为「远程访问」；新增访问密钥/设备路由", () => {
-  // 只断言“代码形态”不存在（注释里允许出现说明文字）
-  assert.doesNotMatch(SOURCE, /slots\.inject\("sidebar\.footer\.action"/);
+test("源码约束：侧栏入口走官方槽位/无浮动面板/无切换账号；命名统一为「远程访问」", () => {
+  // 2026-10-10 三修：侧栏入口**改回**官方槽位（业主口径「就要放侧栏底部那个位置」），
+  // 所以这条从"不得出现 footer.action"翻转为"必须走官方槽位、不得自己注入 DOM"。
+  assert.match(SOURCE, /slots\.inject\("sidebar\.footer\.action"/);
+  assert.doesNotMatch(SOURCE, /insertBefore\(btn, host\)/, "不得再自己插 DOM 找落点");
   assert.doesNotMatch(SOURCE, /dru-backdrop\{/);
   assert.doesNotMatch(SOURCE, /切换账号/);
   assert.doesNotMatch(SOURCE, /dsh-remote-panel/);

package/packages/dsh-remote-web/test/setup-output.test.mjs

@@ -156,3 +156,40 @@ test("★ 插件覆盖必须原子：staging → 必需文件自检 → rename
     "🔴 不得再出现「先删 dest 再原地逐文件拷贝」——那正是这次事故的成因");
   assert.match(fn, /\.staging-\$\{process\.pid\}|\.staging-/, "被强杀留下的 staging 要能清理");
 });
+
+test("★ 插件拷贝必须保留**自带的 runtime/node_modules**（ws 是桥唯一的裸依赖）", () => {
+  // 2026-10-10 事故形态：过滤规则写的是"任何一段叫 node_modules 就剔除"，
+  // 本意只想去掉插件自己的依赖目录（那些由 profile 的包管理器管），
+  // 却把 `runtime/node_modules/ws` 一起剔了 —— 而这份运行时正是"只有插件半"的机器
+  // **自愈补装时的唯一来源**。剔掉它 → 自愈出来的运行环境缺 ws
+  // （bridge 顶层 `import WebSocket from "ws"`）→ 一启动就崩，而且自检还说"已就绪"。
+  const src = readFileSync(SETUP, "utf8");
+  const i = src.indexOf("const cpOpts = {");
+  assert.ok(i > 0, "应能定位 cpOpts");
+  const j = src.indexOf("};", i);
+  const objSrc = src.slice(i, j + 2);
+  const pluginDir = "/some/node_modules/dsh-remote-web";   // 源本身就在 node_modules 之下（历史坑）
+  const path = require$path();
+  // eslint-disable-next-line no-new-func
+  const make = new Function("path", "pluginDir", `${objSrc}\nreturn cpOpts;`);
+  const cpOpts = make(path, pluginDir);
+  const keep = (p) => cpOpts.filter(p) === true;
+
+  assert.equal(keep(pluginDir), true, "插件根目录本身必须保留");
+  assert.equal(keep(path.join(pluginDir, "lib", "index.js")), true, "普通文件必须保留");
+  // ① 自带运行时的 node_modules **必须保留**（本次修复的核心）
+  assert.equal(keep(path.join(pluginDir, "runtime", "node_modules")), true, "runtime/node_modules 必须保留");
+  assert.equal(keep(path.join(pluginDir, "runtime", "node_modules", "ws", "package.json")), true,
+    "★ runtime/node_modules/ws 必须被拷进 profile —— 否则自愈出来的运行环境起不来");
+  // ② runtime 之外的 node_modules 仍然要剔除（profile 的包管理器管那部分）
+  assert.equal(keep(path.join(pluginDir, "node_modules", "foo", "index.js")), false,
+    "runtime 之外的依赖目录仍应剔除（避免把解析器裁决权抢过来）");
+  // ③ 垃圾照旧剔除
+  assert.equal(keep(path.join(pluginDir, ".git", "config")), false, ".git 必须剔除");
+  assert.equal(keep(path.join(pluginDir, "lib", ".DS_Store")), false, ".DS_Store 必须剔除");
+});
+
+/** 只在本用例里用到的 path 注入（避免为一行断言引入模块级 require 语义）。 */
+function require$path() {
+  return { join: (...a) => a.join("/"), sep: "/", relative: (from, to) => to.startsWith(from + "/") ? to.slice(from.length + 1) : to };
+}

package/packages/dsh-remote-web/test/telemetry.test.mjs

@@ -414,6 +414,44 @@ const m = await import(${JSON.stringify(INDEX_URL)});
 console.log(JSON.stringify(m.__telemetryInternals.eventOf("plugin_loaded")));
 `;
 
+test("★ 宿主版本（桌面端 0.2 真机形态）：argv[1] 是开关时，仍能从 argv 里的宿主根取到版本", async () => {
+  // 真机实测（DeepSeek Harness 0.2，Electron）宿主进程 argv：
+  //   [0] …/MacOS/DeepSeek Harness
+  //   [1] --expose-internals                                  ← 开关，不是路径
+  //   [2] …/app.asar/dsh/node_modules/@deepseek-ai/dsh-desktop-host/lib/index.js
+  //   [3] …/app.asar/dsh                                      ← 宿主根（含 node_modules/@deepseek-ai/dsh）
+  // 旧实现只看 argv[1] → 桌面端**必然**取不到版本（这正是生产反馈里答不出宿主版本的原因）。
+  const root = await mkdtemp(path.join(os.tmpdir(), "dsh-harness-desktop-"));
+  try {
+    const hostRoot = path.join(root, "app.asar", "dsh");
+    await fakeHarness(path.join(hostRoot, "node_modules", "@deepseek-ai", "dsh"), { version: "0.2.0-rc.2" });
+    assert.equal(TELEMETRY.harnessVersionFromRoot(hostRoot), "0.2.0-rc.2", "宿主根里应能读到 @deepseek-ai/dsh 的版本");
+
+    const argv = [
+      "/Applications/DeepSeek Harness.app/Contents/MacOS/DeepSeek Harness",
+      "--expose-internals",
+      path.join(hostRoot, "node_modules", "@deepseek-ai", "dsh-desktop-host", "lib", "index.js"),
+      hostRoot,
+      path.join(root, "profiles", "desktop"),
+    ];
+    assert.equal(TELEMETRY.harnessVersionFromArgv(argv), "0.2.0-rc.2", "★桌面端 argv 必须能解析出宿主版本");
+
+    // 开关/相对路径绝不能被当成路径去 realpath（否则抛错或被当成"未知"掩盖真实问题）
+    assert.equal(TELEMETRY.harnessVersionFromArgv(["--expose-internals", "-x"]), "", "全是开关 → 空串");
+    assert.equal(TELEMETRY.harnessVersionFromArgv(["relative/path", ""]), "", "非绝对路径 → 空串");
+    assert.equal(TELEMETRY.harnessVersionFromArgv([]), "", "空 argv → 空串");
+    assert.equal(TELEMETRY.harnessVersionFromArgv(undefined), "", "undefined → 空串（绝不抛）");
+    // 不是 DSH 的宿主根（有 package.json 但名字不对）→ 空串，绝不猜
+    const otherRoot = path.join(root, "other-root");
+    await fakeHarness(path.join(otherRoot, "node_modules", "@deepseek-ai", "dsh"), { name: "not-dsh", version: "1.0.0" });
+    assert.equal(TELEMETRY.harnessVersionFromRoot(otherRoot), "", "名字不是 @deepseek-ai/dsh → 空串");
+    // Web 版形态仍然照旧可用（argv[1] 是 DSH 主模块）
+    const webEntry = await fakeHarness(path.join(root, "web", "node_modules", "@deepseek-ai", "dsh"), { version: "0.1.5-rc.2" });
+    assert.equal(TELEMETRY.harnessVersionFromArgv([webEntry]), "0.1.5-rc.2", "Web 版（argv[1]=主模块）路径不得被改坏");
+  } finally { await rm(root, { recursive: true, force: true }); }
+});
+
+
 test("宿主版本：运行时从主模块解析（argv[1] → 上一级 package.json）；未知一律空串且不抛", async () => {
   const root = await mkdtemp(path.join(os.tmpdir(), "dsh-harness-"));
   try {

package/packages/dsh-remote-web/test/uninstall-runtime.test.mjs

@@ -264,7 +264,15 @@ exit 0
     // 当前 HOME 的 LaunchAgents 里有 plist（服务此前装过，但现在未运行）
     const plist = path.join(tempHome, "Library", "LaunchAgents", "com.dshremote.bridge.plist");
     await mkdir(path.dirname(plist), { recursive: true });
-    await writeFile(plist, "<?xml version=\"1.0\"?><plist version=\"1.0\"><dict/></plist>");
+    /* ⚠️ 2026-10-10：夹具必须写成**真实形态的 plist** —— 内容里要含 `<relayDir>/dsh-setup.mjs`。
+       清理助手（与插件里的两条路径）现在会先校验"这份 plist 是不是给本 relayDir 装的"：
+       只有含本 relayDir 入口脚本的 plist 才允许删。以前这里写的是空 `<dict/>`，
+       于是它同时**掩盖**了两件事：① 夹具不像真 plist；② 真实世界里那个守卫若缺失，
+       这条件会真的去删开发者的 plist（当天就发生了）。 */
+    await writeFile(plist, `<?xml version="1.0" encoding="UTF-8"?>
+<plist version="1.0"><dict>
+  <key>ProgramArguments</key><array><string>/usr/bin/node</string><string>${path.join(relayDir, "dsh-setup.mjs")}</string><string>run</string></array>
+</dict></plist>`);
 
     const routes = boot(relayDir);
     const { host, base } = await serve(routes);