dsh-maoying 0.1.20 → 0.1.22

package/lib/client.js

@@ -193,7 +193,7 @@ window.__ModuleLoader__.load({
         opts.signal = ctrl.signal;
         timer = setTimeout(function () { ctrl.abort(); }, limit);
       }
-      return fetch(API_BASE + path, opts).then(function (r) {
+      var p = fetch(API_BASE + path, opts).then(function (r) {
         // 先取全文再 JSON.parse：代理错误页 / 空体不再抛 SyntaxError。
         return r.text().then(function (raw) {
           var d = null;
@@ -211,11 +211,20 @@ window.__ModuleLoader__.load({
       }).catch(function (err) {
         if (ctrl && err && err.name === "AbortError") throw new Error(tf("api.timeout", { s: Math.round(limit / 1000) }));
         throw err;
-      }).finally(function () {
+      });
+      if (!ctrl) {
+        // 老宿主无 AbortController：fetch 中断不了，race 一个超时 reject 兜底，
+        // 照样防按钮永久转圈（真连接留在后台，本次调用不再等它）。
+        p = Promise.race([p, new Promise(function (_resolve, reject) {
+          timer = setTimeout(function () { reject(new Error(tf("api.timeout", { s: Math.round(limit / 1000) }))); }, limit);
+        })]);
+      }
+      return p.finally(function () {
         if (timer !== null) clearTimeout(timer);
       });
     }
-    function apiGet(path, params) {
+    function apiGet(path, params, opts) {
+      var quiet = opts && opts.silent;
       var qs = "";
       if (params) {
         var usp = new URLSearchParams();
@@ -223,16 +232,18 @@ window.__ModuleLoader__.load({
         qs = usp.toString();
       }
       return maoyingApi(path + (qs ? (path.indexOf("?") === -1 ? "?" : "&") + qs : "")).catch(function (err) {
-        toast.err(tf("toast.prefix", { msg: err.message }));
+        // silent：调用方自渲染卡内错误位时抑制 toast，同一错误只展示一次。
+        if (!quiet) toast.err(tf("toast.prefix", { msg: err.message }));
         throw err;
       });
     }
-    function apiPost(path, body) {
+    function apiPost(path, body, opts) {
+      var quiet = opts && opts.silent;
       return maoyingApi(path, body || {}).then(function (d) {
         toast.ok(apiPostOkText(path, d));
         return d;
       }, function (err) {
-        toast.err(tf("toast.prefix", { msg: err.message }));
+        if (!quiet) toast.err(tf("toast.prefix", { msg: err.message })); // silent 同 apiGet
         throw err;
       });
     }
@@ -285,6 +296,10 @@ window.__ModuleLoader__.load({
       };
     }
     var toast = createToastCtrl();
+    // 脏退出守卫的跨组件脏标记：编辑面（正文/章纲/受管文件/风格/元信息）各自
+    // 在渲染后写入「是否有未保存草稿」，切 tab 等自身不知情的退出路径读它拦截
+    // 确认。面板同一时刻至多一个编辑面打开，单布尔够用；卸载时清零防残留误拦。
+    var DIRTY_EXIT = { dirty: false };
 
     function ToastHost() {
       var _t = useState(function () { return toast.snapshot(); }), items = _t[0], setItems = _t[1];
@@ -758,6 +773,39 @@ window.__ModuleLoader__.load({
           toast.err(tf("toast.prefix", { msg: err.message }));
         });
       }
+      // 手动检测更新：update-check 只在面板打开时拉一次，页面开久了拿不到
+      // 新判定（服务端还有 1h 缓存）——这里带 fresh=1 让服务端绕过缓存现测。
+      // 不走 apiGet：成功要带版本号、失败要报「检测失败」，apiGet 会先统一
+      // toast 一遍错误再 rethrow，这里直连 maoyingApi 与 runSelfUpdate 同一
+      // 理由（避免双份错误糊屏）；超时沿用统一 60s（服务端 10s 就收敛）。
+      // 错误瘦身：服务端 error 可能是三路全败的长串排障文案，只取首句，
+      // 首句仍超 ~80 字符再截断加省略号，别糊屏。
+      function shortErrText(msg) {
+        var s = String(msg || "").trim();
+        var end = s.indexOf("。");
+        if (end !== -1) s = s.slice(0, end);
+        if (s.length > 80) s = s.slice(0, 79) + "…";
+        return s || tt("common.unknownErr");
+      }
+      var _verChecking = useState(false), verChecking = _verChecking[0], setVerChecking = _verChecking[1];
+      function runVerCheck() {
+        if (verChecking) return;
+        setVerChecking(true);
+        maoyingApi("update-check?fresh=1").then(function (d) {
+          if (d && d.current) setVer(d); // 徽章与一键升级按钮随 setVer 自然出现/消失
+          if (d && d.updateAvailable) {
+            toast.ok(tf("toast.selfUpdate.found", { ver: (d && d.latest) || "?" }));
+          } else if (d && !d.error) {
+            toast.ok(tf("toast.selfUpdate.upToDate", { ver: (d && d.current) || "?" }));
+          } else {
+            toast.err(tf("toast.selfUpdate.checkFail", { msg: shortErrText(d && d.error) }));
+          }
+        }).catch(function (err) {
+          toast.err(tf("toast.selfUpdate.checkFail", { msg: shortErrText(err && err.message) }));
+        }).finally(function () {
+          setVerChecking(false); // 无论成败按钮都恢复可点
+        });
+      }
       useEffect(function () { loadWorkspaces(); }, [loadWorkspaces]);
       // 每次打开面板都重拉工作区列表与整份 state 快照：懒挂载下关闭只是摘掉
       // active 属性，组件不卸载，上面的 mount effect 整个页面生命周期只跑一
@@ -792,6 +840,9 @@ window.__ModuleLoader__.load({
         setSelWs(path);
       }
       function gotoTab(next, chapterFile) {
+        // 脏退出守卫：任一编辑面（DIRTY_EXIT.dirty）有未保存草稿先确认，取消
+        // 则留在原地——切 tab 会卸载组件，草稿本来会被静默丢弃。
+        if (DIRTY_EXIT.dirty && !window.confirm(tt("common.dirtyExit"))) return;
         setTab(next);
         setReaderFile(next === "chapters" && chapterFile ? chapterFile : null);
       }
@@ -836,6 +887,13 @@ window.__ModuleLoader__.load({
           h("div", null,
             h("h1", { className: "myt-title" }, "毛颖创作台",
               ver && ver.current ? h("span", { className: "myt-verTag", title: tt("header.curVerTitle") }, ver.current) : null,
+              // 「检测更新」：手动触发 fresh=1 现测（常态只在开面板时拉一次，
+              // 页面开久判定陈旧）；与一键升级同形描边胶囊，检测中禁用防连点。
+              h("button", {
+                type: "button", className: "myt-verCheck", disabled: verChecking,
+                title: verChecking ? tt("header.checkingUpdate") : tt("header.checkUpdate"),
+                onClick: runVerCheck,
+              }, verChecking ? tt("header.checkingUpdate") : tt("header.checkUpdate")),
               ver && ver.updateAvailable
                 ? [
                     // 徽章（跳发布页）+「一键升级」按钮双元素；装完（installed）
@@ -1020,9 +1078,11 @@ window.__ModuleLoader__.load({
 
     // ── 轻量 Markdown 渲染（零依赖）：先整体 HTML 转义再施加 md 变换，杜绝
     // 注入；支持标题/加粗/斜体/删除线/行内码/围栏码/引用/有序无序列表/分隔线/
-    // 链接/段落换行。供章纲、世界观条目等 md 阅读位使用，正文手稿仍走 pre。 ──
+    // 链接/GFM 管道表格/段落换行。供章纲、世界观条目等 md 阅读位使用，正文
+    // 手稿仍走 pre。 ──
     function escapeHtml(s) {
-      return String(s).replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;").replace(/"/g, "&quot;");
+      // 单引号也转义：属性当前虽全双引号，零成本防御纵深。
+      return String(s).replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;").replace(/"/g, "&quot;").replace(/'/g, "&#39;");
     }
     // 链接 scheme 白名单：仅放行 http/https 绝对地址与无 scheme 的相对路径 /
     // 锚点 / //协议相对；javascript:/data:/vbscript: 等一律拒绝（调用方落纯文本）。
@@ -1049,6 +1109,56 @@ window.__ModuleLoader__.load({
         });
       return out.replace(/\u0000MYTCODE(\d+)\u0000/g, function (_m, i) { return codes[Number(i)] || ""; });
     }
+    // ── GFM 管道表格辅助：输入行均已过 escapeHtml（反斜杠原样保留），只做
+    // 结构识别与切格，单元格文本最终仍走 inlineMd，不自建未转义通道。 ──
+    // 分隔行解析：仅由 |、:、-、空白组成，去掉首尾 | 后按 | 切出 ≥1 段、每段
+    // :?-{1,}:?（--- / :--- / ---: / :---:）；是分隔行则返回各列对齐标记
+    // （'l'|'c'|'r'|''，与表头单元格一一对应），否则 null。
+    function tableSepAligns(line) {
+      if (!/^[\s:|-]+$/.test(line) || line.indexOf("-") === -1) return null;
+      var trimmed = String(line).trim();
+      if (trimmed.charAt(0) === "|") trimmed = trimmed.slice(1);
+      if (trimmed.charAt(trimmed.length - 1) === "|") trimmed = trimmed.slice(0, -1);
+      var segs = trimmed.split("|");
+      var aligns = [];
+      for (var k = 0; k < segs.length; k++) {
+        var seg = segs[k].trim();
+        if (!/^:?-{1,}:?$/.test(seg)) return null;
+        aligns.push(seg.charAt(0) === ":" && seg.charAt(seg.length - 1) === ":" ? "c"
+          : seg.charAt(seg.length - 1) === ":" ? "r"
+          : seg.charAt(0) === ":" ? "l" : "");
+      }
+      return aligns;
+    }
+    // 表格行切格：转义管道 \| 先换哨兵（NUL 前缀序列，正文不可能出现）再按 |
+    // 切，逐格 trim 后回填为字面 |；首尾空单元（外圈竖线）丢弃。
+    function splitTableCells(line) {
+      var raw = String(line).replace(/\\\|/g, "\u0000MYTPIPE").split("|");
+      var cells = [];
+      for (var k = 0; k < raw.length; k++) cells.push(raw[k].trim().replace(/\u0000MYTPIPE/g, "|"));
+      while (cells.length && cells[0] === "") cells.shift();
+      while (cells.length && cells[cells.length - 1] === "") cells.pop();
+      return cells;
+    }
+    // 表格起始：当前行含 |、下一行是分隔行，且表头至少一个非空单元格。
+    function isTableStart(lines, i) {
+      if (i + 1 >= lines.length || lines[i].indexOf("|") === -1) return false;
+      var aligns = tableSepAligns(lines[i + 1]);
+      if (!aligns) return false;
+      var head = splitTableCells(lines[i]);
+      // GFM 规范：表头列数须与分隔行列数相等才认表——否则「含 | 的段落行 +
+      // --- 分隔线」会被误吞成表头（数据行列数宽容是另一回事，见 renderMd）。
+      if (head.length !== aligns.length || head.length === 0) return false;
+      for (var k = 0; k < head.length; k++) { if (head[k] !== "") return true; }
+      return false;
+    }
+    // 对齐落 class（th/td 共用，不用 inline style，深浅色主题只吃令牌）。
+    function tableAlignCls(a) {
+      if (a === "l") return ' class="myt-ta-l"';
+      if (a === "c") return ' class="myt-ta-c"';
+      if (a === "r") return ' class="myt-ta-r"';
+      return "";
+    }
     function renderMd(src) {
       var lines = escapeHtml(src).split(/\r?\n/);
       var html = [];
@@ -1101,9 +1211,37 @@ window.__ModuleLoader__.load({
           html.push('<ol class="myt-mdList">' + oitems.join("") + "</ol>");
           continue;
         }
+        // GFM 管道表格：表头行 + |---|---| 分隔行 + 数据行。数据行逐行吃到
+        // 空行 / 不含 | 的行 / 其它块起始（围栏/标题/引用/列表/hr）为止；列数
+        // 不齐宽容渲染（缺列补空 td、多列照渲染，对齐按列号取、越界无 class）。
+        if (isTableStart(lines, i)) {
+          var aligns = tableSepAligns(lines[i + 1]);
+          var headCells = splitTableCells(lines[i]);
+          i += 2; // 吃掉表头行与分隔行
+          var bodyCells = [];
+          while (i < lines.length && lines[i].indexOf("|") !== -1 && !/^\s*$/.test(lines[i]) && !/^```|^#{1,6}\s|^\s*&gt;|^\s*[-*+]\s|^\s*\d+[.)]\s|^ {0,3}(?:-{3,}|\*{3,}|_{3,})\s*$/.test(lines[i])) {
+            bodyCells.push(splitTableCells(lines[i]));
+            i++;
+          }
+          var ths = [];
+          for (var t = 0; t < headCells.length; t++) ths.push("<th" + tableAlignCls(aligns[t]) + ">" + inlineMd(headCells[t]) + "</th>");
+          var trs = [];
+          for (t = 0; t < bodyCells.length; t++) {
+            var tds = [];
+            for (var d = 0; d < Math.max(headCells.length, bodyCells[t].length); d++) {
+              tds.push("<td" + tableAlignCls(aligns[d]) + ">" + inlineMd(bodyCells[t][d] || "") + "</td>");
+            }
+            trs.push("<tr>" + tds.join("") + "</tr>");
+          }
+          // 宽表由 .myt-mdTableWrap 横向滚动；th/td 对齐全走 myt-ta-* class。
+          html.push('<div class="myt-mdTableWrap"><table class="myt-mdTable"><thead><tr>' + ths.join("") + "</tr></thead><tbody>" + trs.join("") + "</tbody></table></div>");
+          continue;
+        }
         var para = [line];
         i++;
-        while (i < lines.length && !/^\s*$/.test(lines[i]) && !/^```|^\s*&gt;|^\s*[-*+]\s|^\s*\d+[.)]\s|^#{1,6}\s/.test(lines[i])) {
+        // 段落兜底遇到表格起始（|a|b| + |---|---|）也要截断：段落后紧跟表格时
+        // 表格独立成块，不把管道行并进段落（GitHub 行为）。
+        while (i < lines.length && !/^\s*$/.test(lines[i]) && !/^```|^\s*&gt;|^\s*[-*+]\s|^\s*\d+[.)]\s|^#{1,6}\s/.test(lines[i]) && !isTableStart(lines, i)) {
           para.push(lines[i]); i++;
         }
         html.push('<p class="myt-mdP">' + inlineMd(para.join("<br>")) + "</p>");
@@ -1137,10 +1275,12 @@ window.__ModuleLoader__.load({
         "header.upgradeBtn": "一键升级", "header.upgrading": "安装中…", "header.upgraded": "已安装，待重启",
         "header.upgradeTitle": "用 pnpm 安装 npm 最新版（最长约 3 分钟），装完需重启 DeepSeek 生效",
         "header.upgradedTitle": "已安装新版，重启 DeepSeek 后生效",
+        "header.checkUpdate": "检测更新", "header.checkingUpdate": "检测中…",
         "toast.selfUpdate.ok": "已安装 {ver}，重启 DeepSeek 后生效",
         "toast.selfUpdate.upToDate": "已是最新版（{ver}）",
         "toast.selfUpdate.globalOk": "全局 maoying CLI {from} → {to}", "toast.selfUpdate.globalFail": "全局 CLI 更新失败：{error}",
         "toast.selfUpdate.devLink": "开发目录安装，请 git pull 更新", "toast.selfUpdate.pnpmMissing": "未找到 pnpm，请手动安装",
+        "toast.selfUpdate.found": "发现新版 {ver}", "toast.selfUpdate.checkFail": "检测失败：{msg}",
         "header.workspace": "工作区", "header.wsAria": "选择工作区", "header.noNovel": "（无 novel）", "header.untitled": "未命名",
         "header.settings": "系统设置", "header.refresh": "重新拉取", "header.closeAria": "关闭创作台", "header.closeTitle": "关闭",
         "tabs.aria": "创作台分区",
@@ -1158,6 +1298,7 @@ window.__ModuleLoader__.load({
         "guide.copied": "已复制 maoying init", "guide.copyFailed": "复制失败，请手动选择命令文本", "guide.copying": "复制中…", "guide.copyCmd": "复制命令",
         "common.retry": "重试", "common.empty": "暂无数据", "common.uncategorized": "未分类", "common.charCount": "{n} 字",
         "common.closeTip": "关闭提示", "common.unknownErr": "未知错误", "common.priorityTitle": "优先级：{pri}", "common.priorityAria": "优先级{pri}",
+        "common.dirtyExit": "有未保存的修改，离开将丢失。确定要放弃吗？",
         "common.chapterNum": "第 {n} 章", "pri.high": "高", "pri.normal": "中", "pri.low": "低",
         "toast.prefix": "毛颖创作台：{msg}", "toast.success": "操作成功", "toast.indexRebuilt": "索引已重建（{n} 章）",
         "toast.chapterStatus": "章节状态已更新", "toast.chapterCreated": "已从章纲建章「{title}」（待写）", "toast.foreshadowStatus": "伏笔状态已更新", "toast.phaseAdvanced": "阶段已推进到「{phase}」",
@@ -1167,7 +1308,8 @@ window.__ModuleLoader__.load({
         "src.deleteFile": "删除文件", "src.deleteTip": "删除文件：{rel}",
         "src.loading": "源文件加载中…", "src.loadFailed": "源文件读取失败：{msg}",
         "src.editHint": "直接编辑文件全文；保存时做结构校验（账本 yml 须解析为条目数组、md 实体卡须带 frontmatter 围栏），语义问题交给保存后的静态体检。",
-        "src.conflictReloaded": "文件已被外部修改，草稿已丢弃，已放回磁盘最新内容。",
+        "edit.conflict409": "保存冲突：文件在编辑期间被外部修改（{msg}）。草稿已保留，请选择处理方式。",
+        "edit.conflictDrop": "载入磁盘版（放弃草稿）", "edit.conflictKeep": "基于最新版重改",
         "src.slugLabel": "文件名 slug", "src.slugPh": "如 lin-waner（小写字母/数字与 -）", "src.slugInvalid": "slug 只接受小写字母/数字与 -，且以字母或数字开头",
         "src.createHint": "内容已按模板预填，可修改后再创建。", "src.create": "创建", "src.creating": "创建中…",
         "src.confirmTitle": "确认删除", "src.confirmText": "即将删除 {rel}。此操作不可逆——后悔靠 git 回滚；删除后静态体检会把指向它的悬空引用（伏笔/时间线/关系等）标为问题。",
@@ -1223,7 +1365,7 @@ window.__ModuleLoader__.load({
         "chapters.emptyWithOutlines": "chapters/ 目录还没有章节文件；下方「按单写作」已列出未建章章纲",
         "reader.back": "返回", "reader.backTip": "返回章节列表", "reader.copyPath": "复制路径", "reader.copyPathTip": "复制章节文件路径",
         "reader.edit": "编辑", "reader.editTip": "编辑章节正文（frontmatter 保留不动）",
-        "reader.save": "保存", "reader.bodyEditHint": "直接编辑正文；frontmatter（--- 围栏）保留不动。编辑期间文件被作者或 agent 改过时保存会被拒绝，并放回磁盘最新内容。",
+        "reader.save": "保存", "reader.bodyEditHint": "直接编辑正文：改动约 2 秒自动保存；回车换行自动加段首两个全角空格缩进。frontmatter（--- 围栏）保留不动；文件被外部改过时保存会被拒绝并给出处理出口。", "reader.autoSaved": "已自动保存（{time}）",
         "outline.editTip": "编辑章纲", "outline.editHint": "直接编辑章纲全文；编辑期间文件被外部改过时保存会被拒绝，并放回磁盘最新内容。",
         "reader.copied": "已复制章节文件路径", "reader.copyFailed": "复制失败，请手动选择路径文本", "reader.loadFailed": "正文读取失败：{msg}",
         "reader.noOutline": "暂无章纲", "reader.emptyBody": "（空章节）", "reader.finalState": "已定稿（终态）", "reader.statusFlow": "状态流转：",
@@ -1251,10 +1393,12 @@ window.__ModuleLoader__.load({
         "header.upgradeBtn": "Upgrade now", "header.upgrading": "Installing…", "header.upgraded": "Installed — restart pending",
         "header.upgradeTitle": "Install the latest npm release with pnpm (up to ~3 min); takes effect after restarting DeepSeek",
         "header.upgradedTitle": "New version installed — takes effect after restarting DeepSeek",
+        "header.checkUpdate": "Check updates", "header.checkingUpdate": "Checking…",
         "toast.selfUpdate.ok": "Installed {ver} — takes effect after restarting DeepSeek",
         "toast.selfUpdate.upToDate": "Already up to date ({ver})",
         "toast.selfUpdate.globalOk": "Global maoying CLI {from} → {to}", "toast.selfUpdate.globalFail": "Global CLI update failed: {error}",
         "toast.selfUpdate.devLink": "Installed from a dev directory — update with git pull", "toast.selfUpdate.pnpmMissing": "pnpm not found — install it manually",
+        "toast.selfUpdate.found": "New version {ver} found", "toast.selfUpdate.checkFail": "Check failed: {msg}",
         "header.workspace": "Workspace", "header.wsAria": "Select workspace", "header.noNovel": "(no novel)", "header.untitled": "Untitled",
         "header.settings": "Settings", "header.refresh": "Refresh", "header.closeAria": "Close Maoying Studio", "header.closeTitle": "Close",
         "tabs.aria": "Studio sections",
@@ -1272,6 +1416,7 @@ window.__ModuleLoader__.load({
         "guide.copied": "Copied maoying init", "guide.copyFailed": "Copy failed — select the command text manually", "guide.copying": "Copying…", "guide.copyCmd": "Copy command",
         "common.retry": "Retry", "common.empty": "No data", "common.uncategorized": "Uncategorized", "common.charCount": "{n} chars",
         "common.closeTip": "Dismiss notification", "common.unknownErr": "Unknown error", "common.priorityTitle": "Priority: {pri}", "common.priorityAria": "Priority {pri}",
+        "common.dirtyExit": "You have unsaved changes that will be lost. Discard them?",
         "common.chapterNum": "Ch. {n}", "pri.high": "High", "pri.normal": "Normal", "pri.low": "Low",
         "toast.prefix": "Maoying Studio: {msg}", "toast.success": "Success", "toast.indexRebuilt": "Index rebuilt ({n} chapters)",
         "toast.chapterStatus": "Chapter status updated", "toast.chapterCreated": "Created chapter \"{title}\" from the outline (pending)", "toast.foreshadowStatus": "Foreshadowing status updated", "toast.phaseAdvanced": "Phase advanced to {phase}",
@@ -1281,7 +1426,8 @@ window.__ModuleLoader__.load({
         "src.deleteFile": "Delete file", "src.deleteTip": "Delete file: {rel}",
         "src.loading": "Loading source file…", "src.loadFailed": "Failed to load source file: {msg}",
         "src.editHint": "Edit the whole file; saving runs structural validation (ledger yml must parse as an entry array, md entity cards must carry frontmatter fences) — semantics are left to the static check after saving.",
-        "src.conflictReloaded": "The file was changed externally; your draft was dropped and the latest on-disk content has been restored.",
+        "edit.conflict409": "Save conflict: the file was changed externally while editing ({msg}). Your draft is kept — choose how to proceed.",
+        "edit.conflictDrop": "Load disk version (discard draft)", "edit.conflictKeep": "Rebase onto latest",
         "src.slugLabel": "File slug", "src.slugPh": "e.g. lin-waner (lowercase letters/digits and -)", "src.slugInvalid": "Slug accepts lowercase letters/digits and - only, starting with a letter or digit",
         "src.createHint": "Pre-filled from the template — adjust it, then create.", "src.create": "Create", "src.creating": "Creating…",
         "src.confirmTitle": "Confirm delete", "src.confirmText": "About to delete {rel}. This is irreversible — recovery is via git rollback; afterwards the static check will flag dangling references to it (foreshadows / timeline / relations etc.).",
@@ -1337,7 +1483,7 @@ window.__ModuleLoader__.load({
         "chapters.emptyWithOutlines": "No chapter files in chapters/ yet — the Writing Queue below lists outlines without chapters",
         "reader.back": "Back", "reader.backTip": "Back to chapter list", "reader.copyPath": "Copy path", "reader.copyPathTip": "Copy chapter file path",
         "reader.edit": "Edit", "reader.editTip": "Edit the chapter text (frontmatter is preserved)",
-        "reader.save": "Save", "reader.bodyEditHint": "Edit the chapter text directly; the frontmatter (--- fence) is preserved. If the file was changed externally while editing, saving is rejected and the latest content is restored.",
+        "reader.save": "Save", "reader.bodyEditHint": "Edit the chapter text directly: changes auto-save after ~2s; Enter starts a new paragraph indented with two full-width spaces. The frontmatter (--- fence) is preserved; if the file was changed externally, saving is rejected with recovery options.", "reader.autoSaved": "Auto-saved ({time})",
         "outline.editTip": "Edit outline", "outline.editHint": "Edit the outline text directly; if the file was changed externally while editing, saving is rejected and the latest content is restored.",
         "reader.copied": "Copied chapter file path", "reader.copyFailed": "Copy failed — select the path text manually", "reader.loadFailed": "Failed to load chapter text: {msg}",
         "reader.noOutline": "No chapter outline", "reader.emptyBody": "(empty chapter)", "reader.finalState": "Accepted (final)", "reader.statusFlow": "Status:",
@@ -1407,8 +1553,8 @@ window.__ModuleLoader__.load({
     // ── 章节阅读页（整页视图，替代右侧抽屉）：返回按钮 + 章纲对照 + 正文 +
     // 五维 + 状态流转。原抽屉是 position:fixed 侧弹层，在桌面端会被侧边栏
     // 遮挡；整页视图天然在面板文档流内，无遮挡问题。0.1.19 起正文/章纲可在
-    // 本页编辑保存（textarea + 手动保存，无自动保存——IME 组合词风险天然规
-    // 避；409 人工改动保护链路照 StyleTab）。──
+    // 本页编辑保存；0.1.22 起正文改自动保存（2s 防抖 + 回车自动段首缩进 +
+    // 空章节直开编辑态），章纲仍手动保存；409 人工改动保护链路照 StyleTab。──
     function ChapterReader(props) {
       var file = props.file;
       var wsPath = props.wsPath;
@@ -1428,11 +1574,37 @@ window.__ModuleLoader__.load({
       var _ob = useState(false), olBusy = _ob[0], setOlBusy = _ob[1];
       var _be = useState(""), bodyErr = _be[0], setBodyErr = _be[1];
       var _oerr = useState(""), olErr = _oerr[0], setOlErr = _oerr[1];
+      // 409 冲突态：true 时编辑区亮出「载入磁盘版 / 基于最新版重改」两个出口，
+      // 草稿绝不丢（见 saveBody/saveOutline 的 catch）。
+      var _bc = useState(false), bodyConflict = _bc[0], setBodyConflict = _bc[1];
+      var _oc = useState(false), olConflict = _oc[0], setOlConflict = _oc[1];
+      // 正文自动保存（0.1.22）：最近一次自动保存成功的时刻（HH:MM:SS），缀在编辑
+      // hint 后；手动保存成功或切章时清零。
+      var _as = useState(""), autoSavedAt = _as[0], setAutoSavedAt = _as[1];
       var detailSeqRef = useRef(0); // chapter 请求序号：快速切章时丢弃过期响应
       // 409 后的一次性重置标记：loadDetail 带回磁盘真值时把草稿放回最新内容
-      // （只在保存冲突路径置位；顶栏刷新、状态流转等其他重拉不动正在编辑的草稿）。
+      // （只在保存冲突「放弃草稿」出口置位；顶栏刷新、状态流转等其他重拉不动
+      // 正在编辑的草稿）。
       var bodyResetRef = useRef(false);
       var olResetRef = useRef(false);
+      // 进入编辑态时的原文基线：草稿 ≠ 基线即脏，供取消/返回的退出确认。
+      var bodyBaseRef = useRef("");
+      var olBaseRef = useRef("");
+      // 当前选中章的实时值：在途保存/流转/建章回调用它比对闭包里的旧 file，
+      // 不一致则跳过 UI 状态回填，防旧章数据覆写新章视图（B 标题+A正文）。
+      var fileRef = useRef(file);
+      fileRef.current = file;
+      // editing 实时值：loadDetail 是 useCallback 闭包，直接读 editing state 是
+      // 过期值——空章节直开编辑态的守卫必须走 ref。
+      var editingRef = useRef(false);
+      editingRef.current = editing;
+      // 空章节直开去重：记本次访问已自动进入过编辑态的 file，同章不反复打扰
+      // （手动取消退出后不再自动重进）；切章清空，切走再切回可再次进入。
+      var autoEditRef = useRef("");
+      // 回车缩进的光标恢复：setDraft 提交换行+缩进后 DOM 未更新，下一轮渲染
+      // （draft 已就位）再把光标挪到插入的缩进之后；areaRef 指向正文 textarea。
+      var pendingCaretRef = useRef(null);
+      var areaRef = useRef(null);
       // 0.1.20 写面：新建章纲（无章纲态）/ 删除章节 / 删除章纲（各带确认弹层）。
       var stem = file.replace(/\.md$/i, "");
       var stemOk = /^v\d+-c\d+$/.test(stem); // 章纲 rel 挂钩 vXX-cXXX stem，不合规范不亮按钮
@@ -1445,7 +1617,10 @@ window.__ModuleLoader__.load({
         // 骨架照 spec 六件章纲的其中五件预填（章尾钩子独立成节，留给写的人
         // 展开成 `## 钩子`）；服务端只验形状，成败提示走 toast 通道。
         apiPost("file-create", { path: wsPath, rel: "outlines/" + stem + ".md", text: outlineTemplateOf(ch, stem) })
-          .then(function () { return reload().then(function () { return loadDetail(file); }); })
+          .then(function () { return reload().then(function () {
+            // 时序守卫：建章期间切了章——快照照刷，旧章详情不回填新章视图。
+            if (fileRef.current === file) return loadDetail(file);
+          }); })
           .catch(function () {}).finally(function () { setCoBusy(false); });
       }
       var loadDetail = useCallback(function (f, opts) {
@@ -1456,8 +1631,30 @@ window.__ModuleLoader__.load({
         apiGet("chapter", { path: wsPath, file: f }).then(function (d) {
           if (seq !== detailSeqRef.current) return; // 过期响应：已在看另一章，丢弃
           setDetail({ loading: false, data: d, err: "" });
-          if (bodyResetRef.current) { bodyResetRef.current = false; setDraft(d && typeof d.body === "string" ? d.body : ""); }
-          if (olResetRef.current) { olResetRef.current = false; setOlDraft(d && d.outline && typeof d.outline.body === "string" ? d.outline.body : ""); }
+          if (bodyResetRef.current) {
+            bodyResetRef.current = false;
+            var body0 = d && typeof d.body === "string" ? d.body : "";
+            bodyBaseRef.current = body0; // 放回的磁盘真值即新基线（脏检查归零）
+            setDraft(body0);
+          }
+          if (olResetRef.current) {
+            olResetRef.current = false;
+            var ol0 = d && d.outline && typeof d.outline.body === "string" ? d.outline.body : "";
+            olBaseRef.current = ol0;
+            setOlDraft(ol0);
+          }
+          // 空章节直开编辑态（0.1.22）：正文待写（body 全空白）的章打开即进编辑，
+          // 不再经顶部「编辑」按钮中转。三重守卫缺一不可——正在编辑绝不打扰
+          // （409 放弃草稿等编辑中重拉天然被排除）、同章本轮只自动进一次、
+          // 非空章节照常走「编辑」按钮。预填两个全角空格让首段也有段首缩进，
+          // 基线与预填同值（不判脏，纯缩进占位也不会触发自动保存落盘）。
+          if (!editingRef.current && autoEditRef.current !== f && d && typeof d.body === "string" && d.body.trim() === "") {
+            autoEditRef.current = f;
+            bodyBaseRef.current = "　　";
+            setDraft("　　");
+            setEditing(true);
+            setBodyErr("");
+          }
         }).catch(function (err) {
           if (seq !== detailSeqRef.current) return;
           setDetail({ loading: false, data: null, err: err.message });
@@ -1468,14 +1665,23 @@ window.__ModuleLoader__.load({
       // 走 silent——不闪骨架、不打断 textarea，draft 只在 409 冲突重置路径才
       // 动（上方注释的纪律不变）；阅读态非 silent，换血后照常渲染新正文。
       useEffect(function () {
-        if (reopenSeq > 0) loadDetail(file, { silent: editing });
+        // 重开面板算新一轮访问：直开去重清空，空章节重开再次自动进编辑态。
+        if (reopenSeq > 0) { autoEditRef.current = ""; loadDetail(file, { silent: editing }); }
       }, [reopenSeq]);
       // 切章必须退出编辑态并清草稿：草稿属于「那一章的那一次编辑」，跨章带过
       // 去会把 A 章的文字存进 B 章文件。
       useEffect(function () {
-        setEditing(false); setDraft(""); setBodyErr(""); setBodyBusy(false); bodyResetRef.current = false;
-        setOlEditing(false); setOlDraft(""); setOlErr(""); setOlBusy(false); olResetRef.current = false;
+        setEditing(false); setDraft(""); setBodyErr(""); setBodyBusy(false); bodyResetRef.current = false; setBodyConflict(false);
+        setOlEditing(false); setOlDraft(""); setOlErr(""); setOlBusy(false); olResetRef.current = false; setOlConflict(false);
+        bodyBaseRef.current = ""; olBaseRef.current = "";
+        autoEditRef.current = ""; setAutoSavedAt(""); // 直开去重与自动保存时刻随切章清零，新章新一轮
       }, [file]);
+      // 脏标记上报：Shell 的切 tab 守卫（gotoTab）读 DIRTY_EXIT 拦截；本组件
+      // 不随切 tab 卸载（整页视图），标记随每轮渲染同步，卸载时清零。
+      useEffect(function () {
+        DIRTY_EXIT.dirty = (editing && draft !== bodyBaseRef.current) || (olEditing && olDraft !== olBaseRef.current);
+        return function () { DIRTY_EXIT.dirty = false; };
+      });
       var ch = null;
       var chapters = (snap && snap.chapters) || [];
       for (var i = 0; i < chapters.length; i++) { if (chapters[i].file === file) { ch = chapters[i]; break; } }
@@ -1487,7 +1693,10 @@ window.__ModuleLoader__.load({
         setFlowBusy(true);
         apiPost("chapter-status", { path: wsPath, file: ch.file, status: next })
           .then(function () { return reload(); })
-          .then(function () { return loadDetail(ch.file); })
+          .then(function () {
+            // 时序守卫：流转期间切了章——快照照刷（无害），旧章详情不回填。
+            if (fileRef.current === ch.file) return loadDetail(ch.file);
+          })
           .catch(function () {}).finally(function () { setFlowBusy(false); });
       }
       function copyChapterPath() {
@@ -1499,34 +1708,114 @@ window.__ModuleLoader__.load({
       function startBodyEdit() {
         if (!detail.data || typeof detail.data.body !== "string") return;
         setBodyErr("");
+        setAutoSavedAt(""); // 上一次编辑会话的自动保存时刻不带进新一轮
+        bodyBaseRef.current = detail.data.body; // 进入编辑态即记基线，供脏检查
         setDraft(detail.data.body);
         setEditing(true);
       }
       function cancelBodyEdit() {
         if (bodyBusy) return; // 保存在途不许退出：避免卸载后 setState
-        setEditing(false); setDraft(""); setBodyErr("");
+        if (draft !== bodyBaseRef.current && !window.confirm(tt("common.dirtyExit"))) return; // 脏退出先确认
+        setEditing(false); setDraft(""); setBodyErr(""); setBodyConflict(false);
       }
-      function saveBody() {
+      // 返回章节列表：正文或章纲任一有未保存草稿，先确认再退。
+      function leaveReader() {
+        if ((editing && draft !== bodyBaseRef.current) || (olEditing && olDraft !== olBaseRef.current)) {
+          if (!window.confirm(tt("common.dirtyExit"))) return;
+        }
+        onBack();
+      }
+      function saveBody(opts) {
+        var auto = !!(opts && opts.auto); // 自动保存（2s 防抖调度）：成功不退出编辑态、不清草稿
         if (bodyBusy || !detail.data) return;
         setBodyBusy(true); setBodyErr("");
-        // 成败提示统一走 apiPost 的 toast 通道（这里不再另弹，避免双 toast）。
-        apiPost("chapter-save", { path: wsPath, file: file, body: draft, base_hash: detail.data.hash }).then(function (res) {
-          // 写后指纹即下一轮基线（连续保存不再被自家 409 拦住）；本地 data 同步
-          // 为新正文，退出编辑态立即看到刚落盘的内容（不等重拉，防闪回旧文）。
-          setDetail({ loading: false, data: Object.assign({}, detail.data, {
-            body: draft,
-            hash: res && typeof res.hash === "string" ? res.hash : detail.data.hash,
-          }), err: "" });
-          setEditing(false); setDraft("");
+        var bodyToSave = draft; // 调用点快照：在途期间继续打字的文本不该被误标已保存
+        // 失败经卡内 bodyErr 呈现（silent 抑制 apiPost 同文 toast）；成功提示仍走 toast。
+        apiPost("chapter-save", { path: wsPath, file: file, body: bodyToSave, base_hash: detail.data.hash }, { silent: true }).then(function (res) {
+          // 时序守卫：保存期间切了章——旧章结果不得覆写当前 detail（快照 reload 无害照做）。
+          if (fileRef.current === file) {
+            // 写后指纹即下一轮基线（连续保存不再被自家 409 拦住）；本地 data 同步
+            // 为新正文，退出编辑态立即看到刚落盘的内容（不等重拉，防闪回旧文）。
+            setDetail({ loading: false, data: Object.assign({}, detail.data, {
+              body: bodyToSave,
+              hash: res && typeof res.hash === "string" ? res.hash : detail.data.hash,
+            }), err: "" });
+            bodyBaseRef.current = bodyToSave; // 写盘内容即新基线：连续自动保存不假脏
+            setBodyConflict(false);
+            if (auto) {
+              // 自动保存：停留编辑态续写，时刻缀在 hint；手动保存维持原行为退出。
+              setAutoSavedAt(new Date().toTimeString().slice(0, 8));
+            } else {
+              setEditing(false); setDraft(""); setAutoSavedAt("");
+            }
+          }
           return reload(); // 字数/统计随正文变，快照由 reload 刷新
         }).catch(function (err) {
-          setBodyErr(err.message);
-          // 409 = 章节文件在进入编辑态后被外部改过：草稿丢弃、重拉磁盘真值放回
-          // 编辑器（与 ProjectMetaForm 同纪律），别让用户在过期基线上盲改。
-          if (err && err.status === 409) { bodyResetRef.current = true; loadDetail(file); }
-          // 其他失败（网络抖动等）不动草稿，只报错。
+          if (fileRef.current !== file) return; // 切章后的过期失败：不打扰当前章
+          if (err && err.status === 409) {
+            // 409 = 章节文件在进入编辑态后被外部改过：草稿绝不丢——保留编辑态
+            // 与草稿原文，报冲突并亮两个出口（放弃草稿载入磁盘版 / 基于磁盘
+            // 最新版重改），由用户选择，不再静默重拉覆盖草稿。
+            setBodyConflict(true);
+            setBodyErr(tf("edit.conflict409", { msg: err.message }));
+          } else {
+            setBodyErr(err.message); // 其他失败（网络抖动等）不动草稿，只报错。
+          }
         }).finally(function () { setBodyBusy(false); });
       }
+      // 正文自动保存调度（0.1.22）：无 dep 数组，每轮渲染重排——任何一次渲染都先
+      // 清掉上一个 2s 定时器再按最新 draft 重排，连续打字永远差 2s 才落盘；切章、
+      // 409 冲突、保存在途不排。draft 回到基线（刚保存/刚进编辑）不动作；纯缩进
+      // 占位（trim 为空）不落盘，且旧「已保存」时刻一并撤下。setAutoSavedAt("")
+      // 传同值时 React 不重渲，不会循环。
+      useEffect(function () {
+        if (!editing || bodyConflict || bodyBusy) return;
+        if (!detail || !detail.data) return;
+        if (draft === bodyBaseRef.current || draft.trim() === "") {
+          if (draft !== bodyBaseRef.current) setAutoSavedAt(""); // 纯缩进占位：旧时刻不亮
+          return;
+        }
+        setAutoSavedAt(""); // 新改动入列，清掉旧的「已保存」标
+        var t = setTimeout(function () { if (fileRef.current === file) saveBody({ auto: true }); }, 2000);
+        return function () { clearTimeout(t); };
+      });
+      // 回车缩进的光标恢复：DOM 换新后把光标放到插入的「\n　　」缩进之后，
+      // 打字位置即视觉位置；无待恢复请求（普通打字）直接跳过。
+      useEffect(function () {
+        if (pendingCaretRef.current == null) return;
+        var pos = pendingCaretRef.current; pendingCaretRef.current = null;
+        var ta = areaRef.current;
+        if (ta) { ta.selectionStart = ta.selectionEnd = pos; }
+      }, [draft]);
+      // 编辑器自动长高（0.1.22）：排版对齐只读正文（同 UI 字体 13px/22px 行高），
+      // 高度随内容长上去，至少 320px；非编辑态（textarea 已卸载）跳过。
+      useEffect(function () {
+        var ta = areaRef.current;
+        if (!editing || !ta) return;
+        ta.style.height = "auto";
+        ta.style.height = Math.max(320, ta.scrollHeight + 2) + "px";
+      }, [draft, editing]);
+      // 409 出口①：放弃草稿——磁盘真值放回编辑器（bodyResetRef 一次性重置链路）。
+      function dropBodyDraft() {
+        if (bodyBusy) return;
+        setBodyConflict(false); setBodyErr("");
+        bodyResetRef.current = true;
+        loadDetail(file);
+      }
+      // 409 出口②：基于磁盘最新版重改——只把 detail 换成磁盘最新（拿到新
+      // base_hash），草稿原样留在编辑器，用户改完再存即用新基线。
+      function rebaseBodyDraft() {
+        if (bodyBusy) return;
+        var seq = ++detailSeqRef.current;
+        apiGet("chapter", { path: wsPath, file: file }).then(function (d) {
+          if (seq !== detailSeqRef.current) return; // 过期响应：已切章，丢弃
+          setDetail({ loading: false, data: d, err: "" });
+          setBodyConflict(false); setBodyErr("");
+        }).catch(function (err2) {
+          if (seq !== detailSeqRef.current) return;
+          setBodyErr(err2.message); // 重拉失败：冲突态保留，出口仍在可重试
+        });
+      }
       function startOutlineEdit() {
         var ol = detail.data && detail.data.outline;
         if (!ol || typeof ol.body !== "string") return;
@@ -1536,33 +1825,67 @@ window.__ModuleLoader__.load({
       }
       function cancelOutlineEdit() {
         if (olBusy) return;
-        setOlEditing(false); setOlDraft(""); setOlErr("");
+        if (olDraft !== olBaseRef.current && !window.confirm(tt("common.dirtyExit"))) return; // 脏退出先确认
+        setOlEditing(false); setOlDraft(""); setOlErr(""); setOlConflict(false);
       }
       function saveOutline() {
         var ol = detail.data && detail.data.outline;
         if (olBusy || !ol) return;
         setOlBusy(true); setOlErr("");
-        apiPost("outline-save", { path: wsPath, file: file, body: olDraft, base_hash: ol.hash }).then(function (res) {
-          setDetail({ loading: false, data: Object.assign({}, detail.data, {
-            outline: Object.assign({}, ol, { body: olDraft, hash: res && typeof res.hash === "string" ? res.hash : ol.hash }),
-          }), err: "" });
-          setOlEditing(false); setOlDraft("");
+        // 失败经卡内 olErr 呈现（silent 抑制 apiPost 同文 toast）；成功提示仍走 toast。
+        apiPost("outline-save", { path: wsPath, file: file, body: olDraft, base_hash: ol.hash }, { silent: true }).then(function (res) {
+          if (fileRef.current === file) { // 时序守卫：同 saveBody
+            setDetail({ loading: false, data: Object.assign({}, detail.data, {
+              outline: Object.assign({}, ol, { body: olDraft, hash: res && typeof res.hash === "string" ? res.hash : ol.hash }),
+            }), err: "" });
+            setOlConflict(false);
+            setOlEditing(false); setOlDraft("");
+          }
           // 章纲字数 chip 客户端不算 CJK——silent 重拉静默对齐，不闪骨架。
-          return reload().then(function () { return loadDetail(file, { silent: true }); });
+          return reload().then(function () {
+            if (fileRef.current === file) return loadDetail(file, { silent: true });
+          });
         }).catch(function (err) {
-          setOlErr(err.message);
-          if (err && err.status === 409) { olResetRef.current = true; loadDetail(file); }
+          if (fileRef.current !== file) return; // 切章后的过期失败：不打扰当前章
+          if (err && err.status === 409) {
+            // 409 = 章纲文件被外部改过：草稿绝不丢，两个出口同 saveBody。
+            setOlConflict(true);
+            setOlErr(tf("edit.conflict409", { msg: err.message }));
+          } else {
+            setOlErr(err.message);
+          }
         }).finally(function () { setOlBusy(false); });
       }
+      // 409 出口①：放弃章纲草稿——磁盘真值放回编辑器（olResetRef 一次性重置链路）。
+      function dropOutlineDraft() {
+        if (olBusy) return;
+        setOlConflict(false); setOlErr("");
+        olResetRef.current = true;
+        loadDetail(file);
+      }
+      // 409 出口②：基于磁盘最新版重改——只换 detail 拿新 base_hash，章纲草稿
+      // 原样留在编辑器，改完再存即用新基线。
+      function rebaseOutlineDraft() {
+        if (olBusy) return;
+        var seq = ++detailSeqRef.current;
+        apiGet("chapter", { path: wsPath, file: file }).then(function (d) {
+          if (seq !== detailSeqRef.current) return;
+          setDetail({ loading: false, data: d, err: "" });
+          setOlConflict(false); setOlErr("");
+        }).catch(function (err2) {
+          if (seq !== detailSeqRef.current) return;
+          setOlErr(err2.message); // 重拉失败：冲突态保留，出口仍在可重试
+        });
+      }
       // 章纲编辑钩子（传给 OutlinePanel；无章纲返回 null = 只读，不给编辑入口——
-      // v1 不做面板新建章纲文件）。
+      // v1 不做面板新建章纲文件）。conflict/drop/rebase：409 两出口透传。
       function outlineEditor() {
         if (!detail.data || !detail.data.outline) return null;
-        return { active: olEditing, draft: olDraft, busy: olBusy, err: olErr, start: startOutlineEdit, change: setOlDraft, cancel: cancelOutlineEdit, save: saveOutline };
+        return { active: olEditing, draft: olDraft, busy: olBusy, err: olErr, conflict: olConflict, start: startOutlineEdit, change: setOlDraft, cancel: cancelOutlineEdit, save: saveOutline, drop: dropOutlineDraft, rebase: rebaseOutlineDraft };
       }
       return h("div", { className: "myt-reader" },
         h("div", { className: "myt-readerBar" },
-          h("button", { type: "button", className: "myt-btn", onClick: onBack, title: tt("reader.backTip") },
+          h("button", { type: "button", className: "myt-btn", onClick: leaveReader, title: tt("reader.backTip") },
             ic("IconChevronRightOutlineRegular", 13), tt("reader.back")),
           h("h2", { className: "myt-readerTitle" }, ch ? chFullTitle(ch) : file),
           ch ? statusBadge(ch.status) : null,
@@ -1605,11 +1928,31 @@ window.__ModuleLoader__.load({
                   editing
                     ? h("div", { key: "body", className: "myt-bodyEdit" },
                         h("textarea", {
+                          ref: areaRef,
                           className: "myt-chapterEditArea", rows: 20, spellCheck: false,
                           value: draft, onChange: function (e) { setDraft(e.target.value); },
+                          onKeyDown: function (e) {
+                            // 回车 = 换行 + 段首两个全角空格（网文段落缩进惯例）；IME
+                            // 组态中的回车是选词确认，不得劫持。
+                            if (e.key !== "Enter") return;
+                            if (e.keyCode === 229) return; // IME 组态中
+                            if (e.nativeEvent && e.nativeEvent.isComposing) return; // 中文输入法回车选词
+                            var ta = e.target;
+                            var s = ta.selectionStart, en = ta.selectionEnd;
+                            if (typeof s !== "number" || typeof en !== "number") return; // 退化环境交给默认
+                            e.preventDefault();
+                            var next = ta.value.slice(0, s) + "\n　　" + ta.value.slice(en);
+                            pendingCaretRef.current = s + 3; // "\n" + 两个全角空格
+                            setDraft(next);
+                          },
                         }),
-                        h("div", { className: "myt-editHint" }, tt("reader.bodyEditHint")),
+                        h("div", { className: "myt-editHint" },
+                          tt("reader.bodyEditHint"),
+                          autoSavedAt ? " · " + tf("reader.autoSaved", { time: autoSavedAt }) : null),
                         bodyErr ? h(ErrorStrip, { text: bodyErr }) : null,
+                        bodyConflict ? h("div", { className: "myt-setActions" },
+                          h("button", { type: "button", className: "myt-btn", disabled: bodyBusy, onClick: dropBodyDraft }, tt("edit.conflictDrop")),
+                          h("button", { type: "button", className: "myt-btn myt-btnPrimary", disabled: bodyBusy, onClick: rebaseBodyDraft }, tt("edit.conflictKeep"))) : null,
                         h("div", { className: "myt-setActions" },
                           h("button", { type: "button", className: "myt-btn", disabled: bodyBusy, onClick: cancelBodyEdit }, tt("novel.cancel")),
                           h("button", { type: "button", className: "myt-btn myt-btnPrimary", disabled: bodyBusy, onClick: saveBody }, bodyBusy ? tt("novel.saving") : tt("reader.save"))))
@@ -1704,14 +2047,24 @@ window.__ModuleLoader__.load({
       }, [snap, wsPath]);
       var _b = useState(false), busy = _b[0], setBusy = _b[1];
       var _e = useState(""), saveErr = _e[0], setSaveErr = _e[1];
+      // 脏检查：表单与磁盘初值（进入编辑态时的 project 快照）逐键比对，任一
+      // 不同即脏——取消退出确认与 Shell 切 tab 拦截共用。上报卸载即清零。
+      var diskForm = settingsFormOf(project);
+      var dirty = (function () {
+        for (var k in diskForm) { if (String(form[k]) !== String(diskForm[k])) return true; }
+        return false;
+      })();
+      useEffect(function () {
+        DIRTY_EXIT.dirty = dirty;
+        return function () { DIRTY_EXIT.dirty = false; };
+      });
       function set(k, v) { setForm(Object.assign({}, form, (function () { var o = {}; o[k] = v; return o; })())); }
       function save() {
         if (busy) return;
         if (!String(form.title || "").trim()) { setSaveErr(tt("novel.titleRequired")); return; }
         setBusy(true); setSaveErr("");
-        // 成败提示统一走 apiPost 的 toast 通道（这里不再另弹，避免双 toast）；
-        // 卡内 saveErr 只承担表单旁的错误态。
-        apiPost("project-save", { path: wsPath, values: form, base_hash: baseHashRef.current }).then(function (res) {
+        // 失败经卡内 saveErr 呈现（silent 抑制 apiPost 同文 toast）；成功提示仍走 toast。
+        apiPost("project-save", { path: wsPath, values: form, base_hash: baseHashRef.current }, { silent: true }).then(function (res) {
           // 写后指纹即下一轮基线：不等 reload 快照就先接住——连续两次保存时
           // 第二次若还回传载入时的旧指纹，会被自家 409 拦住（假冲突）。
           if (res && typeof res.project_hash === "string") baseHashRef.current = res.project_hash;
@@ -1746,6 +2099,7 @@ window.__ModuleLoader__.load({
       }
       function cancel() {
         if (busy) return; // 保存在途不许退出：避免卸载后 setState
+        if (dirty && !window.confirm(tt("common.dirtyExit"))) return; // 脏退出先确认
         onDone();
       }
       return h("div", { className: "myt-stack" },
@@ -1819,6 +2173,9 @@ window.__ModuleLoader__.load({
               }),
               h("div", { className: "myt-editHint" }, tt("outline.editHint")),
               ed.err ? h(ErrorStrip, { text: ed.err }) : null,
+              ed.conflict ? h("div", { className: "myt-setActions" },
+                h("button", { type: "button", className: "myt-btn", disabled: ed.busy, onClick: ed.drop }, tt("edit.conflictDrop")),
+                h("button", { type: "button", className: "myt-btn myt-btnPrimary", disabled: ed.busy, onClick: ed.rebase }, tt("edit.conflictKeep"))) : null,
               h("div", { className: "myt-setActions" },
                 h("button", { type: "button", className: "myt-btn", disabled: ed.busy, onClick: ed.cancel }, tt("novel.cancel")),
                 h("button", { type: "button", className: "myt-btn myt-btnPrimary", disabled: ed.busy, onClick: ed.save }, ed.busy ? tt("novel.saving") : tt("reader.save"))))
@@ -1905,9 +2262,10 @@ window.__ModuleLoader__.load({
     }
     // 编辑既有受管文件全文。打开即 GET file-source（请求序号防快速开关时的
     // 过期响应，对照 ChapterReader）；保存 POST file-save 带 base_hash 基线，
-    // 409 = 编辑期间文件被外部改过——照 ChapterReader 纪律：草稿丢弃、重拉
-    // 磁盘真值放回编辑器，别让用户在过期基线上盲改。成功后关弹层并触发调用
-    // 方 reload（快照重算），成败提示走 apiPost 的 toast 通道。
+    // 409 = 编辑期间文件被外部改过——草稿绝不丢：保留草稿报冲突，亮两个出口
+    // （放弃草稿载入磁盘版 / 基于磁盘最新版重改），别让用户在过期基线上盲改
+    // 也不许静默覆盖草稿。关闭统一走脏检查，未保存草稿先确认。成功后关弹层
+    // 并触发调用方 reload（快照重算），成功提示走 apiPost 的 toast 通道。
     function SourceEditorModal(props) {
       var title = props.title;
       var rel = props.rel;
@@ -1918,10 +2276,22 @@ window.__ModuleLoader__.load({
       var _dr = useState(""), draft = _dr[0], setDraft = _dr[1];
       var _b = useState(false), busy = _b[0], setBusy = _b[1];
       var _e = useState(""), err = _e[0], setErr = _e[1];
+      var _c = useState(false), conflict = _c[0], setConflict = _c[1];
       var seqRef = useRef(0);
+      // 脏检查基线 = detail.data.text：拉取/重基线都随 data 一致更新，草稿是否
+      // 偏离磁盘原文直接可比。上报 DIRTY_EXIT 供 Shell 切 tab 拦截，卸载清零。
+      var dirty = !!detail && !!detail.data && draft !== ((detail.data && detail.data.text) || "");
+      useEffect(function () {
+        DIRTY_EXIT.dirty = dirty;
+        return function () { DIRTY_EXIT.dirty = false; };
+      });
+      function close() {
+        if (dirty && !window.confirm(tt("common.dirtyExit"))) return; // 脏退出先确认
+        onClose();
+      }
       var load = useCallback(function () {
         var seq = ++seqRef.current;
-        setDetail(null); setErr("");
+        setDetail(null); setErr(""); setConflict(false);
         apiGet("file-source", { path: wsPath, rel: rel }).then(function (d) {
           if (seq !== seqRef.current) return;
           setDetail({ data: d, err: "" });
@@ -1935,22 +2305,41 @@ window.__ModuleLoader__.load({
       function save() {
         if (busy || !detail || !detail.data) return;
         setBusy(true); setErr("");
-        apiPost("file-save", { path: wsPath, rel: rel, text: draft, base_hash: detail.data.hash }).then(function () {
+        // 失败经卡内 err 呈现（silent 抑制 apiPost 同文 toast）；成功提示仍走 toast。
+        apiPost("file-save", { path: wsPath, rel: rel, text: draft, base_hash: detail.data.hash }, { silent: true }).then(function () {
           onClose();
           if (onSaved) onSaved();
         }).catch(function (e2) {
-          if (e2 && e2.status === 409) { setErr(tt("src.conflictReloaded")); load(); }
-          else setErr(e2 && e2.message ? e2.message : tt("common.unknownErr"));
+          if (e2 && e2.status === 409) {
+            // 草稿绝不丢：报冲突并亮两个出口（见顶部注释），不再静默 load 覆盖。
+            setConflict(true);
+            setErr(tf("edit.conflict409", { msg: e2.message }));
+          } else setErr(e2 && e2.message ? e2.message : tt("common.unknownErr"));
         }).finally(function () { setBusy(false); });
       }
+      // 409 出口①：放弃草稿——重拉磁盘真值回填（load 原行为）。
+      function dropDraft() { setConflict(false); setErr(""); load(); }
+      // 409 出口②：基于磁盘最新版重改——只换 detail 拿新 base_hash，草稿原样
+      // 留在编辑器，改完再存即用新基线。
+      function rebaseDraft() {
+        var seq = ++seqRef.current;
+        apiGet("file-source", { path: wsPath, rel: rel }).then(function (d) {
+          if (seq !== seqRef.current) return;
+          setDetail({ data: d, err: "" });
+          setConflict(false); setErr("");
+        }).catch(function (e3) {
+          if (seq !== seqRef.current) return;
+          setErr(e3 && e3.message ? e3.message : tt("common.unknownErr")); // 冲突态保留可重试
+        });
+      }
       return h(MaskPortal, {
           className: "myt-modalMask",
-          onMouseDown: function (e) { if (e.target === e.currentTarget && !busy) onClose(); },
+          onMouseDown: function (e) { if (e.target === e.currentTarget && !busy) close(); },
         },
         h("div", { className: "myt-modalCard myt-srcCard", role: "dialog", "aria-modal": "true", "aria-label": tt("src.modalAria") },
           h("div", { className: "myt-modalHead" },
             h("h2", { className: "myt-modalTitle" }, title),
-            h("button", { type: "button", className: "myt-closeBtn", "aria-label": tt("src.closeAria"), onClick: onClose }, h("span", { className: "myt-closeGlyph", "aria-hidden": "true" }, "×"))),
+            h("button", { type: "button", className: "myt-closeBtn", "aria-label": tt("src.closeAria"), onClick: close }, h("span", { className: "myt-closeGlyph", "aria-hidden": "true" }, "×"))),
           h("div", { className: "myt-modalBody" },
             h("div", { className: "myt-srcRel" }, rel),
             h("div", { className: "myt-muted myt-srcHint" }, tt("src.editHint")),
@@ -1960,8 +2349,11 @@ window.__ModuleLoader__.load({
                     h("textarea", { key: "a", className: "myt-setInput myt-setArea myt-srcArea", rows: 16, spellCheck: false,
                       value: draft, onChange: function (e) { setDraft(e.target.value); } }),
                     err ? h(ErrorStrip, { key: "e", text: err }) : null,
+                    conflict ? h("div", { key: "c", className: "myt-setActions" },
+                      h("button", { type: "button", className: "myt-btn", disabled: busy, onClick: dropDraft }, tt("edit.conflictDrop")),
+                      h("button", { type: "button", className: "myt-btn myt-btnPrimary", disabled: busy, onClick: rebaseDraft }, tt("edit.conflictKeep"))) : null,
                     h("div", { key: "s", className: "myt-setActions" },
-                      h("button", { type: "button", className: "myt-btn", disabled: busy, onClick: onClose }, tt("novel.cancel")),
+                      h("button", { type: "button", className: "myt-btn", disabled: busy, onClick: close }, tt("novel.cancel")),
                       h("button", { type: "button", className: "myt-btn myt-btnPrimary", disabled: busy, onClick: save }, busy ? tt("novel.saving") : tt("novel.save"))),
                   ])));
     }
@@ -1984,7 +2376,8 @@ window.__ModuleLoader__.load({
         if (busy) return;
         if (!slugOk) { setErr(tt("src.slugInvalid")); return; }
         setBusy(true); setErr("");
-        apiPost("file-create", { path: wsPath, rel: dir + "/" + slug + ".md", text: text }).then(function () {
+        // 失败经卡内 err 呈现（silent 抑制 apiPost 同文 toast）；成功提示仍走 toast。
+        apiPost("file-create", { path: wsPath, rel: dir + "/" + slug + ".md", text: text }, { silent: true }).then(function () {
           onClose();
           if (onSaved) onSaved();
         }).catch(function (e2) { setErr(e2 && e2.message ? e2.message : tt("common.unknownErr")); })
@@ -2257,7 +2650,7 @@ window.__ModuleLoader__.load({
             h("div", { className: "myt-boardHead" },
               h("span", { className: "myt-boardTitle" }, tt("foreshadow." + col)),
               h("span", { className: "myt-boardCount" }, items.length)),
-            items.map(function (fs) {
+            items.map(function (fs, i) {
               var next = FS_FLOW[col] || null;
               var busy = busyId === fs.id;
               // status 行缺失（服务端要求每条恰一处 status，写必 409）：禁用流
@@ -2268,7 +2661,8 @@ window.__ModuleLoader__.load({
                 ? tt("foreshadow.noIdTip")
                 : tt("foreshadow.noStatusTip");
               var chRange = [fs.planted_chapter || tt("foreshadow.plantedUnmarked"), fs.expected_resolve].filter(Boolean).join(" → ");
-              return h("div", { key: fs.id || fs.title, className: "myt-fsCard" },
+              // key 索引兜底：无 id 且标题重复时 id||title 相撞会丢行
+              return h("div", { key: fs.id || (fs.title + ":" + i), className: "myt-fsCard" },
                 h("div", { className: "myt-fsTitle" },
                   priDot(fs.priority), h("span", null, orDash(fs.title) || orDash(fs.id)),
                   // 回填徽章（五期账本回填）：区别于写前规划条目，悬浮见来源。
@@ -2329,8 +2723,8 @@ window.__ModuleLoader__.load({
     // 遵守）。挂载/换工作区时 GET style 按需拉取（请求序号防过期响应，对照
     // OverviewTab 的 check effect）；视图态 MdView 渲染全文，缺失时空态卡用
     // 插件模板预填创建；编辑态整文件保存（style-save 携 base_hash，409 人工
-    // 改动保护链路照 ProjectMetaForm：成功接写后新指纹防连续保存假冲突，
-    // 409 重拉磁盘真值后编辑器原地重置、停留编辑态让用户自行取舍）。──
+    // 改动保护链路：成功接写后新指纹防连续保存假冲突；409 草稿绝不丢——保留
+    // 草稿报冲突，亮「载入磁盘版 / 基于最新版重改」两个出口，同 ChapterReader）。
     function StyleTab(props) {
       var wsPath = props.wsPath;
       var _st = useState(null), st = _st[0], setSt = _st[1]; // {loading, data, err}
@@ -2341,6 +2735,8 @@ window.__ModuleLoader__.load({
       var _dh = useState(null), draftHash = _dh[0], setDraftHash = _dh[1];
       var _er = useState(""), editErr = _er[0], setEditErr = _er[1];
       var _b = useState(false), busy = _b[0], setBusy = _b[1];
+      // 409 冲突态：true 时编辑区亮出「载入磁盘版 / 基于最新版重改」两个出口。
+      var _cf = useState(false), conflict = _cf[0], setConflict = _cf[1];
       // 409 后的一次性重置标记：reload 带回磁盘真值时把编辑器与基线一并重置
       // （只置位于保存冲突路径；顶栏刷新等其他拉取不碰正在编辑的内容）。
       var pendingResetRef = useRef(false);
@@ -2353,8 +2749,8 @@ window.__ModuleLoader__.load({
           if (seq !== seqRef.current) return; // 过期响应：已有更新的请求在途，丢弃
           setSt({ loading: false, data: d, err: "" });
           if (pendingResetRef.current) {
-            // 409 冲突后的重拉：编辑器放回磁盘真值、基线对齐最新指纹，停留
-            // 编辑态让用户基于最新内容自行取舍。
+            // 409 冲突出口①「放弃草稿」的重拉：编辑器放回磁盘真值、基线对齐
+            // 最新指纹，停留编辑态。
             pendingResetRef.current = false;
             setDraft(d && typeof d.text === "string" ? d.text : "");
             setDraftHash(d && typeof d.hash === "string" ? d.hash : null);
@@ -2367,7 +2763,7 @@ window.__ModuleLoader__.load({
       useEffect(function () {
         if (wsRef.current !== wsPath) {
           wsRef.current = wsPath;
-          setDraft(null); setDraftHash(null); setEditErr(""); pendingResetRef.current = false;
+          setDraft(null); setDraftHash(null); setEditErr(""); setConflict(false); pendingResetRef.current = false;
         }
         load();
       }, [wsPath, load]);
@@ -2385,30 +2781,62 @@ window.__ModuleLoader__.load({
       }
       function cancelEdit() {
         if (busy) return; // 保存在途不许退出：避免卸载后 setState
-        setDraft(null); setDraftHash(null); setEditErr("");
+        if (dirty && !window.confirm(tt("common.dirtyExit"))) return; // 脏退出先确认
+        setDraft(null); setDraftHash(null); setEditErr(""); setConflict(false);
       }
       function save() {
         if (busy) return;
         setBusy(true); setEditErr("");
-        // 成败提示统一走 apiPost 的 toast 通道；空文本允许保存（空文件 = 无
-        // 基准，agent 侧优雅降级），不做非空校验。
-        apiPost("style-save", { path: wsPath, text: draft, base_hash: draftHash }).then(function (res) {
+        // 失败经卡内 editErr 呈现（silent 抑制 apiPost 同文 toast）；成功提示仍走
+        // toast 通道。空文本允许保存（空文件 = 无基准，agent 侧优雅降级）。
+        apiPost("style-save", { path: wsPath, text: draft, base_hash: draftHash }, { silent: true }).then(function (res) {
           // 写后指纹即下一轮基线（连续保存不再被自家 409 拦住）；本地数据
           // 同步为新文本，取消编辑退回视图态时看到的已是刚落盘的内容。
           var hash = res && typeof res.hash === "string" ? res.hash : null;
           setDraftHash(hash);
+          setConflict(false);
           setSt({ loading: false, data: { found: true, text: draft, hash: hash, template: st.data ? st.data.template : null }, err: "" });
         }).catch(function (err) {
-          setEditErr(err.message);
-          // 409 = style.md 在进入编辑态后被外部改过：重拉磁盘真值并一次性
-          // 把编辑器放回最新内容（停留编辑态），别让用户在过期基线上盲改。
           if (err && err.status === 409) {
-            pendingResetRef.current = true;
-            load();
+            // 409 = style.md 在进入编辑态后被外部改过：草稿绝不丢——报冲突并
+            // 亮两个出口（放弃草稿载入磁盘版 / 基于最新版重改），不再静默重置。
+            setConflict(true);
+            setEditErr(tf("edit.conflict409", { msg: err.message }));
+          } else {
+            setEditErr(err.message);
           }
         }).finally(function () { setBusy(false); });
       }
+      // 409 出口①：放弃草稿——重拉磁盘真值放回编辑器（pendingResetRef 老链路）。
+      function dropStyleDraft() {
+        if (busy) return;
+        setConflict(false); setEditErr("");
+        pendingResetRef.current = true;
+        load();
+      }
+      // 409 出口②：基于磁盘最新版重改——只换 data 拿新指纹（draftHash），草稿
+      // 原样留在编辑器，改完再存即用新基线。
+      function rebaseStyleDraft() {
+        if (busy) return;
+        var seq = ++seqRef.current;
+        apiGet("style", { path: wsPath }).then(function (d) {
+          if (seq !== seqRef.current) return;
+          setSt({ loading: false, data: d, err: "" });
+          setDraftHash(d && typeof d.hash === "string" ? d.hash : null);
+          setConflict(false); setEditErr("");
+        }).catch(function (err) {
+          if (seq !== seqRef.current) return;
+          setEditErr(err.message); // 重拉失败：冲突态保留可重试
+        });
+      }
       var data = st ? st.data : null;
+      // 脏检查：草稿偏离磁盘原文即脏（模板创建时磁盘原文按空算）。上报
+      // DIRTY_EXIT 供切 tab 拦截——本 tab 切走即卸载，草稿会丢。
+      var dirty = draft !== null && draft !== (data && typeof data.text === "string" ? data.text : "");
+      useEffect(function () {
+        DIRTY_EXIT.dirty = dirty;
+        return function () { DIRTY_EXIT.dirty = false; };
+      });
       var head = h("div", { className: "myt-cardHead" },
         h("h3", { className: "myt-cardTitle" }, tt("tabs.style")),
         h("span", { className: "myt-muted" }, tt("style.note")),
@@ -2443,6 +2871,9 @@ window.__ModuleLoader__.load({
               value: draft, onChange: function (e) { setDraft(e.target.value); },
             })),
           editErr ? h(ErrorStrip, { text: editErr }) : null,
+          conflict ? h("div", { className: "myt-setActions" },
+            h("button", { type: "button", className: "myt-btn", disabled: busy, onClick: dropStyleDraft }, tt("edit.conflictDrop")),
+            h("button", { type: "button", className: "myt-btn myt-btnPrimary", disabled: busy, onClick: rebaseStyleDraft }, tt("edit.conflictKeep"))) : null,
           h("div", { className: "myt-setActions" },
             h("button", { type: "button", className: "myt-btn", disabled: busy, onClick: cancelEdit }, tt("novel.cancel")),
             h("button", { type: "button", className: "myt-btn myt-btnPrimary", disabled: busy, onClick: save },
@@ -2713,10 +3144,19 @@ window.__ModuleLoader__.load({
         var ctx = canvas.getContext("2d");
         if (!ctx) return undefined;
         var dpr = (window.devicePixelRatio || 1) > 0 ? window.devicePixelRatio || 1 : 1;
-        var sim = { zoom: 1, drag: null, raf: 0, frame: 0, w: 0, h: 0, tokens: null };
+        // 收敛停机参数：能量（速度平方和）阈值 + 碰撞位移静阈 + 连续静止帧数
+        // （~0.5s@60fps）；STILL_CAP 是单次唤醒的帧数上限（~15s）兜底——拖拽
+        // 节点压着邻居时，弹簧+碰撞+限速会形成持续亚像素抖动的极限环，永远
+        // 到不了静止判据，必须有硬上限。面板关闭仅 CSS 隐藏、组件不卸载，rAF
+        // 不停就后台永久燃 CPU。
+        var ENERGY_TAU = 0.5;
+        var MOVE_EPS = 0.5;
+        var STILL_FRAMES = 30;
+        var STILL_CAP = 900;
+        var sim = { zoom: 1, drag: null, raf: 0, frame: 0, w: 0, h: 0, tokens: null, still: 0, frames: 0 };
         // 缩放按钮桥：渲染层按钮 → effect 内 sim.zoom（钳制与滚轮同口径 0.4-2.5）
         zoomApiRef.current = {
-          zoomBy: function (k) { sim.zoom = Math.min(2.5, Math.max(0.4, sim.zoom * k)); },
+          zoomBy: function (k) { sim.zoom = Math.min(2.5, Math.max(0.4, sim.zoom * k)); wake(); },
         };
         // 令牌缓存：每 30 帧重读 computed style，浅/深色切换约半秒内跟上。
         function readTokens() {
@@ -2735,6 +3175,7 @@ window.__ModuleLoader__.load({
           sim.h = wrap.clientHeight || 480;
           canvas.width = Math.max(1, Math.round(sim.w * dpr));
           canvas.height = Math.max(1, Math.round(sim.h * dpr));
+          wake(); // 改 width 即清空位图：停机后也要立刻重画（含全屏进出触发的 RO）
         }
         // 初始摆在同心圆上，交给力导向收敛。
         var R = Math.max(90, Math.min(sim.w, sim.h) / 3);
@@ -2824,6 +3265,8 @@ window.__ModuleLoader__.load({
         }
         function step() {
           var nodes = graph.nodes, edges = graph.edges, n = nodes.length;
+          var energy = 0; // 节点速度平方和：本帧系统总动能
+          var movedPx = 0; // 硬碰撞分离的本帧位移量：纯位置修正能量看不见，按位移计静
           for (var i = 0; i < n; i++) {
             for (var j = i + 1; j < n; j++) {
               var a = nodes[i], b = nodes[j];
@@ -2851,6 +3294,7 @@ window.__ModuleLoader__.load({
             nd.vx *= 0.85; nd.vy *= 0.85;
             nd.x += Math.max(-8, Math.min(8, nd.vx));
             nd.y += Math.max(-8, Math.min(8, nd.vy));
+            energy += nd.vx * nd.vx + nd.vy * nd.vy; // 固定/拖拽节点速度已清零不计
           });
           // 硬碰撞分离：力式斥力有上限（f 封顶 4），拥挤时节点仍会压叠；这里在
           // 速度积分之后按最小间距 62（两节点半径 18×2 + 名字 label 纵向净空）
@@ -2873,12 +3317,14 @@ window.__ModuleLoader__.load({
                 var bFixed = nb.fixed || nb === (sim.drag && sim.drag.node);
                 if (aFixed && bFixed) continue;
                 var mA = aFixed ? 0 : (bFixed ? 1 : 0.5); // 固定方不动，另一方全担
+                movedPx += (MIN_DIST - cd) * (mA + mB); // 有实际位移才计（双固定跳过不计）
                 var mB = bFixed ? 0 : (aFixed ? 1 : 0.5);
                 na.x -= cdx * push * mA; na.y -= cdy * push * mA;
                 nb.x += cdx * push * mB; nb.y += cdy * push * mB;
               }
             }
           }
+          return { energy: energy, movedPx: movedPx };
         }
         function draw() {
           if (sim.frame % 30 === 0 || !sim.tokens) sim.tokens = readTokens();
@@ -2924,9 +3370,26 @@ window.__ModuleLoader__.load({
           ctx.restore();
         }
         function loop() {
-          step();
+          var m = step();
           draw();
           sim.frame++;
+          // 收敛停机：能量与碰撞位移都低于静阈连续 STILL_FRAMES 帧即真停 rAF
+          // （raf 归零），不再每帧 O(n²) + 全量重绘空转；交互经 wake() 重启。
+          // STILL_CAP 兜底：拖拽压邻等病态抖动循环到不了静止判据，也必须停。
+          if (m.energy < ENERGY_TAU && m.movedPx < MOVE_EPS) {
+            if (++sim.still >= STILL_FRAMES) { sim.raf = 0; return; }
+          } else {
+            sim.still = 0;
+          }
+          if (++sim.frames >= STILL_CAP) { sim.raf = 0; return; }
+          sim.raf = requestAnimationFrame(loop);
+        }
+        // 唤醒：静止停机后任何会改变画面/物理的交互都要重启循环（幂等，已跑不
+        // 叠加），并重新给满静止计数与帧数预算。
+        function wake() {
+          if (sim.raf) return;
+          sim.still = 0;
+          sim.frames = 0;
           sim.raf = requestAnimationFrame(loop);
         }
         resize();
@@ -2944,6 +3407,7 @@ window.__ModuleLoader__.load({
             sim.drag = { node: nd };
             nd.fixed = true; // 拖拽固定
             canvas.dataset.dragging = "true";
+            wake(); // 拖拽移动物理系统，停机态先唤醒
             e.preventDefault();
           }
         }
@@ -2972,11 +3436,13 @@ window.__ModuleLoader__.load({
           e.preventDefault();
           var next = sim.zoom * Math.exp(-e.deltaY * 0.0012);
           sim.zoom = Math.min(2.5, Math.max(0.4, next));
+          wake(); // 缩放变了画面：停机态也要重绘
         }
         function onDbl() {
           sim.zoom = 1; // 复位：缩放回 1、释放全部拖拽固定
           graph.nodes.forEach(function (nd) { nd.fixed = false; });
           setTip(null);
+          wake(); // 释放固定后力导向要重新收敛
         }
         canvas.addEventListener("mousedown", onDown);
         window.addEventListener("mousemove", onMove);