dsh-maoying 0.1.19 → 0.1.21

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;
       });
     }
@@ -246,6 +257,9 @@ window.__ModuleLoader__.load({
       if (path === "style-save") return tt("toast.styleSaved");
       if (path === "chapter-save") return tt("toast.chapterSaved");
       if (path === "outline-save") return tt("toast.outlineSaved");
+      if (path === "file-save") return tf("toast.fileSaved", { rel: (d && d.rel) || "" });
+      if (path === "file-create") return tf("toast.fileCreated", { rel: (d && d.rel) || "" });
+      if (path === "file-delete") return tf("toast.fileDeleted", { rel: (d && d.rel) || "" });
       return tt("toast.success");
     }
 
@@ -282,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];
@@ -545,8 +563,8 @@ window.__ModuleLoader__.load({
     }
 
     // ── 页面骨架：顶栏（工作区下拉 + 刷新 + 关闭）+ tab 条 + 内容区 ─────────
-    // 数据流：workspaces 每次打开面板都重拉（懒挂载下关闭不卸载，见下方
-    // activate 监听）；state 跟随选中工作区；写操作 POST 成功后
+    // 数据流：workspaces 与 state 每次打开面板都重拉（懒挂载下关闭不卸载，
+    // 见下方 activate 监听）；state 另跟随选中工作区；写操作 POST 成功后
     // 整份重拉 state（不乐观更新）。选择记 localStorage('maoying.workspace')。
     function PageShell(props) {
       var onClose = props.onClose;
@@ -559,6 +577,8 @@ window.__ModuleLoader__.load({
       var _tb = useState("overview"), tab = _tb[0], setTab = _tb[1];
       // 章节阅读页（整页视图，替代原右侧抽屉）：null = 列表态。
       var _rd = useState(null), readerFile = _rd[0], setReaderFile = _rd[1];
+      // 面板重开序号：每次 activate 广播自增，透传 ChapterReader 驱动本章重拉。
+      var _rs = useState(0), reopenSeq = _rs[0], setReopenSeq = _rs[1];
       // 系统设置：字号档位持久化 + 面板整体缩放（portal 节点读同一 CSS 变量）。
       var _sm = useState(false), showSettings = _sm[0], setShowSettings = _sm[1];
       var _fs = useState(function () {
@@ -753,21 +773,61 @@ 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]);
-      // 每次打开面板都重拉工作区列表：懒挂载下关闭只是摘掉 active 属性，
-      // 组件不卸载，上面的 mount effect 整个页面生命周期只跑一次，期间外部
-      // （CLI / 其他面板）新建或删除的工作区在重开时看不见。mountPanel 每次
-      // 打开都会广播 dsh-panel-activate（source: "maoying"），借它触发重拉；
-      // 首次打开的广播早于本组件挂载（render 异步调度），收不到也无妨——
-      // mount effect 已覆盖首拉。其余面板的同名广播按 source 过滤掉。
+      // 每次打开面板都重拉工作区列表与整份 state 快照：懒挂载下关闭只是摘掉
+      // active 属性，组件不卸载，上面的 mount effect 整个页面生命周期只跑一
+      // 次，期间外部（CLI / agent / 其他面板）新建/删除的工作区、改动的小说
+      // 内容在重开时看不见——state 原本只跟 effectiveWs 走，同工作区重开不
+      // 会重拉，用户得手点右上角刷新。mountPanel 每次打开都会广播
+      // dsh-panel-activate（source: "maoying"），借它触发三重重拉：workspaces、
+      // state 快照、阅读页本章（reopenSeq 自增）；首次打开的广播早于本组件挂
+      // 载（render 异步调度），收不到也无妨——mount effect 已覆盖首拉。其余
+      // 面板的同名广播按 source 过滤掉。重拉不动编辑中的草稿：loadState 本就
+      // 不碰草稿，阅读页走 silent 刷新（见 ChapterReader）。
       useEffect(function () {
         var onActivate = function (event) {
           var source = event && event.detail && event.detail.source;
-          if (source === "maoying") loadWorkspaces();
+          if (source !== "maoying") return;
+          loadWorkspaces();
+          reload(); // 重开即最新小说内容，不必手点右上角刷新
+          setReopenSeq(function (n) { return n + 1; });
         };
         document.addEventListener(ACTIVATE_EVENT, onActivate);
         return function () { document.removeEventListener(ACTIVATE_EVENT, onActivate); };
-      }, [loadWorkspaces]);
+      }, [loadWorkspaces, reload]);
       useEffect(function () { loadState(effectiveWs); }, [effectiveWs, loadState]);
       // 校正后的选择回写记忆（首次打开 / 记忆失效时自动落位）。
       useEffect(function () {
@@ -780,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);
       }
@@ -807,7 +870,7 @@ window.__ModuleLoader__.load({
         });
       } else if (snap) {
         var tabProps = { snap: snap, reload: reload, wsPath: effectiveWs };
-        if (readerFile) body = h(ChapterReader, { file: readerFile, snap: snap, reload: reload, wsPath: effectiveWs, onBack: function () { setReaderFile(null); } });
+        if (readerFile) body = h(ChapterReader, { file: readerFile, snap: snap, reload: reload, wsPath: effectiveWs, refreshSeq: reopenSeq, onBack: function () { setReaderFile(null); } });
         else if (tab === "chapters") body = h(ChaptersTab, Object.assign({ onOpenChapter: function (f) { setReaderFile(f); } }, tabProps));
         else if (tab === "characters") body = h(CharactersTab, tabProps);
         else if (tab === "foreshadows") body = h(ForeshadowsTab, tabProps);
@@ -824,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）
@@ -906,6 +976,8 @@ window.__ModuleLoader__.load({
       var project = snap.project || {};
       // 编辑态：true 时 hero 卡切换为书稿元信息表单（ProjectMetaForm）。
       var _ed = useState(false), editing = _ed[0], setEditing = _ed[1];
+      // 分卷规划账源文件直达（0.1.20 写面）：volumes.yml 整文件可编辑。
+      var _src = useState(null), srcRel = _src[0], setSrcRel = _src[1];
       var totals = snap.totals || {};
       var byStatus = totals.byStatus || {};
       var _b = useState(false), phaseBusy = _b[0], setPhaseBusy = _b[1];
@@ -981,7 +1053,8 @@ window.__ModuleLoader__.load({
           }))),
         volumes.length ? h("div", { className: "myt-card" },
           h("div", { className: "myt-cardHead" }, h("h3", { className: "myt-cardTitle" }, tt("overview.volumes")),
-            h("span", { className: "myt-boardCount" }, volumes.length)),
+            h("span", { className: "myt-boardCount" }, volumes.length),
+            srcEditBtn("volumes.yml", function () { setSrcRel("volumes.yml"); })),
           h("div", { className: "myt-stack" }, volumes.map(function (v, i) {
             return h("div", { key: v.id || i, className: "myt-worldGroup" },
               h("div", { className: "myt-listHead" },
@@ -999,14 +1072,17 @@ window.__ModuleLoader__.load({
                   h("span", { className: "myt-chPath" }, chWhere(ch)),
                   h("span", { className: "myt-wordsCell" }, tf("common.charCount", { n: fmtNum(ch.words) })));
               }))
-            : h(Empty, { text: tt("chapters.empty") })));
+             : h(Empty, { text: tt("chapters.empty") })),
+        srcRel ? h(SourceEditorModal, { title: tt("src.editSource"), rel: srcRel, wsPath: wsPath, onClose: function () { setSrcRel(null); }, onSaved: reload }) : null);
     }
 
     // ── 轻量 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: 等一律拒绝（调用方落纯文本）。
@@ -1033,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 = [];
@@ -1085,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>");
@@ -1121,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": "创作台分区",
@@ -1142,10 +1298,26 @@ 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}」",
         "toast.styleSaved": "写作风格已保存", "toast.chapterSaved": "章节正文已保存", "toast.outlineSaved": "章纲已保存",
