dsh-unlag 0.0.0-stage → 1.7.3

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 regrevia
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -1,3 +1,53 @@
-# Temporary Holding Version
+# dsh-unlag（解除卡顿）
 
-This version is a temporary placeholder for this package. An operational version to replace this has been submitted for review and is awaiting a staged release.
+一个按钮，把「改完插件要重启才生效」变成点一下，顺便治好用久了的卡顿。
+
+窗口右上角那个按钮只做两件事：把改过的插件代码原地换掉、把界面重建一次。全程不重启进程，所以会话、正在跑的轮次、排队的消息、没发出的输入都还在。
+
+## 为什么有用
+
+- 开发插件：改完 `.js` 点一下就生效，不用重启 App，也不用刷新页面。
+- 装新插件：装完点一下让它进来，接着用。
+- 界面用久了发卡：点一下重建，滚动位置和草稿都保留。
+
+以前这三种都得重启 App，现在都不用。有会话正在跑的时候也能点：**马上换，不等空闲**——轮次不会被打断；某一步正好调到被换掉的插件时会报错重来，会话继续。
+
+## 装
+
+```sh
+dsh plugin install dsh-unlag
+```
+
+装完重载一次 App 让它进来，之后所有更新都走按钮。
+
+## 用
+
+点右上角按钮即可。设置里两行决定它做什么：
+
+- **按下刷新时换掉插件代码**（默认开）
+- **按下刷新时重建界面**（默认开）
+
+都开＝先换代码再重建；只开一个＝另一项完全不动（只换代码时页面不刷新，渲染状态和滚动位置全保留）；都不开＝点击无反应。
+
+## 不会丢什么
+
+- 轮次、子代理、终端进程：在宿主侧，不受影响。
+- 排队消息、引导队列、输入草稿和附件：重建前会先提交焦点里的内容。
+- 有未保存改动或还开着弹窗时：重建被拦下并提示，不硬刷。
+- 它自己从不重启或退出 App；缺启动模块时宁可放弃重建并提示，也不冒把 App 带下去的风险。
+
+## 管不到的地方
+
+独立进程和进程级的东西：宠物窗口自己的配置、DSH 自身升级、原生依赖变化。
+
+## 排错
+
+- 日志：`~/.dsh/unlag-reload.log`，每次换代码／跳过／被拦各一行含原因。
+- 状态：`GET /dsh-unlag/state` → `{"plugins":true,"page":true}` 是两个开关的当前值。
+
+## 测试
+
+```sh
+node test/button.test.mjs   # 开关、接口、忙时立刻换、无宿主不崩
+node test/safety.test.mjs   # 崩坏路径与未处理拒绝
+```

package/client.js

