dsh-remote-web 0.7.6-beta.2 → 0.7.6-beta.4

package/lib/client.js

@@ -2950,6 +2950,8 @@ window.__ModuleLoader__.load({
         : "已停止";
       // 是否需要重启 DeepSeek harness（首次安装/在线更新后置顶提醒 + 底部常驻按钮）
       var restartInfo = (st && st.restart) || {};
+      // 桌面端「暫存插件更新」：新版本已下载，退出应用后由 bridge 自动安装（见 dsh-bridge 的 applier）
+      var desktopUpdatePending = (st && st.desktopUpdatePending) || null;
       var restartPending = !!restartInfo.pending;
       // 宿主形态（node 半下发）：桌面端（Electron）Host 由桌面应用托管，重启这个动作
       // 在那边**做不到也不该做**（强行退出会弹原生致命错误）。面板据此：
@@ -5309,12 +5311,18 @@ window.__ModuleLoader__.load({
           // 不该混在桌面端适配里顺手做掉。桌面端才走新文案。
           // 2026-10-17（业主）：桌面端运行环境由应用托管、更新自动热加载 ——
           // **不再引导用户重启 DeepSeek Harness**，统一只说「刷新页面即可生效」。
-          var restartRowText = (desktopHost || !isRestartHard)
-            ? "🔄 插件已更新：刷新页面即可生效"
-            : "🔄 插件已更新：重启 dsh web 后生效";
+          // 桌面端：插件更新需要退出并重新打开应用（应用独占 profile，不能热改）；
+          // 若已暂存新版本，bridge 会在应用退出后自动安装，重开即生效 —— 绝不说「刷新页面即可」。
+          var restartRowText = desktopHost
+            ? (desktopUpdatePending
+              ? "🆕 新版本已下载：退出并重新打开 DeepSeek Harness 后自动生效（无需终端）"
+              : "🔄 插件已更新：退出并重新打开 DeepSeek Harness 后生效")
+            : (!isRestartHard
+              ? "🔄 插件已更新：刷新页面即可生效"
+              : "🔄 插件已更新：重启 dsh web 后生效");
           rows.push(h("div", { className: "dru-access-tip-row", key: "restart" },
             h("span", null, restartRowText),
-            (isRefreshOnly || !desktopHost) ? h("button", {
+            (!desktopHost || isRefreshOnly) && !desktopHost ? h("button", {
               type: "button",
               className: "dru-linkbtn",
               disabled: busy !== "",
@@ -5366,13 +5374,17 @@ window.__ModuleLoader__.load({
                     // **任何情况都不再引导"重启/退出重开应用"**，只说「刷新页面即可生效」。
                     // 非桌面端（自建 dsh web）保留原有 isRestartHard 判据，文案不变。
                     desktopHost
-                      ? "插件已更新：刷新页面即可生效"
+                      ? (desktopUpdatePending
+                        ? "新版本已下载：退出并重新打开 DeepSeek Harness 后生效"
+                        : "插件已更新：退出并重新打开 DeepSeek Harness 后生效")
                       : (isRestartHard
                         ? "插件已更新，重启 dsh web 后生效"
                         : (isRefreshOnly ? "插件已更新，刷新页面即可生效" : "需要重启 dsh web 才能载入新插件"))),
                   h("div", { className: "dru-restart-alert-sub" },
                     desktopHost
-                      ? "新插件已经在磁盘上，刷新一下这个页面即可载入（手机端连接与已登录状态都不受影响）。如果刷新后仍看不到面板，在应用内「插件」页重新安装一次即可。"
+                      ? (desktopUpdatePending
+                        ? "新版本已经下载到本机；DeepSeek Harness 退出后，后台服务会自动完成安装，重新打开应用即生效（无需终端，手机端连接与已登录状态都不受影响）。"
+                        : "新插件已在磁盘上，但桌面应用仍在运行旧插件；退出 DeepSeek Harness 后重新打开即可载入新版（应用退出后后台服务会自动完成安装，无需终端）。")
                       : (isRestartHard
                         ? "新版本已经装到这台电脑上，但当前运行的 dsh web 还是旧代码（新的后台路由与面板要等它重新载入）。手机端连接与已登录状态都不受影响；重启期间页面会短暂断开，然后自动恢复。"
                         : (isRefreshOnly

package/lib/index.js

@@ -2817,6 +2817,29 @@ function writeRestartState(relayDir, state) {
  * 标记「需要用户动一下」的状态。kind = refresh(插件被运行时改写,刷新页面即可)。
  * 历史 kind(first-install / update)已废弃:热加载落地后,装插件与在线更新都不再需要重启 harness。
  */
+/** 桌面端「暫存插件更新」marker（dsh-setup 在应用运行时暂存；bridge 在应用退出后自动安装）。 */
+function readDesktopUpdatePending(relayDir) {
+  try {
+    const m = JSON.parse(readFileSync(join(relayDir, ".plugin-update-pending.json"), "utf8"));
+    return { version: String(m.version || ""), stagedAt: Number(m.stagedAt) || 0 };
+  } catch {
+    return null;
+  }
+}
+
+/** 更新进程成功收尾后写「待生效」提示：桌面端暂存更新 → 退出应用后自动安装；其它 → 重启 dsh web。 */
+function markUpdateRestartPending(relayDir) {
+  const staged = readDesktopUpdatePending(relayDir);
+  if (staged) {
+    return markRestartPending(
+      relayDir,
+      "restart-app",
+      `新版本${staged.version ? ` ${staged.version}` : ""} 已下载：退出并重新打开 DeepSeek Harness 后自动生效（无需终端）`
+    );
+  }
+  return markRestartPending(relayDir, "restart", "插件已更新，重启 dsh web 后生效");
+}
+
 function markRestartPending(relayDir, kind, reason) {
   const cur = readRestartState(relayDir);
   if (cur.pending && cur.kind === kind) return cur; // 幂等：同一原因不反复重写
@@ -3748,6 +3771,8 @@ async function composeStatus(relayDir) {
     // 是否需要重启 DeepSeek harness（首次安装 / 在线更新后必须重启才加载插件本体）：
     // {pending, kind: first-install|update, reason, at}，供面板顶部醒目提示 + 重启按钮。
     restart: readRestartState(relayDir),
+    // 桌面端暂存的插件更新（存在 = 新版本已下载，退出应用后由 bridge 自动安装并生效）
+    desktopUpdatePending: readDesktopUpdatePending(relayDir),
     // 安装/配对自检（2026-10-17 事故）：运行时（clients/）与配对（.dsh-config.json）是否齐全、
     // 缺什么、下一步该做什么；配对主配置缺失但备份存在时给出可一键恢复的 backup.action。
     // 字段契约见 setupStateOf；connect.setup 是同一份对象（bridge-status 短轮询也能拿到）。
@@ -4586,7 +4611,7 @@ async function runOnlineUpdate(relayDir) {
           updateFailures.delete(String(relayDir));
           sweepIfSucceeded(); // C8：装完清残留（按更新前的 pid 点名 + 命令行复核）
           // 更新成功 → 落一条「必须重启 dsh web」的强提醒（见 run() 成功分支的同款注释）
-          markRestartPending(relayDir, "restart", "插件已更新，重启 dsh web 后生效");
+          markUpdateRestartPending(relayDir);
         }
       });
       child.unref();
@@ -4676,7 +4701,7 @@ async function runOnlineUpdate(relayDir) {
           // 客户端按 kind 一一对应地换文案与主按钮（见 client.js 的 restartAlert），
           // 混用一个 kind 就会再次出现"文案说刷新、状态其实是重启"。
           // settleRestartState() 靠 bootId 自动结清 —— 用户真的重启后这条提示自己消失，不需要额外清理。
-          markRestartPending(relayDir, "restart", "插件已更新，重启 dsh web 后生效");
+          markUpdateRestartPending(relayDir);
         }
       });
       child.unref();

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "dsh-remote-web",
-  "version": "0.7.6-beta.2",
+  "version": "0.7.6-beta.4",
   "description": "公网远程控制 DeepSeek Harness（dsh web）：安装即得专属加密地址，人在外面也能用手机访问电脑上的 dsh——无需同一局域网/WiFi、无需公网 IP 与内网穿透，全程加密；手机端 100% 还原电脑体验（对话/工具/审批/设置）。技术用户可选自建服务，流量走自己的服务器。Remote control DeepSeek Harness (dsh web) from anywhere over the public internet — install, get an encrypted URL, use it from your phone on any network (dual-half cordis plugin: Settings panel + same-origin /dsh-remote routes). (2026-09 由 dsh-remote-ui 更名 / renamed from dsh-remote-ui; dsh-remote 的 dsh web 插件半，不是纯 UI/皮肤插件)",
   "type": "module",
   "main": "lib/index.js",

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

@@ -82,6 +82,7 @@ import WebSocket from "ws";
 import fs from "node:fs";
 import os from "node:os";
 import path from "node:path";
+import net from "node:net";
 import { execSync, spawnSync } from "node:child_process";
 import { randomBytes, generateKeyPairSync, createHash } from "node:crypto";
 import { pathToFileURL, fileURLToPath } from "node:url";
@@ -630,7 +631,10 @@ export function dcSend(dc, obj) {
  *   · 每轮发送前先排空控制车道，并检查 `ws.bufferedAmount`：超过高水位就停手等它排空。
  *     于是控制帧前面最多只有「高水位 + 一片」的待发字节 —— 默认 64KB + 64KB，手机 1Mbps
  *     下 ≈1s，8Mbps 下 ≈0.13s，远小于 router 的 20s，也满足「大响应传输中 1s 内应答」目标。
- *   · 小帧（交互消息 / SSE 块）单独一条车道，优先于大帧的下一片（交互不被整帧传输拖住）。
+ *   · **数据帧严格 FIFO**（2026-10-24 修）：早期实现让小帧（交互/SSE 块）插到大帧下一片之前，
+ *     这在同一 WS 流里是**乱序** —— 生产表现为手机远程页「历史加载失败：session event stream
+ *     emitted an entry before its opening cursor」。现在只有一个数据队列，大帧按片就地推进，
+ *     绝不因大小/类型被后来的帧超越；只有控制帧（不承载有序数据）保留插队权。
  *   · 阈值 / 分片大小可用环境变量调（见 tunnelBulkOptionsFromEnv），弱网部署可再调低。
  */
 export const TUNNEL_BULK_HWM_DEFAULT = 64 * 1024;    // 发送缓冲高水位（字节）
@@ -679,13 +683,19 @@ export function makePrioritySender({
   let pumping = false;
   let scheduled = false;
   let timerPending = false;
-  const smallQ = []; // 小帧（可整帧直发）：交互消息 / SSE 块 —— 优先于大帧的下一片
-  const bigQ = [];   // 大帧：{ frames: string[], i }
-  const stats = { controlSent: 0, smallSent: 0, bigFrames: 0, bigChunks: 0, waits: 0, dropped: 0 };
-
-  function enqueueBulk(text) {
+  // 🔴 2026-10-24 事故修复：数据帧**必须严格 FIFO**。
+  //   旧实现分「小帧车道 / 大帧车道」，小帧会插到大帧下一片之前 —— 这违反了同一 WS 流里
+  //   消息的顺序语义，生产表现为手机远程页「历史加载失败：session event stream emitted an
+  //   entry before its opening cursor（gateway/internal）」：事件流请求/响应被乱序送达，
+  //   客户端的游标推进到了前面，重连时服务端按该游标回放就触发 cursor 错乱。
+  //   现在：控制帧仍可插队（它们是协议控制帧，不承载有序数据）；**数据帧只有一个队列**，
+  //   大帧按片就地推进，绝不因大小/类型被后来的帧超越。
+  const dataQ = []; // { frames: string[], i: number }；frames.length===1 = 未分片小帧
+  const stats = { controlSent: 0, dataSent: 0, bigFrames: 0, bigChunks: 0, waits: 0, dropped: 0 };
+
+  function enqueueData(text) {
     if (text.length <= chunkSize) {
-      smallQ.push(text);
+      dataQ.push({ frames: [text], i: 0 });
       return;
     }
     const cid = `c${++chunkSeq}`;
@@ -695,7 +705,7 @@ export function makePrioritySender({
       frames[i] = JSON.stringify({ __chunk: { id: cid, n, i, data: text.slice(i * chunkSize, (i + 1) * chunkSize) } });
     }
     stats.bigFrames += 1;
-    bigQ.push({ frames, i: 0 });
+    dataQ.push({ frames, i: 0 });
   }
 
   function scheduleNext(waitMs) {
@@ -715,7 +725,7 @@ export function makePrioritySender({
     if (pumping || closed) return;
     pumping = true;
     let yieldMode = ""; // ""=没有剩余，"schedule"=让出事件循环，"poll"=等缓冲排空
-    let budget = 32;    // 一轮最多发多少条小帧
+    let budget = 64;    // 一轮最多发多少条未分片小帧（大帧每轮只发一片）
     try {
       for (;;) {
         // ① 控制车道永远先走：哪怕大帧正传着 16MB，控制帧也在**下一轮**第一时间出去。
@@ -724,31 +734,31 @@ export function makePrioritySender({
           try { rawSend(frame); stats.controlSent += 1; } catch { closed = true; }
         }
         if (closed) { yieldMode = ""; break; }
-        // ② 小帧优先于大帧的下一片：大包传输期间，交互消息 / SSE 块不该排在它后面。
-        if (smallQ.length > 0 && budget > 0) {
-          try { rawSend(smallQ.shift()); stats.smallSent += 1; } catch { closed = true; break; }
+        if (dataQ.length === 0) { yieldMode = ""; break; }
+        if (budget <= 0) { yieldMode = "schedule"; break; }
+        const head = dataQ[0];
+        if (head.frames.length === 1) {
+          // 未分片小帧：可连着多发几条，但绝不越过队头（保证 FIFO）
+          try { rawSend(head.frames[0]); stats.dataSent += 1; } catch { closed = true; break; }
+          dataQ.shift();
           budget -= 1;
           continue; // 回环顶先查控制车道
         }
-        if (smallQ.length > 0) { yieldMode = "schedule"; break; } // 一轮预算用完
-        if (bigQ.length === 0) { yieldMode = ""; break; }
-        // ③ 背压：已入队字节超过高水位 → 停手等排空，别把控制帧埋进几十秒的队列里。
+        // 队头是大帧：每轮只推一片，片间让出事件循环（控制帧/入站帧不被饿死），顺序不变
         let pending = 0;
         try { pending = Number(bufferedAmount()) || 0; } catch { pending = 0; }
         if (pending > bulkHighWater) { stats.waits += 1; yieldMode = "poll"; break; }
-        const item = bigQ[0];
-        try { rawSend(item.frames[item.i]); stats.bigChunks += 1; } catch { closed = true; break; }
-        item.i += 1;
-        if (item.i >= item.frames.length) bigQ.shift();
-        yieldMode = "schedule"; // 大帧：一片一让，给入站帧 / 控制帧 / 小帧机会
+        try { rawSend(head.frames[head.i]); stats.dataSent += 1; stats.bigChunks += 1; } catch { closed = true; break; }
+        head.i += 1;
+        if (head.i >= head.frames.length) dataQ.shift();
+        yieldMode = "schedule";
         break;
       }
     } finally {
       pumping = false;
       if (closed) {
         controlQ.length = 0;
-        smallQ.length = 0;
-        bigQ.length = 0;
+        dataQ.length = 0;
       } else if (yieldMode) {
         scheduleNext(yieldMode === "poll" ? pollMs : 0);
       }
@@ -760,7 +770,7 @@ export function makePrioritySender({
     try { text = JSON.stringify(obj); } catch { return false; }
     if (closed) { stats.dropped += 1; return false; }
     if (isControlFrame(obj)) controlQ.push(text);
-    else enqueueBulk(text);
+    else enqueueData(text);
     pump();
     return true;
   }
@@ -769,8 +779,7 @@ export function makePrioritySender({
   function close() {
     closed = true;
     controlQ.length = 0;
-    smallQ.length = 0;
-    bigQ.length = 0;
+    dataQ.length = 0;
   }
 
   return {
@@ -778,11 +787,11 @@ export function makePrioritySender({
     close,
     stats: () => ({
       ...stats,
-      queued: smallQ.length + bigQ.length,
+      queued: dataQ.length,
       controlQueued: controlQ.length,
       closed
     }),
-    hasBacklog: () => smallQ.length > 0 || bigQ.length > 0 || controlQ.length > 0
+    hasBacklog: () => dataQ.length > 0 || controlQ.length > 0
   };
 }
 
@@ -2723,9 +2732,109 @@ async function main() {
     console.log("[bridge] 单实例锁检查降级（取不到进程命令行或锁不可写）——照常启动；若出现 code=4000 互踢，本实例会自动让位。");
   }
   process.on("exit", releaseInstanceLock);
+  // 桌面端插件「暂存更新」自动安装（应用退出后生效；见 applyPendingPluginUpdate 注释）
+  startPendingPluginUpdateWatcher();
   return runTunnel();
 }
 
+// ── 桌面端插件「暫存安装」落地（2026-10-24）────────────────────────────────────────────
+// dsh-setup 在桌面应用运行时无法直接改写它的 profile（会触发应用退出/重启），改为暂存到
+// <relayDir>/pending-plugin/ 并写 marker；bridge 常驻、检测到应用退出后自动原子替换插件目录，
+// 用户下次打开应用即加载新版 —— 这样「一键更新」对桌面端也能真正生效（不再需要终端）。
+const PENDING_PLUGIN_MARKER = path.join(RELAY_DIR, ".plugin-update-pending.json");
+const PENDING_PLUGIN_REQUIRED = ["package.json", "lib/index.js", "lib/client.js", "cordis.patch.yml"];
+const PENDING_PLUGIN_DISABLED = process.env.DSH_BRIDGE_PENDING_UPDATE === "0";
+
+/** upstream 端口是否在监听（= DeepSeek Harness 桌面端在运行）。TCP 判断，跨平台。 */
+export function probeUpstreamListening({ host = "127.0.0.1", port, timeoutMs = 400 } = {}) {
+  return new Promise((resolve) => {
+    if (!port) return resolve(false);
+    const sock = net.connect({ host, port });
+    let done = false;
+    const finish = (v) => { if (done) return; done = true; try { sock.destroy(); } catch { /* 忽略 */ } resolve(v); };
+    sock.setTimeout(timeoutMs, () => finish(false));
+    sock.once("connect", () => finish(true));
+    sock.once("error", () => finish(false));
+  });
+}
+function upstreamPortOf(url) {
+  try { const u = new URL(String(url)); return Number(u.port) || (u.protocol === "https:" ? 443 : 80); } catch { return 0; }
+}
+
+/**
+ * 应用暂存的插件更新（仅在桌面应用不在运行时）。原子替换：staging → rename，失败保留旧版。
+ * @returns {{applied:boolean, reason?:string, version?:string, error?:string}}
+ */
+export async function applyPendingPluginUpdate({ relayDir = RELAY_DIR, isAppRunning, now = Date.now(), log = console } = {}) {
+  const markerPath = path.join(relayDir, ".plugin-update-pending.json");
+  let marker;
+  try { marker = JSON.parse(fs.readFileSync(markerPath, "utf8")); } catch { return { applied: false, reason: "no_pending" }; }
+  const stageDir = String(marker.stageDir || "");
+  const profileDir = String(marker.profileDir || "");
+  const name = String(marker.pluginDirName || "dsh-remote-web-plugin");
+  if (!stageDir || !profileDir || !fs.existsSync(stageDir)) {
+    try { fs.rmSync(markerPath, { force: true }); } catch { /* 忽略 */ }
+    return { applied: false, reason: "staging_missing" };
+  }
+  const running = typeof isAppRunning === "function"
+    ? await isAppRunning()
+    : await probeUpstreamListening({ port: upstreamPortOf(UPSTREAM) });
+  if (running) return { applied: false, reason: "app_running" };
+  const dest = path.join(profileDir, name);
+  const stage = `${dest}.staging-${process.pid}`;
+  const backup = `${dest}.backup-${process.pid}`;
+  try {
+    fs.rmSync(stage, { recursive: true, force: true });
+    fs.cpSync(stageDir, stage, { recursive: true });
+    for (const rel of PENDING_PLUGIN_REQUIRED) {
+      if (!fs.existsSync(path.join(stage, rel))) throw new Error(`暂存包缺少 ${rel}`);
+    }
+    fs.rmSync(backup, { recursive: true, force: true });
+    const had = fs.existsSync(dest);
+    if (had) fs.renameSync(dest, backup);
+    try {
+      fs.renameSync(stage, dest);
+    } catch (e) {
+      if (had) { try { fs.renameSync(backup, dest); } catch { /* 忽略 */ } }
+      throw e;
+    }
+    if (had) { try { fs.rmSync(backup, { recursive: true, force: true }); } catch { /* 忽略 */ } }
+    try {
+      fs.writeFileSync(
+        path.join(relayDir, ".plugin-update-applied.json"),
+        JSON.stringify({ version: marker.version, appliedAt: now, profileDir }, null, 2) + "\n"
+      );
+    } catch { /* 忽略 */ }
+    try { fs.rmSync(markerPath, { force: true }); fs.rmSync(stageDir, { recursive: true, force: true }); } catch { /* 忽略 */ }
+    log.info?.(`[bridge] ✅ 插件新版本 ${marker.version} 已自动安装到 ${profileDir}（桌面应用退出后）；重新打开应用即生效`);
+    return { applied: true, version: marker.version };
+  } catch (e) {
+    try { fs.rmSync(stage, { recursive: true, force: true }); } catch { /* 忽略 */ }
+    log.warn?.(`[bridge] 插件暂存安装失败（保留旧版可回退）：${e && e.message ? e.message : e}`);
+    return { applied: false, reason: "apply_failed", error: String((e && e.message) || e) };
+  }
+}
+
+function startPendingPluginUpdateWatcher() {
+  if (PENDING_PLUGIN_DISABLED) return null;
+  let closedStreak = 0;
+  const tick = async () => {
+    try {
+      if (!fs.existsSync(PENDING_PLUGIN_MARKER)) { closedStreak = 0; return; }
+      const running = await probeUpstreamListening({ port: upstreamPortOf(UPSTREAM) });
+      if (running) { closedStreak = 0; return; }
+      closedStreak += 1;
+      if (closedStreak < 2) return; // 连续两次（≈30s）判定不在运行才动手，避开退出/重启瞬间
+      await applyPendingPluginUpdate({});
+      closedStreak = 0;
+    } catch { /* 绝不影响隧道业务 */ }
+  };
+  const t = setInterval(tick, 15_000);
+  t.unref?.();
+  void tick();
+  return t;
+}
+
 // test hooks：镜像页加载看门狗的内部状态（给用例断言"后续请求会撤掉它"，见 test/bridge-html-inject.test.mjs）
 export function __mirrorLoadWatchState() { return mirrorLoadWatch ? { ...mirrorLoadWatch } : null; }
 export function __armMirrorLoadWatch(path) { armMirrorLoadWatch(path); }

package/runtime/dsh-setup.mjs

@@ -2583,6 +2583,45 @@ function missingPluginFiles(dir) {
  *
  * 另外清掉上次被强杀留下的 `.staging-*` / `.backup-*`，不留垃圾。
  */
+// ── 桌面端「暫存安装」：应用运行中不能改写它的 profile（会把它弄退出/重启），
+// 但用户点「一键更新」必须能装到桌面端。做法：先整份拷到 ~/.dsh-remote/pending-plugin/ 并写 marker，
+// 由常驻的 bridge 在检测到应用退出后自动原子替换 profile 内的插件目录（见 dsh-bridge.mjs）。
+const PENDING_PLUGIN_MARKER = path.join(CONFIG_DIR, ".plugin-update-pending.json");
+const PENDING_PLUGIN_DIR = path.join(CONFIG_DIR, "pending-plugin");
+
+/** 暂存一份插件更新（供 bridge 在应用退出后安装）。返回 marker 对象。 */
+function stagePluginUpdateForProfile(profileDir, pluginDir) {
+  fs.rmSync(PENDING_PLUGIN_DIR, { recursive: true, force: true });
+  fs.mkdirSync(PENDING_PLUGIN_DIR, { recursive: true });
+  const cpOpts = {
+    recursive: true,
+    filter: (src) => {
+      if (src === pluginDir) return true;
+      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;
+    }
+  };
+  fs.cpSync(pluginDir, PENDING_PLUGIN_DIR, cpOpts);
+  for (const rel of PLUGIN_REQUIRED_FILES) {
+    const f = path.join(PENDING_PLUGIN_DIR, rel);
+    if (!fs.existsSync(f)) throw new Error(`暂存校验失败：缺少 ${rel}`);
+  }
+  const version = JSON.parse(fs.readFileSync(path.join(pluginDir, "package.json"), "utf8")).version;
+  const marker = {
+    version,
+    profileDir,
+    pluginDirName: PLUGIN_LOCAL_DIR,
+    stageDir: PENDING_PLUGIN_DIR,
+    stagedAt: Date.now()
+  };
+  fs.writeFileSync(PENDING_PLUGIN_MARKER, JSON.stringify(marker, null, 2) + "\n");
+  return marker;
+}
+
 function copyPluginIntoProfile(profileDir, pluginDir) {
   // 清理历史名残留目录（≤0.4.9 的 dsh-remote-ui-plugin），避免与新版并存
   for (const id of PLUGIN_LEGACY_IDS) {
@@ -3031,16 +3070,21 @@ async function pluginCmd(argv) {
   let last = null;
   let ok = 0;
   let skippedRunning = 0;
+  let stagedRunning = 0;
   const force = hasFlag(argv, "--force");
   for (const t of targets) {
     // ⚠️ 桌面应用在运行时**绝不改写它的 profile**：应用会因此退出/重启（2026-10-11 实测故障）
     if (t.name === "desktop" && !force && dshDesktopAppRunning()) {
-      console.log(`⚠️ 跳过 desktop：DeepSeek Harness 应用正在运行。`);
-      console.log(`   应用独占该 profile，运行中改写会让应用自己退出/重启。请任选其一：`);
-      console.log(`     · 完全退出应用后重跑本命令；或`);
-      console.log(`     · 在应用内「插件」页安装/更新 dsh-remote-web（官方路径，装完即热加载）。`);
-      console.log(`   （确实要强行写入：加 --force）`);
-      skippedRunning += 1;
+      console.log(`⚠️ DeepSeek Harness 应用正在运行 → 不直接改写它的 profile（会把它弄退出/重启）。`);
+      try {
+        const staged = stagePluginUpdateForProfile(t.dir, path.join(THIS_DIR, "packages", PLUGIN_ID));
+        stagedRunning += 1;
+        console.log(`   ✅ 新版本 ${staged.version} 已暂存：**退出 DeepSeek Harness 后会自动安装**，重新打开应用即生效（无需终端）。`);
+      } catch (e) {
+        console.log(`   ⚠️ 暂存失败：${e && e.message ? e.message : e}`);
+        console.log(`   请完全退出应用后重跑本命令，或在应用内「插件」页安装/更新 dsh-remote-web。`);
+        skippedRunning += 1;
+      }
       continue;
     }
     if (multi) console.log(`\n── profile: ${t.name}（${t.dir}）`);
@@ -3050,6 +3094,7 @@ async function pluginCmd(argv) {
     if (r !== undefined && r !== null) last = r;
   }
   if (ok === 0 && skippedRunning === 0) process.exit(1);
+  if (stagedRunning > 0) console.log(`ℹ 桌面端插件已暂存（${stagedRunning} 个）：退出 DeepSeek Harness 后由后台服务自动安装，重开应用生效。`);
   if (skippedRunning > 0) console.log(`ℹ 本次跳过了 ${skippedRunning} 个 profile（应用在运行）；桥与运行环境不受影响。`);
   return last;
 }