+        "src.modalAria": "源文件编辑", "src.closeAria": "关闭源文件编辑",
+        "src.editSource": "编辑源文件", "src.editSourceTip": "编辑源文件：{rel}",
+        "src.deleteFile": "删除文件", "src.deleteTip": "删除文件：{rel}",
+        "src.loading": "源文件加载中…", "src.loadFailed": "源文件读取失败：{msg}",
+        "src.editHint": "直接编辑文件全文；保存时做结构校验（账本 yml 须解析为条目数组、md 实体卡须带 frontmatter 围栏），语义问题交给保存后的静态体检。",
+        "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 回滚；删除后静态体检会把指向它的悬空引用（伏笔/时间线/关系等）标为问题。",
+        "src.confirmDelete": "确认删除", "src.deleting": "删除中…",
+        "toast.fileSaved": "已保存 {rel}", "toast.fileCreated": "已创建 {rel}", "toast.fileDeleted": "已删除 {rel}",
+        "reader.createOutline": "新建章纲", "reader.deleteChapter": "删除章节",
+        "outline.deleteBtn": "删除章纲",
+        "char.createBtn": "新建角色", "world.createBtn": "新建设定", "world.createScienceBtn": "新建科学设定",
         "api.notJson": "响应不是 JSON（HTTP {code}）", "api.timeout": "请求超时（{s} 秒）",
         "status.pending": "待写", "status.writing": "写作中", "status.review": "审校中", "status.accepted": "已定稿", "status.rawSuffix": "（{raw}）",
         "phase.idea": "立意", "phase.setting": "设定", "phase.outline": "大纲", "phase.writing": "写作", "phase.review": "审校",
@@ -1168,7 +1340,7 @@ window.__ModuleLoader__.load({
         "timeline.empty": "timeline.yml 还没有时间线条目", "timeline.importance": "重要度 {n}", "timeline.linkedChapter": "关联章节：{ch}",
         "world.title": "世界观条目", "world.empty": "world/ 目录还没有设定条目", "world.science": "科学设定",
         "world.scienceEmpty": "science/ 目录还没有科学设定", "world.research": "资料检索", "world.ref": "参考 {n}：{r}",
-        "world.researchEmpty": "research/ 目录还没有考据资料", "world.subTabsAria": "设定分区",
+        "world.researchEmpty": "research/ 目录还没有考据资料", "world.subTabsAria": "设定分区", "world.catTabsAria": "世界观分类",
         "relations.title": "角色关系图", "relations.counts": "{n} 节点 · {m} 关系",
         "relations.help": "拖节点固定位置 · 滚轮或 ＋/－ 按钮缩放 · 双击复位 · 悬停边看关系描述 · 右上角按钮全屏",
         "relations.unlinkedTitle": "未入图角色（无关系边）", "relations.noData": "没有角色或关系数据，无法绘图",
@@ -1221,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",
@@ -1242,10 +1416,26 @@ 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}",
         "toast.styleSaved": "Style baseline saved", "toast.chapterSaved": "Chapter text saved", "toast.outlineSaved": "Outline saved",
+        "src.modalAria": "Source file editor", "src.closeAria": "Close source editor",
+        "src.editSource": "Edit source file", "src.editSourceTip": "Edit source file: {rel}",
+        "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.",
+        "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.).",
+        "src.confirmDelete": "Delete", "src.deleting": "Deleting…",
+        "toast.fileSaved": "Saved {rel}", "toast.fileCreated": "Created {rel}", "toast.fileDeleted": "Deleted {rel}",
+        "reader.createOutline": "Create outline", "reader.deleteChapter": "Delete chapter",
+        "outline.deleteBtn": "Delete outline",
+        "char.createBtn": "New character", "world.createBtn": "New world entry", "world.createScienceBtn": "New science entry",
         "api.notJson": "Response is not JSON (HTTP {code})", "api.timeout": "Request timed out ({s} s)",
         "status.pending": "Pending", "status.writing": "Writing", "status.review": "Review", "status.accepted": "Accepted", "status.rawSuffix": "({raw})",
         "phase.idea": "Idea", "phase.setting": "Setting", "phase.outline": "Outline", "phase.writing": "Writing", "phase.review": "Review",
@@ -1268,7 +1458,7 @@ window.__ModuleLoader__.load({
         "timeline.empty": "No entries in timeline.yml yet", "timeline.importance": "Importance {n}", "timeline.linkedChapter": "Related chapter: {ch}",
         "world.title": "Worldbuilding entries", "world.empty": "No worldbuilding entries in world/ yet", "world.science": "Science settings",
         "world.scienceEmpty": "No science entries in science/ yet", "world.research": "Research", "world.ref": "Ref {n}: {r}",
-        "world.researchEmpty": "No research notes in research/ yet", "world.subTabsAria": "Worldbuilding sections",
+        "world.researchEmpty": "No research notes in research/ yet", "world.subTabsAria": "Worldbuilding sections", "world.catTabsAria": "Worldbuilding categories",
         "relations.title": "Character relations", "relations.counts": "{n} nodes · {m} relations",
         "relations.help": "Drag a node to pin it · scroll or the ＋/－ buttons to zoom · double-click to reset · hover an edge for its description · top-right button for full screen",
         "relations.unlinkedTitle": "Unlinked characters (no relation edges)", "relations.noData": "No character or relation data to draw",
@@ -1370,6 +1560,7 @@ window.__ModuleLoader__.load({
       var wsPath = props.wsPath;
       var snap = props.snap;
       var reload = props.reload;
+      var reopenSeq = props.refreshSeq || 0; // 面板重开序号（PageShell 广播自增）
       var onBack = props.onBack;
       var _d = useState(null), detail = _d[0], setDetail = _d[1]; // {loading, data, err}
       var _b = useState(false), flowBusy = _b[0], setFlowBusy = _b[1];
@@ -1383,11 +1574,41 @@ 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];
       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;
+      // 0.1.20 写面：新建章纲（无章纲态）/ 删除章节 / 删除章纲（各带确认弹层）。
+      var stem = file.replace(/\.md$/i, "");
+      var stemOk = /^v\d+-c\d+$/.test(stem); // 章纲 rel 挂钩 vXX-cXXX stem，不合规范不亮按钮
+      var _co = useState(false), coBusy = _co[0], setCoBusy = _co[1];
+      var _dc = useState(false), delChapterOpen = _dc[0], setDelChapterOpen = _dc[1];
+      var _do = useState(false), delOutlineOpen = _do[0], setDelOutlineOpen = _do[1];
+      function createOutline() {
+        if (coBusy || !stemOk) return;
+        setCoBusy(true);
+        // 骨架照 spec 六件章纲的其中五件预填（章尾钩子独立成节，留给写的人
+        // 展开成 `## 钩子`）；服务端只验形状，成败提示走 toast 通道。
+        apiPost("file-create", { path: wsPath, rel: "outlines/" + stem + ".md", text: outlineTemplateOf(ch, stem) })
+          .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) {
         var seq = ++detailSeqRef.current;
         if (!f) { setDetail(null); return; }
@@ -1396,20 +1617,43 @@ 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);
+          }
         }).catch(function (err) {
           if (seq !== detailSeqRef.current) return;
           setDetail({ loading: false, data: null, err: err.message });
         });
       }, [wsPath]);
       useEffect(function () { loadDetail(file); }, [file, loadDetail]);
+      // 面板重开（reopenSeq 递增）：重拉本章让磁盘最新内容即时可见。编辑中
+      // 走 silent——不闪骨架、不打断 textarea，draft 只在 409 冲突重置路径才
+      // 动（上方注释的纪律不变）；阅读态非 silent，换血后照常渲染新正文。
+      useEffect(function () {
+        if (reopenSeq > 0) 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 = "";
       }, [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; } }
@@ -1421,7 +1665,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() {
@@ -1433,34 +1680,73 @@ window.__ModuleLoader__.load({
       function startBodyEdit() {
         if (!detail.data || typeof detail.data.body !== "string") return;
         setBodyErr("");
+        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 leaveReader() {
+        if ((editing && draft !== bodyBaseRef.current) || (olEditing && olDraft !== olBaseRef.current)) {
+          if (!window.confirm(tt("common.dirtyExit"))) return;
+        }
+        onBack();
       }
       function saveBody() {
         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("");
+        // 失败经卡内 bodyErr 呈现（silent 抑制 apiPost 同文 toast）；成功提示仍走 toast。
+        apiPost("chapter-save", { path: wsPath, file: file, body: draft, 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: draft,
+              hash: res && typeof res.hash === "string" ? res.hash : detail.data.hash,
+            }), err: "" });
+            setBodyConflict(false);
+            setEditing(false); setDraft("");
+          }
           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); });
       }