@@ -0,0 +1,407 @@
+window.__ModuleLoader__.load({
+  id: 'dsh-unlag',
+  factory(require) {
+    const React = require('react');
+    const h = React.createElement;
+
+    const zh = /^zh/i.test(navigator.language || '');
+    const COPY = zh
+      ? { label: '解除卡顿', hint: '卡顿时用：换掉插件代码并重建界面；运行中的任务、排队的消息保留', blocked: '暂时无法重建界面，稍后再试', unsaved: '有未保存的改动，先保存再重试', dialog: '先关闭打开的窗口再重载', queued: '已排队：任务跑完自动重载' } // ui-copy-ignore
+      : { label: 'Unlag', hint: 'For a sluggish interface: replaces plugin code and rebuilds the page; running turns and queued messages are kept', blocked: 'Cannot rebuild the page right now; try again', unsaved: 'Unsaved changes; save them, then retry', dialog: 'Close the open window first', queued: 'Queued; it reloads once the turn ends' };
+
+    // Desktop shell only: the macOS and Windows desktop build owns the page and the running
+    // app, so this is where the button belongs. A browser tab can reload freely on its own.
+    const desktop = /Electron\//.test(navigator.userAgent || '');
+
+    /**
+     * Announced before the interface is rebuilt. Any plugin holding state that a rebuild would
+     * drop can listen, save synchronously, or add a promise to `detail.pending`; calling
+     * `preventDefault()` keeps the interface as it is. Nothing here is required to know about
+     * this plugin, and no plugin is required to answer.
+     */
+    const PREPARE_EVENT = 'dsh-unlag:before';
+
+    /** Set while a rebuild is pending, so a repeated click cannot start a second one. */
+    const STAMP_KEY = 'dsh-unlag:at'; // ui-copy-ignore
+
+    /**
+     * What a press does is decided by the plugin's settings row, read from the running app, so
+     * neither half assumes the other one is wanted. An app that does not answer leaves the press
+     * doing what it did before: rebuild the interface.
+     */
+    const HOST_BASE = '/dsh-unlag'; // ui-copy-ignore
+
+    async function readSettings() {
+      try {
+        const response = await fetch(`${HOST_BASE}/state`, { cache: 'no-store', credentials: 'same-origin' });
+        if (!response.ok) return null;
+        const data = await response.json();
+        if (data === null || typeof data !== 'object') return null;
+        return { plugins: data.plugins !== false, page: data.page !== false };
+      } catch {
+        return null;
+      }
+    }
+
+    /**
+     * Leave one line per press outcome in the log the app keeps. Without it a press that stopped
+     * before rebuilding looks exactly like one that never happened, and the page itself is gone by
+     * the time anyone reads it.
+     */
+    function report(event, gate) {
+      const query = gate === undefined ? `event=${event}` : `event=${event}&gate=${encodeURIComponent(gate)}`;
+      try {
+        fetch(`${HOST_BASE}/report?${query}`, {
+          method: 'POST', // ui-copy-ignore
+          credentials: 'same-origin',
+          headers: { 'x-dsh-unlag': '1' }, // ui-copy-ignore
+          keepalive: true, // ui-copy-ignore
+        }).catch(() => {});
+      } catch {}
+    }
+
+    /** Ask the running app to replace changed plugins now; a running turn is reported, never cut. */
+    async function replacePlugins() {
+      try {
+        const response = await fetch(`${HOST_BASE}/reload`, {
+          method: 'POST', // ui-copy-ignore
+          credentials: 'same-origin',
+          headers: { 'content-type': 'application/json', 'x-dsh-unlag': '1' }, // ui-copy-ignore
+          body: '{}', // ui-copy-ignore
+        });
+        if (!response.ok) return 'failed';
+        const data = await response.json();
+        return typeof data?.status === 'string' ? data.status : 'failed';
+      } catch {
+        return 'failed';
+      }
+    }
+
+    /** The plugin ids one startup bundle covers, read from its `??<id>/client.js,…` list. */
+    function bundledIds(url) {
+      const match = /\?\?([^&]+)/.exec(url);
+      if (match === null) return [];
+      return match[1].split(',').map((part) => decodeURIComponent(part).replace(/\/client\.js.*$/u, '')).filter((id) => id !== '');
+    }
+
+    /** Read every bundle the next boot would load and prove each listed plugin is inside. */
+    async function bundlesCoverStartup(graph) {
+      if (graph === null || typeof graph !== 'object') return false;
+      const entries = Array.isArray(graph.entries) ? graph.entries : [];
+      const batches = Array.isArray(graph.batches) ? graph.batches : [];
+      if (entries.length === 0 || batches.length === 0) return false;
+      const covered = new Set();
+      const sources = [];
+      for (const batch of batches) {
+        const url = typeof batch?.url === 'string' ? batch.url : '';
+        if (url === '') continue;
+        const listed = Array.isArray(batch.entries) && batch.entries.every((id) => typeof id === 'string') ? batch.entries : [];
+        const ids = listed.length > 0 ? listed : bundledIds(url);
+        if (ids.length === 0) return false;
+        for (const id of ids) covered.add(id);
+        sources.push({ url: new URL(url, location.href), ids });
+      }
+      if (sources.length === 0) return false;
+      for (const entry of entries) {
+        const id = typeof entry === 'string' ? entry : entry?.id;
+        if (typeof id !== 'string' || !covered.has(id)) return false;
+      }
+      for (const source of sources) {
+        try {
+          const response = await fetch(source.url.toString(), { cache: 'no-store', credentials: 'same-origin' });
+          if (!response.ok) return false;
+          const body = await response.text();
+          if (body.length === 0) return false;
+          for (const id of source.ids) {
+            if (!body.includes(id)) return false;
+          }
+        } catch {
+          return false;
+        }
+      }
+      return true;
+    }
+
+    /** The first balanced JSON object after `__DSH_BOOT__` in a served document. */
+    function graphFromHtml(html) {
+      const at = html.indexOf('__DSH_BOOT__'); // ui-copy-ignore
+      if (at < 0) return null;
+      const start = html.indexOf('{', at);
+      if (start < 0) return null;
+      let depth = 0;
+      let quoted = false;
+      let escaped = false;
+      for (let index = start; index < html.length; index += 1) {
+        const ch = html[index];
+        if (quoted) {
+          if (escaped) escaped = false;
+          else if (ch === '\\') escaped = true;
+          else if (ch === '"') quoted = false;
+          continue;
+        }
+        if (ch === '"') quoted = true;
+        else if (ch === '{') depth += 1;
+        else if (ch === '}') {
+          depth -= 1;
+          if (depth === 0) {
+            try {
+              return JSON.parse(html.slice(start, index + 1));
+            } catch {
+              return null;
+            }
+          }
+        }
+      }
+      return null;
+    }
+
+    /**
+     * The startup list a rebuild would actually get. This page's own list is only true of the
+     * page already running: a plugin swapped since then is listed there under its old module,
+     * so asking it first would refuse a rebuild that is in fact safe.
+     */
+    /**
+     * The startup list the next document would get, read from the running app. It renders that
+     * list for every index response, so this is the same row the next boot reads, described by
+     * the side that serves the bundles rather than by whatever this document happens to hold.
+     */
+    async function hostBootGraph() {
+      try {
+        const response = await fetch(`${HOST_BASE}/graph`, { cache: 'no-store', credentials: 'same-origin' });
+        if (!response.ok) return null;
+        const data = await response.json();
+        const graph = data?.graph;
+        return graph !== null && typeof graph === 'object' ? graph : null;
+      } catch {
+        return null;
+      }
+    }
+
+    async function servedBootGraph() {
+      const fromHost = await hostBootGraph();
+      if (fromHost !== null) return fromHost;
+      try {
+        const response = await fetch(location.href, { cache: 'no-store', credentials: 'same-origin' });
+        if (!response.ok) return null;
+        return graphFromHtml(await response.text());
+      } catch {
+        return null;
+      }
+    }
+
+    /**
+     * Whether a rebuild can re-run the interface at all. A boot activates one module per plugin
+     * in the startup list and stops the desktop app when any of them is missing, so a list row
+     * whose module is absent from the bundles it points at would end the app and every running
+     * turn along with it. Reading the bundles back proves each row still resolves before the
+     * interface is rebuilt; one repeat covers a bundle swapped while the app was re-composing.
+     * @returns true when every listed plugin's module is present in the served bundles.
+     */
+    async function startupLooksServable() {
+      for (let attempt = 0; attempt < 2; attempt += 1) {
+        const graph = (await servedBootGraph()) ?? window.__DSH_BOOT__;
+        if (await bundlesCoverStartup(graph)) return true;
+        if (attempt === 0) await new Promise((resolve) => setTimeout(resolve, 300)); // ui-copy-ignore
+      }
+      return false;
+    }
+
+    /**
+     * Whether the other plugins are ready for the rebuild: their saves run first, and a refusal
+     * from any of them stops the rebuild instead of discarding work they still hold.
+     */
+    async function otherPluginsAreReady() {
+      const detail = { pending: [] };
+      const event = new CustomEvent(PREPARE_EVENT, { cancelable: true, detail });
+      window.dispatchEvent(event);
+      if (event.defaultPrevented) return false;
+      const pending = Array.isArray(detail.pending) ? detail.pending.filter((item) => item !== null && typeof item?.then === 'function') : [];
+      if (pending.length === 0) return true;
+      await Promise.race([
+        Promise.allSettled(pending),
+        new Promise((resolve) => setTimeout(resolve, 1200)), // ui-copy-ignore
+      ]);
+      return event.defaultPrevented === false;
+    }
+
+    /**
+     * Commit whatever the focused field holds. A field keeps the last keystrokes in its own
+     * state until the next write, so blurring it and yielding one frame leaves the draft in the
+     * session's stored input before the document goes away.
+     */
+    async function commitFocusedField() {
+      const active = document.activeElement;
+      if (active !== null && typeof active.blur === 'function') active.blur();
+      await new Promise((resolve) => requestAnimationFrame(() => resolve()));
+    }
+
+    /** Re-enter the interface on a fresh document, keeping the current view in the address. */
+    function reloadFreshPage() {
+      const graph = window.__DSH_BOOT__;
+      const stamp = typeof graph?.rev === 'string' && graph.rev !== '' ? graph.rev : String(Date.now());
+      const target = new URL(location.href);
+      target.searchParams.set('interface', stamp);
+      window.location.replace(target.toString());
+    }
+
+    /** A window the user still has open would go away with the rebuild. */
+    function screenHasOpenWindow() {
+      return document.querySelector('[aria-modal="true"], dialog[open]') !== null; // ui-copy-ignore
+    }
+
+    /**
+     * Whether anything still in the page would hold a navigation back. Asking the question without
+     * navigating runs the very listeners a rebuild would run, so work that is not committed yet is
+     * caught here rather than behind the leave-page prompt a navigation would raise.
+     * @returns true when a listener refuses to leave the page.
+     */
+    function stillHeldBack() {
+      const probe = new Event('beforeunload', { cancelable: true }); // ui-copy-ignore
+      window.dispatchEvent(probe);
+      return probe.defaultPrevented === true;
+    }
+
+    /**
+     * The automatic judgement: every reason a rebuild would take something away is checked here,
+     * in the order that costs the user least. A null answer means the interface can go.
+     * @returns the copy key of the reason to stop, or null when a rebuild is safe.
+     */
+    async function prepareInterface() {
+      if (!(await startupLooksServable())) return 'blocked';
+      if (screenHasOpenWindow()) return 'dialog';
+      await commitFocusedField();
+      const ready = await otherPluginsAreReady();
+      if (!ready || stillHeldBack()) return 'unsaved';
+      return null;
+    }
+
+    const WRAP_STYLE = { position: 'relative', display: 'inline-flex', alignItems: 'center' };
+
+    const BUTTON_STYLE = {
+      display: 'inline-flex', // ui-copy-ignore
+      alignItems: 'center',
+      justifyContent: 'center',
+      width: 28, // ui-copy-ignore
+      height: 28, // ui-copy-ignore
+      padding: 0, // ui-copy-ignore
+      border: 'none', // ui-copy-ignore
+      borderRadius: 6,
+      background: 'transparent',
+      color: 'inherit', // ui-copy-ignore
+      cursor: 'pointer', // ui-copy-ignore
+      opacity: 0.75, // ui-copy-ignore
+    };
+
+    const PILL_STYLE = {
+      position: 'absolute', // ui-copy-ignore
+      top: 30, // ui-copy-ignore
+      right: 0, // ui-copy-ignore
+      padding: '4px 8px', // ui-copy-ignore
+      borderRadius: 6,
+      border: '1px solid var(--dsh-color-border, rgba(127,127,127,0.28))',
+      background: 'var(--dsh-color-surface, Canvas)',
+      color: 'var(--dsh-color-text-secondary, inherit)',
+      fontSize: 12, // ui-copy-ignore
+      whiteSpace: 'nowrap', // ui-copy-ignore
+    };
+
+    function ReloadButton() {
+      const [hover, setHover] = React.useState(false);
+      const [pending, setPending] = React.useState(false);
+      const [notice, setNotice] = React.useState(null);
+
+      React.useEffect(() => {
+        if (notice === null) return undefined;
+        const timer = setTimeout(() => setNotice(null), 8000);
+        return () => clearTimeout(timer);
+      }, [notice]);
+
+      const style = pending
+        ? { ...BUTTON_STYLE, opacity: 0.4 }
+        : hover
+          ? { ...BUTTON_STYLE, opacity: 1, background: 'var(--dsh-color-surface-hover, rgba(127,127,127,0.14))' }
+          : BUTTON_STYLE;
+
+      const onClick = async () => {
+        if (pending) return;
+        const previous = Number(window.sessionStorage.getItem(STAMP_KEY) ?? 0);
+        if (Number.isFinite(previous) && Date.now() - previous < 3000) return; // ui-copy-ignore
+        setPending(true);
+        setNotice(null);
+        const stop = (key) => {
+          setPending(false);
+          setNotice(COPY[key]);
+        };
+        const settings = await readSettings();
+        const replace = settings === null ? false : settings.plugins;
+        const rebuild = settings === null ? true : settings.page;
+        // Both switches off: a press does nothing at all.
+        if (!replace && !rebuild) {
+          setPending(false);
+          return;
+        }
+        // Replace first: a plugin that only changed the interface is then covered by the rebuild.
+        let pluginNote = null;
+        if (replace) {
+          const status = await replacePlugins();
+          if (status === 'queued') pluginNote = 'queued';
+          else if (status !== 'done' && status !== 'off') pluginNote = 'blocked';
+        }
+        if (!rebuild) {
+          setPending(false);
+          if (pluginNote !== null) setNotice(COPY[pluginNote]);
+          return;
+        }
+        window.sessionStorage.setItem(STAMP_KEY, String(Date.now()));
+        const reason = await prepareInterface();
+        if (reason !== null) {
+          report('held', reason);
+          return stop(reason);
+        }
+        report('rebuild');
+        reloadFreshPage();
+        setTimeout(() => setPending(false), 4000); // ui-copy-ignore
+      };
+
+      return h('span', { style: WRAP_STYLE },
+        h('button', {
+          type: 'button', // ui-copy-ignore
+          title: notice ?? COPY.hint, // ui-copy-ignore
+          'aria-label': COPY.label,
+          style,
+          onMouseEnter: () => setHover(true),
+          onMouseLeave: () => setHover(false),
+          onClick,
+        }, h('svg', {
+          viewBox: '0 0 16 16', // ui-copy-ignore
+          width: 16, // ui-copy-ignore
+          height: 16, // ui-copy-ignore
+          fill: 'none', // ui-copy-ignore
+          stroke: 'currentColor', // ui-copy-ignore
+          strokeWidth: 1.4,
+          strokeLinecap: 'round',
+          strokeLinejoin: 'round',
+          'aria-hidden': true,
+        },
+        h('path', { d: 'M13 8a5 5 0 1 1-1.9-3.94' }),
+        h('path', { d: 'M13 2.7v3.6H9.4' }))),
+        notice === null ? null : h('span', { role: 'status', 'aria-live': 'polite', style: PILL_STYLE }, notice));
+    }
+
+    return {
+      inject: ['slots'], // ui-copy-ignore
+      apply(ctx) {
+        if (!desktop) return;
+        // Leave a line in the log per rebuilt interface: it is the one place that shows which
+        // plugin code a running page actually loaded.
+        report('mounted');
+        ctx.slots.inject('conversation.session.header.utilities', () => ctx.slots.register({
+          name: 'conversation.session.header.utilities',
+          id: 'dsh-unlag', // ui-copy-ignore
+          order: 29, // ui-copy-ignore
+          label: () => COPY.label, // ui-copy-ignore
+        }, ReloadButton));
+      },
+    };
+  },
+});

