@nimoxie/dsh-ui-tweaks 0.2.1 → 0.2.2

package/lib/client.js

@@ -17,7 +17,7 @@ window.__ModuleLoader__.load({
     const module = { exports: {} };
     const exports = module.exports;
 
-    const BUILD = "0.2.1";
+    const BUILD = "0.2.2";
 
     /* 每个模块的注册各套一层 guard：失败只记 warn（座位/模块失败模式是「静默消失」，
        必须主动吭声；但不能让一个模块的异常打断同文件里其它模块的 apply）。 */
@@ -725,27 +725,62 @@ window.__ModuleLoader__.load({
          （预检 + 二次确认 + host 已写生效豁免）才会带上它。用完即删、终态也清。 */
       var forcedNames = {};   // name → true
 
-      function hostPost(route, body) {
+      /* 调 host 半区的本机回环路由。**必须带超时**：回包丢了不能让面板永远停在
+         「正在写入豁免表…」—— 真机遇到过响应没回来、阶段无限停留（写盘其实已成功）。
+         AbortController 到点 abort，结果统一收敛成 {ok:false, code:"timeout"}。 */
+      function hostPost(route, body, timeoutMs) {
+        var ms = Math.max(1000, Number(timeoutMs) || 15000);
+        var ctl = null, timer = null;
+        try { if (typeof AbortController === "function") { ctl = new AbortController(); } } catch (e0) {}
+        function stop() { if (timer) { clearTimeout(timer); timer = null; } }
+        var opts = {
+          method: "POST", cache: "no-store",
+          headers: { "Content-Type": "application/json" },
+          body: JSON.stringify(body || {}),
+        };
+        if (ctl) {
+          opts.signal = ctl.signal;
+          timer = setTimeout(function () { try { ctl.abort(); } catch (e2) {} }, ms);
+        }
         try {
-          return fetch("/api/ui-tweaks/" + route, {
-            method: "POST", cache: "no-store",
-            headers: { "Content-Type": "application/json" },
-            body: JSON.stringify(body || {}),
-          }).then(function (r) {
+          return fetch("/api/ui-tweaks/" + route, opts).then(function (r) {
+            stop();
             return r.json().then(function (j) { return j; }, function () { return { ok: false, code: "HTTP " + r.status }; });
-          }).catch(function (e) { return { ok: false, code: String((e && e.message) || e) }; });
+          }).catch(function (e) {
+            stop();
+            var aborted = false;
+            try { aborted = !!(ctl && ctl.signal && ctl.signal.aborted); } catch (e3) {}
+            return { ok: false, code: aborted ? "timeout" : String((e && e.message) || e) };
+          });
         } catch (e) {
+          stop();
           return Promise.resolve({ ok: false, code: String((e && e.message) || e) });
         }
       }
-      function hostGet(route) {
+      function hostGet(route, timeoutMs) {
+        var ms = Math.max(1000, Number(timeoutMs) || 10000);
+        var ctl = null, timer = null;
+        try { if (typeof AbortController === "function") { ctl = new AbortController(); } } catch (e0) {}
+        function stop() { if (timer) { clearTimeout(timer); timer = null; } }
+        var opts = { cache: "no-store" };
+        if (ctl) {
+          opts.signal = ctl.signal;
+          timer = setTimeout(function () { try { ctl.abort(); } catch (e2) {} }, ms);
+        }
         try {
-          return fetch("/api/ui-tweaks/" + route, { cache: "no-store" })
+          return fetch("/api/ui-tweaks/" + route, opts)
             .then(function (r) {
+              stop();
               return r.json().then(function (j) { return j; }, function () { return { ok: false, code: "HTTP " + r.status }; });
             })
-            .catch(function (e) { return { ok: false, code: String((e && e.message) || e) }; });
+            .catch(function (e) {
+              stop();
+              var aborted = false;
+              try { aborted = !!(ctl && ctl.signal && ctl.signal.aborted); } catch (e3) {}
+              return { ok: false, code: aborted ? "timeout" : String((e && e.message) || e) };
+            });
         } catch (e) {
+          stop();
           return Promise.resolve({ ok: false, code: String((e && e.message) || e) });
         }
       }
@@ -1030,7 +1065,7 @@ window.__ModuleLoader__.load({
           rstStage = 'confirm';
           rstRender();
         }
-        hostGet('restart').then(function (j) { plan = j || { ok: false, code: 'empty' }; decide(); });
+        hostGet('restart', 10000).then(function (j) { plan = j || { ok: false, code: 'empty' }; decide(); });
         runningSessions(function (n, names) { running = n; rstNames = names || []; decide(); });
       }
 
@@ -1040,7 +1075,7 @@ window.__ModuleLoader__.load({
         showScrim(true);
         armKillTimer();
         rstRender();
-        hostPost('restart', {}).then(function (j) {
+        hostPost('restart', {}, 16000).then(function (j) {
           if (!j || !j.ok) {
             /* 回包中断多半就是宿主已经退出（连接先断是正常的），但"多半"不等于一定：
                如实报成失败并给可点的出口（重试 / 刷新页面看看），别留一个死状态。 */
@@ -1079,10 +1114,16 @@ window.__ModuleLoader__.load({
         var row = findRow(name);
         if (!row || row.state !== "cooling" || !row.latest) { return; }
         forceSet(name, "checking");
-        hostPost("precheck-exempt", { name: name, version: row.latest, windowMs: policyWindowMs }).then(function (r) {
+        /* 预检要逐包查 registry 发布时长，可能十几秒；给足 30 秒但仍要有上限 */
+        hostPost("precheck-exempt", { name: name, version: row.latest, windowMs: policyWindowMs }, 30000).then(function (r) {
           var cur = findRow(name);
           if (!cur || cur.state !== "cooling") { forceReset(name); return; }
-          if (!r || !r.ok) { forceSet(name, "error", "预检没能完成：" + String((r && r.code) || "未知原因")); return; }
+          if (!r || !r.ok) {
+            forceSet(name, "error", (r && r.code) === "timeout"
+              ? "预检超时（registry 响应慢），稍后重试。"
+              : "预检没能完成：" + String((r && r.code) || "未知原因"));
+            return;
+          }
           var b = (r.blocked || []).filter(function (x) { return x && x.name && x.name !== name; });
           if (b.length) { forceBlocked[name] = b; forceSet(name, "blocked"); return; }
           forceSet(name, "confirm");
@@ -1094,10 +1135,33 @@ window.__ModuleLoader__.load({
         if (!row || !row.latest) { return; }
         var ver = row.latest;
         forceSet(name, "writing");
-        hostPost("force-exempt", { name: name, version: ver }).then(function (r) {
-          if (!r || !r.ok) { forceSet(name, "error", "写入豁免表失败：" + String((r && r.code) || "未知原因")); return; }
+        /* 写豁免表是幂等的（同值重复写返回 changed:false），所以超时可以安全重试一次：
+           回包丢失时上一次很可能已经写成功，重试只会立刻返回 changed:false。 */
+        function attempt(left) {
+          return hostPost("force-exempt", { name: name, version: ver }, 15000).then(function (r) {
+            if (r && r.code === "timeout" && left > 0) { return attempt(left - 1); }
+            return r;
+          });
+        }
+        attempt(1).then(function (r) {
+          if (!r || !r.ok) {
+            forceSet(name, "error", (r && r.code) === "timeout"
+              ? "写入豁免表没有等到回应（超时）。这一步是幂等的：很可能已经写进去了 —— 点「重试」或先在官方插件页看一下豁免表都安全。"
+              : "写入豁免表失败：" + String((r && r.code) || "未知原因"));
+            return;
+          }
           forceReset(name);
           forcedNames[name] = true;   // 硬闸放行凭据（一次性，终态清理）
+          /* 豁免不能「装完立刻删」：pnpm 每次安装都拿整个 lockfile 校验供应链策略，
+             被强制装上的版本还没满 24h 时删掉豁免，接下来几小时里所有 pnpm 操作都会被
+             整体拒绝。登记成熟时刻（+60s 缓冲），由 host 到点自动删掉这一条。 */
+          try {
+            var mature = isFinite(row.matureAt) ? Number(row.matureAt) : NaN;
+            if (!isFinite(mature) && isFinite(row.publishedAt)) { mature = Number(row.publishedAt) + policyWindowMs; }
+            if (isFinite(mature) && mature > 0) {
+              hostPost("schedule-exempt-cleanup", { name: name, version: ver, dropAt: mature + 60000 }, 8000);
+            }
+          } catch (e1) { /* 登记失败只是这条豁免会多留一阵，不影响安装 */ }
           enqueue(name, { force: true });
         });
       }
@@ -1173,9 +1237,40 @@ window.__ModuleLoader__.load({
         return null;
       }
 
+      /* 安装进度心跳：pnpm 一次重链几十个包时可能好几分钟零输出，看门狗不能只按总时长
+         判死。官方 client 用 remote.$on 订阅安装事件（plugin-manager/install-log 等），
+         我们拿同一组事件当「还在动」的心跳；拿不到就退回按总时长兜底。 */
+      var pmEventsBound = false;
+      var lastPmProgressAt = 0;
+      function bindPmEvents() {
+        if (pmEventsBound) { return; }
+        var root = null;
+        try { root = (ctx && ctx.remote) || null; } catch (e0) { root = null; }
+        if (!root) { try { root = pickService(null, "remote"); } catch (e1) { root = null; } }
+        if (!root || typeof root.$on !== "function") { return; }
+        pmEventsBound = true;
+        function note() { lastPmProgressAt = Date.now(); }
+        try {
+          root.$on("plugin-manager/install-log", note);
+          root.$on("plugin-manager/install-state", note);
+          root.$on("plugin-manager/changed", note);
+        } catch (e2) {}
+      }
+
+      /* /latest 必须带超时：比对是**串行**的，一个请求挂住会让后面所有包永远停在
+         「比对中 …」（fetch 默认没有超时，网络半死/代理吞包时最容易撞上）。 */
+      var REGISTRY_TIMEOUT_MS = 12000;
       function fetchLatest(name) {
         var path = String(name).split("/").map(encodeURIComponent).join("/");
-        return fetch("https://registry.npmjs.org/" + path + "/latest", { cache: "no-store" })
+        var ctl = null, timer = null;
+        try { if (typeof AbortController === "function") { ctl = new AbortController(); } } catch (e0) {}
+        function stop() { if (timer) { clearTimeout(timer); timer = null; } }
+        var opts = { cache: "no-store" };
+        if (ctl) {
+          opts.signal = ctl.signal;
+          timer = setTimeout(function () { try { ctl.abort(); } catch (e2) {} }, REGISTRY_TIMEOUT_MS);
+        }
+        return fetch("https://registry.npmjs.org/" + path + "/latest", opts)
           .then(function (r) {
             if (r.status === 404) {
               /* npm 上没有这个包：本地直装（link:/file:）或尚未发布 —— 不是「检查失败」。
@@ -1189,6 +1284,13 @@ window.__ModuleLoader__.load({
           })
           .then(function (d) {
             return d && d.version ? { version: String(d.version), requiresDsh: dshRequirementOf(d) } : null;
+          })
+          .then(function (v) { stop(); return v; }, function (e) {
+            stop();
+            if (e && (e.name === "AbortError" || /abort/i.test(String(e.message || "")))) {
+              throw new Error("registry 请求超时（" + Math.round(REGISTRY_TIMEOUT_MS / 1000) + " 秒）");
+            }
+            throw e;
           });
       }
 
@@ -1226,17 +1328,29 @@ window.__ModuleLoader__.load({
        * 来源判定主路径是 host 半区的 /api/ui-tweaks/local-plugins（读 profile
        * 依赖声明）：本地路径（link:/file:）与仓库/URL 直装（git/github/http）分列，
        * host 未重启/路由不可用时退回 registry 404 签名。 */
+      /* host 半区的来源名单：它**卡住整条比对链**（回调不回来，所有行都停在「比对中 …」），
+         所以同样要超时；拿不到就当没有，退回 404 签名判定。 */
+      var LOCAL_NAMES_TIMEOUT_MS = 8000;
       function fetchLocalNames(cb) {
-        fetch("/api/ui-tweaks/local-plugins", { cache: "no-store" })
+        var ctl = null, timer = null;
+        try { if (typeof AbortController === "function") { ctl = new AbortController(); } } catch (e0) {}
+        function stop() { if (timer) { clearTimeout(timer); timer = null; } }
+        var opts = { cache: "no-store" };
+        if (ctl) {
+          opts.signal = ctl.signal;
+          timer = setTimeout(function () { try { ctl.abort(); } catch (e2) {} }, LOCAL_NAMES_TIMEOUT_MS);
+        }
+        fetch("/api/ui-tweaks/local-plugins", opts)
           .then(function (r) { if (!r.ok) { throw new Error("HTTP " + r.status); } return r.json(); })
           .then(function (d) {
+            stop();
             cb({
               local: d && d.ok && Array.isArray(d.local) ? d.local : [],
               remote: d && d.ok && Array.isArray(d.remote) ? d.remote : [],
               dsh: d && d.ok && typeof d.dsh === "string" ? d.dsh : ""
             });
           })
-          .catch(function () { cb({ local: [], remote: [] }); });
+          .catch(function () { stop(); cb({ local: [], remote: [] }); });
       }
       function isLocalSrc(src) { return /^(link:|file:)/.test(String(src || "")); }
       function isRemoteSrc(src) { return /^(git[+:@]|github:|git:|http)/.test(String(src || "")); }
@@ -1257,8 +1371,25 @@ window.__ModuleLoader__.load({
       var busyBefore = "";       // 本次安装前该行的版本（回读比对基准，不受中途重查影响）
       var busyLatest = "";       // 本次安装解析出的目标版本（取消后退回「有新版本」要用）
       var cancelling = false;
+      /* 队列放行闸：底层请求真的收尾（busyChainDone）+ 终态已判定（busyFinished）才释放
+         busy 并 pump 下一项。真机上「看门狗到点先放行、旧请求还在跑」会让两条 pnpm
+         叠在一起抢 profile 锁，表现就是全都卡住。 */
+      var busyChainDone = true;
+      var busyFinished = true;
+      var busyReleased = true;
+      var busyWatchdog = 0;
+      var busyStartedAt = 0;
       var checking = false;
       var updatedCount = 0;       // 本次页面会话里成功更新的插件数（>0 时头部挂「重启生效」提示条）
+      /* 本次会话里成功更新、但装完仍是「关闭」的插件：重启提示栏里给一枚「启用」按钮。
+         官方安装默认不启用（installBundle 的 enabled 默认 false），我们更新时又刻意保留
+         行内原状态，所以「原本关着的插件」更新完仍然关着。按钮逐个调
+         pluginManager.setBundleEnabled(name, true)（官方插件页那个总开关用的同一 API），
+         只动**这次更新过**的包，不碰用户没更新的插件。 */
+      var updatedNames = [];      // 更新成功的插件名（按顺序，去重）
+      var updatedOff = {};        // name → true：更新后回读清单发现仍是关闭
+      var enableStage = "";       // "" | "running" | "error"
+      var enableNote = "";        // 启用失败的说明
       var isDesktop = /Electron/i.test(String(navigator.userAgent || ""));
       var listeners = [];         // 面板重绘订阅（面板未开时也维护状态）
 
@@ -1309,14 +1440,29 @@ window.__ModuleLoader__.load({
                 var name = b.name || b.id || "";
                 var ver = b.version != null ? String(b.version) : (b.installedVersion != null ? String(b.installedVersion) : "");
                 var src = typeof b.installed === "string" ? b.installed : (typeof b.source === "string" ? b.source : "");
+                var errCode = b.error && b.error.code ? String(b.error.code) : "";
+                var errDiag = b.error && b.error.diagnostic ? String(b.error.diagnostic) : "";
+                /* listBundles 对「装了但读不到」的包仍会返回一行（带 error、没有 version）。
+                   旧实现只显示「无法比对」，看不出是文件缺失还是清单坏了；把原因带到
+                   标签悬停里（见 tagHtml 的 unknown 分支）。 */
+                var why = "";
+                if (!ver) {
+                  if (errCode) {
+                    why = "插件清单报错 " + errCode + (errDiag ? "（" + errDiag.slice(0, 160) + "）" : "") + "：读不到已装版本";
+                  } else if (b.availability === "missing") {
+                    why = "安装文件缺失（package.json 读不到）";
+                  }
+                }
                 return {
                   name: name, version: ver, latest: "",
                   state: isLocalSrc(src) ? "local" : (isRemoteSrc(src) ? "remote" : (ver ? "checking" : "unknown")),
-                  src: src, enabled: b.enabled !== false, why: ""
+                  src: src, enabled: b.enabled !== false, why: why
                 };
               }).filter(function (x) { return x.name; })
               /* 官方 @deepseek-ai 插件由 dsh 本体更新流程负责，直接从检查列表里剔除 */
               .filter(function (x) { return !/^@deepseek-ai\//.test(x.name); });
+              /* 重查顺便校正「更新过但仍关闭」的标记（比如刚在官方插件页手动打开了） */
+              rows.forEach(function (x) { if (x.enabled !== false) { delete updatedOff[x.name]; } });
               /* 与在飞的安装对齐（见 reconcileInstallStates）：重查不得抹掉「更新中/等待更新」 */
               reconcileInstallStates();
               checking = false;
@@ -1447,6 +1593,21 @@ window.__ModuleLoader__.load({
         queue.splice(i, 1);
         setRow(name, { state: "update", why: "" });
       }
+      /* 放行队列（幂等）：busy 状态、看门狗、强制凭据一起收掉，再 pump 下一项。
+         只有「底层请求已收尾 + 终态已判定」才该调用它（见 startOne / finishOne 的 done）。
+         expectedName：旧一项的迟到回调（先前超时被放行的链）不得放行**当前**这一项。 */
+      function releaseBusy(expectedName) {
+        if (busyReleased) { return; }
+        if (expectedName && busyName && expectedName !== busyName) { return; }
+        busyReleased = true;
+        if (busyWatchdog) { clearInterval(busyWatchdog); busyWatchdog = 0; }
+        var nm = busyName;
+        busyName = ""; busyReq = ""; busyBefore = ""; busyLatest = "";
+        cancelling = false;
+        if (nm) { delete forcedNames[nm]; }   // 放行凭据只对一次安装生效，终态一律清掉
+        emit();
+        pump();
+      }
 
       /* ---- 更新 = 「先卸载、再安装」（DSH 安装接口的硬约束）--------------------
          官方 installBundle 在**开着 HMR（热重载）的运行时**里会直接拒绝：
@@ -1484,6 +1645,12 @@ window.__ModuleLoader__.load({
       var REMOVE_POLL_MS = 400;            // 轮询间隔
       var INSTALL_RETRY_TIMES = 3;         // 被 already-installed 拒后的重试次数
       var INSTALL_RETRY_DELAY_MS = 1500;   // 每次重试前等多久
+      /* 看门狗（真机教训：一次重链 44 个包的卸载跑了 5 分 08 秒，旧的固定 240 秒把它
+         判成超时，队列提前放行，旧请求还在跑 → 两条 pnpm 抢锁，全都卡住）： */
+      var WATCHDOG_TICK_MS = 5000;         // 巡检间隔
+      var SLOW_NOTE_MS = 90000;            // 无进度 90s：只在行内提示「还在跑」
+      var HARD_CAP_MS = 15 * 60000;        // 单项总时长上限：到点才判超时
+      var HARD_CAP_GRACE_MS = 5 * 60000;   // 判超时后再等底层收尾 5 分钟才放行队列
       function bundleStillListed(pm, nm) {
         return Promise.resolve(pm.listBundles()).then(function (r) {
           var list = r && r.ok === false ? null : (r && r.value) || [];
@@ -1521,8 +1688,23 @@ window.__ModuleLoader__.load({
           }
           return Promise.resolve(pm.removeBundle(nm)).then(function (rm) {
             var rmFail = resultFailure(rm);
-            /* 卸载被拒：把原始拒绝交回去，同时把"卸载失败"这个真实原因一起带出，别再吞掉 */
-            if (rmFail) { return { result: res, removed: false, removeFailure: rmFail }; }
+            /* 卸载被拒：把原始拒绝交回去，同时把"卸载失败"这个真实原因一起带出，别再吞掉。
+               光一个 operation-error 没法排查 —— 把卸载那次的 diagnostic / pnpm 输出首行
+               一并带上（例如 pnpm 读不了 pnpm-workspace.yaml 时的 YAML 报错）。 */
+            if (rmFail) {
+              var diag = "";
+              try {
+                var st = rm && rm.value;
+                diag = String((st && st.error && st.error.diagnostic) || (st && st.packageResult && st.packageResult.output) || "");
+              } catch (e0) { diag = ""; }
+              diag = stripAnsi(diag).split("\n").filter(function (ln) { return String(ln).trim(); })[0] || "";
+              if (diag.length > 160) { diag = diag.slice(0, 160) + "…"; }
+              try {
+                var pr = rm && rm.value && rm.value.packageResult;
+                if (pr && pr.logPath) { diag += (diag ? "；" : "") + "日志 " + pr.logPath; }
+              } catch (e1) { /* 字段缺失就算了 */ }
+              return { result: res, removed: false, removeFailure: rmFail + (diag ? "：" + diag : "") };
+            }
             if (onRemoved) { onRemoved(); }
             return waitBundlesGone(pm, nm)
               .then(function () { return installRetrying(pm, spec, opts); })
@@ -1549,28 +1731,54 @@ window.__ModuleLoader__.load({
 
       function startOne(name) {
         var row = findRow(name);
+        var pm = pickService(null, "remote.pluginManager");
         busyName = name;
         busyBefore = row ? row.version : "";
         busyLatest = (row && row.latest) || "";
         busyReq = uuid();
+        busyChainDone = false;
+        busyFinished = false;
+        busyReleased = false;
+        busyStartedAt = Date.now();
         setRow(name, { state: "busy", why: "" });
         emit();
-        var pm = pickService(null, "remote.pluginManager");
-        if (!pm) { finishOne(name, "failed", "remote.pluginManager 不可用"); return; }
+        if (!pm) { busyChainDone = true; finishOne(name, "failed", "remote.pluginManager 不可用"); return; }
         var settled = false;
         var busyRemoved = false;   // 本次更新走没走「先卸载再安装」：卸载过 → 失败必须回滚
-        /* 看门狗只作兜底：正常路径一次调用就定案，不等它。 */
-        var watchdog = setTimeout(function () {
-          finish("unknown", "更新超时（240 秒未结束）；结果未知，请点「重新检查」确认");
-          try { var pm2 = pickService(null, "remote.pluginManager"); if (pm2 && pm2.cancelInstall && busyReq) { pm2.cancelInstall(busyReq); } } catch (e) {}
-        }, 240000);
+        var lastProgress = busyStartedAt;
+        var slowNote = "";
+        bindPmEvents();
+        /* 看门狗改成「有进度就不算卡」：①无输出 90s 只在行内提示仍在跑；②单项 15 分钟
+           才判超时；③判超时后仍等底层请求收尾（最多再 5 分钟）才放行队列 —— 否则旧请求
+           没结束、下一项又开始，两条 pnpm 会在 profile 锁上互相等，表现就是全都卡住。 */
+        busyWatchdog = setInterval(function () {
+          if (settled) { return; }
+          var now = Date.now();
+          if (lastPmProgressAt > lastProgress) { lastProgress = lastPmProgressAt; }
+          var total = now - busyStartedAt;
+          var idle = now - lastProgress;
+          if (total >= HARD_CAP_MS) {
+            clearInterval(busyWatchdog); busyWatchdog = 0;
+            finish("unknown", "更新超时（" + Math.round(total / 60000) + " 分钟未结束）；结果未知，请点「重新检查」确认");
+            try { var pm2 = pickService(null, "remote.pluginManager"); if (pm2 && pm2.cancelInstall && busyReq) { pm2.cancelInstall(busyReq); } } catch (e) {}
+            /* 判超时后底层请求可能还在跑：再给 5 分钟收尾，才放行队列 */
+            setTimeout(function () { if (!busyReleased && busyName === name) { releaseBusy(name); } }, HARD_CAP_GRACE_MS);
+            return;
+          }
+          if (idle >= SLOW_NOTE_MS && !settled) {
+            var note = "pnpm 仍在运行（已 " + Math.max(1, Math.round(total / 60000)) +
+              " 分钟，最近一次输出在 " + Math.round(idle / 1000) + " 秒前）；要重链几十个包时可能超过 5 分钟，请再等等";
+            if (note !== slowNote) { slowNote = note; setRow(name, { state: "busy", why: note }); emit(); }
+          }
+        }, WATCHDOG_TICK_MS);
         function finish(kind, why, meta) {
           if (settled) { return; }
           settled = true;
-          clearTimeout(watchdog);
+          busyFinished = true;
+          if (busyWatchdog) { clearInterval(busyWatchdog); busyWatchdog = 0; }
           /* 卸载成功但重装没成（失败/被取消）→ 把旧版本装回去，绝不把插件留在"没了"的状态。
              只有 failed / cancelled 自动回滚：unknown 时安装可能仍在飞，硬回滚会打架，
-             改为在文案里讲清楚"中途卸载过，确认它装回来了没有"。 */
+             改为交给 recoverAfterUnknown 复查（见下）。 */
           if (busyRemoved && busyBefore && (kind === "failed" || kind === "cancelled")) {
             var pmR = pickService(null, "remote.pluginManager");
             if (pmR && typeof pmR.installBundle === "function") {
@@ -1589,11 +1797,40 @@ window.__ModuleLoader__.load({
             return;
           }
           if (busyRemoved && kind === "unknown") {
-            finishOne(name, kind, (why || "") + "（注意：本次更新中途卸载过该插件，请点「重新检查」确认它是否装回来了）", meta);
+            recoverAfterUnknown(name, busyBefore, why || "", meta);
             return;
           }
           finishOne(name, kind, why || "", meta);
         }
+        /* 超时(unknown)且本次中途卸载过：不能只写一句「请确认」就放走 —— 真机上
+           @linxin666/dsh-session-archive 就是这样被卸掉后没装回来（后续「装回」步骤的
+           结果还会因为 settled 被丢弃）。这里主动复查清单：不在就自动装回旧版本。 */
+        function recoverAfterUnknown(nm, ver, why, meta) {
+          var pmR = pickService(null, "remote.pluginManager");
+          if (!ver || !pmR || typeof pmR.listBundles !== "function") {
+            finishOne(nm, "unknown", why + (ver ? "；本次中途卸载过该插件，请手动重装 " + nm + "@" + ver : ""), meta);
+            return;
+          }
+          setRow(nm, { state: "busy", why: "更新超时，正在确认 " + nm + " 还在不在并自动回滚 …" });
+          emit();
+          Promise.resolve(pmR.listBundles()).then(function (r) {
+            var list = r && r.ok !== false ? (r.value || []) : [];
+            var present = false;
+            for (var i = 0; i < list.length; i++) { if (list[i] && list[i].name === nm) { present = true; break; } }
+            if (present) {
+              finishOne(nm, "unknown", why + "；该插件仍在清单中，版本请点「重新检查」确认", meta);
+              return;
+            }
+            return Promise.resolve(pmR.installBundle(nm + "@" + ver, { enabled: true })).then(function (rr) {
+              var rf = resultFailure(rr);
+              finishOne(nm, "unknown", why + (rf
+                ? "；自动回滚失败（" + rf + "），请手动重装 " + nm + "@" + ver
+                : "；已自动装回 " + nm + "@" + ver), meta);
+            });
+          }).catch(function () {
+            finishOne(nm, "unknown", why + "；复查/回滚失败，请手动确认并重装 " + nm + "@" + ver, meta);
+          });
+        }
         function settle(st) {
           if (!st || typeof st !== "object") { finish("unknown", "安装未返回可判定的结果"); return; }
           var app = st.application;
@@ -1635,17 +1872,17 @@ window.__ModuleLoader__.load({
         function abortForCooling(version, publishedAt, matureAt) {
           if (settled) { return; }
           settled = true;
-          clearTimeout(watchdog);
+          busyFinished = true;
+          if (busyWatchdog) { clearInterval(busyWatchdog); busyWatchdog = 0; }
           setRow(name, {
             state: "cooling", latest: version, why: "", publishedAt: publishedAt, matureAt: matureAt,
             detail: "安装前校验：registry 记录 " + version + " 发布于 " + new Date(publishedAt).toISOString() +
               "，仍在 minimumReleaseAge 窗口内（" + fmtWindow(policyWindowMs) + "），本次安装已拦下（未安装）。"
           });
           scheduleCoolingRefresh(name, matureAt);
-          busyName = ""; busyReq = ""; busyBefore = ""; busyLatest = "";
-          cancelling = false;
-          emit();
-          pump();
+          /* 还没开始装就被拦下：底层链不会再跑，直接放行队列 */
+          busyChainDone = true;
+          releaseBusy(name);
         }
         function guardMaturity(nm, version, go) {
           if (!version) { go(); return; }                                  // 版本未知（@latest 兜底路径）不拦
@@ -1702,7 +1939,15 @@ window.__ModuleLoader__.load({
             finish("failed", text); return;
           }
           settle(res.value);
-        }).catch(function (e) { finish("failed", "安装请求失败：" + msgOf(e)); });
+        }).catch(function (e) { finish("failed", "安装请求失败：" + msgOf(e)); })
+          .then(chainSettled, chainSettled);
+        /* 底层链真正收尾：只有「终态已判定 + 链已收尾」才放行队列 —— 旧实现看门狗到点就
+           done()→pump()，旧请求还在跑，下一项又发 pnpm，两条操作叠在 profile 锁上。 */
+        function chainSettled() {
+          if (busyName !== name) { return; }   // 这一项早已收尾/被放行：别动当前项
+          busyChainDone = true;
+          if (busyFinished) { releaseBusy(name); }
+        }
       }
 
       /* 终态落定：回读清单核对真实版本（registry 解析与 pnpm 实际安装可能不一致，
@@ -1714,16 +1959,27 @@ window.__ModuleLoader__.load({
         var before = busyBefore;
         var latest = busyLatest;
         var pm = pickService(null, "remote.pluginManager");
+        var doneOnce = false;
+        var doneGuard = 0;
         function done() {
-          busyName = ""; busyReq = ""; busyBefore = ""; busyLatest = "";
-          cancelling = false;
-          delete forcedNames[name];   // 放行凭据只对一次安装生效，终态一律清掉
-          emit();
-          pump();
-        }
-        function judge(ver) {
+          if (doneOnce) { return; }
+          doneOnce = true;
+          if (doneGuard) { clearTimeout(doneGuard); doneGuard = 0; }
+          if (busyName !== name) { return; }   // 迟到回调（旧一项已被放行）：不改当前项
+          busyFinished = true;
+          /* 链已收尾就直接放行；否则等 chainSettled（例如 lostReply 还在等 waitForInstall） */
+          if (busyChainDone) { releaseBusy(name); }
+        }
+        /* 回读清单本身也可能挂住（RPC 无超时）：60 秒还没结论就先收尾，别让队列陪着它卡死 */
+        doneGuard = setTimeout(done, 60000);
+        function judge(ver, info) {
           if (ver && ver !== before) {
             updatedCount++;   // 版本真的变了：装到盘上的已是新代码，运行中的进程还是旧的
+            if (updatedNames.indexOf(name) < 0) { updatedNames.push(name); }
+            /* 装完回读的 enabled 才是真的：官方安装默认不启用，我们传的是行内原状态，
+               所以「原本关着的插件」更新完仍然关着 —— 记下来给重启提示栏的启用按钮用。 */
+            var onNow = info ? info.enabled !== false : ((findRow(name) || {}).enabled !== false);
+            if (onNow) { delete updatedOff[name]; } else { updatedOff[name] = true; }
             setRow(name, { version: ver, state: "current", latest: ver, why: "", publishedAt: NaN, matureAt: NaN, detail: "" });
             /* 安装真的落地了：顺手让 host 半边归并豁免表，免得陈旧条遮蔽下一次安装 */
             normalizeExcludes();
@@ -1750,23 +2006,85 @@ window.__ModuleLoader__.load({
           done();
         }
         function attempt(n) {
-          if (!pm || !pm.listBundles) { judge(""); return; }
+          if (!pm || !pm.listBundles) { judge("", null); return; }
           Promise.resolve(pm.listBundles()).then(function (r) {
             var bundles = (r && r.ok && r.value) || [];
             if (!bundles.length && n < 3) { setTimeout(function () { attempt(n + 1); }, 1500); return; }
-            var ver = "";
+            var found = null;
             for (var i = 0; i < bundles.length; i++) {
-              if (bundles[i].name === name) { ver = bundles[i].version != null ? String(bundles[i].version) : ""; break; }
+              if (bundles[i].name === name) { found = bundles[i]; break; }
             }
-            judge(ver);
+            judge(found && found.version != null ? String(found.version) : "", found || null);
           }).catch(function () {
             if (n < 3) { setTimeout(function () { attempt(n + 1); }, 1500); return; }
-            judge("");
+            judge("", null);
           });
         }
         attempt(0);
       }
 
+      /* ---- 重启提示栏里的「启用已更新的插件」 ---------------------------------
+       * 官方安装/更新的默认结果是**不启用**（installBundle 的 enabled 默认 false），
+       * 面板更新又刻意保留行内原状态，于是「原本关着的插件」更新完仍然关着。
+       * 这里给一个显式按钮：逐个调 setBundleEnabled(name, true)（官方插件页总开关同款），
+       * 串行执行（host 每次启用都会写 manifest + reload，别并发），只动本次更新过的包。
+       * 成功就从标记里删掉；失败留在按钮里可重试，原因写在提示条下方。 */
+      function pendingEnableNames() {
+        var out = [];
+        for (var i = 0; i < updatedNames.length; i++) {
+          if (updatedOff[updatedNames[i]]) { out.push(updatedNames[i]); }
+        }
+        return out;
+      }
+      function enableUpdated() {
+        if (enableStage === "running") { return; }
+        var todo = pendingEnableNames();
+        if (!todo.length) { return; }
+        var pm = pickService(null, "remote.pluginManager");
+        if (!pm || typeof pm.setBundleEnabled !== "function") {
+          enableStage = "error";
+          enableNote = "这个 dsh 版本的插件管理器没有 setBundleEnabled，请到官方插件页手动打开这几个插件。";
+          emit();
+          return;
+        }
+        enableStage = "running";
+        enableNote = "";
+        emit();
+        var failed = [];
+        function step(i) {
+          if (i >= todo.length) {
+            enableStage = failed.length ? "error" : "";
+            enableNote = failed.length ? "有 " + failed.length + " 个没启用成功：" + failed.join("、") + "；可以再点一次。" : "";
+            emit();
+            return;
+          }
+          var nm = todo[i];
+          var p;
+          try { p = Promise.resolve(pm.setBundleEnabled(nm, true)); }
+          catch (e0) { failed.push(nm + "（" + msgOf(e0) + "）"); step(i + 1); return; }
+          p.then(function (res) {
+            var code = "";
+            if (!res || res.ok === false) {
+              code = String((res && res.error && res.error.code) || "unknown-error");
+            } else {
+              var st = res.value;
+              if (st && st.application === "failed") { code = String((st.error && st.error.code) || "unknown-error"); }
+            }
+            if (code) {
+              failed.push(nm + "（" + code + "）");
+            } else {
+              delete updatedOff[nm];
+              setRow(nm, { enabled: true });
+            }
+            step(i + 1);
+          }, function (e) {
+            failed.push(nm + "（" + msgOf(e) + "）");
+            step(i + 1);
+          });
+        }
+        step(0);
+      }
+
       /* 取消：排队项只摘自己（cancelQueued）；在装项请求取消**本次**，队列保留，
          等它落定后 done() → pump() 自然接着装下一项。
          旧实现把整个 queue 清空，于是「等待更新」的项全部退回「有新版本」——
@@ -1879,7 +2197,7 @@ window.__ModuleLoader__.load({
           var rw = liveWrap(RST_PANEL_ID, '.rwrap');
           if (rw) { placeNear(rstBtn, rw, RST_WIDTH, 180); }
           var pw = liveWrap(PANEL_ID, '.wrap');
-          if (pw) { placeNear(document.getElementById(BTN_ID), pw, PANEL_WIDTH, 220); }
+          if (pw) { placeNear(document.getElementById(BTN_ID), pw, PANEL_WIDTH, 220); syncSb(pw); }
         };
         try { if (typeof requestAnimationFrame === 'function') { requestAnimationFrame(run); return; } } catch (e) {}
         setTimeout(run, 0);
@@ -1923,7 +2241,20 @@ window.__ModuleLoader__.load({
           ".hd b{flex:1;font-size:13px;font-weight:600}" +
           ".x{cursor:pointer;opacity:.55;font-size:17px;line-height:1;padding:0 3px}" +
           ".x:hover{opacity:1}" +
-          ".rows{flex:1 1 auto;min-height:0;overflow:auto}" +
+          ".rowswrap{flex:1 1 auto;min-height:0;position:relative;display:flex;flex-direction:column}" +
+          /* 列表容器：隐藏原生滚动条（Windows 上会吃掉 17px 行内宽），改用浮层拇指 */
+          ".rows{flex:1 1 auto;min-height:0;overflow-y:auto;overflow-x:hidden;scrollbar-width:none;-ms-overflow-style:none}" +
+          ".rows::-webkit-scrollbar{width:0;height:0}" +
+          /* 浮层滚动条：与对话区那条自绘滚动条同一套观感（currentColor、7px→9px、可拖动） */
+          ".sbbar{position:absolute;top:0;right:0;width:12px;height:100%;z-index:2;" +
+          "user-select:none;-webkit-user-select:none;touch-action:none}" +
+          ".sbbar[hidden]{display:none}" +
+          ".sbthumb{position:absolute;right:0;top:0;width:100%;background:transparent}" +
+          ".sbthumb::after{content:\"\";position:absolute;top:0;bottom:0;right:2px;width:7px;border-radius:4px;" +
+          "background:rgba(128,128,128,.45);background:color-mix(in srgb,currentColor 36%,transparent);" +
+          "transition:width .12s,right .12s,background .12s}" +
+          ".sbbar:hover .sbthumb::after,.sbthumb.drag::after{right:1px;width:9px;" +
+          "background:rgba(128,128,128,.68);background:color-mix(in srgb,currentColor 60%,transparent)}" +
           ".rowwrap{border-bottom:1px solid var(--dsw-alias-border-l2,rgba(128,128,128,.12))}" +
           ".rowwrap:last-child{border-bottom:0}" +
           ".row{display:flex;align-items:center;gap:8px;padding:7px 12px}" +
@@ -1972,6 +2303,9 @@ window.__ModuleLoader__.load({
           ".restart{flex:0 0 auto;padding:6px 12px;font-size:12px;line-height:1.5;" +
           "background:rgba(62,207,142,.12);color:#4fbf8b;" +
           "border-bottom:1px solid var(--dsw-alias-border-l2,rgba(128,128,128,.18))}" +
+          /* 提示栏里的「启用已更新的插件」：与冷静期详情里的强制按钮同一套 .fbtn.fgo 样式 */
+          ".restart .fbtn{margin-left:8px;vertical-align:1px}" +
+          ".rnote{margin-top:4px;font-size:11px;line-height:1.45;color:#e07070;opacity:.9}" +
           ".foot{padding:8px 12px;font-size:11px;line-height:1.5;opacity:.6;" +
           "border-top:1px solid var(--dsw-alias-border-l2,rgba(128,128,128,.12))}" +
           "</style><div class=\"wrap\" role=\"dialog\" aria-label=\"插件更新\" tabindex=\"-1\" hidden></div>";
@@ -2009,6 +2343,8 @@ window.__ModuleLoader__.load({
             rows.forEach(function (r) { if (r.state === "update" && queue.indexOf(r.name) < 0 && r.name !== busyName) { enqueue(r.name); } });
             return;
           }
+          /* 重启提示栏里的「启用已更新的插件」（橙色按钮，样式同强制更新） */
+          if (t.classList.contains("renable")) { enableUpdated(); return; }
           if (t.classList.contains("cooling")) {
             /* 冷静期标签：只展开 / 收起详情，绝不触发安装 */
             var nm0 = t.getAttribute("data-n");
@@ -2141,15 +2477,127 @@ window.__ModuleLoader__.load({
         return "<div class=\"warn\">⚠ 有会话在用「自动审查」：装/更新插件容易失败，工具调用也可能被审查拦掉。建议先切「工作区内修改」，装完再切回。</div>";
       }
 
+      /* ---- 浮层滚动条（更新面板）-----------------------------------------------
+       * 原生滚动条会在 Windows 上占掉列表 17px 的宽，把每一行往里挤；这里隐藏原生条，
+       * 只在内容右缘画一条拇指（绝对定位、不参与布局）。
+       * **抄对话区那条自绘滚动条的观感与手感**（模块 2，A/B 实测过的实现）：
+       *   · 视觉：默认 `color-mix(currentColor 32%)`、悬停/拖动时加宽到 9px、55%；
+       *     不自动隐藏（常驻半透明，一眼看得出还能滚）。
+       *   · 拖动：PointerCapture + 按下点偏移（不是「拇指中心跳过来」），
+       *     点轨道时先把拇指中心移到点击处再顺势进入拖动；pointermove 同步写
+       *     scrollTop，scroll 事件回纠几何；轨道上滚轮转发给真容器。
+       * 面板是 Shadow DOM 浮层：事件只挂在面板内部节点，不监听 document。 */
+      var SB_THUMB_MIN = 28;
+      function sbParts(wrap) {
+        var sc = wrap && wrap.querySelector(".rows");
+        var bar = wrap && wrap.querySelector(".sbbar");
+        var th = bar && bar.querySelector(".sbthumb");
+        return sc && bar && th ? { sc: sc, bar: bar, th: th } : null;
+      }
+      /* 几何：高 = 轨道 × 可见比，位置 = scrollTop / 可滚动范围。
+         注意别用 bar.clientHeight 量轨道高：`hidden` 时它是 0，会把自己永久锁在隐藏。
+         轨道与滚动容器同高（都填满 .rowswrap），用视口高即可。 */
+      function syncSb(wrap) {
+        var p = sbParts(wrap);
+        if (!p) { return; }
+        var viewH = p.sc.clientHeight;
+        var range = p.sc.scrollHeight - viewH;
+        if (range <= 0 || viewH <= 0) { p.bar.hidden = true; return; }
+        p.bar.hidden = false;
+        var barH = viewH;
+        var h = Math.round(barH * viewH / p.sc.scrollHeight);
+        if (h < SB_THUMB_MIN) { h = SB_THUMB_MIN; }
+        if (h > barH) { h = barH; }
+        var maxTop = barH - h;
+        var top = maxTop > 0 ? Math.round(maxTop * p.sc.scrollTop / range) : 0;
+        if (top < 0) { top = 0; }
+        if (top > maxTop) { top = maxTop; }
+        if (p.th.style.height !== h + "px") { p.th.style.height = h + "px"; }
+        if (p.th.style.top !== top + "px") { p.th.style.top = top + "px"; }
+      }
+      function bindSb(wrap) {
+        var p = sbParts(wrap);
+        if (!p || p.bar.__sbBound) { return; }
+        p.bar.__sbBound = true;
+        var sc = p.sc, bar = p.bar, th = p.th;
+        var drag = null;
+        sc.addEventListener("scroll", function () { syncSb(wrap); }, { passive: true });
+        bar.addEventListener("pointerdown", function (e) {
+          if (e.button !== undefined && e.button !== 0) { return; }
+          var range = sc.scrollHeight - sc.clientHeight;
+          var barH = sc.clientHeight;
+          if (range <= 0 || barH <= 0) { return; }
+          syncSb(wrap);
+          var barRect = bar.getBoundingClientRect();
+          var thRect = th.getBoundingClientRect();
+          if (e.clientY >= thRect.top && e.clientY <= thRect.bottom) {
+            /* 按在拇指上：保持按下点与拇指顶部的偏移 */
+            drag = { offsetY: e.clientY - thRect.top, barRect: barRect };
+          } else {
+            /* 按在轨道上：先把拇指中心挪到点击处，再顺势进入拖动 */
+            var h = th.offsetHeight || SB_THUMB_MIN;
+            var maxTop = Math.max(0, barH - h);
+            var top0 = Math.round(e.clientY - barRect.top - h / 2);
+            if (top0 < 0) { top0 = 0; }
+            if (top0 > maxTop) { top0 = maxTop; }
+            sc.scrollTop = maxTop > 0 ? top0 / maxTop * range : 0;
+            syncSb(wrap);
+            thRect = th.getBoundingClientRect();
+            drag = { offsetY: e.clientY - thRect.top, barRect: barRect };
+          }
+          th.classList.add("drag");
+          try { bar.setPointerCapture(e.pointerId); } catch (e0) {}
+          e.preventDefault();
+        });
+        bar.addEventListener("pointermove", function (e) {
+          if (!drag) { return; }
+          var range = sc.scrollHeight - sc.clientHeight;
+          var barH = sc.clientHeight;
+          var h = th.offsetHeight || SB_THUMB_MIN;
+          var maxTop = Math.max(0, barH - h);
+          var top = e.clientY - drag.barRect.top - drag.offsetY;
+          if (top < 0) { top = 0; }
+          if (top > maxTop) { top = maxTop; }
+          sc.scrollTop = maxTop > 0 ? top / maxTop * range : 0;
+          syncSb(wrap);
+          e.preventDefault();
+        });
+        function release(e) {
+          if (!drag) { return; }
+          drag = null;
+          th.classList.remove("drag");
+          try { bar.releasePointerCapture(e.pointerId); } catch (e0) {}
+        }
+        bar.addEventListener("pointerup", release);
+        bar.addEventListener("pointercancel", release);
+        /* 指针压在条上时，滚轮转发给真容器（条是覆盖层，不是滚动容器本身） */
+        bar.addEventListener("wheel", function (e) {
+          e.preventDefault();
+          sc.scrollTop += e.deltaY;
+          syncSb(wrap);
+        }, { passive: false });
+        syncSb(wrap);
+      }
+
       function paint() {
         var wrap = panelWrap();
         var upd = 0;
         /* 有成功更新就常驻提示：装到盘上的是新代码，运行中的还是旧的，
            不重启（桌面端）/不重启 dsh 并强刷（web 端）就不会生效。 */
         function restartBar() {
-          if (!updatedCount) { return ""; }
-          return "<div class=\"restart\">已更新 " + updatedCount + " 个插件，" +
-            (isDesktop ? "重启客户端后生效" : "重启 dsh 服务并刷新页面后生效") + "</div>";
+          var pending = pendingEnableNames();
+          if (!updatedCount && !pending.length) { return ""; }
+          var head = updatedCount
+            ? "已更新 " + updatedCount + " 个插件" +
+              (pending.length ? "，其中 " + pending.length + " 个仍是关闭状态" : "") +
+              "，" + (isDesktop ? "重启客户端后生效" : "重启 dsh 服务并刷新页面后生效")
+            : "";
+          var btn = pending.length
+            ? "<span class=\"fbtn fgo renable\"" + KBD + " title=\"调用插件管理器的 setBundleEnabled，逐个打开这次更新过、但仍是关闭的插件\">" +
+              (enableStage === "running" ? "正在启用 …" : "启用已更新的 " + pending.length + " 个插件") + "</span>"
+            : "";
+          var note = enableNote ? "<div class=\"rnote\">" + esc(enableNote) + "</div>" : "";
+          return "<div class=\"restart\">" + head + btn + note + "</div>";
         }
         rows.forEach(function (r) { if (r.state === "update") { upd++; } });
         var allBtn = upd ? "<span class=\"allbtn\"" + KBD + ">全部更新（" + upd + "）</span>" : "<span class=\"allbtn\" hidden></span>";
@@ -2177,7 +2625,9 @@ window.__ModuleLoader__.load({
         }
         var html = "<div class=\"hd\"><b>插件更新 · " + (busyName ? "正在更新 " + esc(busyName) + " …" : (checking ? "检查中…" : (rows.length ? upd + " 个插件有新版本" : "插件更新检查"))) + "</b>" +
           "<span class=\"recheck\"" + KBD + " title=\"重新读取插件清单并比对 registry\">重新检查</span>" + allBtn +
-          "<span class=\"x\"" + KBD + " title=\"关闭\" aria-label=\"关闭\">×</span></div>" + restartBar() + accessModeBar() + "<div class=\"rows\">" + body + "</div>" +
+          "<span class=\"x\"" + KBD + " title=\"关闭\" aria-label=\"关闭\">×</span></div>" + restartBar() + accessModeBar() +
+          "<div class=\"rowswrap\"><div class=\"rows\">" + body + "</div>" +
+          "<div class=\"sbbar\" aria-hidden=\"true\"><div class=\"sbthumb\"></div></div></div>" +
           /* 面板脚注：把「只查第三方」这条口径写在明处（plugin-manager 同款一句） */
           "<div class=\"foot\">只检查第三方插件；官方 @deepseek-ai/ 包随 DSH 本体升级。</div>";
         if (wrap.innerHTML !== html) {
@@ -2192,6 +2642,9 @@ window.__ModuleLoader__.load({
           wrap.hidden = false;
           /* 位置只有一个来源：那枚「检查更新」按钮（不可拖动） */
           placeNear(document.getElementById(BTN_ID), wrap, PANEL_WIDTH, 220);
+          /* 浮层滚动条：先绑事件（innerHTML 换过就重绑），再按当前高度画拇指 */
+          bindSb(wrap);
+          syncSb(wrap);
         }
       }
 
@@ -2867,6 +3320,7 @@ window.__ModuleLoader__.load({
      * ====================================================================== */
     var ADAPTER_SUMMARY_SUFFIX = "/api/changes.summary";
     var ADAPTER_DIFF_SUFFIX = "/api/changes.diff";
+    var ADAPTER_OPEN_SUFFIX = "/api/changes.open";
     var ADAPTER_CONTEXT_LINES = 3;
     var ADAPTER_MAX_HUNK_LINES = 2000;
 
@@ -2953,7 +3407,7 @@ window.__ModuleLoader__.load({
         });
       }
       out.sort(function (left, right) { return left.display < right.display ? -1 : (left.display > right.display ? 1 : 0); });
-      return { sessionId: String(sessionId), seq: String(seq), turn: turn, files: out, stateFiles: files };
+      return { sessionId: String(sessionId), seq: String(seq), turn: turn, files: out, stateFiles: files, cwd: cwd || null };
     }
 
     /* 会话 cwd：官方 display 的基准。取不到就退化为绝对路径（不影响校验，只是显示不同）。 */
@@ -3013,6 +3467,54 @@ window.__ModuleLoader__.load({
       } catch (e) { return null; }
     }
 
+    /* ---------- 动作路由补位（会话释放后官方 /api/changes.open 只回 404） ----------
+       官方那条路由要先查 Host 内存里的改动摘要才能把 file.path 解析成绝对路径，
+       会话一释放就 404 —— 文件却还在盘上。这里补两件事：
+         GET  → 由 host 枚举系统关联，返回真实应用列表（官方控件的主按钮＝第一个应用，
+                菜单列全部；枚举不出来就给空数组，控件退化成只有「显示文件位置」）；
+         POST → 用自己 host 半区的 /api/ui-tweaks/open-path 打开 / 定位 / 用指定应用打开。
+       只对索引里已有的坐标生效，活会话照旧走官方原路（先试官方，404 才补位）。 */
+    function changesAbsPath(entry, p) {
+      var s = String(p == null ? "" : p);
+      if (!s) { return null; }
+      var isWin = /^[A-Za-z]:[\\/]/.test(s) || s.slice(0, 2) === "\\\\";
+      if (isWin || s.charAt(0) === "/") { return s; }
+      var cwd = entry && entry.cwd ? String(entry.cwd) : "";
+      if (!cwd) { return null; }
+      var sep = (/^[A-Za-z]:[\\/]/.test(cwd) || cwd.slice(0, 2) === "\\\\") ? "\\" : "/";
+      return cwd.replace(/[\\/]+$/, "") + sep + s.replace(/^[\\/]+/, "").split("/").join(sep);
+    }
+    /* 调 host 半区回环路由（模块 5b 自身作用域；带超时，回包丢失不会吊死动作） */
+    function adapterHostPost(route, body, timeoutMs) {
+      var ms = Math.max(1000, Number(timeoutMs) || 8000);
+      var ctl = null, timer = null;
+      try { if (typeof AbortController === "function") { ctl = new AbortController(); } } catch (e0) {}
+      function stop() { if (timer) { clearTimeout(timer); timer = null; } }
+      var opts = {
+        method: "POST", cache: "no-store",
+        headers: { "Content-Type": "application/json" },
+        body: JSON.stringify(body || {}),
+      };
+      if (ctl) {
+        opts.signal = ctl.signal;
+        timer = setTimeout(function () { try { ctl.abort(); } catch (e2) {} }, ms);
+      }
+      try {
+        return fetch("/api/ui-tweaks/" + route, opts).then(function (r) {
+          stop();
+          return r.json().then(function (j) { return j; }, function () { return { ok: false, code: "HTTP " + r.status }; });
+        }).catch(function (e) {
+          stop();
+          var aborted = false;
+          try { aborted = !!(ctl && ctl.signal && ctl.signal.aborted); } catch (e3) {}
+          return { ok: false, code: aborted ? "timeout" : String((e && e.message) || e) };
+        });
+      } catch (e) {
+        stop();
+        return Promise.resolve({ ok: false, code: String((e && e.message) || e) });
+      }
+    }
+
     function installChangesFetchAdapter() {
       if (adapterInstalled) { return; }
       if (typeof window === "undefined" || typeof window.fetch !== "function") { return; }
@@ -3026,11 +3528,67 @@ window.__ModuleLoader__.load({
         var path = url.pathname || "";
         var isSummary = path.length >= ADAPTER_SUMMARY_SUFFIX.length && path.slice(-ADAPTER_SUMMARY_SUFFIX.length) === ADAPTER_SUMMARY_SUFFIX;
         var isDiff = path.length >= ADAPTER_DIFF_SUFFIX.length && path.slice(-ADAPTER_DIFF_SUFFIX.length) === ADAPTER_DIFF_SUFFIX;
-        if (!isSummary && !isDiff) { return original.apply(this, arguments); }
+        var isOpen = path.length >= ADAPTER_OPEN_SUFFIX.length && path.slice(-ADAPTER_OPEN_SUFFIX.length) === ADAPTER_OPEN_SUFFIX;
+        if (!isSummary && !isDiff && !isOpen) { return original.apply(this, arguments); }
         var sessionId = url.searchParams.get("sessionId");
         var seq = url.searchParams.get("seq");
         var entry = changesEntryFor(sessionId, seq);
         if (!entry) { return original.apply(this, arguments); }
+        if (isOpen) {
+          /* 先走官方原路：活会话它本来就能干活（有真应用列表）。只有它答 404
+             （会话释放：Host 内存里没有改动摘要了）才由我们补位。 */
+          var self = this, args = arguments;
+          var fallbackOpen = function () {
+            var method = "GET";
+            try { method = String((init && init.method) || "GET").toUpperCase(); } catch (eM) { method = "GET"; }
+            var openIndex = Number(url.searchParams.get("index"));
+            var openFile = entry.files[openIndex] || null;
+            var openTarget = changesAbsPath(entry, openFile ? openFile.path : "");
+            if (method === "GET") {
+              /* 应用列表交给 host（复用官方 native-command 枚举系统关联，只回真实应用）；
+                 host 不可用或枚举失败就给空数组 —— 官方控件的退化形态就是「显示文件位置」。 */
+              return adapterHostPost("open-apps", { path: openTarget || "" }, 20000).then(function (r) {
+                var apps = (r && r.ok && Array.isArray(r.apps)) ? r.apps : [];
+                var res = changesJsonResponse(apps);
+                if (!res) { return new Response("unavailable", { status: 500 }); }
+                try {
+                  console.info("[dsh-ui-tweaks:" + BUILD + "] 动作补位 · 应用列表 " + apps.length + " 项（" +
+                    ((r && r.source) || "fallback") + (r && r.code ? " · " + r.code : "") + "）");
+                } catch (e2) {}
+                return res;
+              });
+            }
+            if (!openTarget) {
+              try { console.warn("[dsh-ui-tweaks:" + BUILD + "] 动作补位失败：拿不到绝对路径", openFile); } catch (e3) {}
+              return Promise.resolve(new Response("no-path", { status: 404 }));
+            }
+            var openAction = url.searchParams.get("action") === "reveal" ? "reveal" : "open";
+            /* 菜单里选中的应用 id 原样交给 host（它按官方 openNativeFileApplication 启动）；
+               host 不认的 id 由它按默认关联打开，不会把点击变成失败。 */
+            var openApp = url.searchParams.get("application") || "";
+            return adapterHostPost("open-path", { path: openTarget, action: openAction, application: openApp }, 20000).then(function (r) {
+              if (r && r.ok) { return new Response(null, { status: 204 }); }
+              var code = r && r.code ? String(r.code) : "failed";
+              var status = code === "path-not-found" ? 404 : (code === "timeout" ? 504 : 500);
+              try {
+                console.warn("[dsh-ui-tweaks:" + BUILD + "] 动作补位失败：" + code +
+                  (r && r.source ? "（" + r.source + "）" : "") + " · " + openTarget);
+              } catch (e4) {}
+              return new Response(code, { status: status });
+            });
+          };
+          var attempt;
+          try { attempt = original.apply(self, args); }
+          catch (eA) { return fallbackOpen(); }
+          if (!attempt || typeof attempt.then !== "function") {
+            /* 不是 Promise（被别的包装改了签名）：原样交回 */
+            return attempt;
+          }
+          return attempt.then(function (res) {
+            if (res && res.status === 404) { return fallbackOpen(); }
+            return res;
+          }, function () { return fallbackOpen(); });
+        }
         var payload = isSummary ? changesSummaryPayload(entry) : changesDiffPayload(entry, Number(url.searchParams.get("index")));
         if (payload === null) { return original.apply(this, arguments); }
         var response = changesJsonResponse(payload);