+      // 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;
@@ -1470,33 +1756,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,
@@ -1510,15 +1830,31 @@ window.__ModuleLoader__.load({
               type: "button", className: "myt-btn myt-copyBtn",
               title: tt("reader.copyPathTip"), "aria-label": tt("reader.copyPathTip"),
               onClick: copyChapterPath,
-            }, ic("IconCopyOutlineRegular", 13), tt("reader.copyPath")))),
+            }, ic("IconCopyOutlineRegular", 13), tt("reader.copyPath")),
+            // 删除章节（0.1.20 写面）：服务端不做二次确认，弹层在下方强制；
+            // 删除成功 → 重拉快照 + 退出阅读页回列表（章节已不存在）。
+            h("button", {
+              type: "button", className: "myt-btn myt-btnDanger",
+              title: tt("reader.deleteChapter"), "aria-label": tt("reader.deleteChapter"),
+              onClick: function () { setDelChapterOpen(true); },
+            }, tt("reader.deleteChapter")))),
         h("div", { className: "myt-readerBody" },
           !detail || detail.loading ? h("div", { className: "myt-stack" }, h("div", { className: "myt-skel myt-skelRow" }), h("div", { className: "myt-skel myt-skelRow", style: { width: "80%" } }), h("div", { className: "myt-skel myt-skelRow", style: { width: "64%" } }))
             : detail.err ? h(ErrorStrip, { text: tf("reader.loadFailed", { msg: detail.err }), onRetry: function () { loadDetail(file); } })
               : [
                   (function () {
                     var ol = detail.data && detail.data.outline;
-                    return ol ? h(OutlinePanel, { key: "outline", outline: ol, editor: outlineEditor() })
-                      : h("div", { key: "outline-none", className: "myt-outlineEmpty" }, tt("reader.noOutline"));
+                    return ol ? h(OutlinePanel, { key: "outline", outline: ol, editor: outlineEditor(), onDelete: stemOk ? function () { setDelOutlineOpen(true); } : null })
+                      : [
+                          h("div", { key: "outline-none", className: "myt-outlineEmpty" }, tt("reader.noOutline")),
+                          // 新建章纲（0.1.20 写面）：outlines/<stem>.md 原不存在才走到
+                          // 这里；预填五件内容骨架，建好即重拉详情点亮章纲对照栏。
+                          stemOk ? h("button", {
+                            key: "outline-create", type: "button", className: "myt-btn",
+                            disabled: coBusy, title: tt("reader.createOutline"), "aria-label": tt("reader.createOutline"),
+                            onClick: createOutline,
+                          }, coBusy ? tt("src.creating") : tt("reader.createOutline")) : null,
+                        ];
                   })(),
                   editing
                     ? h("div", { key: "body", className: "myt-bodyEdit" },
@@ -1528,6 +1864,9 @@ window.__ModuleLoader__.load({
                         }),
                         h("div", { className: "myt-editHint" }, tt("reader.bodyEditHint")),
                         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"))))
@@ -1546,7 +1885,29 @@ window.__ModuleLoader__.load({
             return [h("span", { className: "myt-muted", key: "t" }, tt("reader.statusFlow")),
               h("button", { key: "b", type: "button", className: "myt-btn myt-btnPrimary", disabled: flowBusy, onClick: advance },
                 flowBusy ? tt("reader.flowing") : tf("reader.advanceTo", { next: tt("status." + next) }))];
-          })()) : null);
+          })()) : null,
+        delChapterOpen ? h(ConfirmModal, {
+          title: tt("reader.deleteChapter"),
+          text: tf("src.confirmText", { rel: "chapters/" + file }),
+          onCancel: function () { setDelChapterOpen(false); },
+          onConfirm: function () {
+            return apiPost("file-delete", { path: wsPath, rel: "chapters/" + file }).then(function () {
+              setDelChapterOpen(false);
+              return reload().then(onBack); // 章已删：重拉快照后退出阅读页回列表
+            });
+          },
+        }) : null,
+        delOutlineOpen ? h(ConfirmModal, {
+          title: tt("outline.deleteBtn"),
+          text: tf("src.confirmText", { rel: "outlines/" + stem + ".md" }),
+          onCancel: function () { setDelOutlineOpen(false); },
+          onConfirm: function () {
+            return apiPost("file-delete", { path: wsPath, rel: "outlines/" + stem + ".md" }).then(function () {
+              setDelOutlineOpen(false);
+              return reload().then(function () { return loadDetail(file); }); // 章纲栏熄灭、空态亮出
+            });
+          },
+        }) : null);
     }
 
     // ── 书稿元信息编辑表单（概览「编辑」按钮展开）：可视化 project.yml 平
@@ -1600,14 +1961,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;
@@ -1642,6 +2013,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" },
@@ -1698,6 +2070,13 @@ window.__ModuleLoader__.load({
             onClick: function (e) { e.stopPropagation(); ed.start(); },
             onKeyDown: function (e) { if (e.key === "Enter" || e.key === " ") { e.preventDefault(); e.stopPropagation(); ed.start(); } },
           }, ic("IconEditOutlineRegular", 12), tt("reader.edit")) : null,
+          // 删除章纲（0.1.20 写面）：同 head-span 形态；确认弹层由 ChapterReader 渲染。
+          props.onDelete && ed !== null && !ed.active ? h("span", {
+            className: "myt-outlineEditBtn myt-outlineDelBtn", role: "button", tabIndex: 0,
+            title: tt("outline.deleteBtn"), "aria-label": tt("outline.deleteBtn"),
+            onClick: function (e) { e.stopPropagation(); props.onDelete(); },
+            onKeyDown: function (e) { if (e.key === "Enter" || e.key === " ") { e.preventDefault(); e.stopPropagation(); props.onDelete(); } },
+          }, tt("outline.deleteBtn")) : null,
           h("span", { className: "myt-outlineChevron", "aria-hidden": "true" },
             ic(open ? "IconChevronDownOutlineRegular" : "IconChevronRightOutlineRegular", 14))),
         open ? (ed !== null && ed.active
@@ -1708,6 +2087,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"))))
@@ -1764,6 +2146,207 @@ window.__ModuleLoader__.load({
                 : h(MdView, { text: (detail.data && detail.data.body) || tt("outline.empty"), className: "myt-outlineBody" }))));
     }
 