package/cordis.patch.yml

@@ -0,0 +1,17 @@
+- insert:
+    - id: dsh-unlag
+      name: 'dsh-unlag'
+
+# Turn on the shipped module watcher, which the desktop launcher leaves off.
+# `base` resolves against the plugin's own location, and an installed plugin
+# lives inside app.asar, which the watcher cannot stat — hence the working
+# directory, the one directory that always exists on the machine that boots it.
+# `root` stays empty here: the profile's own modules are watched by the watcher
+# installed-plugin path, and this entry only needs to start. To also watch
+# source checkouts, add their absolute paths to `root` in your own profile
+# patch layer.
+- id: hmr
+  disabled: false
+  config:
+    base: !!js 'process.cwd()'
+    root: []

package/icon.svg

@@ -0,0 +1,5 @@
+<svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 64 64">
+  <circle cx="32" cy="32" r="28" fill="#1f6feb"/>
+  <path d="M46 32a14 14 0 1 1-5.3-10.95" fill="none" stroke="#fff" stroke-width="4.5" stroke-linecap="round"/>
+  <path d="M46 15v9.5h-9.5" fill="none" stroke="#fff" stroke-width="4.5" stroke-linecap="round" stroke-linejoin="round"/>
+</svg>

package/index.js

@@ -0,0 +1,514 @@
+import { appendFileSync, existsSync, readFileSync, statSync, watch } from 'node:fs'
+import { homedir } from 'node:os'
+import { join, resolve } from 'node:path'
+
+/**
+ * One header button, three ways new code reaches the running app:
+ *
+ * - Plugins (this half): a saved file below a watched development root replaces the affected
+ *   plugin in place. The page is not rebuilt, so drafts, queued messages and running turns stay.
+ * - Interface (client half): the header button rebuilds the page once and keeps the session.
+ * - Both at once: the button asks this half to replace the changed plugins first, then the client
+ *   half rebuilds the interface, so one press leaves neither half on old code. Either half can be
+ *   switched off in the plugin's settings row; with both off a press does nothing.
+ *
+ * This half is written so that no path here can end the app: every callback body is inside a
+ * `try`, every failure is written to a log and dropped, and the reload itself waits for idle
+ * agents and refuses to re-enter. A plugin that cannot start is worse than a plugin that does
+ * nothing, because the desktop shell treats a failed startup entry as fatal.
+ */
+export const name = 'dsh-unlag'
+/**
+ * Cordis has no optional injection: every key of an object declaration is read as a required
+ * service name, so `{ optional: [...] }` waits forever for a service called "optional". Declare
+ * only the web server, which any interface that can show the button has, and look the reload
+ * service up per use instead so a disabled reloader costs the plugin half, not the whole entry.
+ */
+export const inject = ['webServer']
+
+const LOG_PATH = join(homedir(), '.dsh', 'unlag-reload.log')
+/** Tests point this at a scratch file, so a test run leaves the live log readable. */
+const logTarget = () => process.env.DSH_UNLAG_LOG ?? LOG_PATH
+/** Survives a module replacement, so a reload cannot leave a second watcher behind. */
+const WATCHER_KEY = Symbol.for('dsh-unlag.watchers')
+/** The same, for the HTTP entry points the header button calls. */
+const ROUTES_KEY = Symbol.for('dsh-unlag.routes')
+const BASE_PATH = '/dsh-unlag'
+/** A same-origin page sets this itself; a cross-site form post cannot, and fails the preflight. */
+const BUTTON_HEADER = 'x-dsh-unlag'
+const CODE_EXTENSIONS = new Set(['.js', '.mjs', '.cjs'])
+/** Build output and dependency trees change without the source a developer edits changing. */
+const IGNORED_PATH = /(^|\/)(node_modules|\.git|\.cache|dist|build|coverage)([./]|$)/u
+const DEFAULT_ROOTS = [join(homedir(), '.dsh', 'plugins')]
+/** A turn that never goes idle must not turn this into an endless poll. */
+const MAX_DEFERRALS = 40
+const MIN_INTERVAL_MS = 1500
+
+/**
+ * The two rows this plugin shows in Settings, in the schema dialect the settings form reads.
+ * Both default on: a press then leaves nothing on old code.
+ */
+const SCHEMA = {
+  uid: 6, // ui-copy-ignore
+  refs: {
+    2: { type: 'boolean', meta: { default: true, description: '按下刷新时换掉插件代码' } }, // ui-copy-ignore
+    5: { type: 'boolean', meta: { default: true, description: '按下刷新时重建界面' } }, // ui-copy-ignore
+    6: { type: 'object', meta: { default: {} }, dict: { reloadPlugins: 2, reloadInterface: 5 } }, // ui-copy-ignore
+  },
+}
+
+/** The same rows as plain nodes, which is the shape the settings form projects values through. */
+const FIELDS = {
+  reloadPlugins: { type: 'boolean', meta: { default: true, description: '按下刷新时换掉插件代码' } },
+  reloadInterface: { type: 'boolean', meta: { default: true, description: '按下刷新时重建界面' } },
+}
+
+/**
+ * Exported as the row's Config so Settings can show the two switches. Validation never throws:
+ * an unreadable value falls back to the default instead of failing the startup entry, because a
+ * rejected config here would take the whole app down at boot.
+ */
+export const Config = {
+  ...SCHEMA,
+  type: 'object', // ui-copy-ignore
+  dict: FIELDS, // ui-copy-ignore
+  meta: { default: {} }, // ui-copy-ignore
+  toJSON() {
+    return SCHEMA
+  },
+  '~standard': {
+    version: 1, // ui-copy-ignore
+    vendor: 'dsh-unlag', // ui-copy-ignore
+    validate(value) {
+      const source = value !== null && typeof value === 'object' ? value : {}
+      return { value: { ...source, ...settingsOf(source) } }
+    },
+  },
+}
+
+/** The two switches, defaulted on, from any config shape. */
+function settingsOf(config) {
+  return {
+    reloadPlugins: config?.reloadPlugins !== false,
+    reloadInterface: config?.reloadInterface !== false,
+  }
+}
+
+function log(line) {
+  try {
+    appendFileSync(logTarget(), `${new Date().toISOString()} ${line}\n`)
+  } catch {}
+}
+
+function closeAll(closer) {
+  if (typeof closer === 'function') {
+    try {
+      closer()
+    } catch {}
+  }
+}
+
+/** Development roots the profile links by path; a packaged dependency is not watched. */
+function linkedRoots(baseDir) {
+  const roots = []
+  try {
+    const manifest = JSON.parse(readFileSync(join(baseDir, 'package.json'), 'utf8'))
+    const deps = { ...manifest.dependencies, ...manifest.devDependencies }
+    for (const [name, spec] of Object.entries(deps)) {
+      if (typeof spec !== 'string' || !/^(link|file):/u.test(spec)) continue
+      const path = resolve(baseDir, spec.replace(/^(link|file):/u, ''))
+      if (existsSync(path)) roots.push(path)
+      else log(`skip ${name}: ${path} is missing`)
+    }
+  } catch (error) {
+    log(`cannot read the profile manifest: ${error?.message ?? error}`)
+  }
+  return roots
+}
+
+/** Whether a watched path is worth a reload: source only, and never this log. */
+function worthReloading(filename) {
+  const name = typeof filename === 'string' ? filename : ''
+  if (name === '') return false
+  if (!CODE_EXTENSIONS.has(name.slice(name.lastIndexOf('.')))) return false
+  return !IGNORED_PATH.test(name)
+}
+
+/**
+ * The plugin half. One controller serves both callers: a saved file (debounced) and the header
+ * button (immediate). A swap never waits for turns, never interrupts them, and never re-enters.
+ */
+function pluginReloader(ctx, config) {
+  /** HMR can start after this half, so ask per use instead of once at load. */
+  const hmrService = () => {
+    const hmr = ctx.get('hmr')
+    if (hmr === null || typeof hmr?.reconcileProfile !== 'function' || typeof hmr?.runExclusive !== 'function') return null
+    return hmr
+  }
+  const available = () => hmrService() !== null
+  /** Opt-in: wait for a quiet moment instead of swapping at once. Off by default. */
+  const idleOnly = config?.idleOnly === true
+  const debounce = Number.isFinite(config?.debounce) ? config.debounce : 300
+
+  let timer = null
+  let running = false
+  let again = false
+  let deferrals = 0
+  let lastRun = 0
+
+  /** Resolve true when the HMR queue is empty, i.e. no transaction is really running right now. */
+  const queueIsIdle = async (hmr) => {
+    const queue = hmr?.operations
+    if (typeof queue?.then !== 'function') return true
+    let settled = false
+    Promise.resolve(queue).then(
+      () => (settled = true),
+      () => (settled = true),
+    )
+    await new Promise((resolve) => setTimeout(resolve, 40))
+    return settled
+  }
+
+  const turnsRunning = () => {
+    try {
+      const agents = ctx.get('agents')
+      const list = typeof agents?.list === 'function' ? agents.list() : []
+      return Array.isArray(list) && list.some((agent) => agent?.status !== 'idle')
+    } catch {
+      return false
+    }
+  }
+  const busy = () => idleOnly && turnsRunning()
+
+  /**
+   * Ask the HMR service to recompose; it throws rather than half-applying, so a catch is enough.
+   * Another reload may already hold the transaction (a save landing next to a session's own swap),
+   * so a nested refusal is retried instead of being reported as a reload that failed.
+   */
+  const reload = async (hmr) => {
+    let result = null
+    for (let attempt = 0; ; attempt += 1) {
+      try {
+        result = await hmr.runExclusive(() => hmr.reconcileProfile([]))
+        break
+      } catch (error) {
+        const message = String(error?.message ?? error)
+        if (message.includes('nested') === false) throw error
+        if (await queueIsIdle(hmr)) {
+          // The refusal came from a finished transaction whose context this callback inherited
+          // (a watcher created while a reload was restarting this plugin). With the queue empty
+          // there is nothing to serialize against, so recompose directly.
+          log('reload ran outside the queue: the caller inherited a finished transaction')
+          result = await hmr.reconcileProfile([])
+          break
+        }
+        if (attempt >= 9) throw error
+        await new Promise((resolve) => setTimeout(resolve, 250 * (attempt + 1)))
+      }
+    }
+    const warnings = Array.isArray(result?.warnings) ? result.warnings.length : 0
+    const pending = Array.isArray(result?.pending) ? result.pending.length : 0
+    const suffix = typeof result?.restartReason === 'string' ? ` restart=${result.restartReason}` : ''
+    log(`plugins reloaded (warnings=${warnings} pending=${pending}${suffix})`)
+  }
+
+  const flush = async () => {
+    timer = null
+    if (running) {
+      again = true
+      return
+    }
+    try {
+      if (busy()) {
+        deferrals += 1
+        if (deferrals > MAX_DEFERRALS) {
+          deferrals = 0
+          log('reloading while turns are still running; they keep running')
+        } else {
+          timer = setTimeout(() => void flush(), 500)
+          return
+        }
+      }
+      const wait = lastRun + MIN_INTERVAL_MS - Date.now()
+      if (wait > 0) {
+        timer = setTimeout(() => void flush(), wait)
+        return
+      }
+      const hmr = hmrService()
+      if (hmr === null) return
+      deferrals = 0
+      lastRun = Date.now()
+      running = true
+      await reload(hmr)
+    } catch (error) {
+      log(`reload failed, the previous code keeps running: ${error?.message ?? error}`)
+    } finally {
+      running = false
+      if (again) {
+        again = false
+        if (timer === null) timer = setTimeout(() => void flush(), debounce)
+      }
+    }
+  }
+
+  const schedule = (filename) => {
+    try {
+      if (!worthReloading(filename)) return
+      if (timer !== null) clearTimeout(timer)
+      timer = setTimeout(() => void flush(), debounce)
+    } catch (error) {
+      log(`ignored a watch event: ${error?.message ?? error}`)
+    }
+  }
+
+  /**
+   * Opt-in (`idleOnly`) quiet-moment mode: wait for a gap, and after a short grace swap anyway,
+   * because waiting forever would leave busy machines with a dead button.
+   */
+  const WAIT_MAX_MS = Number.isFinite(config?.busyWaitMs) ? Math.max(0, config.busyWaitMs) : 60_000
+  let queued = null
+  const queueReload = () => {
+    if (queued !== null) return 'queued'
+    const started = Date.now()
+    const tick = () => {
+      queued = null
+      if (running) {
+        queued = setTimeout(tick, 500)
+        return
+      }
+      if (busy() && Date.now() - started < WAIT_MAX_MS) {
+        queued = setTimeout(tick, 1000)
+        return
+      }
+      if (busy()) log('reloading while turns are still running; they keep running')
+      void reloadNow(true)
+    }
+    queued = setTimeout(tick, 1000)
+    return 'queued'
+  }
+
+  /**
+   * The button path: run now and report what happened, so the page can tell the user why the
+   * press did not replace anything instead of looking broken.
+   * @returns 'done' | 'queued' | 'unavailable' | 'failed'
+   */
+  const reloadNow = async (force = false) => {
+    const hmr = hmrService()
+    if (hmr === null) return 'unavailable'
+    if (turnsRunning()) log('reloading while turns are still running; they keep running')
+    if (running || (force === false && busy())) return queueReload()
+    const wait = lastRun + MIN_INTERVAL_MS - Date.now()
+    if (wait > 0) await new Promise((resolve) => setTimeout(resolve, Math.min(wait, 2000)))
+    if (running || (force === false && busy())) return queueReload()
+    if (timer !== null) {
+      clearTimeout(timer)
+      timer = null
+    }
+    running = true
+    deferrals = 0
+    lastRun = Date.now()
+    try {
+      await reload(hmr)
+      return 'done'
+    } catch (error) {
+      log(`reload failed, the previous code keeps running: ${error?.message ?? error}`)
+      return 'failed'
+    } finally {
+      running = false
+      again = false
+    }
+  }
+
+  /** Watch the development roots; a missing or unreadable root is logged, never fatal. */
+  const startWatching = () => {
+    const hmr = hmrService()
+    if (hmr === null) return null
+    const configured = Array.isArray(config?.roots) ? config.roots.filter((root) => typeof root === 'string') : []
+    const roots = [...new Set([...configured, ...linkedRoots(hmr.baseDir ?? process.cwd()), ...DEFAULT_ROOTS])]
+    const closers = []
+    let watching = 0
+    for (const root of roots) {
+      try {
+        if (statSync(root).isDirectory() === false) continue
+        const closer = watch(root, { recursive: true }, (_event, filename) => schedule(filename))
+        closer.on?.('error', (error) => log(`watch ${root} stopped: ${String(error?.message ?? error)}`))
+        closers.push(() => closer.close())
+        watching += 1
+      } catch (error) {
+        log(`cannot watch ${root}: ${error?.message ?? error}`)
+      }
+    }
+    log(`watching ${watching} package dir(s)`)
+    return () => {
+      if (timer !== null) clearTimeout(timer)
+      timer = null
+      for (const close of closers) closeAll(close)
+    }
+  }
+
+  const stop = () => {
+    if (queued !== null) clearTimeout(queued)
+    queued = null
+  }
+
+  return { reloadNow, startWatching, available, stop }
+}
+
+/** Write one JSON answer; a response already gone must not throw into the caller. */
+function sendJson(res, status, payload) {
+  try {
+    if (res.writableEnded === true || res.destroyed === true) return
+    const body = JSON.stringify(payload)
+    res.writeHead(status, {
+      'content-type': 'application/json; charset=utf-8',
+      'cache-control': 'no-store',
+      'content-length': Buffer.byteLength(body),
+    })
+    res.end(body)
+  } catch {}
+}
+
+/**
+ * The startup list the server would hand the next document, read from the live index injection
+ * table. The page's own copy describes the page already running: a plugin swapped since then
+ * leaves it naming a module graph that no longer resolves, which is exactly the list a rebuild
+ * must not trust.
+ */
+function liveBootGraph(server) {
+  try {
+    if (typeof server.collectIndexInjections !== 'function') return null
+    const rows = server.collectIndexInjections()
+    if (!Array.isArray(rows)) return null
+    for (const row of rows) {
+      if (row?.kind !== 'global') continue
+      let value = row.value
+      if (typeof value === 'string') {
+        try {
+          value = JSON.parse(value)
+        } catch {
+          continue
+        }
+      }
+      if (value === null || typeof value !== 'object') continue
+      if (Array.isArray(value.entries) && Array.isArray(value.batches)) return value
+    }
+    return null
+  } catch (error) {
+    log(`cannot read the startup list: ${error?.message ?? error}`)
+    return null
+  }
+}
+
+/**
+ * The entry points the header button calls. Each answers with the current switches so the page
+ * never guesses: with both off it does nothing, and a turn still running is reported rather than
+ * cut. The press outcome is written to the log, because a press that stopped before rebuilding
+ * leaves no other trace once the page goes on running.
+ */
+function serveButton(ctx, controller, config) {
+  const server = ctx.get('webServer')
+  if (server === undefined || server === null || typeof server.register !== 'function') {
+    log('no web server: the header button cannot ask for a reload')
+    return null
+  }
+  const settings = settingsOf(config)
+  const handlers = [
+    [
+      `${BASE_PATH}/state`,
+      (_req, res) => {
+        sendJson(res, 200, { plugins: settings.reloadPlugins, page: settings.reloadInterface })
+      },
+    ],
+    [
+      `${BASE_PATH}/graph`,
+      (_req, res) => {
+        sendJson(res, 200, { graph: liveBootGraph(server) })
+      },
+    ],
+    [
+      `${BASE_PATH}/report`,
+      (req, res) => {
+        const method = String(req?.method ?? 'GET').toUpperCase()
+        if (method !== 'POST') return sendJson(res, 405, { status: 'method' })
+        let query = ''
+        try {
+          query = new URL(String(req?.url ?? ''), 'http://x').searchParams.toString()
+        } catch {}
+        const params = new URLSearchParams(query)
+        const event = params.get('event') ?? ''
+        const gate = params.get('gate') ?? ''
+        if (event === 'mounted') log('interface rebuilt; the page runs the plugins as served now')
+        else if (event === 'rebuild') log('rebuild allowed: the page re-enters on the served modules')
+        else if (event === 'held') log(`rebuild held back: ${gate === '' ? 'unknown' : gate}`)
+        sendJson(res, 200, { status: 'done' })
+      },
+    ],
+    [
+      `${BASE_PATH}/reload`,
+      async (req, res) => {
+        const method = String(req?.method ?? 'GET').toUpperCase()
+        if (method !== 'POST') return sendJson(res, 405, { status: 'method' })
+        const header = req?.headers?.[BUTTON_HEADER]
+        if (typeof header !== 'string' || header === '') return sendJson(res, 403, { status: 'forbidden' })
+        if (!settings.reloadPlugins) return sendJson(res, 200, { status: 'off' })
+        const status = await controller.reloadNow()
+        sendJson(res, 200, { status })
+      },
+    ],
+  ]
+  const disposers = []
+  for (const [path, handler] of handlers) {
+    try {
+      const dispose = server.register({ kind: 'exact', path, handler })
+      if (typeof dispose === 'function') disposers.push(dispose)
+    } catch (error) {
+      log(`cannot answer ${path}: ${error?.message ?? error}`)
+    }
+  }
+  return () => {
+    for (const dispose of disposers) closeAll(dispose)
+  }
+}
+
+export function apply(ctx, config) {
+  try {
+    closeAll(globalThis[WATCHER_KEY])
+    closeAll(globalThis[ROUTES_KEY])
+    globalThis[WATCHER_KEY] = null
+    globalThis[ROUTES_KEY] = null
+
+    const controller = pluginReloader(ctx, config ?? {})
+    /** Watching needs HMR; start as soon as it exists, drop the watcher when it goes away. */
+    const syncWatching = () => {
+      if (config?.plugins === 'off') return
+      if (controller.available() === false) {
+        closeAll(globalThis[WATCHER_KEY])
+        globalThis[WATCHER_KEY] = null
+        return
+      }
+      if (globalThis[WATCHER_KEY] !== null) return
+      globalThis[WATCHER_KEY] = controller.startWatching()
+    }
+    if (config?.plugins === 'off') log('file watching is off')
+    else {
+      syncWatching()
+      if (globalThis[WATCHER_KEY] === null) log('plugin reload is unavailable: the hmr entry is not running')
+    }
+    if (typeof ctx.on === 'function') {
+      ctx.on('internal/service', (service) => {
+        if (service === 'hmr') syncWatching()
+      })
+    }
+    globalThis[ROUTES_KEY] = serveButton(ctx, controller, config ?? {})
+
+    ctx.on('dispose', () => {
+      controller.stop()
+      closeAll(globalThis[WATCHER_KEY])
+      closeAll(globalThis[ROUTES_KEY])
+      globalThis[WATCHER_KEY] = null
+      globalThis[ROUTES_KEY] = null
+    })
+  } catch (error) {
+    log(`plugin reload did not start: ${error?.message ?? error}`)
+  }
+}

