@nimoxie/dsh-ui-tweaks 0.2.0 → 0.2.2

package/lib/client.js

@@ -1,9 +1,12 @@
 /* dsh-ui-tweaks browser half.
  *
- * 三个独立模块，任一失败都不得拖垮其它（各自 guard）：
- *   1. tablefix   —— 宽表格越界修复（纯 CSS 覆盖，见 README「宽表格修复」）
+ * 五个模块各自 guard，任一失败都不得拖垮其它：
+ *   1. tablefix   —— 宽表格越界修复（纯 CSS 覆盖）
  *   2. scrollbar  —— 对话区左侧自绘滚动条（从 dsh-web-shell 移植，选择器适配 0.2.x）
  *   3. updates    —— 插件更新检查面板（不含 dsh 本体；remote.pluginManager/pluginInventory）
+ *   4. anim       —— 动画修复（忽略 prefers-reduced-motion，恢复界面动画）
+ *   5. changes    —— 回合尾改动卡：日志聚合 + 模块 5b 数据适配层（喂数据给官方卡）
+ * host 半区（lib/index.js）另有两项：窗口记忆（模块 6）、立即重启路由（模块 7）。
  *
  * 装载机制：shell 的 window.__ModuleLoader__.load + factory(require)；
  * apply(ctx) 由客户端 cordis 上下文调用（同 dsh-model-organizer 的结构）。
@@ -14,7 +17,7 @@ window.__ModuleLoader__.load({
     const module = { exports: {} };
     const exports = module.exports;
 
-    const BUILD = "0.2.0";
+    const BUILD = "0.2.2";
 
     /* 每个模块的注册各套一层 guard：失败只记 warn（座位/模块失败模式是「静默消失」，
        必须主动吭声；但不能让一个模块的异常打断同文件里其它模块的 apply）。 */
@@ -354,6 +357,9 @@ window.__ModuleLoader__.load({
      * 全部走官方 remote API，不自建 host 路由：
      *   remote.pluginManager.listBundles()   → 已装插件包（name/version/installed）
      *   remote.pluginManager.installBundle(spec, {enabled, requestId}) → 更新
+     *     （开着 HMR 的运行时里，安装**已装过**的包会被拒 already-installed —— 与版本无关；
+     *       此时退回"先 removeBundle 再 installBundle"，见 installBundleEx）
+     *   remote.pluginManager.removeBundle(包名)        → 卸载（两步更新时用）
      *   remote.pluginManager.waitForInstall(requestId) → 安装进度轮询
      *   remote.pluginManager.cancelInstall(requestId)  → 取消
      * registry 比对从浏览器直连（registry.npmjs.org 带 CORS *）。
@@ -719,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) });
         }
       }
@@ -1024,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(); });
       }
 
@@ -1034,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) {
             /* 回包中断多半就是宿主已经退出（连接先断是正常的），但"多半"不等于一定：
                如实报成失败并给可点的出口（重试 / 刷新页面看看），别留一个死状态。 */
@@ -1073,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");
@@ -1088,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 });
         });
       }
@@ -1167,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:）或尚未发布 —— 不是「检查失败」。
@@ -1183,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;
           });
       }
 
@@ -1220,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 || "")); }
@@ -1251,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 = [];         // 面板重绘订阅（面板未开时也维护状态）
 