+    // ── 受管文件通用弹层三件套（0.1.20「全量可编辑写面」）────────────────────
+    // 新建实体卡的预填模板（服务端只验形状，内容由客户端模板兜底——spec 各
+    // 文件的最小骨架；数据文件按约定中文书写，不随界面语言切换）。
+    var MANAGED_SLUG_RE = /^[a-z0-9][a-z0-9-]*$/; // 与服务端 managedRelCheck 同一条正则
+    var TPL_CHARACTER = "---\nname: \nrole: supporting\n---\n\n";
+    var TPL_WORLD = "---\ncategory: 地点\n---\n\n";
+    var TPL_SCIENCE = "---\nlabel: known\n---\n\n";
+    function outlineTemplateOf(ch, stem) {
+      var num = ch && ch.num ? ch.num : ((stem.match(/c(\d+)/i) || [])[1] || "?");
+      var title = ch && ch.title ? " " + ch.title : "";
+      return "# 第" + num + "章" + title + " 章纲\n\n- 本章目标：\n- 节拍：\n- 出场角色：\n- 需埋/需收伏笔：\n- 与前章接口：\n";
+    }
+    // 各 tab 复用的「编辑源文件 / 删除文件」小按钮：title 点名文件路径，
+    // 删除走红色按钮（确认弹层由调用方持 state 渲染）。
+    function srcEditBtn(rel, onOpen) {
+      return h("button", {
+        type: "button", className: "myt-btn",
+        title: tf("src.editSourceTip", { rel: rel }), "aria-label": tf("src.editSourceTip", { rel: rel }),
+        onClick: onOpen,
+      }, ic("IconEditOutlineRegular", 13), tt("src.editSource"));
+    }
+    function srcDeleteBtn(rel, onAsk) {
+      return h("button", {
+        type: "button", className: "myt-btn myt-btnDanger",
+        title: tf("src.deleteTip", { rel: rel }), "aria-label": tf("src.deleteTip", { rel: rel }),
+        onClick: onAsk,
+      }, tt("src.deleteFile"));
+    }
+    // 编辑既有受管文件全文。打开即 GET file-source（请求序号防快速开关时的
+    // 过期响应，对照 ChapterReader）；保存 POST file-save 带 base_hash 基线，
+    // 409 = 编辑期间文件被外部改过——草稿绝不丢：保留草稿报冲突，亮两个出口
+    // （放弃草稿载入磁盘版 / 基于磁盘最新版重改），别让用户在过期基线上盲改
+    // 也不许静默覆盖草稿。关闭统一走脏检查，未保存草稿先确认。成功后关弹层
+    // 并触发调用方 reload（快照重算），成功提示走 apiPost 的 toast 通道。
+    function SourceEditorModal(props) {
+      var title = props.title;
+      var rel = props.rel;
+      var wsPath = props.wsPath;
+      var onClose = props.onClose;
+      var onSaved = props.onSaved;
+      var _d = useState(null), detail = _d[0], setDetail = _d[1]; // { data, err }
+      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(""); setConflict(false);
+        apiGet("file-source", { path: wsPath, rel: rel }).then(function (d) {
+          if (seq !== seqRef.current) return;
+          setDetail({ data: d, err: "" });
+          setDraft(d && typeof d.text === "string" ? d.text : "");
+        }).catch(function (e2) {
+          if (seq !== seqRef.current) return;
+          setDetail({ data: null, err: e2 && e2.message ? e2.message : tt("common.unknownErr") });
+        });
+      }, [wsPath, rel]);
+      useEffect(function () { load(); }, [load]);
+      function save() {
+        if (busy || !detail || !detail.data) return;
+        setBusy(true); setErr("");
+        // 失败经卡内 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) {
+            // 草稿绝不丢：报冲突并亮两个出口（见顶部注释），不再静默 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) 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: 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")),
+            !detail ? h("div", { className: "myt-muted" }, tt("src.loading"))
+              : detail.err ? h(ErrorStrip, { text: tf("src.loadFailed", { msg: detail.err }), onRetry: 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: close }, tt("novel.cancel")),
+                      h("button", { type: "button", className: "myt-btn myt-btnPrimary", disabled: busy, onClick: save }, busy ? tt("novel.saving") : tt("novel.save"))),
+                  ])));
+    }
+    // 新建受管 md 实体卡（角色/设定/科学设定共用）：slug 客户端预校（与服务
+    // 端同一条正则，错在敲键时就报），内容按模板预填可改；失败（409 已存在等）
+    // 留在弹层内报错，草稿不丢——建卡是低频操作，丢一遍模板重填太伤。
+    function CreateFileModal(props) {
+      var title = props.title;
+      var dir = props.dir;
+      var template = props.template;
+      var wsPath = props.wsPath;
+      var onClose = props.onClose;
+      var onSaved = props.onSaved;
+      var _s = useState(""), slug = _s[0], setSlug = _s[1];
+      var _t = useState(template), text = _t[0], setText = _t[1];
+      var _b = useState(false), busy = _b[0], setBusy = _b[1];
+      var _e = useState(""), err = _e[0], setErr = _e[1];
+      var slugOk = MANAGED_SLUG_RE.test(slug);
+      function create() {
+        if (busy) return;
+        if (!slugOk) { setErr(tt("src.slugInvalid")); return; }
+        setBusy(true); setErr("");
+        // 失败经卡内 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")); })
+          .finally(function () { setBusy(false); });
+      }
+      return h(MaskPortal, {
+          className: "myt-modalMask",
+          onMouseDown: function (e) { if (e.target === e.currentTarget && !busy) onClose(); },
+        },
+        h("div", { className: "myt-modalCard", role: "dialog", "aria-modal": "true", "aria-label": title },
+          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("div", { className: "myt-modalBody" },
+            h("label", { className: "myt-setField" },
+              h("span", { className: "myt-setFieldLabel" }, tt("src.slugLabel")),
+              h("input", { type: "text", className: "myt-setInput", placeholder: tt("src.slugPh"), value: slug, spellCheck: false,
+                onChange: function (e) { setSlug(e.target.value); setErr(""); } })),
+            h("div", { className: "myt-muted myt-srcHint" }, tt("src.createHint")),
+            h("textarea", { className: "myt-setInput myt-setArea myt-srcArea", rows: 10, spellCheck: false,
+              value: text, onChange: function (e) { setText(e.target.value); } }),
+            err ? h(ErrorStrip, { text: err }) : null,
+            h("div", { className: "myt-setActions" },
+              h("button", { type: "button", className: "myt-btn", disabled: busy, onClick: onClose }, tt("novel.cancel")),
+              h("button", { type: "button", className: "myt-btn myt-btnPrimary", disabled: busy || slug === "", onClick: create }, busy ? tt("src.creating") : tt("src.create"))))));
+    }
+    // 删除二次确认（服务端不做二次确认，UI 层强制——删除不可逆，文案点名后
+    // 悔靠 git、check 会标孤儿引用）。onConfirm 返回 promise，在途禁双击；
+    // 成败提示走 apiPost 的 toast 通道。
+    function ConfirmModal(props) {
+      var title = props.title;
+      var text = props.text;
+      var onCancel = props.onCancel;
+      var onConfirm = props.onConfirm;
+      var _b = useState(false), busy = _b[0], setBusy = _b[1];
+      function confirm() {
+        if (busy) return;
+        setBusy(true);
+        Promise.resolve(onConfirm()).catch(function () {}).finally(function () { setBusy(false); });
+      }
+      return h(MaskPortal, {
+          className: "myt-modalMask",
+          onMouseDown: function (e) { if (e.target === e.currentTarget && !busy) onCancel(); },
+        },
+        h("div", { className: "myt-modalCard myt-confirmCard", role: "alertdialog", "aria-modal": "true", "aria-label": title },
+          h("div", { className: "myt-modalHead" },
+            h("h2", { className: "myt-modalTitle" }, title),
+            h("button", { type: "button", className: "myt-closeBtn", "aria-label": tt("src.closeAria"), disabled: busy, onClick: onCancel }, h("span", { className: "myt-closeGlyph", "aria-hidden": "true" }, "×"))),
+          h("div", { className: "myt-modalBody" },
+            h("div", { className: "myt-confirmText" }, text),
+            h("div", { className: "myt-setActions" },
+              h("button", { type: "button", className: "myt-btn", disabled: busy, onClick: onCancel }, tt("novel.cancel")),
+              h("button", { type: "button", className: "myt-btn myt-btnDanger", disabled: busy, onClick: confirm }, busy ? tt("src.deleting") : tt("src.confirmDelete"))))));
+    }
+
     function ChaptersTab(props) {
       var snap = props.snap;
       var wsPath = props.wsPath;
@@ -1885,10 +2468,20 @@ window.__ModuleLoader__.load({
     ];
     function CharactersTab(props) {
       var characters = props.snap.characters || [];
+      var wsPath = props.wsPath;
+      var reload = props.reload;
       var _m = useState(null), modalFile = _m[0], setModalFile = _m[1];
+      // 受管文件三态：编辑 rel / 新建弹层开关 / 删除确认 rel（0.1.20 写面）。
+      var _src = useState(null), srcRel = _src[0], setSrcRel = _src[1];
+      var _new = useState(false), createOpen = _new[0], setCreateOpen = _new[1];
+      var _del = useState(null), delRel = _del[0], setDelRel = _del[1];
       var modal = null;
       for (var i = 0; i < characters.length; i++) { if (characters[i].file === modalFile) { modal = characters[i]; break; } }
       return h("div", { className: "myt-stack" },
+        h("div", { className: "myt-cardHead" },
+          h("h3", { className: "myt-cardTitle" }, tt("tabs.characters")),
+          h("span", { className: "myt-boardCount" }, characters.length),
+          h("button", { type: "button", className: "myt-btn", onClick: function () { setCreateOpen(true); } }, tt("char.createBtn"))),
         characters.length ? h("div", { className: "myt-charWall" }, characters.map(function (c) {
           return h("button", { key: c.file, type: "button", className: "myt-card myt-charCard", onClick: function () { setModalFile(c.file); } },
             h("div", { className: "myt-charHead" },
@@ -1923,7 +2516,27 @@ window.__ModuleLoader__.load({
                     : "—")),
               h("div", { className: "myt-kvRow" },
                 h("span", { className: "myt-kvKey" }, tt("char.file")),
-                h("span", { className: "myt-kvVal" }, modal.file || "—"))))) : null);
+                h("span", { className: "myt-kvVal" }, modal.file || "—")),
+              // 源文件直达（0.1.20 写面）：rel 由快照 basename 拼目录前缀。
+              h("div", { className: "myt-setActions" },
+                h("button", { type: "button", className: "myt-btn", onClick: function () { setSrcRel("characters/" + modal.file); } },
+                  ic("IconEditOutlineRegular", 13), tt("src.editSource")),
+                h("button", { type: "button", className: "myt-btn myt-btnDanger", onClick: function () { setDelRel("characters/" + modal.file); } },
+                  tt("src.deleteFile")))))) : null,
+        srcRel ? h(SourceEditorModal, { title: tt("src.editSource"), rel: srcRel, wsPath: wsPath, onClose: function () { setSrcRel(null); }, onSaved: reload }) : null,
+        createOpen ? h(CreateFileModal, { title: tt("char.createBtn"), dir: "characters", template: TPL_CHARACTER, wsPath: wsPath, onClose: function () { setCreateOpen(false); }, onSaved: reload }) : null,
+        delRel ? h(ConfirmModal, {
+          title: tf("src.deleteTip", { rel: delRel }),
+          text: tf("src.confirmText", { rel: delRel }),
+          onCancel: function () { setDelRel(null); },
+          onConfirm: function () {
+            return apiPost("file-delete", { path: wsPath, rel: delRel }).then(function () {
+              setDelRel(null);
+              if (modalFile && "characters/" + modalFile === delRel) setModalFile(null); // 删的是打开中的卡：详情弹层一并收
+              return reload();
+            });
+          },
+        }) : null);
     }
 
     // ── 伏笔 tab：四列看板（列头计数 + 推进按钮 + priority 色点）────────────