package/locale/en.json

@@ -0,0 +1,6 @@
+{
+  "meta": {
+    "title": "Unlag",
+    "description": "When the interface gets sluggish: replace changed plugin code and rebuild the page in one press. Running turns, queued messages and unsent input are kept."
+  }
+}

package/locale/zh.json

@@ -0,0 +1,6 @@
+{
+  "meta": {
+    "title": "解除卡顿",
+    "description": "用了很久开始卡顿时，一键换掉插件代码并重建界面。正在跑的任务、排队的消息、没发出去的输入都会保留。"
+  }
+}

package/package.json

@@ -1,6 +1,51 @@
 {
   "name": "dsh-unlag",
-  "version": "0.0.0-stage",
-  "stub": true,
-  "description": "Temporary package placeholder for staged publishing"
-}
+  "version": "1.7.3",
+  "type": "module",
+  "description": "Clear a sluggish DeepSeek Harness workbench without restarting: rebuild the interface and swap plugin code in place, keeping running turns, queued messages and unsent drafts.",
+  "license": "MIT",
+  "exports": {
+    ".": "./index.js",
+    "./client": "./client.js",
+    "./locale/*.json": "./locale/*.json",
+    "./icon": "./icon.svg"
+  },
+  "files": [
+    "index.js",
+    "client.js",
+    "cordis.patch.yml",
+    "locale/*.json",
+    "README.md",
+    "icon.svg"
+  ],
+  "keywords": [
+    "dsh-plugin",
+    "deepseek-harness",
+    "cordis",
+    "hot-reload",
+    "hmr"
+  ],
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/regrevia/dsh-unlag.git"
+  },
+  "homepage": "https://github.com/regrevia/dsh-unlag#readme",
+  "bugs": {
+    "url": "https://github.com/regrevia/dsh-unlag/issues"
+  },
+  "engines": {
+    "dsh": ">=0.2.0-rc.1"
+  },
+  "dsh": {
+    "bundle": {
+      "patch": "./cordis.patch.yml"
+    },
+    "client": {
+      "platform": "web",
+      "immediately": true,
+      "inject": [
+        "@deepseek-ai/dsh-client-ui-conversation"
+      ]
+    }
+  }
+}