@@ -1303,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;
@@ -1403,7 +1555,8 @@ window.__ModuleLoader__.load({
         "bundle-in-use": "插件正在使用中，无法替换",
         "stale-approval": "构建脚本授权已失效，需重新授权",
         "incompatible-version": "版本与当前 dsh 不兼容",
-        "operation-error": "安装命令执行失败（pnpm 非零退出）"
+        "operation-error": "安装命令执行失败（pnpm 非零退出）",
+        "already-installed": "该插件已安装，DSH 不允许原地覆盖版本（已自动尝试「先卸载再安装」，仍未成功）"
       };
       /* failureText 与 coolingFromResult 都在文件上方的「纯函数区」里（错误码表作为
          参数传入），这里只保留这张码表；旧的长文案实现已删除，避免两份逻辑漂移。 */
@@ -1440,29 +1593,244 @@ 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（热重载）的运行时**里会直接拒绝：
+         `already-installed` —— 判据是"这个包名已经在 profile 依赖里"，与版本无关
+         （@deepseek-ai/dsh-plugin-manager/lib/index.js 的 installBundle：
+         `if (ownerContext.get("hmr") !== void 0 && hasOwn(before, name)) throw`）。
+         官方工具说明给出的正路就是"先 removeBundle 再 installBundle"。因此：
+           ① 先按老办法直接装 —— 没有 HMR 的运行时这一步就成功，且不用碰卸载；
+           ② 只有被 already-installed 拒绝时，才退回"卸载 → 安装"两步。
+         返回最终那次 installBundle 的信封；onRemoved 在"确实卸载过"时回调（供失败回滚）。 */
+      function isAlreadyInstalledResult(res) {
+        if (!res) { return false; }
+        /* 形状①：远程 API 的拒绝信封（web 端 / 未来版本） */
+        if (res.ok === false) { return String((res.error && res.error.code) || "") === "already-installed"; }
+        /* 形状②：桌面端进程内管理器把它报成「应用层失败」—— true 信封里 value.application === "failed"
+           且 value.error.code 就是那个码（failureText 正是这么取码的，实测就是这条路径） */
+        var st = res.value;
+        return !!(st && st.application === "failed" && String((st.error && st.error.code) || "") === "already-installed");
+      }
+      /* 结果信封到底是成功还是失败？**不能只看 ok**：桌面端进程内管理器把失败包成
+         `{ok:true, value:{application:"failed", error:{code}}}`（0.2.1 第一版就栽在这，
+         把"卸载被拒"当成卸载成功，于是"已回滚"是假话、"仍需卸载"这条真正的原因被吞掉）。
+         返回空串＝不是失败；否则返回失败码。 */
+      function resultFailure(res) {
+        if (!res) { return "empty-result"; }
+        if (res.ok === false) { return String((res.error && res.error.code) || "unknown-error"); }
+        var st = res.value;
+        if (st && st.application === "failed") { return String((st.error && st.error.code) || "unknown-error"); }
+        return "";
+      }
+      /* 卸载会触发一次 profile 重载。真机踩过的坑：卸载刚返回就立刻重装，新请求可能仍在
+         上一代管理器里执行、读到的还是卸载前的清单 → 又被 already-installed 拒。
+         所以两步之间要**等清单里真的没有它**再装，装的时候再按退避重试几次。 */
+      var REMOVE_SETTLE_MS = 10000;        // 等清单消失的上限
+      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) || [];
+          if (!list || !list.length) { return false; }   // 拿不到清单：当作"没有"，别把更新卡死
+          for (var i = 0; i < list.length; i++) {
+            if (list[i] && list[i].name === nm) { return true; }
+          }
+          return false;
+        }, function () { return false; });
+      }
+      function waitBundlesGone(pm, nm, timeoutMs) {
+        if (typeof pm.listBundles !== "function") { return Promise.resolve(false); }
+        var deadline = Date.now() + (timeoutMs || REMOVE_SETTLE_MS);
+        function poll() {
+          return bundleStillListed(pm, nm).then(function (still) {
+            if (!still) { return true; }
+            if (Date.now() >= deadline) { return false; }
+            return new Promise(function (r) { setTimeout(r, REMOVE_POLL_MS); }).then(poll);
+          });
+        }
+        return poll();
+      }
+      function installRetrying(pm, spec, opts, left) {
+        var n = left === undefined ? INSTALL_RETRY_TIMES : left;
+        return Promise.resolve(pm.installBundle(spec, opts)).then(function (res) {
+          if (!isAlreadyInstalledResult(res) || n <= 1) { return res; }
+          return new Promise(function (r) { setTimeout(r, INSTALL_RETRY_DELAY_MS); })
+            .then(function () { return installRetrying(pm, spec, opts, n - 1); });
+        });
+      }
+      function installBundleEx(pm, spec, nm, opts, onRemoved) {
+        return Promise.resolve(pm.installBundle(spec, opts)).then(function (res) {
+          if (!isAlreadyInstalledResult(res) || typeof pm.removeBundle !== "function") {
+            return { result: res, removed: false, removeFailure: "" };
+          }
+          return Promise.resolve(pm.removeBundle(nm)).then(function (rm) {
+            var rmFail = resultFailure(rm);
+            /* 卸载被拒：把原始拒绝交回去，同时把"卸载失败"这个真实原因一起带出，别再吞掉。
+               光一个 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); })
+              .then(function (res2) { return { result: res2, removed: true, removeFailure: "" }; });
+          });
+        });
+      }
+      /* 安装器返回的错误码翻成人话（这些码是稳定契约，优先用它，而不是甩一串英文） */
+      function installCodeText(code) {
+        var map = {
+          "already-installed": "该插件已安装，DSH 不允许原地覆盖版本（已自动尝试「先卸载再安装」，仍未成功）",
+          "incompatible-version": "这个版本与本机 dsh 不兼容，已被安装器拒绝",
+          "invalid-spec": "安装参数不合法",
+          "not-removable": "这个条目不允许卸载，因此没法用「卸载 + 安装」的方式更新",
+          "bundle-in-use": "该插件正在使用中，安装器拒绝了卸载",
+          "unknown-plugin": "安装器不认识这个插件，请点「重新检查」确认清单",
+          "operation-error": "安装器执行失败",
+          "stale-approval": "上一次安装的批准已过期，请重试",
+          "ambiguous-install": "这次依赖变更没指明唯一插件，请点「重新检查」确认"
+        };
+        var t = map[String(code || "")];
+        return t ? t + "（" + code + "）" : "";
+      }
 
       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 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 busyRemoved = false;   // 本次更新走没走「先卸载再安装」：卸载过 → 失败必须回滚
+        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") {
+              setRow(name, { state: "busy", why: "正在回滚到 " + busyBefore + "…" });
+              emit();
+              Promise.resolve(pmR.installBundle(name + "@" + busyBefore, { enabled: enabled })).then(function (r) {
+                var rf = resultFailure(r);
+                finishOne(name, kind, (why || "") +
+                  (rf ? "；回滚也失败了（" + rf + "），请手动重装 " + name + "@" + busyBefore : "；该插件已回滚到 " + busyBefore), meta);
+              }, function () {
+                finishOne(name, kind, (why || "") + "；回滚失败，请手动重装 " + name + "@" + busyBefore, meta);
+              });
+              return;
+            }
+            finishOne(name, kind, (why || "") + "；未能回滚，请手动重装 " + name + "@" + busyBefore, meta);
+            return;
+          }
+          if (busyRemoved && kind === "unknown") {
+            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;
@@ -1504,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 兜底路径）不拦
@@ -1544,11 +1912,42 @@ window.__ModuleLoader__.load({
             guardMaturity(name, targetVersion, function () { resolve(spec); });
           });
         }).then(function (spec) {
-          return pm.installBundle(spec, { enabled: enabled, requestId: busyReq });
-        }).then(function (res) {
-          if (!res || res.ok === false) { lostReply(res); return; }
+          return installBundleEx(pm, spec, name, { enabled: enabled, requestId: busyReq }, function () {
+            busyRemoved = true;
+            /* 让用户看清这两步：HMR 运行时不允许原地覆盖已装的包，只能先卸再装 */
+            setRow(name, { state: "busy", why: "该插件已装过：DSH 不允许原地覆盖版本，正在先卸载、再用 " + targetVersion + " 装回…" });
+            emit();
+          });
+        }).then(function (out) {
+          var res = out.result;
+          if (!res || res.ok === false) {
+            /* 明确的拒绝（带错误码）直接翻成人话给用户看；没有码才按"回包丢了"去追结果 */
+            var code = res && res.error ? res.error.code : "";
+            var human = installCodeText(code);
+            if (human) { finish("failed", human); return; }
+            lostReply(res); return;
+          }
+          var fail = resultFailure(res);
+          if (fail) {
+            var text = installCodeText(fail);
+            if (!text) { lostReply(res); return; }
+            if (out.removeFailure) {
+              text += "；这一步必须「先卸载再安装」，但卸载被拒（" + out.removeFailure + "），所以没法用两步法更新它";
+            } else if (!out.removed) {
+              text += "（DSH 不允许原地覆盖已装的包，需要「先卸载再安装」）";
+            }
+            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 实际安装可能不一致，
@@ -1560,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();
+          if (doneOnce) { return; }
+          doneOnce = true;
+          if (doneGuard) { clearTimeout(doneGuard); doneGuard = 0; }
+          if (busyName !== name) { return; }   // 迟到回调（旧一项已被放行）：不改当前项
+          busyFinished = true;
+          /* 链已收尾就直接放行；否则等 chainSettled（例如 lostReply 还在等 waitForInstall） */
+          if (busyChainDone) { releaseBusy(name); }
         }
-        function judge(ver) {
+        /* 回读清单本身也可能挂住（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();
@@ -1596,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 清空，于是「等待更新」的项全部退回「有新版本」——
@@ -1725,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);
@@ -1769,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}" +
@@ -1818,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>";
@@ -1855,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");
@@ -1984,7 +2474,109 @@ window.__ModuleLoader__.load({
       }
       function accessModeBar() {
         if (!hasAutoReviewSession()) { return ""; }
-        return "<div class=\"warn\">⚠ 有会话正在用「自动审查」（Auto review）访问模式：这个模式下装/更新插件有时会失败，助手这边也会跟着一连串报错，要重启客户端才能恢复；该模式下每次工具调用还会先过一遍审查，审查服务不可用或限流时，这次调用会被直接拒绝、不执行。建议先把该会话切换成「工作区内修改」，装完再切回「自动审查」。</div>";
+        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() {
@@ -1993,9 +2585,19 @@ window.__ModuleLoader__.load({
         /* 有成功更新就常驻提示：装到盘上的是新代码，运行中的还是旧的，
            不重启（桌面端）/不重启 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>";
@@ -2023,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) {
@@ -2038,6 +2642,9 @@ window.__ModuleLoader__.load({
           wrap.hidden = false;
           /* 位置只有一个来源：那枚「检查更新」按钮（不可拖动） */
           placeNear(document.getElementById(BTN_ID), wrap, PANEL_WIDTH, 220);
+          /* 浮层滚动条：先绑事件（innerHTML 换过就重绑），再按当前高度画拇指 */
+          bindSb(wrap);
+          syncSb(wrap);
         }
       }
 
@@ -2203,34 +2810,69 @@ window.__ModuleLoader__.load({
     }
 
     /* ======================================================================
-     * 模块 5：回合尾「本回合改动」补位卡（0.2.0 起）
+     * 模块 5：回合尾「本回合改动」——数据聚合 + 两种兜底情形下的自画卡
      *
-     * 缺陷（0.2.1-rc.2 实测）：官方回合尾卡读的是 workspaceChanges 服务，摘要与
-     * 对比只在内存 + 系统临时目录里活着，Session 一释放就 404，卡片变成一句
-     * 「这轮改动的内容已不可用」。但每次文件工具调用都把前后全文写在工具结果事件的
-     * meta.diffs: [{path, oldText, newText}] 里，**随会话日志永久保存** —— 客户端画
-     * 工具卡 diff 用的就是它（dsh-client-ui-tool 的 appliedDiffs）。所以本模块
+     * 缺陷（0.2.1-rc.2 实测）：官方回合尾卡读的是 workspaceChanges 服务，摘要与对比
+     * 只活在 Host 内存 + 系统临时目录里，Session 一释放就 404，卡片直接不画。但每次
+     * 文件工具调用都把前后全文写在工具结果事件的 meta.diffs:[{path,oldText,newText}]
+     * 里，**随会话日志永久保存** —— 客户端画工具卡 diff 用的就是它。所以本模块
      * **不新增任何持久化**：用 uiConversation 的 Turn Definition 把一回合内这些
-     * meta.diffs 聚合起来，注册到 conversation.chat.turnTail（官方声明的 list 槽位，
-     * 已有 deliverables / plan / schedule 三家），并且**只在官方卡已经失效时才补位**。
+     * meta.diffs 按文件聚合起来，注册到 conversation.chat.turnTail（官方声明的 list
+     * 槽位），供两处使用：
+     *   1. 模块 5b：喂给官方卡的数据（主路径，官方组件自己渲染）；
+     *   2. 本模块的自画卡：只在官方一定不会画的两种情形下出现（见下）。
+     *
+     * 0.2.1 修的两处（0.2.0 实测「卡片一次都没画出来」）：
+     *   - **必须实现 buildLocationData**：会话装配器只为实现了它的 Definition 发布
+     *     Turn 作用域数据，而 changesCard 读的 `owner.turn.data.get(CHANGES_KIND)`
+     *     正是这里发布的 value。0.2.0 缺了它 → state 恒为 null → 卡片永不画。
+     *   - **补位条件按「官方那侧会不会画」判断，不是只按「探测到 404」**：官方卡还受
+     *     设置项「显示编码工具视图」约束（showCodeDiff = configForms.developerTools
+     *     .enabled）；开关关着时路由照样 200，只按 404 判断会两边都不画。同理，该回合
+     *     没有 workspace/changes 公告（seq 为 null）时官方没有可请求的摘要。
      *
-     * 边界（README 同步）：
+     * 自画卡的边界（README 同步）：
      *   - 只覆盖**文件工具**的改动；pwsh / npm 等造成的改动进不来（只有官方卡含）。
      *   - 嵌套调用（run_code 里的 edit）走 tool/ptc-dispatch 事件，该事件没有 turn 字段，
      *     用 rootCallId → turn 的映射（来自 tool/call）挂回回合。
      *   - 探测结果只缓存在本次连接内（connection/reset 清空）。官方自己永久缓存 missing，
      *     那会在宿主恢复后留下双份卡。
+     *   - 外观照官方骨架（60px 卡头 / 图标块 / 千分位统计 / 4 行折叠 / hover 迷你 diff），
+     *     点击一律打开官方右侧 Review；没有任何内联展开的 diff。
      * ====================================================================== */
     var REACT = null;
     try { REACT = require("react"); } catch (e) { REACT = null; }
 
     var CHANGES_KIND = "ui-tweaks-changes";
     var SUMMARY_ROUTE = "api/changes.summary";   /* 文档相对，勿加前导斜杠（同官方 CHANGED_FILES_ROUTE） */
-    var DIFF_ROW_LIMIT = 400;                    /* 单个文件最多画多少行 diff */
     var LCS_LINE_LIMIT = 1200;                   /* 超过就退化为「全删 + 全增」，避免 DP 吃内存 */
     var probeCache = {};                         /* sessionId:seq -> "ok" | "missing" */
     var rootTurn = {};                           /* rootCallId -> turn（ptc 事件没有 turn） */
 
+    /* 官方卡还受设置项「显示编码工具视图」约束（官方 deliverables 的 showCodeDiff =
+       configForms.developerTools.enabled）。关着时官方卡不画，但 /api/changes.summary
+       照样 200 —— 只按探测结果判断会两边都不画。拿不到这个 store（注入未就绪）时按
+       「可能开着」处理：仍然走探测，结果与 0.2.0 一致，不会多出一张卡。 */
+    var devToolsStore = null;
+    function useDevToolsEnabled() {
+      var s = REACT.useState(function () {
+        return devToolsStore && typeof devToolsStore.getSnapshot === "function"
+          ? devToolsStore.getSnapshot() === true
+          : true;
+      });
+      var enabled = s[0], setEnabled = s[1];
+      REACT.useEffect(function () {
+        if (!devToolsStore || typeof devToolsStore.subscribe !== "function") { return undefined; }
+        var sync = function () {
+          try { setEnabled(devToolsStore.getSnapshot() === true); } catch (e) {}
+        };
+        sync();
+        var off = devToolsStore.subscribe(sync);
+        return function () { if (typeof off === "function") { off(); } };
+      }, []);
+      return enabled;
+    }
+
     function splitLines(text) {
       var s = text == null ? "" : String(text);
       if (s === "") { return []; }
@@ -2274,26 +2916,6 @@ window.__ModuleLoader__.load({
       }
       return { added: added, deleted: deleted };
     }
-    /* 同一文件在回合内被改多次时按 old→new 链折成一份净变化；链断返回 null（分段显示）。 */
-    function foldParts(parts) {
-      if (!parts || parts.length === 0) { return null; }
-      var before = parts[0][0] == null ? "" : String(parts[0][0]);
-      var after = parts[0][1] == null ? "" : String(parts[0][1]);
-      for (var i = 1; i < parts.length; i++) {
-        var o = parts[i][0];
-        if (o != null && String(o) !== after) { return null; }
-        if (parts[i][1] != null) { after = String(parts[i][1]); }
-      }
-      return { before: before, after: after };
-    }
-    function countParts(parts) {
-      var added = 0, deleted = 0;
-      for (var i = 0; i < parts.length; i++) {
-        var c = countRows(diffRows(parts[i][0], parts[i][1]));
-        added += c.added; deleted += c.deleted;
-      }
-      return { added: added, deleted: deleted };
-    }
     function metaDiffs(data) {
       if (!data || typeof data !== "object") { return null; }
       var meta = data.meta;
@@ -2344,25 +2966,109 @@ window.__ModuleLoader__.load({
           }
           return null;
         },
-        start: function () { return { seq: null, files: [] }; },
+        start: function (context, match) {
+          var turn = match && match.event && match.event.data ? match.event.data.turn : undefined;
+          return { turn: turn, seq: null, files: [] };
+        },
         update: function (context, match) {
-          var prev = (context && context.state) || context || { seq: null, files: [] };
-          var next = { seq: prev.seq == null ? null : prev.seq, files: prev.files || [] };
+          var prev = (context && context.state) || context || { turn: undefined, seq: null, files: [] };
+          var next = { turn: prev.turn, seq: prev.seq == null ? null : prev.seq, files: prev.files || [] };
           var event = match && match.event;
           if (!event) { return next; }
-          if (event.type === "workspace/changes") { return { seq: event.seq, files: next.files }; }
+          if (event.type === "workspace/changes") { return { turn: next.turn, seq: event.seq, files: next.files }; }
           var list = metaDiffs(event.data || {});
           if (!list) { return next; }
           var files = next.files;
           for (var i = 0; i < list.length; i++) { files = mergeDiff(files, list[i]); }
-          return { seq: next.seq, files: files };
+          return { turn: next.turn, seq: next.seq, files: files };
+        },
+        /* 卡片的取数通路（0.2.0 漏了它 → 卡片一次都没画）：装配器只为实现了本方法的
+           Definition 发布 Turn 作用域数据，changesCard 的 owner.turn.data.get(CHANGES_KIND)
+           读到的就是这里的 value。约定：data.kind === scope、"key === 本 Definition 的 kind"、
+           data.turn 是安全整数，任一条不满足装配器会直接抛错 —— 所以这里只做保守返回。 */
+        buildLocationData: function (context, scope, previous) {
+          if (scope !== "turn") { return null; }
+          var state = context && context.state;
+          var turn = state ? state.turn : undefined;
+          if (typeof turn !== "number" || !Number.isSafeInteger(turn) || turn < 0) { return null; }
+          if (previous && previous.kind === "turn" && previous.turn === turn && previous.key === CHANGES_KIND &&
+              previous.value && previous.value.seq === state.seq && previous.value.files === state.files) {
+            return previous;   /* 引用不变 → 装配器判定未变化，卡片不跟着重绘 */
+          }
+          return { kind: "turn", turn: turn, key: CHANGES_KIND, value: { seq: state.seq, files: state.files } };
         }
       };
     }
-    function shortPath(p) {
+    /* ---------- 自画卡对齐官方所需的取数/渲染辅助（只服务两种兜底情形） ----------
+
+       官方那张卡由 deliverables 自己渲染，我们抢不过来也不该抢；但有两种情形官方一定
+       不画：①「显示编码工具视图」关着（源码里 announced = showCodeDiff ? … : null）；
+       ② 该回合根本没有 workspace/changes 公告。这两处才由本卡补位，外观尽量贴官方：
+       类名不硬编码（hash 每版会变），运行时从官方注入的 CSS module <style> 里读出前缀。 */
+    var officialClassCache = null;
+    function officialChangesClasses() {
+      if (officialClassCache !== null) { return officialClassCache; }
+      officialClassCache = false;
+      try {
+        var tag = document.querySelector("style[data-plugin-css$=\"ChangedFiles.module.css\"]");
+        var text = tag && tag.textContent ? String(tag.textContent) : "";
+        var hit = /\.([A-Za-z0-9_-]{4,12})_card\b/.exec(text);
+        if (!hit) { return officialClassCache; }
+        var k = hit[1];
+        officialClassCache = {
+          card: k + "_card", header: k + "_header", tile: k + "_tile",
+          titles: k + "_titles", title: k + "_title", stat: k + "_stat",
+          statCounts: k + "_statCounts", previewHint: k + "_previewHint",
+          list: k + "_list", row: k + "_row", path: k + "_path",
+          counts: k + "_counts", toggle: k + "_toggle",
+          preview: k + "_preview", previewPath: k + "_previewPath"
+        };
+      } catch (e) { officialClassCache = false; }
+      return officialClassCache;
+    }
+    /* 读不到官方样式表时的近似样式（只影响观感，不影响结构/交互）。 */
+    var CHANGES_FALLBACK_STYLES = {
+      card: { marginTop: "4px", border: "0.5px solid var(--dsw-alias-border-l2, rgba(128,128,128,.3))", borderRadius: "var(--dsw-radius-lg, 8px)", background: "var(--dsw-alias-bg-layer-1, transparent)", display: "flex", flexDirection: "column", overflow: "hidden" },
+      header: { display: "flex", alignItems: "center", gap: "10px", width: "100%", boxSizing: "border-box", height: "60px", padding: "8px 10px", background: "var(--dsw-static-neutral-50, rgba(128,128,128,.08))", color: "inherit", textAlign: "left", border: "0", cursor: "pointer", font: "inherit" },
+      tile: { display: "grid", placeItems: "center", width: "40px", height: "40px", flex: "none", borderRadius: "10px", border: "0.5px solid var(--dsw-alias-border-l1, rgba(128,128,128,.25))" },
+      titles: { display: "flex", flexDirection: "column", flex: "1", minWidth: "0" },
+      title: { fontSize: "13px", fontWeight: 500, lineHeight: "20px", overflow: "hidden", textOverflow: "ellipsis", whiteSpace: "nowrap" },
+      stat: { display: "inline-flex", gap: "6px", fontSize: "10px", lineHeight: "16px", color: "var(--dsw-alias-label-tertiary, #888)" },
+      list: { margin: "0", padding: "0", listStyle: "none", borderTop: "0.5px solid var(--dsw-alias-border-l2, rgba(128,128,128,.3))" },
+      row: { display: "flex", alignItems: "center", justifyContent: "space-between", gap: "10px", width: "100%", boxSizing: "border-box", padding: "7px 18px 7px 14px", minHeight: "24px", background: "none", border: "0", cursor: "pointer", textAlign: "left", color: "var(--dsw-alias-label-tertiary, #888)", fontFamily: "var(--ds-font-family-code, monospace)", fontSize: "11px", lineHeight: "18px" },
+      path: { minWidth: "0", fontFamily: "var(--dsw-font-family, inherit)", fontSize: "12px", overflow: "hidden", textOverflow: "ellipsis", whiteSpace: "nowrap" },
+      counts: { display: "inline-flex", gap: "6px", flex: "none" },
+      toggle: { display: "inline-flex", alignItems: "center", gap: "4px", width: "100%", padding: "10px 18px 10px 14px", background: "none", border: "0", cursor: "pointer", color: "var(--dsw-alias-label-tertiary, #888)", fontSize: "12px", lineHeight: "18px", textAlign: "left" }
+    };
+    var CHANGES_ADDED_STYLE = { color: "var(--dsw-alias-state-success-primary, #3fb950)" };
+    var CHANGES_DELETED_STYLE = { color: "var(--dsw-alias-state-error-primary, #f85149)" };
+    var changesNumberFormat = null;
+    var changesHoverTimer = null;
+    var sidebarRightForChanges = null;
+
+    function changesNumber(value) {
+      try {
+        changesNumberFormat = changesNumberFormat || new Intl.NumberFormat("en-US");
+        return changesNumberFormat.format(value);
+      } catch (e) { return String(value); }
+    }
+    function changesBaseName(p) {
       var s = String(p);
-      return s.length > 64 ? "…" + s.slice(s.length - 63) : s;
+      var at = Math.max(s.lastIndexOf("/"), s.lastIndexOf("\\"));
+      return at < 0 ? s : s.slice(at + 1);
+    }
+    /* 点卡头/行 → 官方右侧 Review（地址与 ReviewTab 注册的 tab 类型对得上）。 */
+    function openOfficialChangesReview(sessionId, seq, turn, index) {
+      try {
+        var svc = sidebarRightForChanges || pickService(null, "sidebarRight");
+        if (!svc || typeof svc.openResource !== "function" || turn == null) { return false; }
+        var address = "dsh-resource://changes-review/session/" + encodeURIComponent(String(sessionId)) +
+          "/" + String(seq) + "/" + String(turn);
+        svc.openResource(address, { params: { index: index } });
+        return true;
+      } catch (e) { return false; }
     }
+
     function changesCard(props) {
       var owner = props || {};
       var state = null;
@@ -2373,14 +3079,27 @@ window.__ModuleLoader__.load({
       } catch (e) { state = null; }
       var sessionId = owner.sessionId;
       var seq = state && state.seq != null ? state.seq : null;
+      /* 模块 5b：把这条坐标（sessionId + seq → 文件/统计/hunk）登记进适配层索引。
+         必须在这里（渲染期）而不是 useEffect：React 先跑完所有 slot 的 render 才跑
+         effect，官方那个组件正是在它的 useEffect 里发请求，所以登记必然早于请求。 */
+      try {
+        registerChangesCoordinates(sessionId, seq, state,
+          (owner.turn && typeof owner.turn.turn === "number") ? owner.turn.turn : undefined);
+      } catch (e) {}
+      var devEnabled = useDevToolsEnabled();
+      /* 官方卡成立的两个前提：①「显示编码工具视图」开着；②该回合有 workspace/changes
+         公告（没公告就没有可请求的 seq，官方那侧一定不画）。缺任一个都不必探测。 */
+      var officialMayRender = devEnabled === true && seq != null;
       var key = (sessionId && seq != null) ? String(sessionId) + ":" + String(seq) : null;
       var cached = key && probeCache[key] ? probeCache[key] : null;
       var probeState = REACT.useState(cached || "pending");
       var probe = probeState[0], setProbe = probeState[1];
       var expState = REACT.useState(false);
       var expanded = expState[0], setExpanded = expState[1];
+      var hoverState = REACT.useState(null);   /* {index, top, left} | null：hover 迷你 diff 的锚点 */
+      var hover = hoverState[0], setHover = hoverState[1];
       REACT.useEffect(function () {
-        if (!key || cached) { return undefined; }
+        if (!key || !officialMayRender || cached) { return undefined; }
         var cancelled = false;
         try {
           fetch(SUMMARY_ROUTE + "?" + new URLSearchParams({ sessionId: String(sessionId), seq: String(seq) }),
@@ -2392,85 +3111,509 @@ window.__ModuleLoader__.load({
           }).catch(function () {});
         } catch (e) {}
         return function () { cancelled = true; };
-      }, [key, cached]);
-      /* 只在「官方已失效」时才补位：ok / pending / error 一律不画，避免出现双份卡。 */
-      if (!state || !state.files || state.files.length === 0 || seq == null || probe !== "missing") { return null; }
-
-      var files = state.files, totals = { added: 0, deleted: 0 }, prepared = [], i, j;
-      for (i = 0; i < files.length; i++) {
-        var net = foldParts(files[i].parts);
-        var rows = (expanded && net !== null) ? diffRows(net.before, net.after) : null;
-        var counted = net !== null ? countRows(diffRows(net.before, net.after)) : countParts(files[i].parts);
-        totals.added += counted.added; totals.deleted += counted.deleted;
-        prepared.push({ path: files[i].path, parts: files[i].parts, added: counted.added, deleted: counted.deleted, rows: rows });
-      }
-
-      var mono = "ui-monospace, SFMono-Regular, Menlo, Consolas, monospace";
-      var dim = { opacity: 0.6, fontSize: 11 };
-      var add = { color: "#3fb950" };
-      var del = { color: "#f85149" };
-      var children = [];
-      children.push(REACT.createElement("div", {
-        key: "head",
-        style: { display: "flex", alignItems: "center", gap: 8, cursor: "pointer", userSelect: "none" },
-        onClick: function () { setExpanded(!expanded); }
+      }, [key, cached, officialMayRender]);
+      if (!state || !state.files || state.files.length === 0) { return null; }
+      /* 只在「官方那侧不会画」时补位：官方可能画且探测不是 missing（ok / pending / error）
+         一律不画，避免双份卡。 */
+      if (officialMayRender && probe !== "missing") { return null; }
+
+      /* 数据直接复用模块 5b 的入口：保证卡片上的数字/hunk 与喂给官方卡的完全是同一份
+         （官方口径 = 回合首末净变化），不另算一套。无公告的回合用合成坐标 0 供 Review 取数。 */
+      var turnNumber = (owner.turn && typeof owner.turn.turn === "number") ? owner.turn.turn : null;
+      var seqForReview = seq != null ? seq : 0;
+      try { registerChangesCoordinates(sessionId, seqForReview, state, turnNumber); } catch (e) {}
+      var entry = changesEntryFor(sessionId, seqForReview);
+      if (!entry || entry.files.length === 0) { return null; }
+      var list = entry.files;
+      var total = list.length;
+      var single = total === 1 ? list[0] : null;
+      var foldable = total > 4;
+      var visible = foldable && !expanded ? list.slice(0, 4) : list;
+      var totals = { added: 0, deleted: 0 }, i;
+      for (i = 0; i < list.length; i++) { totals.added += list[i].added; totals.deleted += list[i].deleted; }
+
+      var classes = officialChangesClasses();
+      var classOf = function (name) { return classes ? classes[name] : undefined; };
+      var styleOf = function (name) {
+        if (classes) { return undefined; }
+        return CHANGES_FALLBACK_STYLES[name];
+      };
+      var hiddenNote = seq == null
+        ? "由 dsh-ui-tweaks 补位 · 该回合没有官方的改动记录"
+        : (devEnabled === true ? null : "由 dsh-ui-tweaks 补位 · 显示编码工具视图已关闭");
+      function beginHover(index, event) {
+        try {
+          var rect = event.currentTarget.getBoundingClientRect();
+          if (changesHoverTimer) { clearTimeout(changesHoverTimer); }
+          changesHoverTimer = setTimeout(function () {
+            setHover({ index: index, top: rect.bottom + 6, left: Math.max(8, rect.left) });
+          }, 500);
+        } catch (e) {}
+      }
+      function endHover() {
+        if (changesHoverTimer) { clearTimeout(changesHoverTimer); changesHoverTimer = null; }
+        if (hover) { setHover(null); }
+      }
+      function countsOf(added, deleted) {
+        return [
+          REACT.createElement("span", { key: "a", style: CHANGES_ADDED_STYLE }, "+" + changesNumber(added)),
+          REACT.createElement("span", { key: "d", style: CHANGES_DELETED_STYLE }, "−" + changesNumber(deleted))
+        ];
+      }
+
+      var header = REACT.createElement("button", {
+        key: "header",
+        type: "button",
+        className: classOf("header"),
+        style: styleOf("header"),
+        title: hiddenNote || undefined,
+        "aria-label": single === null ? "打开本回合改动审查" : ("查看 " + single.display + " 的逐行对比"),
+        onClick: function () { openOfficialChangesReview(sessionId, seqForReview, turnNumber, 0); },
+        onMouseEnter: single === null ? undefined : function (event) { beginHover(0, event); },
+        onMouseLeave: single === null ? undefined : endHover
       },
-        REACT.createElement("span", { style: { fontWeight: 600 } }, "本回合改动"),
-        REACT.createElement("span", { style: dim }, files.length + " 个文件"),
-        REACT.createElement("span", { style: add }, "+" + totals.added),
-        REACT.createElement("span", { style: del }, "−" + totals.deleted),
-        REACT.createElement("span", { style: { marginLeft: "auto", opacity: 0.6, fontSize: 11 } }, expanded ? "收起" : "展开")
-      ));
-      children.push(REACT.createElement("div", { key: "note", style: { opacity: 0.5, fontSize: 11, marginTop: 2 } },
-        "（据会话日志重建 · 仅文件工具的改动）"));
-      if (expanded) {
-        for (i = 0; i < prepared.length; i++) {
-          var f = prepared[i];
-          var block = [];
-          block.push(REACT.createElement("div", {
-            key: "p", style: { display: "flex", alignItems: "center", gap: 6, marginTop: 6 }
+        REACT.createElement("span", { key: "tile", className: classOf("tile"), style: styleOf("tile") },
+          REACT.createElement("svg", {
+            width: 20, height: 20, viewBox: "0 0 20 20", fill: "none",
+            stroke: "currentColor", strokeWidth: 1.6, strokeLinecap: "round", strokeLinejoin: "round",
+            style: { color: "var(--dsw-alias-link, #6cb6ff)" }
           },
-            REACT.createElement("span", { style: { overflow: "hidden", textOverflow: "ellipsis", whiteSpace: "nowrap", fontFamily: mono }, title: f.path }, shortPath(f.path)),
-            REACT.createElement("span", { style: add }, "+" + f.added),
-            REACT.createElement("span", { style: del }, "−" + f.deleted)
-          ));
-          if (f.rows) {
-            var shown = f.rows.length > DIFF_ROW_LIMIT ? f.rows.slice(0, DIFF_ROW_LIMIT) : f.rows;
-            for (j = 0; j < shown.length; j++) {
-              block.push(REACT.createElement("div", {
-                key: "r" + j,
-                style: { fontFamily: mono, fontSize: 11, whiteSpace: "pre-wrap", wordBreak: "break-all",
-                  color: shown[j].k === "+" ? "#3fb950" : (shown[j].k === "-" ? "#f85149" : "inherit"),
-                  opacity: shown[j].k === " " ? 0.7 : 1 }
-              }, (shown[j].k === " " ? "  " : shown[j].k + " ") + shown[j].t));
-            }
-            if (f.rows.length > DIFF_ROW_LIMIT) {
-              block.push(REACT.createElement("div", { key: "more", style: dim }, "…还有 " + (f.rows.length - DIFF_ROW_LIMIT) + " 行"));
-            }
-          } else {
-            for (j = 0; j < f.parts.length; j++) {
-              block.push(REACT.createElement("div", { key: "seg" + j, style: { opacity: 0.6, fontSize: 11, marginTop: 4 } },
-                "第 " + (j + 1) + " 段改动（与前一段不衔接，分段显示）"));
-              var prows = diffRows(f.parts[j][0], f.parts[j][1]);
-              var pshown = prows.length > DIFF_ROW_LIMIT ? prows.slice(0, DIFF_ROW_LIMIT) : prows;
-              for (var r2 = 0; r2 < pshown.length; r2++) {
-                block.push(REACT.createElement("div", {
-                  key: "pr" + j + "_" + r2,
-                  style: { fontFamily: mono, fontSize: 11, whiteSpace: "pre-wrap", wordBreak: "break-all",
-                    color: pshown[r2].k === "+" ? "#3fb950" : (pshown[r2].k === "-" ? "#f85149" : "inherit"),
-                    opacity: pshown[r2].k === " " ? 0.7 : 1 }
-                }, (pshown[r2].k === " " ? "  " : pshown[r2].k + " ") + pshown[r2].t));
+            REACT.createElement("path", { d: "M7.5 6 4 10l3.5 4" }),
+            REACT.createElement("path", { d: "M12.5 6 16 10l-3.5 4" }))),
+        REACT.createElement("span", { key: "titles", className: classOf("titles"), style: styleOf("titles") },
+          REACT.createElement("span", { key: "title", className: classOf("title"), style: styleOf("title") },
+            single === null ? ("已编辑 " + changesNumber(total) + " 个文件") : changesBaseName(single.path)),
+          REACT.createElement("span", { key: "stat", className: classOf("stat"), style: styleOf("stat") },
+            countsOf(totals.added, totals.deleted))));
+
+      var rows = [];
+      for (i = 0; i < visible.length; i++) {
+        rows.push((function (file, index) {
+          return REACT.createElement("li", { key: "row:" + file.display, style: { display: "block", margin: 0, padding: 0 } },
+            REACT.createElement("button", {
+              type: "button",
+              className: classOf("row"),
+              style: styleOf("row"),
+              title: file.path,
+              "aria-label": "查看 " + file.display + " 的逐行对比",
+              onClick: function () { openOfficialChangesReview(sessionId, seqForReview, turnNumber, index); },
+              onMouseEnter: function (event) { beginHover(index, event); },
+              onMouseLeave: endHover
+            },
+              REACT.createElement("span", { className: classOf("path"), style: styleOf("path") }, file.display),
+              REACT.createElement("span", { className: classOf("counts"), style: styleOf("counts") },
+                countsOf(file.added, file.deleted))));
+        })(visible[i], i));
+      }
+
+      var preview = null;
+      if (hover && list[hover.index]) {
+        var hovered = list[hover.index];
+        var previewLines = [];
+        for (var h = 0; h < hovered.hunks.length; h++) {
+          var hunk = hovered.hunks[h];
+          if (h > 0) { previewLines.push(REACT.createElement("div", { key: "gap" + h, style: { height: "6px" } })); }
+          var oldNo = hunk.oldStart, newNo = hunk.newStart;
+          for (var n = 0; n < hunk.lines.length; n++) {
+            var text = hunk.lines[n];
+            var mark = text.charAt(0);
+            /* 行号照官方：删除行给旧行号，新增行给新行号，上下文行给新行号。 */
+            var shownNo = mark === "-" ? oldNo : newNo;
+            if (mark === "-") { oldNo++; }
+            else if (mark === "+") { newNo++; }
+            else { oldNo++; newNo++; }
+            previewLines.push(REACT.createElement("div", {
+              key: "l" + h + "_" + n,
+              style: {
+                display: "flex", gap: "8px", padding: "0 8px 0 4px",
+                fontFamily: "var(--ds-font-family-code, monospace)", fontSize: "11px", lineHeight: "16px",
+                whiteSpace: "pre",
+                background: mark === "+" ? "rgba(63,185,80,.16)" : (mark === "-" ? "rgba(248,81,73,.16)" : "transparent"),
+                borderLeft: "2px solid " + (mark === "+"
+                  ? "var(--dsw-alias-state-success-primary, #3fb950)"
+                  : (mark === "-" ? "var(--dsw-alias-state-error-primary, #f85149)" : "transparent")),
+                color: mark === "+"
+                  ? "var(--dsw-alias-state-success-primary, #3fb950)"
+                  : (mark === "-" ? "var(--dsw-alias-state-error-primary, #f85149)" : "inherit"),
+                opacity: mark === " " ? 0.72 : 1
               }
+            },
+              REACT.createElement("span", { key: "no", style: { flex: "none", minWidth: "30px", textAlign: "right", opacity: 0.55 } }, String(shownNo)),
+              REACT.createElement("span", { key: "mark", style: { flex: "none", width: "9px", opacity: 0.8 } }, mark === " " ? "" : mark),
+              REACT.createElement("span", { key: "text", style: { flex: "1" } }, text.slice(1))));
+          }
+        }
+        preview = REACT.createElement("div", {
+          key: "preview",
+          style: {
+            position: "fixed", top: hover.top + "px", left: hover.left + "px", zIndex: 9999,
+            maxWidth: "720px", maxHeight: "320px", overflow: "auto", pointerEvents: "none",
+            background: "var(--dsw-alias-bg-layer-1, #1e1e1e)",
+            border: "0.5px solid var(--dsw-alias-border-l2, rgba(128,128,128,.35))",
+            borderRadius: "var(--dsw-radius-lg, 8px)", padding: "0 0 6px",
+            boxShadow: "0 8px 24px rgba(0,0,0,.35)"
+          },
+          children: [
+            REACT.createElement("div", {
+              key: "path",
+              style: { fontSize: "12px", lineHeight: "20px", color: "var(--dsw-alias-label-tertiary, #888)",
+                fontFamily: "var(--ds-font-family-code, monospace)", padding: "6px 10px 4px", whiteSpace: "nowrap" }
+            }, hovered.display)
+          ].concat(previewLines)
+        });
+      }
+
+      var children = [header];
+      if (rows.length > 0) {
+        children.push(REACT.createElement("ul", { key: "list", className: classOf("list"), style: styleOf("list") }, rows));
+      }
+      if (foldable) {
+        children.push(REACT.createElement("button", {
+          key: "toggle",
+          type: "button",
+          className: classOf("toggle"),
+          style: styleOf("toggle"),
+          "aria-expanded": expanded,
+          onClick: function () { setExpanded(!expanded); }
+        }, expanded ? "收起" : ("全部 " + changesNumber(total) + " 个")));
+      }
+      /* 只有「无公告」这种官方压根没有过记录的回合，才在卡内留一行可见小字；编码视图关
+         的情形走 title（鼠标悬停可见），保持与官方外观一致。 */
+      if (seq == null) {
+        children.push(REACT.createElement("div", {
+          key: "note",
+          style: { padding: "0 14px 8px", fontSize: "11px", lineHeight: "16px", color: "var(--dsw-alias-label-tertiary, #888)" }
+        }, hiddenNote));
+      }
+      if (preview) { children.push(preview); }
+
+      var cardProps = {
+        className: classOf("card"),
+        style: styleOf("card"),
+        "data-changed-files": true,
+        title: hiddenNote || undefined
+      };
+      if (single !== null) { cardProps["data-single"] = true; }
+      return REACT.createElement("div", cardProps, children);
+    }
+    /* ======================================================================
+     * 模块 5b：官方改动卡数据适配层（A 线）
+     *
+     * 官方那张卡不自己算数据，它向两条同源路由要东西：
+     *   GET api/changes.summary?sessionId=…&seq=…
+     *   GET api/changes.diff?sessionId=…&seq=…&index=…
+     * 而这两条路由的数据只活在该 Session 的 Host 内存里，会话一释放就 404。本模块把
+     * 会话日志里已聚合好的改动（meta.diffs）在**客户端**按官方形状重算一遍：官方 404 时
+     * 由包装过的 fetch 直接顶上 200，于是**官方组件原生渲染** —— 卡头、hover 预览、
+     * 右侧 Review 面板全是官方的，我们一个像素都不用画。
+     *
+     * 三条硬约束：
+     *   1. 只拦这两个路径、且只对索引里存在的坐标生效；其余请求原样透传给原生 fetch。
+     *   2. 坐标必须在官方组件发请求**之前**进索引 → 卡片在渲染期登记（见 changesCard）。
+     *   3. 形状必须过官方 validator（deliverables 的 isChangesSummary / isChangesDiff）：
+     *      summary = { turn, files:[{path, display, added, deleted}], total, added, deleted }
+     *      diff    = { kind:"text", path, display, before, after, coarse,
+     *                  hunks:[{ oldStart, oldLines, newStart, newLines, lines:["+…"] }] }
+     * 口径差异（有意为之）：官方是「回合开始快照 → 回合结束」的净变化，所以同文件多段
+     * 改动链不上时，我们给首段 oldText → 末段 newText 的净变化，数字因此与旧卡的
+     * 分段累加不同（例如 +16 −13 vs +2 −12）。
+     * ====================================================================== */
+    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;
+
+    var changesCoordinates = {};   /* "sessionId:seq" -> entry */
+    var adapterInstalled = false;
+    var adapterOriginalFetch = null;
+    var adapterPatchedFetch = null;
+    var adapterCtx = null;
+
+    /* 显示口径照官方：工作目录内用相对路径，否则给绝对路径（家目录 ~ 归一化暂缺）。 */
+    function changesDisplayOf(cwd, p) {
+      var abs = String(p);
+      if (cwd) {
+        var base = String(cwd).replace(/[\\/]+$/, "");
+        var low = abs.toLowerCase(), lowBase = base.toLowerCase();
+        if (low === lowBase) { return abs; }
+        if (low.indexOf(lowBase + "\\") === 0 || low.indexOf(lowBase + "/") === 0) {
+          return abs.slice(base.length + 1).replace(/\//g, "\\");
+        }
+      }
+      return abs.replace(/\//g, "\\");
+    }
+
+    /* 行 → 官方 hunk（3 行上下文、1 起始行号、每行带 +/-/空格 前缀）。 */
+    function changesRowsToHunks(rows) {
+      var i, row, idx = [];
+      for (i = 0; i < rows.length; i++) { if (rows[i].k !== " ") { idx[i] = 1; } }
+      var changed = [];
+      for (i = 0; i < rows.length; i++) { if (idx[i] === 1) { changed.push(i); } }
+      if (changed.length === 0) { return []; }
+      var ranges = [];
+      var start = Math.max(0, changed[0] - ADAPTER_CONTEXT_LINES);
+      var end = Math.min(rows.length - 1, changed[0] + ADAPTER_CONTEXT_LINES);
+      for (i = 1; i < changed.length; i++) {
+        if (changed[i] - ADAPTER_CONTEXT_LINES <= end + 1) {
+          end = Math.min(rows.length - 1, changed[i] + ADAPTER_CONTEXT_LINES);
+        } else {
+          ranges.push([start, end]);
+          start = Math.max(0, changed[i] - ADAPTER_CONTEXT_LINES);
+          end = Math.min(rows.length - 1, changed[i] + ADAPTER_CONTEXT_LINES);
+        }
+      }
+      ranges.push([start, end]);
+      var hunks = [], oldNo = 1, newNo = 1, cursor = 0, budget = ADAPTER_MAX_HUNK_LINES, at;
+      for (var r = 0; r < ranges.length; r++) {
+        var from = ranges[r][0], to = ranges[r][1];
+        while (cursor < from) {
+          row = rows[cursor];
+          if (row.k !== "+") { oldNo++; }
+          if (row.k !== "-") { newNo++; }
+          cursor++;
+        }
+        var oldStart = oldNo, newStart = newNo, lines = [], oldLines = 0, newLines = 0;
+        for (at = from; at <= to && budget > 0; at++, budget--) {
+          row = rows[at];
+          lines.push((row.k === " " ? " " : row.k) + row.t);
+          if (row.k !== "+") { oldLines++; oldNo++; }
+          if (row.k !== "-") { newLines++; newNo++; }
+        }
+        cursor = to + 1;
+        hunks.push({ oldStart: oldStart, oldLines: oldLines, newStart: newStart, newLines: newLines, lines: lines });
+        if (budget <= 0) { break; }
+      }
+      return hunks;
+    }
+
+    function buildChangesEntry(sessionId, seq, turn, files, cwd) {
+      var out = [], i, file, parts, before, after, rows, counts;
+      for (i = 0; i < files.length; i++) {
+        file = files[i] || {};
+        parts = Array.isArray(file.parts) ? file.parts : [];
+        before = parts.length > 0 ? parts[0][0] : null;
+        after = parts.length > 0 ? parts[parts.length - 1][1] : null;
+        rows = diffRows(before, after);
+        counts = countRows(rows);
+        out.push({
+          path: String(file.path),
+          display: changesDisplayOf(cwd, file.path),
+          added: counts.added,
+          deleted: counts.deleted,
+          before: before != null,
+          after: after != null,
+          hunks: changesRowsToHunks(rows)
+        });
+      }
+      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, cwd: cwd || null };
+    }
+
+    /* 会话 cwd：官方 display 的基准。取不到就退化为绝对路径（不影响校验，只是显示不同）。 */
+    function changesCwdOf(sessionId) {
+      try {
+        var svc = (adapterCtx && typeof adapterCtx.get === "function") ? adapterCtx.get("sessions") : null;
+        if (!svc) { svc = pickService(null, "sessions"); }
+        var store = svc && svc.list;
+        var snap = store && typeof store.getSnapshot === "function" ? store.getSnapshot() : null;
+        var meta = snap && snap.byId ? snap.byId[sessionId] : null;
+        return meta && typeof meta.cwd === "string" ? meta.cwd : null;
+      } catch (e) { return null; }
+    }
+
+    /* 渲染期登记：必须早于官方组件的 useEffect（React 先跑完所有 slot 的 render）。
+       turn 来自 slot props 里的 TurnLocation（owner.turn.turn），Definition 发布的状态里
+       只有 {seq, files} —— 所以这里显式收 turn，缺了就退回 state.turn。 */
+    function registerChangesCoordinates(sessionId, seq, state, turn) {
+      if (!sessionId || seq == null || !state || !Array.isArray(state.files) || state.files.length === 0) { return; }
+      var turnNumber = (typeof turn === "number" && Number.isSafeInteger(turn) && turn >= 1) ? turn
+        : (typeof state.turn === "number" && Number.isSafeInteger(state.turn) && state.turn >= 1 ? state.turn : null);
+      if (turnNumber === null) { return; }   /* 官方 validator 要求 turn 是 ≥1 的整数，缺了宁可不拦 */
+      var key = String(sessionId) + ":" + String(seq);
+      var current = changesCoordinates[key];
+      if (current && current.stateFiles === state.files && current.turn === turnNumber) { return; }
+      changesCoordinates[key] = buildChangesEntry(sessionId, seq, turnNumber, state.files, changesCwdOf(sessionId));
+    }
+
+    function changesEntryFor(sessionId, seq) {
+      if (!sessionId || seq == null) { return null; }
+      return changesCoordinates[String(sessionId) + ":" + String(seq)] || null;
+    }
+
+    function changesSummaryPayload(entry) {
+      var files = [], added = 0, deleted = 0, i, f;
+      for (i = 0; i < entry.files.length; i++) {
+        f = entry.files[i];
+        files.push({ path: f.path, display: f.display, added: f.added, deleted: f.deleted });
+        added += f.added;
+        deleted += f.deleted;
+      }
+      return { turn: entry.turn, files: files, total: files.length, added: added, deleted: deleted };
+    }
+
+    function changesDiffPayload(entry, index) {
+      var f = entry.files[index];
+      if (!f) { return null; }
+      return { kind: "text", path: f.path, display: f.display, before: f.before, after: f.after, coarse: false, hunks: f.hunks };
+    }
+
+    function changesJsonResponse(payload) {
+      try {
+        return new Response(JSON.stringify(payload), {
+          status: 200,
+          headers: { "content-type": "application/json", "cache-control": "no-store" }
+        });
+      } 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; }
+      var original = window.fetch;
+      var patched = function (input, init) {
+        var raw = "";
+        try { raw = typeof input === "string" ? input : ((input && input.url) || ""); } catch (e0) { raw = ""; }
+        var url = null;
+        try { url = new URL(raw, (typeof location !== "undefined" && location.href) ? location.href : "http://localhost/"); } catch (e1) { url = null; }
+        if (!url) { return original.apply(this, arguments); }
+        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;
+        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;
           }
-          children.push(REACT.createElement("div", { key: "f" + i }, block));
+          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);
+        if (!response) { return original.apply(this, arguments); }
+        try {
+          console.info("[dsh-ui-tweaks:" + BUILD + "] 改动卡数据由会话日志重建 · " + (isSummary ? "summary" : "diff #" + url.searchParams.get("index")) + " · turn " + entry.turn);
+        } catch (e2) {}
+        return Promise.resolve(response);
+      };
+      adapterOriginalFetch = original;
+      adapterPatchedFetch = patched;
+      window.fetch = patched;
+      adapterInstalled = true;
+    }
+
+    function uninstallChangesFetchAdapter() {
+      if (!adapterInstalled) { return; }
+      if (typeof window !== "undefined" && window.fetch === adapterPatchedFetch && adapterOriginalFetch) {
+        window.fetch = adapterOriginalFetch;
       }
-      return REACT.createElement("div", {
-        style: { marginTop: 8, border: "1px solid var(--dsw-alias-border-neutral-secondary, rgba(128,128,128,0.25))",
-          borderRadius: 8, padding: "8px 10px", fontSize: 12 }
-      }, children);
+      adapterInstalled = false;
+      adapterPatchedFetch = null;
+      adapterOriginalFetch = null;
     }
+
     function installChangesCard(scope, ctx) {
       if (!REACT) { throw new Error("ui-tweaks: require(\"react\") 不可用，跳过改动补位卡"); }
       var s = scope || ctx || {};
@@ -2482,7 +3625,41 @@ window.__ModuleLoader__.load({
       if (!slots || typeof slots.register !== "function" || typeof slots.inject !== "function") {
         throw new Error("ui-tweaks: slots 服务不可用");
       }
-      conv.events.register(changesDefinition());
+      var definition = changesDefinition();
+      /* 模块 5b：先装数据适配层。装了之后，已释放会话里官方卡会自己长出来（我们这张卡
+         因为探测同样被答成 200 而自动让位）；活会话不受影响（原生 200 优先，我们不拦）。 */
+      adapterCtx = ctx || null;
+      guard("changes-adapter", installChangesFetchAdapter);
+      try {
+        if (ctx && typeof ctx.effect === "function") {
+          ctx.effect(function () { return uninstallChangesFetchAdapter; });
+        }
+      } catch (e) {}
+      /* 回归闸：buildLocationData 是卡片唯一的取数通路，缺了它 state 恒 null、卡片静默
+         不画（0.2.0 的真实缺陷）。这里宁可显式报错，也不要再静默消失一次。 */
+      if (typeof definition.buildLocationData !== "function") {
+        throw new Error("ui-tweaks: changesDefinition 缺 buildLocationData，补位卡不会渲染");
+      }
+      conv.events.register(definition);
+      /* 官方卡的开关（「显示编码工具视图」）。拿不到就保持 null → useDevToolsEnabled 按
+         「可能开着」走探测，行为与 0.2.0 一致。configForms 缺失时 ctx.inject 的回调不会
+         执行（Cordis 语义），所以这里不当作错误。 */
+      try {
+        ctx.inject(["configForms"], function (cfg) {
+          try {
+            var cf = cfg && cfg.configForms ? cfg.configForms : cfg;
+            if (cf && cf.developerTools && cf.developerTools.enabled) { devToolsStore = cf.developerTools.enabled; }
+          } catch (e) {}
+        });
+      } catch (e) {}
+      try {
+        ctx.inject(["sidebarRight"], function (right) {
+          try {
+            var svc = right && right.sidebarRight ? right.sidebarRight : right;
+            if (svc && typeof svc.openResource === "function") { sidebarRightForChanges = svc; }
+          } catch (e) {}
+        });
+      } catch (e) {}
       slots.inject("conversation.chat.turnTail", function () {
         return slots.register({
           name: "conversation.chat.turnTail",