@@ -1939,14 +2552,19 @@ window.__ModuleLoader__.load({
           .then(reload).catch(function () {}).finally(function () { setBusyId(null); });
       }
       var list = snap.foreshadows || [];
+      // 伏笔台账源文件直达（0.1.20 写面）：foreshadows.yml 整文件可编辑。
+      var _src = useState(null), srcRel = _src[0], setSrcRel = _src[1];
       return h("div", { className: "myt-stack" },
+        h("div", { className: "myt-cardHead" },
+          h("h3", { className: "myt-cardTitle" }, tt("tabs.foreshadows")),
+          srcEditBtn("foreshadows.yml", function () { setSrcRel("foreshadows.yml"); })),
         list.length ? h("div", { className: "myt-board" }, FS_ORDER.map(function (col) {
           var items = list.filter(function (f) { return (f.status || "planted") === col; });
           return h("div", { key: col, className: "myt-boardCol" },
             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）：禁用流
@@ -1957,7 +2575,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)),
                   // 回填徽章（五期账本回填）：区别于写前规划条目，悬浮见来源。
@@ -1973,17 +2592,33 @@ window.__ModuleLoader__.load({
                     ? h("button", { type: "button", className: "myt-btn myt-btnDanger", disabled: busy || noWrite, title: noWriteTip, onClick: function () { setStatus(fs, "abandoned"); } }, tt("foreshadow.abandon")) : null));
             }),
             items.length ? null : h("div", { className: "myt-muted" }, tt("foreshadow.colEmpty")));
-        })) : h(Empty, { text: tt("foreshadow.empty") }));
+        })) : h(Empty, { text: tt("foreshadow.empty") }),
+        srcRel ? h(SourceEditorModal, { title: tt("src.editSource"), rel: srcRel, wsPath: wsPath, onClose: function () { setSrcRel(null); }, onSaved: reload }) : null);
     }
 
     // ── 时间线 tab：垂直轴 + importance 点位（1-5 → 大小/深浅）──────────────
     function TimelineTab(props) {
       var items = (props.snap.timeline || []).slice();
+      var wsPath = props.wsPath;
+      var reload = props.reload;
+      // 时间线账本源文件直达（0.1.20 写面）：空态也保留入口——账本空不等于
+      // 不可编辑，恰恰是第一条要从这里写进去。
+      var _src = useState(null), srcRel = _src[0], setSrcRel = _src[1];
+      var head = h("div", { className: "myt-cardHead" },
+        h("h3", { className: "myt-cardTitle" }, tt("tabs.timeline")),
+        srcEditBtn("timeline.yml", function () { setSrcRel("timeline.yml"); }));
       if (items.length) {
         items.sort(function (a, b) { return String(a.year || "").localeCompare(String(b.year || ""), "zh-CN", { numeric: true }); });
       }
-      if (!items.length) return h(Empty, { text: tt("timeline.empty") });
-      return h("div", { className: "myt-card" },
+      if (!items.length) {
+        return h("div", { className: "myt-stack" },
+          head,
+          h(Empty, { text: tt("timeline.empty") }),
+          srcRel ? h(SourceEditorModal, { title: tt("src.editSource"), rel: srcRel, wsPath: wsPath, onClose: function () { setSrcRel(null); }, onSaved: reload }) : null);
+      }
+      return h("div", { className: "myt-stack" },
+        head,
+        h("div", { className: "myt-card" },
         h("div", { className: "myt-timeline" }, items.map(function (t, i) {
           var imp = Math.min(5, Math.max(1, typeof t.importance === "number" ? t.importance : 3));
           return h("div", { key: i, className: "myt-tlRow" },
@@ -1993,7 +2628,8 @@ window.__ModuleLoader__.load({
               h("div", { className: "myt-tlTitle" }, orDash(t.title)),
               t.description ? h("div", { className: "myt-tlDesc" }, t.description) : null,
               t.chapter ? h("div", { className: "myt-tlChapter" }, tf("timeline.linkedChapter", { ch: t.chapter })) : null));
-        })));
+        }))),
+        srcRel ? h(SourceEditorModal, { title: tt("src.editSource"), rel: srcRel, wsPath: wsPath, onClose: function () { setSrcRel(null); }, onSaved: reload }) : null);
     }
 
     // ── 设定 tab：world 按 category 分组 + science 三色标签 ─────────────────
@@ -2001,8 +2637,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}
@@ -2013,6 +2649,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);
@@ -2025,8 +2663,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);
@@ -2039,7 +2677,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]);
@@ -2057,30 +2695,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")),
@@ -2115,6 +2785,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 },
@@ -2141,9 +2814,16 @@ window.__ModuleLoader__.load({
 
     function WorldTab(props) {
       var snap = props.snap;
+      var wsPath = props.wsPath;
+      var reload = props.reload;
       var world = snap.world || [];
       var science = snap.science || [];
       var research = snap.research || [];
+      // 受管文件三态：编辑 rel / 新建分区（world|science）/ 删除确认 rel。
+      // research 是调研笔记目录，v1 无面板入口（快照有卡，写面暂不开放）。
+      var _src = useState(null), srcRel = _src[0], setSrcRel = _src[1];
+      var _new = useState(null), createDir = _new[0], setCreateDir = _new[1];
+      var _del = useState(null), delRel = _del[0], setDelRel = _del[1];
       // 无原型容器：key 来自数据文件的自由文本（category），值为
       // constructor/__proto__/toString 等时若用普通 {} 会命中 Object.prototype
       // 真值 → TypeError → 整面板白屏；Object.create(null) 杜绝。
@@ -2158,11 +2838,16 @@ window.__ModuleLoader__.load({
       // state 存在本组件（切走再切回不丢；卡头 h3 随卡一起只画激活分区）。
       // research 空时原实现整卡隐藏，现 tab 恒在、空态走 world.researchEmpty。
       var _st = useState("world"), subTab = _st[0], setSubTab = _st[1];
+      // world 分区内的二级分类 tab：state 只存用户上次的偏好，快照重拉后该
+      // 分类可能已不存在（条目被删/改名），此时回落第一个分类；null = 首选
+      // 第一个。单分类时不出 tab 条、直接平铺。
+      var _cat = useState(null), catPref = _cat[0], setCatPref = _cat[1];
       var subDefs = [
         ["world", tt("world.title"), world.length],
         ["science", tt("world.science"), science.length],
         ["research", tt("world.research"), research.length],
       ];
+      var activeCat = catPref !== null && groupKeys.indexOf(catPref) !== -1 ? catPref : groupKeys[0];
       return h("div", { className: "myt-stack" },
         h("nav", { className: "myt-subTabs", "aria-label": tt("world.subTabsAria") },
           subDefs.map(function (s) {
@@ -2172,21 +2857,32 @@ window.__ModuleLoader__.load({
             }, s[1], h("span", { className: "myt-boardCount" }, String(s[2])));
           })),
         subTab === "world" ? h("div", { className: "myt-card" },
-          h("div", { className: "myt-cardHead" }, h("h3", { className: "myt-cardTitle" }, tt("world.title"))),
-          groupKeys.length ? h("div", { className: "myt-stack" }, groupKeys.map(function (key) {
-            return h("div", { key: key, className: "myt-worldGroup" },
-              h("div", { className: "myt-listHead" }, key, h("span", { className: "myt-boardCount" }, groups[key].length)),
-              groups[key].map(function (w, i) {
-                return h("div", { key: w.file || i, className: "myt-worldItem" },
-                  h("div", { className: "myt-worldHead" },
-                    h("span", { className: "myt-worldName" }, orDash(w.name)),
-                    (w.tags || []).length ? h("span", { className: "myt-tagRow" }, w.tags.map(function (t, j) { return h("span", { key: j, className: "myt-tag" }, t); })) : null),
-                  w.description ? h(MdView, { text: w.description, className: "myt-worldDesc" }) : null);
-              }));
+          h("div", { className: "myt-cardHead" },
+            h("h3", { className: "myt-cardTitle" }, tt("world.title")),
+            h("button", { type: "button", className: "myt-btn", onClick: function () { setCreateDir("world"); } }, tt("world.createBtn"))),
+          // 多分类：二级子 tab 条（分类名 + 条目计数），分组头不再需要——tab
+          // 已承载分类名与计数；单分类/无分类不出 tab 条直接平铺。
+          groupKeys.length > 1 ? h("nav", { className: "myt-subTabs myt-subTabsInner", "aria-label": tt("world.catTabsAria") },
+            groupKeys.map(function (key) {
+              return h("button", {
+                key: key, type: "button", className: "myt-subTab", "data-active": activeCat === key ? "true" : undefined,
+                onClick: function () { setCatPref(key); },
+              }, key, h("span", { className: "myt-boardCount" }, String(groups[key].length)));
+            })) : null,
+          groupKeys.length ? h("div", { className: "myt-stack" }, groups[activeCat].map(function (w, i) {
+            return h("div", { key: w.file || i, className: "myt-worldItem" },
+              h("div", { className: "myt-worldHead" },
+                h("span", { className: "myt-worldName" }, orDash(w.name)),
+                (w.tags || []).length ? h("span", { className: "myt-tagRow" }, w.tags.map(function (t, j) { return h("span", { key: j, className: "myt-tag" }, t); })) : null),
+              w.description ? h(MdView, { text: w.description, className: "myt-worldDesc" }) : null,
+              h("div", { className: "myt-itemActions" },
+                srcEditBtn("world/" + w.file, function () { setSrcRel("world/" + w.file); }),
+                srcDeleteBtn("world/" + w.file, function () { setDelRel("world/" + w.file); })));
           })) : h(Empty, { text: tt("world.empty") })) : null,
         subTab === "science" ? h("div", { className: "myt-card" },
           h("div", { className: "myt-cardHead" }, h("h3", { className: "myt-cardTitle" }, tt("world.science")),
-            h("span", { className: "myt-boardCount" }, science.length)),
+            h("span", { className: "myt-boardCount" }, science.length),
+            h("button", { type: "button", className: "myt-btn", onClick: function () { setCreateDir("science"); } }, tt("world.createScienceBtn"))),
           science.length ? h("div", { className: "myt-stack" }, science.map(function (s, i) {
             var label = ["known", "extrapolation", "hypothesis"].indexOf(s.label) !== -1 ? s.label : null;
             return h("div", { key: s.file || i, className: "myt-worldItem" },
@@ -2196,7 +2892,10 @@ window.__ModuleLoader__.load({
                   label ? tt("sci." + label) : (s.label || tt("world.unlabeled")))),
               s.description ? h(MdView, { text: s.description, className: "myt-worldDesc" }) : null,
               (s.references || []).length ? h("div", { className: "myt-refList" },
-                s.references.map(function (r, j) { return h("span", { key: j, className: "myt-refItem" }, tf("world.ref", { n: j + 1, r: r })); })) : null);
+                s.references.map(function (r, j) { return h("span", { key: j, className: "myt-refItem" }, tf("world.ref", { n: j + 1, r: r })); })) : null,
+              h("div", { className: "myt-itemActions" },
+                srcEditBtn("science/" + s.file, function () { setSrcRel("science/" + s.file); }),
+                srcDeleteBtn("science/" + s.file, function () { setDelRel("science/" + s.file); })));
           })) : h(Empty, { text: tt("world.scienceEmpty") })) : null,
         subTab === "research" ? h("div", { className: "myt-card" },
           h("div", { className: "myt-cardHead" }, h("h3", { className: "myt-cardTitle" }, tt("world.research")),
@@ -2208,7 +2907,25 @@ window.__ModuleLoader__.load({
               r.description ? h(MdView, { text: r.description, className: "myt-worldDesc" }) : null,
               (r.sources || []).length ? h("div", { className: "myt-refList" },
                 r.sources.map(function (s, j) { return h("span", { key: j, className: "myt-refItem", title: s }, tf("world.ref", { n: j + 1, r: s })); })) : null);
-          })) : h(Empty, { text: tt("world.researchEmpty") })) : null);
+          })) : h(Empty, { text: tt("world.researchEmpty") })) : null,
+        srcRel ? h(SourceEditorModal, { title: tt("src.editSource"), rel: srcRel, wsPath: wsPath, onClose: function () { setSrcRel(null); }, onSaved: reload }) : null,
+        createDir ? h(CreateFileModal, {
+          title: createDir === "science" ? tt("world.createScienceBtn") : tt("world.createBtn"),
+          dir: createDir,
+          template: createDir === "science" ? TPL_SCIENCE : TPL_WORLD,
+          wsPath: wsPath, onClose: function () { setCreateDir(null); }, onSaved: reload,
+        }) : null,
+        delRel ? h(ConfirmModal, {
+          title: tf("src.deleteTip", { rel: delRel }),
+          text: tf("src.confirmText", { rel: delRel }),
+          onCancel: function () { setDelRel(null); },
+          onConfirm: function () {
+            return apiPost("file-delete", { path: wsPath, rel: delRel }).then(function () {
+              setDelRel(null);
+              return reload();
+            });
+          },
+        }) : null);
     }
 
     // ── 索引板 tab：clues 按 kind 分组（resolved 划线）+ memories 按 category
@@ -2239,6 +2956,8 @@ window.__ModuleLoader__.load({
         memGroups[key].push(m);
       });
       function groupKey(a, b) { return a.localeCompare(b, "zh-CN"); }
+      // 两本索引账源文件直达（0.1.20 写面）：clue-board.yml / memories.yml。
+      var _src = useState(null), srcRel = _src[0], setSrcRel = _src[1];
       return h("div", { className: "myt-stack" },
         h("div", { className: "myt-cardHead" },
           h("h3", { className: "myt-cardTitle" }, tt("index.title")),
@@ -2246,7 +2965,8 @@ window.__ModuleLoader__.load({
             rebuildBusy ? tt("index.rebuilding") : tt("index.rebuild"))),
         h("div", { className: "myt-indexCols" },
           h("div", { className: "myt-card" },
-            h("div", { className: "myt-cardHead" }, h("h3", { className: "myt-cardTitle" }, tt("index.clueBoard")), h("span", { className: "myt-boardCount" }, clues.length)),
+            h("div", { className: "myt-cardHead" }, h("h3", { className: "myt-cardTitle" }, tt("index.clueBoard")), h("span", { className: "myt-boardCount" }, clues.length),
+              srcEditBtn("clue-board.yml", function () { setSrcRel("clue-board.yml"); })),
             clues.length ? Object.keys(clueGroups).sort(groupKey).map(function (kind) {
               var ck = CLUE_KIND_KEYS[kind];
               var label = ck ? tt("clue." + ck) : kind;
@@ -2259,7 +2979,8 @@ window.__ModuleLoader__.load({
                 }));
             }) : h(Empty, { text: tt("index.clueEmpty") })),
           h("div", { className: "myt-card" },
-            h("div", { className: "myt-cardHead" }, h("h3", { className: "myt-cardTitle" }, tt("index.memBoard")), h("span", { className: "myt-boardCount" }, memories.length)),
+            h("div", { className: "myt-cardHead" }, h("h3", { className: "myt-cardTitle" }, tt("index.memBoard")), h("span", { className: "myt-boardCount" }, memories.length),
+              srcEditBtn("memories.yml", function () { setSrcRel("memories.yml"); })),
             memories.length ? Object.keys(memGroups).sort(groupKey).map(function (cat) {
               var isPromise = /promise|承诺/i.test(cat);
               return h("div", { key: cat, className: "myt-worldGroup" },
@@ -2271,13 +2992,18 @@ window.__ModuleLoader__.load({
                     h("span", { className: "myt-clueText" }, orDash(m.content)),
                     m.source_chapter ? h("span", { className: "myt-memChapter" }, m.source_chapter) : null);
                 }));
-            }) : h(Empty, { text: tt("index.memEmpty") }))));
+            }) : h(Empty, { text: tt("index.memEmpty") }))),
+        srcRel ? h(SourceEditorModal, { title: tt("src.editSource"), rel: srcRel, wsPath: wsPath, onClose: function () { setSrcRel(null); }, onSaved: reload }) : null);
     }
 
-    // ── 关系图 tab：canvas 力导向（斥力 + 弹簧 + 中心引力，rAF 循环）─────────
-    // 节点固定 18px、名字 label 下方；边宽 = intensity 1-5 → 1-4px（缺省 3），
-    // type 标在边中点、hover 显示 description；拖拽固定、滚轮缩放、双击复位；
-    // 角色多于 30 个时只画 relations 相关节点，其余进「未入图」。
+    // ── 关系图 tab：canvas 力导向（斥力 + 弹簧 + 中心引力 + 硬碰撞分离，rAF 循环）─
+    // 节点固定 18px、名字 label 下方，最小间距 62 位置级互推保证静止帧不压叠；
+    // 边为二次曲线（绕开途中节点、重复边互相分开），type 标在曲线 t=0.5 点、
+    // hover 显示 description（命中检测按曲线几何采样）；拖拽固定、滚轮缩放、
+    // 双击复位；角色多于 30 个时只画 relations 相关节点，其余进「未入图」。
+    // 关系图节点角色配色：主角红 / 配角蓝 / 反派黑 / 龙套黄（用户指定四色）；
+    // 越枚举/缺省 role 一律并入龙套黄（查表 miss 落 minor），全节点恒有色。
+    var NODE_ROLE_COLORS = { protagonist: "#f53f3f", supporting: "#165dff", antagonist: "#1d2129", minor: "#fadc19" };
     function edgeWidth(intensity) {
       var n = typeof intensity === "number" && isFinite(intensity) ? Math.round(intensity) : 3;
       n = Math.min(5, Math.max(1, n));
@@ -2285,6 +3011,10 @@ window.__ModuleLoader__.load({
     }
     function RelationsTab(props) {
       var snap = props.snap;
+      var wsPath = props.wsPath;
+      var reload = props.reload;
+      // 关系账本源文件直达（0.1.20 写面）：relations.yml 整文件可编辑。
+      var _src = useState(null), srcRel = _src[0], setSrcRel = _src[1];
       var chars = snap.characters || [];
       var rels = (snap.relations || []).filter(function (r) { return r && r.a && r.b && r.a !== r.b; });
       var _tip = useState(null), tip = _tip[0], setTip = _tip[1]; // {x, y, text}
@@ -2311,6 +3041,14 @@ window.__ModuleLoader__.load({
         nodes.forEach(function (nd, i) { idx[nd.id] = i; });
         var edges = rels.filter(function (r) { return idx[r.a] !== undefined && idx[r.b] !== undefined; })
           .map(function (r) { return { a: idx[r.a], b: idx[r.b], type: r.type || "", desc: r.description || "", w: edgeWidth(r.intensity) }; });
+        // 同一对节点的重复边编号：dup = 按 (a,b) 无序对分组后的组内序号（0 起）。
+        // draw 的 edgeCtrl 按 dup 放大曲线偏移并交替朝向，重复边互相分开不重合。
+        var dupCount = Object.create(null);
+        edges.forEach(function (e) {
+          var key = Math.min(e.a, e.b) + "-" + Math.max(e.a, e.b);
+          e.dup = dupCount[key] || 0;
+          dupCount[key] = e.dup + 1;
+        });
         return { nodes: nodes, edges: edges, unlinked: unlinked };
       }, [snap]); // chars/rels 均由 snap 派生，snap 不变则图不变
       useEffect(function () {
@@ -2320,10 +3058,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() {
@@ -2342,6 +3089,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);
@@ -2352,7 +3100,50 @@ window.__ModuleLoader__.load({
           nd.vx = nd.vy = 0;
         });
         function toWorld(sx, sy) { return { x: (sx - sim.w / 2) / sim.zoom, y: (sy - sim.h / 2) / sim.zoom }; }
-        function toScreen(x, y) { return { x: sim.w / 2 + x * sim.zoom, y: sim.h / 2 + y * sim.zoom }; }
+        // 每条边的二次贝塞尔控制点：bow 大小随边长缩放、钳 [12,28] 世界像素；
+        // side ∈ {-1,+1} 曲线朝向（挂边对象上帧间保留，做迟滞防抖）；同一对
+        // 节点的重复边按 dup 序号放大偏移并交替朝向，互相分开不重合。
+        function edgeCtrl(e) {
+          var a = graph.nodes[e.a], b = graph.nodes[e.b];
+          var dx = b.x - a.x, dy = b.y - a.y;
+          var len = Math.sqrt(dx * dx + dy * dy) || 1;
+          var ux = -dy / len, uy = dx / len; // 单位法向
+          var mag = Math.min(28, Math.max(12, len * 0.1));
+          var k = e.dup || 0;
+          var m = mag * (1 + 0.6 * k);
+          var side = (e.side || 1) * (k % 2 ? -1 : 1);
+          return { cx: (a.x + b.x) / 2 + ux * m * side, cy: (a.y + b.y) / 2 + uy * m * side };
+        }
+        // 曲线（A、C、B 三点二次贝塞尔）采样 9 个点到各无关节点（跳过两端）
+        // 的最小距离：值越大说明这一侧越空旷。
+        function clearance(e, cx, cy) {
+          var a = graph.nodes[e.a], b = graph.nodes[e.b];
+          var best = 999;
+          for (var t = 1; t <= 9; t++) {
+            var tt = t / 10, it = 1 - tt;
+            var px = it * it * a.x + 2 * it * tt * cx + tt * tt * b.x;
+            var py = it * it * a.y + 2 * it * tt * cy + tt * tt * b.y;
+            for (var ni = 0; ni < graph.nodes.length; ni++) {
+              if (ni === e.a || ni === e.b) continue;
+              var nd = graph.nodes[ni];
+              var ddx = px - nd.x, ddy = py - nd.y;
+              var d = Math.sqrt(ddx * ddx + ddy * ddy);
+              if (d < best) best = d;
+            }
+          }
+          return best;
+        }
+        // 朝向迟滞更新：算当前侧与取反侧的 clearance，只有另一侧明显更空
+        // （+12 世界像素）才翻转——力导向抖动时曲线不左右闪。
+        function updateSide(e) {
+          var side = e.side || 1;
+          var c1 = edgeCtrl(e);
+          var cur = clearance(e, c1.cx, c1.cy);
+          e.side = -side;
+          var c2 = edgeCtrl(e);
+          var alt = clearance(e, c2.cx, c2.cy);
+          if (alt <= cur + 12) e.side = side; // 另一侧不明显更空：保持原朝向
+        }
         function hitNode(sx, sy) {
           var p = toWorld(sx, sy);
           for (var i = graph.nodes.length - 1; i >= 0; i--) {
@@ -2366,18 +3157,30 @@ window.__ModuleLoader__.load({
           var p = toWorld(sx, sy);
           var best = null, bestD = 10;
           graph.edges.forEach(function (e) {
+            // 命中跟曲线走：二次贝塞尔采样 9 段（10 点含两端），点到各线段
+            // 距离取最小；edgeCtrl 与 draw 同源（side 存边对象上，天然一致）。
             var a = graph.nodes[e.a], b = graph.nodes[e.b];
-            var ax = a.x, ay = a.y, bx = b.x - a.x, by = b.y - a.y;
-            var len2 = bx * bx + by * by || 1;
-            var t = Math.min(1, Math.max(0, ((p.x - ax) * bx + (p.y - ay) * by) / len2));
-            var dx = p.x - (ax + bx * t), dy = p.y - (ay + by * t);
-            var d = Math.sqrt(dx * dx + dy * dy);
-            if (d < bestD) { bestD = d; best = e; }
+            var c = edgeCtrl(e);
+            var qx = a.x, qy = a.y; // 上一采样点，首点 = 端点 A
+            for (var k = 1; k <= 9; k++) {
+              var tt = k / 9, it = 1 - tt;
+              var nx = it * it * a.x + 2 * it * tt * c.cx + tt * tt * b.x;
+              var ny = it * it * a.y + 2 * it * tt * c.cy + tt * tt * b.y;
+              var segx = nx - qx, segy = ny - qy;
+              var len2 = segx * segx + segy * segy || 1;
+              var u = Math.min(1, Math.max(0, ((p.x - qx) * segx + (p.y - qy) * segy) / len2));
+              var dx = p.x - (qx + segx * u), dy = p.y - (qy + segy * u);
+              var d = Math.sqrt(dx * dx + dy * dy);
+              if (d < bestD) { bestD = d; best = e; }
+              qx = nx; qy = ny;
+            }
           });
           return best;
         }
         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];
@@ -2394,7 +3197,7 @@ window.__ModuleLoader__.load({
             var a = nodes[e.a], b = nodes[e.b];
             var dx = b.x - a.x, dy = b.y - a.y;
             var d = Math.sqrt(dx * dx + dy * dy) || 1;
-            var f = (d - 120) * 0.02; // 弹簧，rest 120
+            var f = (d - 130) * 0.02; // 弹簧，rest 130（原 120，多留缝隙配合硬碰撞分离）
             var fx = (dx / d) * f, fy = (dy / d) * f;
             a.vx += fx; a.vy += fy; b.vx -= fx; b.vy -= fy;
           });
@@ -2405,7 +3208,37 @@ 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 纵向净空）
+          // 做位置级互推，保证静止帧节点（含下方 label）不重叠。固定节点
+          // （fixed 或正在拖拽）不动、推对方，双固定跳过；位移不写回速度——
+          // 纯位置修正，靠阻尼自然收敛，不与力导向抢劲。两轮 pass 处理推挤
+          // 连锁（A 推开 B 后 B 又压到 C）。
+          var MIN_DIST = 62;
+          for (var pass = 0; pass < 2; pass++) {
+            for (var ci = 0; ci < n; ci++) {
+              for (var cj = ci + 1; cj < n; cj++) {
+                var na = nodes[ci], nb = nodes[cj];
+                var cdx = nb.x - na.x, cdy = nb.y - na.y;
+                var cd2 = cdx * cdx + cdy * cdy;
+                if (cd2 >= MIN_DIST * MIN_DIST) continue;
+                var cd = Math.sqrt(cd2);
+                if (cd < 0.01) { cdx = 1; cdy = 0; cd = 1; } // 完全重合：任意方向分开
+                var push = (MIN_DIST - cd) / cd; // 归一化差向量：差多少补多少
+                var aFixed = na.fixed || na === (sim.drag && sim.drag.node);
+                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();
@@ -2417,29 +3250,30 @@ window.__ModuleLoader__.load({
           ctx.scale(sim.zoom, sim.zoom);
           graph.edges.forEach(function (e) {
             var a = graph.nodes[e.a], b = graph.nodes[e.b];
+            updateSide(e); // 朝向迟滞：另一侧明显更空才翻，防抖（详见 updateSide）
+            var c = edgeCtrl(e);
             ctx.strokeStyle = tk.line;
             ctx.globalAlpha = 0.8;
             ctx.lineWidth = e.w;
-            ctx.beginPath(); ctx.moveTo(a.x, a.y); ctx.lineTo(b.x, b.y); ctx.stroke();
+            ctx.beginPath(); ctx.moveTo(a.x, a.y); ctx.quadraticCurveTo(c.cx, c.cy, b.x, b.y); ctx.stroke();
             if (e.type && sim.zoom >= 0.7) {
               ctx.globalAlpha = 1;
               ctx.fillStyle = tk.faint;
               ctx.font = "10px sans-serif";
               ctx.textAlign = "center";
-              ctx.fillText(e.type, (a.x + b.x) / 2, (a.y + b.y) / 2 - 3);
+              // type 标在曲线 t=0.5 点（二次贝塞尔中点），与曲线本体一致
+              ctx.fillText(e.type, 0.25 * a.x + 0.5 * c.cx + 0.25 * b.x, 0.25 * a.y + 0.5 * c.cy + 0.25 * b.y - 3);
             }
           });
           ctx.globalAlpha = 1;
           graph.nodes.forEach(function (nd) {
-            var s = toScreen(nd.x, nd.y);
             var r = 18; // 世界坐标画：半径随 zoom 缩放
+            var rc = NODE_ROLE_COLORS[nd.role] || NODE_ROLE_COLORS.minor;
             ctx.beginPath();
             ctx.arc(nd.x, nd.y, r, 0, Math.PI * 2);
-            ctx.fillStyle = nd.fixed ? tk.accent : tk.card;
-            ctx.globalAlpha = nd.fixed ? 0.25 : 1;
+            ctx.fillStyle = rc;
             ctx.fill();
-            ctx.globalAlpha = 1;
-            ctx.lineWidth = 1.5;
+            ctx.lineWidth = nd.fixed ? 3 : 1.5; // 固定态=加粗 accent 描边（全节点恒有色后的唯一固定指示）
             ctx.strokeStyle = tk.accent;
             ctx.stroke();
             ctx.fillStyle = tk.label;
@@ -2450,9 +3284,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();
@@ -2470,6 +3321,7 @@ window.__ModuleLoader__.load({
             sim.drag = { node: nd };
             nd.fixed = true; // 拖拽固定
             canvas.dataset.dragging = "true";
+            wake(); // 拖拽移动物理系统，停机态先唤醒
             e.preventDefault();
           }
         }
@@ -2498,11 +3350,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);
@@ -2559,12 +3413,20 @@ window.__ModuleLoader__.load({
           }
         } catch (e) { /* 全屏 API 个别浏览器仍有策略性拒绝，静默 */ }
       }
-      if (!graph.nodes.length) return h(Empty, { text: tt("relations.noData") });
+      if (!graph.nodes.length) {
+        return h("div", { className: "myt-stack" },
+          h("div", { className: "myt-cardHead" },
+            h("h3", { className: "myt-cardTitle" }, tt("relations.title")),
+            srcEditBtn("relations.yml", function () { setSrcRel("relations.yml"); })),
+          h(Empty, { text: tt("relations.noData") }),
+          srcRel ? h(SourceEditorModal, { title: tt("src.editSource"), rel: srcRel, wsPath: wsPath, onClose: function () { setSrcRel(null); }, onSaved: reload }) : null);
+      }
       return h("div", { className: "myt-stack" },
         h("div", { className: "myt-card" },
           h("div", { className: "myt-cardHead" },
             h("h3", { className: "myt-cardTitle" }, tt("relations.title")),
-            h("span", { className: "myt-muted" }, tf("relations.counts", { n: graph.nodes.length, m: graph.edges.length }))),
+            h("span", { className: "myt-muted" }, tf("relations.counts", { n: graph.nodes.length, m: graph.edges.length })),
+            srcEditBtn("relations.yml", function () { setSrcRel("relations.yml"); })),
           h("div", { className: "myt-graphWrap", ref: wrapRef },
             h("canvas", { className: "myt-graphCanvas", ref: canvasRef, "data-dragging": "false" }),
             tip ? h("div", { className: "myt-graphTip", style: { left: Math.min(tip.x + 12, 320) + "px", top: Math.max(tip.y - 34, 4) + "px" } }, tip.text) : null,
@@ -2572,12 +3434,19 @@ window.__ModuleLoader__.load({
               h("button", { type: "button", className: "myt-graphTool", title: tt("relations.zoomOut"), "aria-label": tt("relations.zoomOut"), onClick: function () { if (zoomApiRef.current) zoomApiRef.current.zoomBy(1 / 1.25); } }, "－"),
               h("button", { type: "button", className: "myt-graphTool", title: tt("relations.zoomIn"), "aria-label": tt("relations.zoomIn"), onClick: function () { if (zoomApiRef.current) zoomApiRef.current.zoomBy(1.25); } }, "＋"),
               canFs ? h("button", { type: "button", className: "myt-graphTool myt-graphToolText", title: isFs ? tt("relations.exitFs") : tt("relations.fs"), "aria-label": isFs ? tt("relations.exitFs") : tt("relations.fs"), onClick: toggleFs }, isFs ? tt("relations.exitFs") : tt("relations.fs")) : null)),
-          h("div", { className: "myt-graphFoot" }, tt("relations.help"))),
+          h("div", { className: "myt-graphFoot" },
+            tt("relations.help"),
+            h("span", { className: "myt-graphLegend" },
+              h("span", { className: "myt-legendItem" }, h("span", { className: "myt-legendDot", "data-role": "protagonist" }), tt("role.protagonist")),
+              h("span", { className: "myt-legendItem" }, h("span", { className: "myt-legendDot", "data-role": "supporting" }), tt("role.supporting")),
+              h("span", { className: "myt-legendItem" }, h("span", { className: "myt-legendDot", "data-role": "antagonist" }), tt("role.antagonist")),
+              h("span", { className: "myt-legendItem" }, h("span", { className: "myt-legendDot", "data-role": "minor" }), tt("role.minor"))))),
         graph.unlinked.length ? h("div", { className: "myt-card" },
           h("div", { className: "myt-cardHead" }, h("h3", { className: "myt-cardTitle" }, tt("relations.unlinkedTitle"))),
           h("div", { className: "myt-unlinked" }, graph.unlinked.map(function (n, i) {
             return h("span", { key: n || i, className: "myt-unlinkedTag" }, n);
-          }))) : null);
+          }))) : null,
+        srcRel ? h(SourceEditorModal, { title: tt("src.editSource"), rel: srcRel, wsPath: wsPath, onClose: function () { setSrcRel(null); }, onSaved: reload }) : null);
     }
 
     // ── cordis client 插件入口 ──────────────────────────────────────────────