@nightpainters/dsh-ling 1.6.2 → 1.7.1

package/lib/client.js

@@ -168,15 +168,27 @@
       // 取不到(经反代打开的页面 / 旧宿主)= 空串 ⇒ 手术请求照旧发,由宿主那边给出明确拒绝。
       var surgeryTicket = '';
       var surgeryTicketTried = false;
+      var surgeryTicketFailCount = 0;   // D2 修复:失败计数,每页面生命周期最多 2 次(第 3 次不再自动试)
       function fetchSurgeryTicket() {
-        surgeryTicketTried = true;   // 无论成败都只试一次(失败不重试,免得把拒绝变成刷屏)
+        surgeryTicketTried = true;   // 标记"正在尝试",阻止 api() 重入路径并发触发第二发
         return fetch(API + '/surgery/ticket', { method: 'POST', headers: { 'content-type': 'application/json' } })
           .then(function (r) { return r.json().catch(function () { return null; }); })
           .then(function (j) {
-            if (j && j.ok && typeof j.ticket === 'string' && j.ticket) { surgeryTicket = j.ticket; return surgeryTicket; }
-            return '';   // 远端 / 未定型:没有票,照常走后面的拒绝路径
+            if (j && j.ok && typeof j.ticket === 'string' && j.ticket) {
+              surgeryTicket = j.ticket;   // 成功:票落袋,保持 tried=true(不再重取)
+              return surgeryTicket;
+            }
+            // 失败(远端拒绝 / 旧宿主):解锁以便再试,但计次;到上限后不再自动试
+            surgeryTicketTried = false;
+            surgeryTicketFailCount++;
+            return '';
           })
-          .catch(function () { return ''; });
+          .catch(function () {
+            // 网络错误 / 超时:同上
+            surgeryTicketTried = false;
+            surgeryTicketFailCount++;
+            return '';
+          });
       }
 
       function api(path, opts) {
@@ -192,7 +204,7 @@
         }).then(function (j) {
           // 宿主说"票据不对/没票"⇒ 现场取一次,原样重发一次(只重发一次,不做循环)。
           // 票据每启动轮换 ⇒ 页面放久了会遇到这一支,那时用户不必手动刷新。
-          if (j && j.ok === false && j.surgery === 'surgery-ticket' && !surgeryTicketTried) {
+          if (j && j.ok === false && j.surgery === 'surgery-ticket' && !surgeryTicketTried && surgeryTicketFailCount < 2) {
             return fetchSurgeryTicket().then(function (t) {
               if (!t) return j;
               var h2 = { 'content-type': 'application/json', 'x-dsh-ling-surgery': t };
@@ -340,6 +352,31 @@
           '.ling-tab:hover{opacity:1;}' +
           '.ling-tab.on{opacity:1;background:var(--lg-hover-bg);border-color:var(--lg-accent);color:var(--lg-hover-text);font-weight:700;}' +
           '.ling-mc .mc-body{flex:1;overflow:auto;min-height:0;font-size:14px;padding-right:2px;}' +
+          // 图书馆(独立库)的样式:全部走既有 --lg-* 变量 ⇒ 明/暗主题自动跟随,不新造配色体系。
+          // 语义色只用三档:ok=accent / warn=gold / bad=红 —— 与面板既有告警语言一致(审计色 #d9a441 同族)。
+          '.lib-status{margin:0 0 10px;padding:10px 12px;border:1px solid var(--lg-border);border-radius:10px;' +
+          'background:var(--lg-rowbg);line-height:1.7;}' +
+          '.lib-status.ok{border-color:var(--lg-accent);}' +
+          '.lib-status.warn{border-color:var(--lg-gold);}' +
+          '.lib-status.bad{border-color:#d9534f;}' +
+          '.lib-card{margin:8px 0;padding:10px 12px;border:1px solid var(--lg-border);border-radius:10px;background:var(--lg-rowbg);}' +
+          '.lib-chip{display:inline-block;margin:0 6px 4px 0;padding:1px 9px;border:1px solid var(--lg-border);' +
+          'border-radius:999px;font-size:12px;opacity:.92;}' +
+          '.lib-mono{font-family:ui-monospace,Consolas,monospace;font-size:12px;word-break:break-all;line-height:1.6;}' +
+          '.lib-pre{white-space:pre-wrap;word-break:break-word;max-height:260px;overflow:auto;padding:8px 10px;' +
+          'border:1px dashed var(--lg-border);border-radius:8px;line-height:1.6;}' +
+          '.lib-form label{display:block;margin:9px 0 3px;font-size:12.5px;opacity:.82;}' +
+          '.lib-form input[type=text],.lib-form input[type=search],.lib-form textarea{width:100%;box-sizing:border-box;' +
+          'padding:6px 10px;border:1px solid var(--lg-input);border-radius:9px;background:transparent;color:var(--lg-text);' +
+          'font-size:14px;font-family:inherit;}' +
+          '.lib-form textarea{min-height:74px;line-height:1.6;}' +
+          '.lib-err{margin:8px 0;color:#d9534f;line-height:1.7;word-break:break-word;}' +
+          '.lib-warn{margin:10px 0;padding:9px 12px;border:1px solid #d9a441;border-left:4px solid #d9a441;' +
+          'border-radius:8px;background:rgba(217,164,65,.10);line-height:1.7;word-break:break-word;}' +
+          '.lib-warn .t{font-weight:600;}' +
+          '.lib-note{margin:8px 0;color:#d9a441;line-height:1.7;word-break:break-word;}' +
+          '.lib-grid{display:grid;grid-template-columns:minmax(120px,max-content) 1fr;gap:4px 12px;align-items:start;}' +
+          '.lib-grid .k{opacity:.62;font-size:12.5px;}' +
           '.m-tools{display:flex;gap:10px;flex-wrap:wrap;align-items:center;margin-bottom:12px;}' +
           '.m-tools input[type=search],.m-tools select{min-height:38px;padding:6px 12px;border:1px solid var(--lg-input);' +
           'border-radius:9px;background:transparent;color:var(--lg-text);font-size:14px;}' +
@@ -430,7 +467,7 @@
 
       function dark() { return document.documentElement.getAttribute('data-ds-theme') === 'dark' ? '1' : '0'; }
 
-      /** 悬停即时小气泡(2026-09-27,尝生反馈"太罗嗦 + 窗口叠加"):
+      /** 悬停即时小气泡(2026-09-27,用户反馈"太罗嗦 + 窗口叠加"):
        *  原生 `title` 由**浏览器**绘制 —— 既不受样式控制,也**不会自动消失**;而悬停 1.5s 会开菜单,
        *  于是浏览器 tooltip 和菜单叠成两层。故完整提醒改走自绘:悬停瞬间出现、`TIP_MS` 后自动移除,
        *  且菜单一开就先收掉它 ⇒ 两者永不同屏。与 `toast` 同规格(都是 dsh-ling-menu 容器 + 定时移除),
@@ -1024,7 +1061,7 @@
             return r || {};
           }).catch(function () { toast('切换失败(网关不可达)'); return {}; });
         }
-        // ⚠️ 这里**故意不问一句** —— 尝生 2026-09-27 裁决(原话):
+        // ⚠️ 这里**故意不问一句** —— 用户 2026-09-27 裁决(原话):
         //   「创建新会话时只能通过调全局默认来调新会话的模式,所以它的使用比想象的频繁一些」
         //   ⇒ 全局默认不是危险开关,而是**开一个不同模式的新会话**的必经入口,属高频正常动作;
         //     事前弹确认 = 给日常添堵,且那个按钮按下本身就是低成本可撤销动作。
@@ -1081,7 +1118,7 @@
         wrap.appendChild(h);
         var kv = el('div', 'kv', '加载中…');
         wrap.appendChild(kv);
-        // E3(2026-09-27 尝生拍板):「那一行」只读块。**必须另起一个节点** —— 上面 `kv` 整块是纯
+        // E3(2026-09-27 用户拍板):「那一行」只读块。**必须另起一个节点** —— 上面 `kv` 整块是纯
         // textContent(一段文字),而「看全文」要一个真能展开/收起的子节点(快照原文放 <pre>,默认收起)。
         // 这一块对模型上下文**零占用**:读的全是 `/state` 面板档(`l0Preview=1`)字段,纯读,不进 prompt。
         var e3box = el('div', 'ling-e3');
@@ -1223,7 +1260,7 @@
           }
           // 全局视图的 L2 三行**必然**缺席:后端 lib/host/api.js 在 global 分支写死 snapshot: null,
           // 而且整个返回里不带 idleRefresh 字段 ⇒ 上面两段一个字符都进不来。
-          // 不写这一行,"按设计没有"与"坏了"在界面上长得一模一样(尝生 2026-09-27 反馈)。
+          // 不写这一行,"按设计没有"与"坏了"在界面上长得一模一样(用户 2026-09-27 反馈)。
           // 放在 L2 本该出现的位置(待应用更新 → 这里 → 人格),两个视图的行序才对得齐。
           if (global && !r.snapshot && !r.idleRefresh) {
             lines.push('(全局视图无会话快照 —— 快照定稿/空闲刷新是按会话统计的,进入某个会话才显示)' + SNAP_TAG);
@@ -1344,7 +1381,7 @@
               if (nextText) {
                 // 号码 `S.ordinal` 与正文 `nextText` **同源**(都是"下一条")⇒ 这个组合是自洽的
                 row('   活行正文' + ((S && S.ordinal != null) ? '(#' + S.ordinal + ')' : '') + ' —— 下一条会长这样: ' + nextText);
-                row('   (' + nextText.length + ' 字符 · 这一条是**预测**:后端知道轮次时才给;只有内容真变了才追加,故它可能连着好几轮不动 —— 那不代表机制失效)', 'e3-meta');
+                row('   (' + nextText.length + ' 字符 · 这一条是预测:后端知道轮次时才给;只有内容真变了才追加,故它可能连着好几轮不动 —— 那不代表机制失效)', 'e3-meta');
               } else {
                 row('   活行正文 —— 下一条会长这样: (后端没给 —— 面板这条路径取不到轮次,故不预测正文,也绝不用"上次那条"顶替)', 'e3-why');
               }
@@ -1394,21 +1431,21 @@
               row('为什么没变(逐条判据):', 'e3-h');
               var running = (cur && cur.running !== undefined) ? !!cur.running : !!r.running;
               row('   快照为什么没变:' + (running
-                ? '会话**运行中** ⇒ 快照不重建(人格/记忆更新要等空闲那一刻落盘;这一条**正在**挡着)'
-                : '会话空闲 ⇒ 这一条**不构成**"没变"的原因(没有在挡它)'));
+                ? '会话运行中 ⇒ 快照不重建(人格/记忆更新要等空闲那一刻落盘;这一条正在挡着)'
+                : '会话空闲 ⇒ 这一条不构成"没变"的原因(没有在挡它)'));
               row('   深摘:' + (r.deepDone === true
-                ? '该会话**已深摘冻结**(kv `deep:<会话id>` = done:…)⇒ 本会话那一行(只有标题那条)不再更新'
+                ? '该会话已深摘冻结(kv `deep:<会话id>` = done:…)⇒ 本会话那一行(只有标题那条)不再更新'
                 : (r.deepDone === false
-                  ? '未深摘 ⇒ 这一条**不构成**"没变"的原因'
+                  ? '未深摘 ⇒ 这一条不构成"没变"的原因'
                   : '后端这一版还没带 deepDone ⇒ 不做猜测')));
               row('   本会话标题行为什么只有标题:' + ((selfRow && selfRow.line)
-                ? '这一行**只有标题**(公式里就没有摘要),进展由②活行承担 —— 两条不同源,**不是印了两遍,也不是 bug**'
+                ? '这一行只有标题(公式里就没有摘要),进展由②活行承担 —— 两条不同源,不是印了两遍,也不是 bug'
                 : '本会话那一行不在 L1 里 ⇒ L2 本会话标题行此刻为空,②活行照旧'));
               row('   档位:' + (known
-                ? ('本拍被判定为「' + (E3_APPEND[rsn] ? '会追加' : (E3_HOLD[rsn] ? '本拍不判定' : '不追加')) + '」—— ' + known + ';另外:15 分钟 / 10 轮那道**档位门已撤除**(追加只看"内容真变了没")')
+                ? ('本拍被判定为「' + (E3_APPEND[rsn] ? '会追加' : (E3_HOLD[rsn] ? '本拍不判定' : '不追加')) + '」—— ' + known + ';另外:15 分钟 / 10 轮那道档位门已撤除(追加只看"内容真变了没")')
                 : ((rsn && !known)
-                  ? ('后端给了个前端未收录的原因("' + rsn + '")⇒ 不在这里翻译;另外:15 分钟 / 10 轮那道**档位门已撤除**')
-                  : '**没有档位门**了(15 分钟 / 10 轮双门已撤除:追加只看"内容真变了没")—— 所以这里没有"距下次还差多久"可算,不编一个')) + ' ' + basisTag, 'e3-why');
+                  ? ('后端给了个前端未收录的原因("' + rsn + '")⇒ 不在这里翻译;另外:15 分钟 / 10 轮那道档位门已撤除')
+                  : '没有档位门了(15 分钟 / 10 轮双门已撤除:追加只看"内容真变了没")—— 所以这里没有"距下次还差多久"可算,不编一个')) + ' ' + basisTag, 'e3-why');
               // ---- 看全文:模型那一轮真正读到的**冻结快照原文**(面板档 snapshot.text;纯读,对模型上下文零占用) ----
               var stext = (snap2 && typeof snap2.text === 'string') ? snap2.text : null;
               if (stext === null) {
@@ -2171,7 +2208,7 @@
         var st = store.get();
         var mode = st.mode || 'life';
         var items = [
-          ['记忆中心(浏览/置顶/导入导出)', openMemoryCenter],
+          ['记忆与数据中心(浏览/置顶/导入导出)', openMemoryCenter],
           ['人格中心(自称/语气/规矩·习惯·底线·定型)', openPersonaEditor],
           ['建议中心(语料提炼+点踩成长)', openFeedbackPanel],
           ['🌱 一键进入复盘', function () { startReviewFromMenu(); }, '与器灵互相复盘总结纠正:复制复盘开场白 + 解锁编辑 + 打开右侧复盘栏'],
@@ -2239,7 +2276,43 @@
           // 一键生成记忆树(autotree):autoOpen=面板开关;autoData=preview 原始返回;
           // autoNames=bucketId→名字(可手改);autoBusy=防重入(命名/应用期间禁用按钮)
           autoOpen: false, autoData: null, autoNames: {}, autoBusy: false, autoExpand: {},
+          // 「图书馆」标签的自己一格状态。**与上面任何记忆字段都不共用**:
+          // 图书馆是另一套库(library.db),混用字段正是"两套东西看起来像一套"的起点。
+          // 竞态三令牌(libSeq/libDetailSeq/libActionSeq)在函数作用域,不在这里(见下方注释)。
+          //   · 例外:结论层标签的代次令牌 `seq` 就放在下面 st.deep 里 —— 它随面板重建
+          //     (openMemoryCenter 每次都新建 st)⇒ 面板一重开,上一轮在飞的请求自动全部作废。
+          // 结论层(B 档,2026-10-15):**只读**面的状态。它不放在 lib 里 —— 深层库与图书馆
+          //   是两套东西(前者是"我记住的结论",后者是"有源可对账的源资料"),混进一个状态对象
+          //   迟早会让某处 `st.lib.x` 读到一个属于结论层的值。
+          deep: { data: null, busy: false, err: '', showRetired: false, limit: 500, seq: 0 },
+          lib: {
+            view: 'list', q: '', offset: 0, limit: 20, items: null,
+            nextOffset: null, truncated: false, searchedOnce: false,
+            status: null, statusLoaded: false, statusLoading: false, statusErr: '',
+            itemId: '', item: null, detailErr: '', hist: null, checks: null,
+            form: null, formMode: 'create', formItem: null,
+            busy: false, checking: false, err: '', notice: '',
+            checkResult: null, checkErr: '', withdrawReason: '',
+            // 导入面的自己一格:源 → 候选 → 勾选 → 入库。
+            // ⚠️ 它**必须**与维护面那几个字段分开:`imp.receipt` 是"候选清单",不是库里的条目 ——
+            //   混用会让"分析过但没入库"的东西看起来像已经在库里了(§8 回执纪律要防的正是这个)。
+            imp: null,
+            // 浏览面(第七面)的自己一格:分组计数表 + 每个已展开组的一页条目 + 选中条的详情/谱系/核对史。
+            // 与维护面字段分开的理由同导入面 —— 这一面**只读**,它的缓存不许被写动作改动。
+            br: null,
+          },
         };
+        // ---- 迟到回画守卫(2026-10-06,加了「图书馆」标签之后补) ----
+        // 四个记忆标签各自都有"请求在飞 → 回来再清 body 重画"的异步尾巴(概览的 Promise.all、
+        // 记忆浏览的 sources、记忆树的 loadTreeAll/paintTree、autotree 的三段尾巴)。若请求在飞时
+        // 主人切到了别的标签(尤其第五「图书馆」),旧尾巴回来照样**清空 body 并画旧标签的内容** ——
+        // 顶部高亮停在图书馆、正文却变成记忆浏览,正是本文件反复出现的 C#8「内容与标签不符」。
+        // 统一用一枚**绘制代次**:每次切标签 +1、每次派发渲染 +1;异步尾巴回来时代次不一致就
+        // **连清都不清**,整条丢弃(不是"先画错再撤回"——那会闪一下,而且丢的是当前视图)。
+        // 与 C#8 那处 `st.tab` 守卫是**互补**的,两者都留:
+        //   · 代次挡住"同一个标签内,旧请求盖掉新渲染"(切走又切回时 st.tab 恰好相等,单靠它拦不住);
+        //   · st.tab 挡住"代次恰好相等却已不在本标签"(双保险,不依赖调用顺序)。
+        var drawGen = 0;
         // 注册同步钩子供模块级"一键进入复盘"使用(见 lingCenterSync 注释)
         lingCenterSync = function (td, conf) {
           st.treeData = td;
@@ -2279,8 +2352,17 @@
         wrap.tabIndex = 0;
         wrap.style.outline = 'none';
         wrap.dataset.dark = dark();
-        var head = el('h3', null, '记忆中心');
-        head.appendChild(el('div', 'hint', '历史会话与 DSH 会话的记忆库:浏览、置顶(提升 L1 权重)、删除、导入导出'));
+        // 中心标题:「记忆与数据中心」—— 六个面同住一个中心,但**分成三段**:
+        //   ① 记忆相关的四面(2026-10-16 用户要求:把记忆的部分挨在一起)
+        //   ② 「接入历史」= 会话接入与导入的流水
+        //   ③ 「图书馆」= 另一套独立库:零注入、不与记忆条目混排
+        var head = el('h3', null, '记忆与数据中心');
+        head.appendChild(el('div', 'hint',
+          '左边四面是记忆本身,挨在一起:概览(数据与后台开关)、浏览(置顶/删除/导入导出)、'
+          + '记忆树(分枝与血缘)、结论层(深层库条目 —— 与开场注入直接相关,只读,'
+          + '落条与作废走工具、面板不提供写入口);'
+          + '「接入历史」是会话接入与导入的流水;'
+          + '最后的「图书馆」是另一套独立库,只放有源可对账的资料,不参与开场注入、不与记忆条目混排。'));
         wrap.appendChild(head);
 
         var tabs = el('div', 'ling-tabs');
@@ -2288,10 +2370,21 @@
         var tabBrowse = el('div', 'ling-tab', '记忆浏览');
         var tabAccess = el('div', 'ling-tab', '接入历史');
         var tabTree = el('div', 'ling-tab', '记忆树');
+        // 图书馆(另一套库 —— 只读状态 + 检索 + 维护 + 核对留痕;零记忆依赖):2026-10-16 起排在最后
+        var tabLib = el('div', 'ling-tab', '图书馆');
+        // 结论层(深层库条目,**只读**)—— 用户 2026-10-15 拍板加这一面;2026-10-16 起紧挨「记忆树」;
+        //   取名就三个字:与前五个标签同量级(4~5 字)才不会把标签条挤成一团,
+        //   面内第一行再写全「深层库 · 结论层」。
+        var tabDeep = el('div', 'ling-tab', '结论层');
+        // 顺序(2026-10-16 用户要求):概览 · 浏览 · 记忆树 · 结论层 · 接入历史 · 图书馆
+        //   ⇒ 记忆相关的四面相邻,接入历史与图书馆靠后。**只改这里的追加顺序** ——
+        //   切换按名字(`switchTab('tree')`)不按下标,故换序不影响任何逻辑。
         tabs.appendChild(tabOverview);
         tabs.appendChild(tabBrowse);
-        tabs.appendChild(tabAccess);
         tabs.appendChild(tabTree);
+        tabs.appendChild(tabDeep);
+        tabs.appendChild(tabAccess);
+        tabs.appendChild(tabLib);
         wrap.appendChild(tabs);
 
         var body = el('div', 'mc-body');
@@ -2307,19 +2400,29 @@
         close.onclick = closeOverlays;
 
         function switchTab(name) {
+          // 切标签即作废上一次绘制:在飞的旧请求回来时代次对不上 ⇒ 不再清 body、不再画。
+          drawGen += 1;
           st.tab = name;
           tabOverview.className = 'ling-tab' + (name === 'overview' ? ' on' : '');
           tabBrowse.className = 'ling-tab' + (name === 'browse' ? ' on' : '');
           tabAccess.className = 'ling-tab' + (name === 'access' ? ' on' : '');
           tabTree.className = 'ling-tab' + (name === 'tree' ? ' on' : '');
+          // ⚠️ 高亮必须与内容同源:这里漏一行,切到图书馆后顶部高亮还停在「记忆树」上
+          //   —— 本文件注释里反复出现的 C#8 那类"内容与标签不符"就是从这个缝里长出来的。
+          tabLib.className = 'ling-tab' + (name === 'library' ? ' on' : '');
+          tabDeep.className = 'ling-tab' + (name === 'deep' ? ' on' : '');
           render();
         }
         tabOverview.onclick = function () { switchTab('overview'); };
         tabBrowse.onclick = function () { switchTab('browse'); };
         tabAccess.onclick = function () { switchTab('access'); };
         tabTree.onclick = function () { switchTab('tree'); };
+        tabLib.onclick = function () { switchTab('library'); };
+        tabDeep.onclick = function () { switchTab('deep'); };
 
         function renderOverview() {
+          // 本次绘制的代次(见文件内「迟到回画守卫」注):Promise.all 的尾巴只认这一枚。
+          var gen = ++drawGen;
           body.textContent = '';
           body.appendChild(el('div', 'kv', '加载器灵概览…'));
           var g = el('div', null);
@@ -2356,7 +2459,13 @@
             api('/suggestions').then(function (r) { meta.sugg = r; }).catch(ov('语料建议')),
             api('/feedback').then(function (r) { meta.fb = r; }).catch(ov('点踩反馈')),
             api('/deep/status').then(function (r) { meta.deep = r; }).catch(ov('深摘状态')),
+            // 后台行为的生效值 + 来源(2026-10-16)。并进这一批而不是另起一次异步回画:
+            // 下面的 `gen !== drawGen` 守卫已经把"请求在飞时切走标签"这条判据写在一处,
+            // 另开一路就得再抄一遍 —— 抄两份的守卫迟早漏一份。
+            api('/auto').then(function (r) { meta.auto = r; }).catch(ov('后台行为')),
           ]).then(function () {
+            // ★迟到回画守卫:期间切走标签(或本标签又重画过一次)⇒ 整条丢弃,**连 body 都不清**。
+            if (gen !== drawGen || st.tab !== 'overview') return;
             body.textContent = '';
             var st8 = meta.state || {};
             var per = st8.persona || {};
@@ -2450,8 +2559,8 @@
                       //    所以只说"这份包 ≈X / 整包超了上限"这个方向性事实,不假装两个数能直接相减。
                       var sizeHint = (f && f.size > 0) ? '(≈' + fmtBytes(f.size) + ')' : '';
                       toast('导入失败:这份包' + sizeHint + '整包超过了服务端单次上限 ' + fmtLimitMB(r.limit) + ' —— 不是包坏了。\n'
-                        + '· 「导入记忆包」是把整份文件**一次**发出去,带对话原文的包很容易超过它(当前通道的结构限制:整包一次发不完)。\n'
-                        + '· 怎么办:改用「⬇ 导出记忆包」重新导出一份**不含原文**的包(那个按钮默认就不含原文,体积小得多),再导入一次即可 —— 记忆/建议/队列都在,只是不含对话原文。',
+                        + '· 「导入记忆包」是把整份文件一次发出去,带对话原文的包很容易超过它(当前通道的结构限制:整包一次发不完)。\n'
+                        + '· 怎么办:改用「⬇ 导出记忆包」重新导出一份不含原文的包(那个按钮默认就不含原文,体积小得多),再导入一次即可 —— 记忆/建议/队列都在,只是不含对话原文。',
                         12000, true);
                     } else {
                       // 其余失败:优先用服务端给的 `message`(它是一句中文),只有连 message 都没有时
@@ -2640,6 +2749,179 @@
             sumZone.appendChild(sumRes);
             g.appendChild(sumZone);
             sumStatus();
+
+            // ---- 后台行为(2026-10-16):自动深摘 / 启动探活 / 反馈回路的总闸 ----
+            // 为什么单开这张卡片:这三件事**默认全开着**,而此前既没文档也没开关 ——
+            // 自动深摘只认插件配置里的旧键(deepSummaryAuto / deepIntervalMin / deepMaxPerRun),
+            // 探活延时干脆是硬编码的 12000ms;主人想看或想关,只能去手改 settings.json。
+            // 两条纪律写进这张卡片:
+            //   · 每个值都标"是谁定的"(后端 resolveAuto 的 source:你设的 / 插件配置 / 默认)——
+            //     看不出处,就没法判断"我改了到底有没有用";
+            //   · 生效时机**如实说**:探活延时与反馈回路是启动期读的(要重启宿主),间隔与每轮上限
+            //     对已挂上的定时器不回溯 —— 写"立即生效"是谎话,比不写更坏。
+            function autoZone(r) {
+              var zone = el('div', 'scan-zone');
+              zone.style.cssText = 'margin-top:10px;padding:10px 12px;border:1px dashed var(--lg-border);border-radius:11px;';
+              var head = el('div', 'm-meta', '⚙ 后台行为(下面几项默认都开着)');
+              head.style.cssText = 'font-weight:700;opacity:.9;margin-bottom:4px;';
+              zone.appendChild(head);
+              var eff = (r && r.effective) ? r.effective : null;
+              var res = el('div', 'm-meta', '');
+              res.style.cssText = 'margin-top:8px;line-height:1.7;white-space:pre-wrap;';
+              if (!eff) {
+                // 读不到就说读不到:这里**不显示**任何"看起来像默认值"的数字 —— 把猜的当生效值
+                // 比空着更坏(主人会以为屏幕上那个 30 分钟就是后台真在跑的间隔)。
+                var miss = el('div', 'hint', '读不到当前的生效值(宿主可能是旧版本,或本次没连上网关)—— '
+                  + '重启宿主后回到本页重看。');
+                miss.style.cssText = 'margin:6px 0 0;line-height:1.7;color:#d9a441;';
+                zone.appendChild(miss);
+                return zone;
+              }
+              var SRC = { settings: '你设的', config: '插件配置', default: '默认' };
+              var srcMap = eff.source || {};
+              function srcLabel(k) { return SRC[srcMap[k]] || '默认'; }
+              /** 一行控件 + 一行 hint。返回节点引用:保存成功后要就地改来源标签。 */
+              function row(label, ctrl, hintText, key) {
+                var box = el('div', null);
+                box.style.cssText = 'margin-top:9px;';
+                var line = el('div', 'btnrow');
+                line.style.cssText = 'justify-content:flex-start;gap:8px;align-items:center;margin-top:0;';
+                var lab = el('span', 'm-meta', label);
+                lab.style.cssText = 'min-width:126px;font-weight:600;';
+                line.appendChild(lab);
+                line.appendChild(ctrl);
+                var src = el('span', 'm-meta', '(' + srcLabel(key) + ')');
+                src.style.cssText = 'opacity:.7;font-size:12px;';
+                line.appendChild(src);
+                var hint = el('div', 'hint', hintText);
+                hint.style.cssText = 'margin:3px 0 0 0;line-height:1.65;opacity:.8;';
+                box.appendChild(line);
+                box.appendChild(hint);
+                return { box: box, src: src };
+              }
+              /** 数字输入 + 保存按钮同排(不引新类,走既有 .btnrow 的左对齐写法)。 */
+              function pair(input, btn) {
+                var d = el('div', null);
+                d.style.cssText = 'display:flex;gap:8px;align-items:center;';
+                d.appendChild(input);
+                d.appendChild(btn);
+                return d;
+              }
+              function numInput(val, min, max) {
+                var n = document.createElement('input');
+                n.type = 'number';
+                n.min = String(min); n.max = String(max); n.step = '1';
+                n.value = String(val);
+                n.style.cssText = 'width:112px;padding:5px 9px;border:1px solid var(--lg-input);border-radius:9px;background:transparent;color:var(--lg-text);font-size:13px;';
+                return n;
+              }
+              var cbDeep = document.createElement('input');
+              cbDeep.type = 'checkbox';
+              cbDeep.checked = eff.deepSummary === true;
+              var cbFb = document.createElement('input');
+              cbFb.type = 'checkbox';
+              cbFb.checked = eff.feedbackAuto === true;
+              var inInt = numInput(eff.deepIntervalMin, 10, 1440);
+              var inMax = numInput(eff.deepMaxPerRun, 1, 20);
+              var inProbe = numInput(eff.bootProbeDelayMs, 0, 600000);
+              var bInt = el('button', null, '保存'); bInt.type = 'button';
+              var bMax = el('button', null, '保存'); bMax.type = 'button';
+              var bProbe = el('button', null, '保存'); bProbe.type = 'button';
+              var rows = {
+                deepSummary: row('自动深摘', cbDeep,
+                  '默认开着:宿主启动探活通过后,按下面「间隔」的节奏自动挑达标的会话深摘(每次真花模型额度)。'
+                  + '关掉后只有你点「深摘 / 深度摘要」时才调用模型;已经深摘过的会话不受影响,只是不再自动跑新的。',
+                  'deepSummary'),
+                deepIntervalMin: row('间隔(分钟)', pair(inInt, bInt), '默认 30 分钟;可填 ≥10(上限 1440 = 一天)。'
+                  + '改动对已经挂上的定时器不回溯 —— 重启宿主后才按新间隔走。', 'deepIntervalMin'),
+                deepMaxPerRun: row('每轮上限', pair(inMax, bMax), '默认 2:一轮最多深摘几个会话。'
+                  + '调大 = 一轮多摘几个(每个都要真花模型额度);调小 = 更省、追平更慢。同样重启后按新值走。', 'deepMaxPerRun'),
+                bootProbeDelayMs: row('启动探活(ms)', pair(inProbe, bProbe),
+                  '默认 12000ms(12 秒):宿主启动后先等这么久,再做一次 LLM 探活,探通了才挂自动深摘。'
+                  + '0 = 立即(刚启动时模型可能还没就绪,探活更容易失败)。这一项是启动时读的 ⇒ 下次重启才生效。',
+                  'bootProbeDelayMs'),
+                feedbackAuto: row('反馈回路', cbFb,
+                  '默认开着:宿主收到反馈事件就当场处理,不去轮询文件。关掉后反馈本身照样被平台记下来,'
+                  + '只是器灵不再自动把它们变成建议(你仍可在「建议中心」手动处理)。这一项也是启动时读的 ⇒ 下次重启才生效。',
+                  'feedbackAuto'),
+              };
+              /** 把一份 effective 铺回控件与来源标签(保存成功后用;保存失败时用它回滚视觉状态)。 */
+              function paint(e) {
+                cbDeep.checked = e.deepSummary === true;
+                cbFb.checked = e.feedbackAuto === true;
+                inInt.value = String(e.deepIntervalMin);
+                inMax.value = String(e.deepMaxPerRun);
+                inProbe.value = String(e.bootProbeDelayMs);
+                srcMap = e.source || srcMap;
+                for (var k in rows) rows[k].src.textContent = '(' + srcLabel(k) + ')';
+              }
+              function save(patch, what) {
+                res.textContent = '保存中…';
+                api('/auto', { method: 'POST', body: { patch: patch } }).then(function (rr) {
+                  // ★迟到回画守卫:保存期间切走标签(或本标签又重画过一次)⇒ 这枚节点已经不是屏幕上的
+                  //   那张卡片,一个字都不许再写(写进去主人也看不见,还会把新卡片的状态搅乱)。
+                  if (gen !== drawGen || st.tab !== 'overview') return;
+                  if (!rr || !rr.ok) {
+                    paint(eff);   // 没能落盘 ⇒ 视觉状态退回"存着的那个值",不假装已改
+                    res.textContent = '✗ ' + ((rr && (rr.message || rr.error)) || '保存失败');
+                    return;
+                  }
+                  var e2 = rr.effective || {};
+                  paint(e2);
+                  var parts = ['自动深摘 ' + (e2.deepSummary ? '开' : '关'),
+                    '间隔 ' + e2.deepIntervalMin + ' 分钟', '每轮 ' + e2.deepMaxPerRun + ' 个',
+                    '探活延时 ' + e2.bootProbeDelayMs + 'ms', '反馈回路 ' + (e2.feedbackAuto ? '开' : '关')];
+                  var extra = [];
+                  if ((rr.clamped || []).length) extra.push('填的值被夹到允许范围内:' + rr.clamped.join(' / '));
+                  if ((rr.dropped || []).length) extra.push('忽略了不认识的字段:' + rr.dropped.join(' / '));
+                  res.textContent = '✓ 已保存(' + what + ')· 现在:' + parts.join(' · ')
+                    + (extra.length ? '\n(' + extra.join(';') + ')' : '');
+                  toast('后台行为已保存(' + what + ')。\n'
+                    + '· 现在:' + parts.join(' · ') + '\n'
+                    + '· 探活延时与反馈回路是宿主启动时读的 ⇒ 下次重启后生效;\n'
+                    + '· 间隔与每轮上限对已经挂上的定时器不回溯 ⇒ 同样是重启后按新值走(已存下的记忆不受影响)。',
+                    9000, true);
+                }).catch(function () {
+                  if (gen !== drawGen || st.tab !== 'overview') return;
+                  paint(eff);
+                  res.textContent = '✗ 保存失败(网关不可达)';
+                });
+              }
+              cbDeep.onchange = function () {
+                save({ deepSummary: cbDeep.checked }, cbDeep.checked ? '打开自动深摘' : '关掉自动深摘');
+              };
+              cbFb.onchange = function () {
+                save({ feedbackAuto: cbFb.checked }, cbFb.checked ? '打开反馈回路' : '关掉反馈回路');
+              };
+              // 三个数字行各自的保存按钮:非数字在前端就拦下(后端对类型不符是**丢弃**并回报 ——
+              // 让主人当场看见"填的不是数字",比让它静默消失更清楚)。
+              function numSave(input, key, what, hint) {
+                return function () {
+                  var v = Number(input.value);
+                  if (String(input.value).trim() === '' || !isFinite(v)) {
+                    res.textContent = '✗ ' + hint;
+                    return;
+                  }
+                  var p = {}; p[key] = v;
+                  save(p, what);
+                };
+              }
+              bInt.onclick = numSave(inInt, 'deepIntervalMin', '间隔', '「间隔」请填一个数字(分钟,≥10)');
+              bMax.onclick = numSave(inMax, 'deepMaxPerRun', '每轮上限', '「每轮上限」请填一个数字(≥1)');
+              bProbe.onclick = numSave(inProbe, 'bootProbeDelayMs', '启动探活延时', '「启动探活」请填一个毫秒数(≥0)');
+              zone.appendChild(rows.deepSummary.box);
+              zone.appendChild(rows.deepIntervalMin.box);
+              zone.appendChild(rows.deepMaxPerRun.box);
+              zone.appendChild(rows.bootProbeDelayMs.box);
+              // 只读一行:兜底模型(读不到你当前模型选择时才会用到,插件不改你的模型选择)。
+              var note = el('div', 'hint', '兜底模型 deepseek-official/deepseek-v4-flash(只在读不到你当前模型选择时使用)。');
+              note.style.cssText = 'margin:9px 0 0;line-height:1.65;opacity:.8;';
+              zone.appendChild(note);
+              zone.appendChild(rows.feedbackAuto.box);
+              zone.appendChild(res);
+              return zone;
+            }
+            g.appendChild(autoZone(meta.auto));
             body.appendChild(g);
           });
         }
@@ -2647,12 +2929,18 @@
         // D8(2026-09-17):先取各来源条数,筛选栏直接显示「历史网页端 (1523)」——
         // 否则 95% 的库(dsweb 1523/1599)在默认视图里沉底,主人无从知道库里到底有什么。
         function renderBrowse() {
+          // 本次绘制的代次(见文件内「迟到回画守卫」注)。
+          var gen = ++drawGen;
           body.textContent = '';
           body.appendChild(el('div', 'm-empty', '加载中…'));
           api('/memories/sources').then(function (sc) {
+            // ★迟到回画守卫:两路(.then/.catch)**都要** —— 失败路径同样会清 body 重画,
+            //   只守成功那一路的话,"请求在飞时切走、回来时失败"照样把第五面板顶掉。
+            if (gen !== drawGen || st.tab !== 'browse') return;
             body.textContent = '';
             renderBrowseInner(sc && sc.ok ? sc : null);
           }).catch(function () {
+            if (gen !== drawGen || st.tab !== 'browse') return;
             body.textContent = '';
             renderBrowseInner(null);
           });
@@ -2910,7 +3198,7 @@
 
         // ---------------- 记忆树 · 复盘(D9-b,2026-09-19) ----------------
         // 树形结构 + 复盘驱动的操作:并脉(归类) / 连边 / 调权重 / 矛盾裁定。
-        // 「一键复盘」按尝生定的设计约束(§10.1)把开场材料一次备齐 —— 复盘的门槛必须接近 0,
+        // 「一键复盘」按用户定的设计约束(§10.1)把开场材料一次备齐 —— 复盘的门槛必须接近 0,
         // 否则它会像"整理房间"一样被无限推迟。树的任何操作都**不改写记忆内容**。
         var TREE_KIND = { trunk: '主干', branch: '枝', vein: '主脉' };
         var TREE_COLOR = { trunk: 'var(--lg-primary)', branch: 'var(--lg-cyan)', vein: '#c58b2f' };
@@ -2943,12 +3231,20 @@
         }
 
         function loadTreeAll() {
+          // ★迟到回画守卫第一层:本函数**先清 body 再拉数据**,而它的调用点里有异步尾巴
+          //   (autotree 应用完成后的 loadTreeAll、侧栏 lingCenterReload)。已不在记忆树标签就
+          //   直接不进 —— 否则会把主人正在看的标签(含第五「图书馆」)清成"正在读取记忆树…"。
+          if (st.tab !== 'tree') return;
+          var gen = ++drawGen;
           body.textContent = '';
           body.appendChild(el('div', 'kv', '正在读取记忆树…'));
           Promise.all([
             api('/tree').catch(function () { return null; }),
             api('/conflicts').catch(function () { return null; }),
           ]).then(function (rs) {
+            // ★迟到回画守卫第二层:代次对不上(切走过,或又发起过一次 loadTreeAll)整条丢弃 ——
+            //   连 st.treeData 都不写:写进去会让下一次 paintTree 拿旧数据画,比不画更坏(看着像最新)。
+            if (gen !== drawGen || st.tab !== 'tree') return;
             st.treeData = (rs[0] && rs[0].ok) ? rs[0] : { roots: [], links: [], total: 0, failed: true };
             st.conflicts = (rs[1] && rs[1].ok) ? (rs[1].conflicts || []) : [];
             if (st.treeSel && !branchById(st.treeSel)) st.treeSel = '';
@@ -2973,7 +3269,7 @@
             };
           }
           row.appendChild(tri);
-          // 显示层(尝生 2026-09-21 定):前端不写运算层级名;主干用一句话表示"还在生长"。
+          // 显示层(用户 2026-09-21 定):前端不写运算层级名;主干用一句话表示"还在生长"。
           var isTrunk = n.id === ((st.treeData && st.treeData.trunk) || 'trunk');
           var badge = el('span', null, isTrunk ? '🌱 你们的故事正在生长' : (TREE_KIND[n.kind] || n.kind));
           badge.style.cssText = 'font-size:11px;padding:1px 6px;border-radius:6px;flex:none;'
@@ -2987,7 +3283,7 @@
             + (n.weightScale && Number(n.weightScale) !== 1 ? ' · ×' + n.weightScale : ''));
           meta.style.cssText = 'flex:none;opacity:.72;';
           row.appendChild(meta);
-          // ---- 连边小标记(尝生 2026-09-25) ----
+          // ---- 连边小标记(用户 2026-09-25) ----
           // 与侧栏记忆树同款:行内只留一个 ⇄N,不在这里铺开"连到哪里" ——
           // 选中本行后,下方"横向连边"区块才展开它的详情。
           var myLinks = (st.linkIndex && st.linkIndex[n.id]) || [];
@@ -3073,7 +3369,7 @@
 
         // ---------------- 一键生成记忆树(autotree,2026-09-20) ----------------
         // 三阶段:① 机械分段(零模型调用) ② 器灵批量命名 ③ 主人改名字后应用。
-        // 尝生的设计约束:模型只做"命名"这一件语义活;分段是机械活,不烧 token,也不该由模型做。
+        // 用户的设计约束:模型只做"命名"这一件语义活;分段是机械活,不烧 token,也不该由模型做。
         function loadAutoPreview() {
           if (st.autoBusy) return;
           st.autoBusy = true;
@@ -3161,6 +3457,9 @@
             toast('已建 ' + nCreated + ' 条枝'
               + (r.skipped ? '(跳过 ' + r.skipped + ' 条)' : '')
               + (r.note ? ' —— ' + r.note : ''));
+            // 先作废树缓存再重载:loadTreeAll 在"已不在记忆树标签"时会直接不进(迟到回画守卫),
+            // 若不作废,切回来时 renderTree 会拿**建枝之前**的旧缓存重画(看着像最新的)。
+            st.treeData = null;
             loadTreeAll();
           }).catch(function () { st.autoBusy = false; paintTree(); toast('✗ 应用失败(网关)'); });
         }
@@ -3206,7 +3505,7 @@
             inp.oninput = function () { st.autoNames[b.id] = inp.value; };
             row.appendChild(inp);
             // 「看内容」:展开这一簇实际包含哪些标题 —— 只给一个名字(如"零散记录")时
-            //   主人无从判断该不该采纳(尝生实测反馈)。内容来自 /tree/autobuild/preview 的 sample。
+            //   主人无从判断该不该采纳(用户实测反馈)。内容来自 /tree/autobuild/preview 的 sample。
             var bPeek = el('button', null, st.autoExpand[b.id] ? '▾ 收起' : '▸ 看内容');
             bPeek.type = 'button';
             bPeek.style.cssText = 'flex:none;font-size:11px;padding:1px 7px;';
@@ -3233,13 +3532,17 @@
         }
 
         function paintTree() {
+          // ★迟到回画守卫第三层(一处覆盖全部 14 个调用点):autotree 的三段流程里有多处
+          //   `.then(... paintTree())` 与 setTimeout 重试尾巴,它们可能在主人切走之后才回来。
+          //   不在记忆树标签 ⇒ 一个字节都不画。数据仍留在 st 里,切回来时 renderTree 会重画。
+          if (st.tab !== 'tree') return;
           body.textContent = '';
           var td = st.treeData || { roots: [], links: [], total: 0 };
           var all = treeAll();
           var links = td.links || [];
           var conf = st.conflicts || [];
           var pend = conf.filter(function (c) { return c.status === 'pending'; });
-          // ---- 连边索引(尝生 2026-09-25):节点 id → 挂在它身上的连边 ----
+          // ---- 连边索引(用户 2026-09-25):节点 id → 挂在它身上的连边 ----
           // 用途两个:① nodeRow 行内画小标记(⇄N),让"这条枝有横向连边"平时可见;
           // ② 下方"横向连边"区块改为**只显示选中项**那几条 —— 原先是无条件铺开全部,
           //    连边一多这块就越来越臃肿,把真正该看的矛盾区挤下去。
@@ -3252,11 +3555,11 @@
           });
 
           var tools = el('div', 'btnrow');
-          // 左对齐(尝生 2026-09-25):`.btnrow` 的全局 CSS 是 justify-content:flex-end(对"保存/取消"
+          // 左对齐(用户 2026-09-25):`.btnrow` 的全局 CSS 是 justify-content:flex-end(对"保存/取消"
           // 这类按钮行合适),但树工具条挂在面板左上,右对齐会让它飘到面板另一头,与下方树列表脱节。
           // 就地覆盖,不动全局 class(它被另外 15 处按钮行复用)。
           tools.style.cssText = 'margin:0 0 4px;flex-wrap:wrap;justify-content:flex-start;';
-          // 记忆中心已改为**只读视图**(2026-09-22 尝生裁决):扫重复 / 模型判定 / 归并零散枝 /
+          // 记忆中心已改为**只读视图**(2026-09-22 用户裁决):扫重复 / 模型判定 / 归并零散枝 /
           // 解锁编辑等**复盘操作**全部移到右侧「器灵 · 复盘」栏 —— 这里只留「看」与一个总入口。
           var bRefresh = el('button', null, '刷新');
           var bReview = el('button', null, '🌱 一键复盘');
@@ -3277,7 +3580,7 @@
           treeHead.style.cssText = 'margin:2px 0 4px;font-weight:700;opacity:.9;';
           body.appendChild(treeHead);
           var treeBox = el('div', null);
-          // 选中/重绘时保持滚动位置(否则每次重建 DOM 都会跳回顶部 —— 尝生 2026-09-22 反馈)
+          // 选中/重绘时保持滚动位置(否则每次重建 DOM 都会跳回顶部 —— 用户 2026-09-22 反馈)
           treeBox.onscroll = function () { st.treeScroll = treeBox.scrollTop; };
           treeBox.style.cssText = 'border:1px solid var(--lg-border);border-radius:11px;padding:6px 8px;'
             + 'max-height:34vh;overflow:auto;';
@@ -3302,7 +3605,7 @@
             : '🔒 树平时只读 —— 进入复盘模式后可修改。(先点一条枝 / 主脉选中它)'));
           body.appendChild(ops);
 
-          // ---- 横向连边(尝生 2026-09-25 改):只显示**选中项**的连边 ----
+          // ---- 横向连边(用户 2026-09-25 改):只显示**选中项**的连边 ----
           // 原先是无条件铺开全部连边 ⇒ 连边一多这块就越来越臃肿,把真正该看的矛盾区挤到下面。
           // 现在:行内只留 ⇄N 小标记(nodeRow 里画),选中哪条才展开它的详情;
           // 未选中时只给一行"共 N 条"的提示,可发现性不丢。
@@ -3356,7 +3659,7 @@
           var cHead = el('div', 'm-meta', '矛盾标记（待复盘 ' + pend.length + ' / 全部 ' + conf.length + '）');
           cHead.style.cssText = 'margin:12px 0 4px;font-weight:700;opacity:.9;';
           body.appendChild(cHead);
-          var cHint = el('div', 'm-meta', '检出但未复盘时 —— 检索以**较新**的那条为准(旧的一条降权,不删除、不改写内容)。');
+          var cHint = el('div', 'm-meta', '检出但未复盘时 —— 检索以较新的那条为准(旧的一条降权,不删除、不改写内容)。');
           cHint.style.cssText = 'margin-bottom:6px;opacity:.8;line-height:1.6;';
           body.appendChild(cHint);
           if (!conf.length) {
@@ -3384,7 +3687,7 @@
               + (c.winner ? ' · 以 ' + (c.winner === 'a' ? 'A' : 'B') + ' 为准' : ''));
             badge.style.cssText = 'opacity:.75;margin-bottom:4px;';
             card.appendChild(badge);
-            // 2026-09-21:每侧标题可点开看**摘要全文** —— 只给标题时人判不出"到底哪矛盾"(尝生实测反馈)。
+            // 2026-09-21:每侧标题可点开看**摘要全文** —— 只给标题时人判不出"到底哪矛盾"(用户实测反馈)。
             function sideLine(tag, title, summary, convId) {
               var wrap = el('div', null);
               var head = el('div', null, tag + '：' + (title || convId || '?'));
@@ -3621,8 +3924,11 @@
           g.appendChild(cardD);
           body.appendChild(g);
 
+          var importLogSeq = 0;   // F-06 修复:导入日志世代守卫(照抄 libSeq 模式,见 :4445)
           function renderImportLog() {
+            var token = ++importLogSeq;
             api('/import/history').then(function (r) {
+              if (token !== importLogSeq) return;   // 迟到的旧应答:丢弃(不把上一次的结果画进这一次)
               logOut.textContent = '';
               if (!r || !r.ok || !r.items || !r.items.length) {
                 logOut.appendChild(el('div', 'm-empty', '还没有导入记录 —— 从上面把一段历史请进来,这里就会留账。'));
@@ -3632,7 +3938,10 @@
                 logOut.appendChild(el('div', null, it.line || ''));
               });
               if (r.items.length > 20) logOut.appendChild(el('div', 'm-meta', '(仅显示最近 20 条)'));
-            }).catch(function () { logOut.textContent = '记录加载失败(网关不可达)'; });
+            }).catch(function () {
+              if (token !== importLogSeq) return;   // 同理:迟到的失败也不许凭空写新视图
+              logOut.textContent = '记录加载失败(网关不可达)';
+            });
           }
           bLogRefresh.onclick = renderImportLog;
           renderImportLog();
@@ -4094,7 +4403,7 @@
               } else if (skipped) {
                 lines.push('⚠ 导入不完全:写入新记忆 ' + totals.newRows + ' 条 · 刷新已有 ' + totals.refreshed + ' 条,另有 ' +
                   skipped + ' 条会话单条太长、没能通过导入通道(已跳过,见下)');
-                lines.push('  这不是文件坏了:是那几条会话**自己**就超过了单次上限 —— 拆小导出文件也拆不开单条。');
+                lines.push('  这不是文件坏了:是那几条会话自己就超过了单次上限 —— 拆小导出文件也拆不开单条。');
               } else {
                 lines.push('✓ 导入完成:写入新记忆 ' + totals.newRows + ' 条 · 刷新已有 ' + totals.refreshed + ' 条' +
                   (totals.upgraded ? ' · 补全对话原文 ' + totals.upgraded + ' 条' : '') +
@@ -4106,7 +4415,7 @@
               // 措辞要点:① 说清**为什么**(该会话在网页端旧库里已经有原文);② 说清**不是失败、也没丢东西**
               // (保住的是原有的真原文,是**更安全**的那一边);③ 与 `⚠` 那两档分开 —— 那两档是真的不完全,这档不是。
               if (notReplaced) {
-                lines.push('  ⓘ 另有 ' + notReplaced + ' 轮原文没有替换:这些会话在网页端旧库里**已经有原文**了 —— '
+                lines.push('  ⓘ 另有 ' + notReplaced + ' 轮原文没有替换:这些会话在网页端旧库里已经有原文了 —— '
                   + '保留原有的那份、不覆盖它(不是失败,也没有丢东西)。');
               }
               rejPreview.forEach(function (x) { lines.push('  ⚠ ' + x); });
@@ -4128,12 +4437,2183 @@
           fileInput.onchange = preview;
         }
 
+        // ---------------- 图书馆(独立库,不与记忆混排) ----------------
+        // 为什么另立一格状态(见 st.lib)而不是塞进既有字段:图书馆是**另一套存储**
+        // (library.db / LibraryStore)——判据是"有源可对账":条目 = 值 + 出处 + 取数时间 + 核对规格。
+        // 它零注入(不参与开场装配、不进 L1、不与记忆条目混排),所以本标签**不读任何记忆端点**,
+        // 也不做迁移/种子填充(契约 §Permanent Boundary:存进记忆库的数据永不迁进图书馆)。
+        //
+        // 三条从契约直接落下来的界面口径(写在这里,免得后来的人"顺手"改掉):
+        //   ① 只读字段(content_hash / state / checked_state / checked_at / 修订链)只**展示**;
+        //      提交体里绝不带它们 —— 带了会被 store 以 readonly_field 拒(拒绝而非静默剥离,
+        //      所以"顺手清掉再提交"这条路不存在)。
+        //   ② 检索回执**没有 total**(只有 count/nextOffset/truncated,library-store.js:1298-1309)
+        //      ⇒ 界面只说"本页几条 + 还有没有更多",绝不把本页条数说成"共 N 条"。
+        //   ③ state=ok 只代表"**声明的那一处比较**与源一致"(契约 §Checker Surface 末句),
+        //      不代表正文/解释/整条资料为真 —— 这句原文照搬到界面上。
+        // 安全:全部资料文本与错误都经 el() 的 textContent 出口(本文件一处 innerHTML 都没有);
+        //      资料里写 <img onerror=…> 只会是**字符**,不会变成节点。
+        var LIB_CAT = { 'standard-value': '标准值', boundary: '边界', 'project-spec': '项目规格', 'external-api': '外部接口' };
+        var LIB_SRC = { standard: '标准', 'official-doc': '官方文档', manual: '人工', 'our-code': '自有代码', web: '网页' };
+        var LIB_ST = { active: '有效', superseded: '已被新版取代', withdrawn: '已撤下' };
+        var LIB_CK = { ok: '一致', wrong: '不一致', unknown: '未能判定' };
+        var LIB_CMP = { exact: 'exact(逐字节)', 'text-lf': 'text-lf(只归一 CRLF/CR)' };
+        // 三个竞态令牌(单调递增整数)。为什么必须有:一次点击 = 一个异步往返,而面板是**同一个
+        // body 反复重画**的 —— 没有令牌时,先发的慢应答会后到,把后来那份内容顶掉(串条目/串列表)。
+        var libSeq = 0;        // 检索
+        var libDetailSeq = 0;  // 条目详情 / 修订链 / 核对留痕
+        var libActionSeq = 0;  // 写操作(新建/修订/撤下/核对)
+
+        function libMap(map, key, fallback) {
+          if (key === null || key === undefined || key === '') return fallback || '—';
+          return Object.prototype.hasOwnProperty.call(map, key) ? map[key] : String(key);
+        }
+        /** 失败回执的人话:`message` 优先(后端写得更准),`reason` 是机器码,**两个都留着**。 */
+        function libWhy(r, fallback) {
+          if (!r) return fallback;
+          var m = r.message ? String(r.message) : '';
+          var c = r.reason ? String(r.reason) : '';
+          if (m && c) return m + '(' + c + ')';
+          return m || c || fallback;
+        }
+        function libHash(h) {
+          var s = String(h || '');
+          return s === '' ? '—' : (s.length > 26 ? (s.slice(0, 18) + '…' + s.slice(-6)) : s);
+        }
+        function libShow(v) {
+          return String(v === null || v === undefined || v === '' ? '—' : v);
+        }
+        function libKV(grid, label, value, mono) {
+          grid.appendChild(el('div', 'k', label));
+          grid.appendChild(el('div', mono ? 'lib-mono' : null, libShow(value)));
+          return grid;
+        }
+        function libStat() {
+          var L = st.lib;
+          var s = L.status && L.status.store ? L.status.store : null;
+          var t = s && s.items ? Number(s.items.total) : null;
+          return Number.isFinite(t) ? t : null;
+        }
+        function libSpecText(spec) {
+          if (spec === null || spec === undefined) return '(null —— 这条不可核对:没有声明任何可机械比较的东西)';
+          try { return JSON.stringify(spec, null, 2); } catch (e) { return '(规格无法序列化)'; }
+        }
+
+        // ---- 状态栏:不可用/未启用必须**显式**,且与"零命中"分开说 ----
+        function libStatusBox() {
+          var L = st.lib;
+          if (!L.statusLoaded) return el('div', 'lib-status', '正在读取图书馆状态…');
+          var r = L.status, tone = 'ok', text = '';
+          if (L.statusErr || !r) {
+            tone = 'bad';
+            text = '图书馆状态读不到(' + (L.statusErr || '网关没有回执') + ')。若下面的检索也失败,说明网关/运行时整体不可达,而不是"图书馆是空的"。';
+          } else if (r.ok === false) {
+            tone = 'bad';
+            text = '图书馆不可用:' + libWhy(r, '运行时未给出原因');
+          } else if (r.enabled === false) {
+            tone = 'warn';
+            text = '图书馆未启用(配置 library.enabled = false)—— 记忆与其余四个标签不受影响。';
+          } else if (r.available === false) {
+            tone = 'bad';
+            text = '图书馆不可用:' + libWhy(r, '存储或裁判员未就绪');
+          } else {
+            var s = (r.store && r.store.ok !== false) ? r.store : null;
+            var c = r.checker || null;
+            var bits = [];
+            if (s && s.items) {
+              bits.push('条目 ' + Number(s.items.total || 0)
+                + '(有效 ' + Number(s.items.active || 0) + ' / 已取代 ' + Number(s.items.superseded || 0)
+                + ' / 已撤下 ' + Number(s.items.withdrawn || 0) + ')');
+            }
+            if (s && s.checks) bits.push('核对留痕 ' + Number(s.checks.total || 0) + ' 条(已采纳 ' + Number(s.checks.adopted || 0) + ')');
+            if (c) {
+              bits.push('裁判员' + (c.closed ? '已关闭' : '就绪')
+                + (Number(c.activeCount) > 0 ? '(在飞 ' + Number(c.activeCount) + ')' : '')
+                + ' · 传输 ' + (c.transport || '?')
+                + ' · 源根 ' + Number(c.codeRootCount || 0) + ' 个 / 官方 URL ' + Number(c.officialUrlCount || 0) + ' 条');
+            }
+            text = '图书馆可用' + (bits.length ? ' · ' + bits.join(' · ') : '');
+          }
+          var box = el('div', 'lib-status ' + tone);
+          box.appendChild(el('div', null, text));
+          box.appendChild(el('div', 'm-meta',
+            '图书馆是独立于记忆库的另一套存储:不参与开场注入、不与记忆条目混排。'
+            + '这里只放"有源可对账"的资料(值 + 出处 + 取数时间 + 核对规格),'
+            + '核对只认证声明的那一处比较,不认证正文或解释。'));
+          return box;
+        }
+        function libLoadStatus(force) {
+          var L = st.lib;
+          // 读在飞时又来了写动作 ⇒ 记一笔"读完再补一次":直接 return 会把这次失效请求**吞掉**,
+          // 屏幕上就留下"写之后统计不动"(2026-10-07 真机缺陷的同一个缝)。
+          if (L.statusLoading) { if (force) L.statusAgain = true; return; }
+          if (L.statusLoaded && !force) return;
+          L.statusLoading = true;
+          var done = function (r, err) {
+            L.statusLoading = false;
+            L.statusLoaded = true;
+            L.status = r || null;
+            L.statusErr = err || (r ? '' : '网关没有回执');
+            if (st.tab === 'library') renderLibrary();
+            if (L.statusAgain) { L.statusAgain = false; libLoadStatus(true); }
+          };
+          api('/library/status').then(function (r) { done(r, ''); })
+            .catch(function () { done(null, '网关不可达'); });
+        }
+
+        // ---- 表单:字段值一律存在 st.lib.form 里 ⇒ 出错重画**不抹掉**主人填的东西 ----
+        function libBlankForm() {
+          return {
+            title: '', body: '', category: 'standard-value', source_kind: 'manual',
+            source_ref: '', as_of: '', version: '', conditions: '',
+            specMode: 'builder', specKind: 'none', start: '1', end: '1', pointer: '',
+            expectedText: '', expectedJson: '', comparison: 'exact', specJson: '',
+          };
+        }
+        function libFormFromItem(it) {
+          var f = libBlankForm();
+          f.title = it.title || '';
+          f.body = it.body || '';
+          f.category = it.category || 'standard-value';
+          f.source_kind = it.source_kind || 'manual';
+          f.source_ref = it.source_ref || '';
+          f.as_of = it.as_of || '';
+          f.version = it.version === null || it.version === undefined ? '' : String(it.version);
+          f.conditions = it.conditions === null || it.conditions === undefined
+            ? '' : (typeof it.conditions === 'string' ? it.conditions : JSON.stringify(it.conditions, null, 2));
+          var sp = it.check_spec;
+          if (sp && sp.locator) {
+            f.comparison = sp.comparison === 'text-lf' ? 'text-lf' : 'exact';
+            if (sp.locator.kind === 'lines') {
+              f.specKind = 'lines';
+              f.start = String(sp.locator.start);
+              f.end = String(sp.locator.end);
+              f.expectedText = typeof sp.expected === 'string' ? sp.expected : JSON.stringify(sp.expected);
+            } else if (sp.locator.kind === 'json-pointer') {
+              f.specKind = 'json-pointer';
+              f.pointer = String(sp.locator.pointer === undefined ? '' : sp.locator.pointer);
+              f.expectedJson = JSON.stringify(sp.expected === undefined ? null : sp.expected, null, 2);
+            }
+          }
+          f.specJson = (sp === null || sp === undefined) ? 'null' : JSON.stringify(sp, null, 2);
+          return f;
+        }
+        /** 必填 + as_of 形状(客户端先拦一道,免得把"我以为填了"发出去;服务端仍会再判一次)。 */
+        function libFormProblems(f) {
+          var out = [];
+          if (!String(f.title || '').trim()) out.push('title 必填');
+          if (String(f.body || '') === '') out.push('body 必填(正文不能为空)');
+          if (!String(f.source_ref || '').trim()) out.push('source_ref 必填(没有出处就不许进图书馆)');
+          var asOf = String(f.as_of || '').trim();
+          if (asOf === '') out.push('as_of 必填(显式 ISO 日期或带 Z 的 UTC 时刻,不由创建时间推断)');
+          else if (!/^\d{4}-\d{2}-\d{2}([T ]\d{2}:\d{2}:\d{2}(\.\d{1,9})?Z)?$/.test(asOf)) {
+            out.push('as_of 形状不对:要 YYYY-MM-DD,或带 Z 的 UTC 时刻(如 2026-10-06T00:00:00Z)');
+          }
+          return out;
+        }
+        /** conditions:空 = 不写;以 { 或 [ 开头按 JSON 解析,否则按纯文本(store 两种都收)。 */
+        function libConditionsOf(f) {
+          var raw = String(f.conditions || '').trim();
+          if (raw === '') return { ok: true, value: undefined };
+          if (raw.charAt(0) === '{' || raw.charAt(0) === '[') {
+            try { return { ok: true, value: JSON.parse(raw) }; }
+            catch (e) { return { ok: false, message: 'conditions JSON 解析失败:' + ((e && e.message) || '语法错误') }; }
+          }
+          return { ok: true, value: raw };
+        }
+        /** 核对规格:{ok:true,value}(null = 不可核)或 {ok:false,message}。**提交前**就要能报错。 */
+        function libSpecProblems(f) {
+          if (f.specMode === 'json') {
+            var raw = String(f.specJson || '').trim();
+            if (raw === '') return { ok: true, value: null };
+            var v;
+            try { v = JSON.parse(raw); }
+            catch (e) { return { ok: false, message: '核对规格 JSON 解析失败:' + ((e && e.message) || '语法错误') }; }
+            if (v === null) return { ok: true, value: null };
+            if (typeof v !== 'object' || Array.isArray(v)) {
+              return { ok: false, message: '核对规格只能是 JSON 对象或 null;有限格式:{locator:{kind,start,end|pointer},expected,comparison}' };
+            }
+            return { ok: true, value: v };
+          }
+          if (f.specKind === 'none') return { ok: true, value: null };
+          if (f.specKind === 'lines') {
+            var s = String(f.start === undefined ? '' : f.start).trim();
+            var e2 = String(f.end === undefined ? '' : f.end).trim();
+            if (!/^\d+$/.test(s) || !/^\d+$/.test(e2) || Number(s) < 1 || Number(e2) < Number(s)) {
+              return { ok: false, message: 'lines 定位要 1 ≤ start ≤ end 的整数行号(现在是 start=' + libShow(s) + ' end=' + libShow(e2) + ')' };
+            }
+            if (f.comparison === 'text-lf' && typeof f.expectedText !== 'string') {
+              return { ok: false, message: 'text-lf 只用于文本:expected 必须是文本' };
+            }
+            return {
+              ok: true,
+              value: {
+                locator: { kind: 'lines', start: Number(s), end: Number(e2) },
+                expected: String(f.expectedText === undefined ? '' : f.expectedText),
+                comparison: f.comparison,
+              },
+            };
+          }
+          var p = String(f.pointer === undefined ? '' : f.pointer).trim();
+          if (p !== '' && p.charAt(0) !== '/') return { ok: false, message: 'RFC 6901 指针必须以 / 开头(空串 = 整篇)' };
+          if (/~(?![01])/.test(p)) return { ok: false, message: 'RFC 6901 指针里 ~ 只能出现在 ~0 / ~1 中' };
+          var rawJ = String(f.expectedJson === undefined ? '' : f.expectedJson).trim();
+          if (rawJ === '') return { ok: false, message: 'json-pointer 规格必须显式给 expected(JSON 值;null 也算显式)' };
+          var ev;
+          try { ev = JSON.parse(rawJ); }
+          catch (e3) { return { ok: false, message: 'expected JSON 解析失败:' + ((e3 && e3.message) || '语法错误') }; }
+          if (f.comparison === 'text-lf' && typeof ev !== 'string') {
+            return { ok: false, message: 'text-lf 只用于文本:json-pointer 的 expected 得是 JSON 字符串(要逐字节比就用 exact)' };
+          }
+          return {
+            ok: true,
+            value: { locator: { kind: 'json-pointer', pointer: p }, expected: ev, comparison: f.comparison },
+          };
+        }
+
+        // ---- 检索 ----
+        function libSearch(offset) {
+          var L = st.lib;
+          var q = String(L.q || '').trim();
+          L.err = '';
+          L.notice = '';
+          if (q === '') {
+            // 服务端口径:空查询是**参数错误**(library-store.js:1268),不是"返回全部"。
+            // 客户端先拦:不发这个注定失败、且容易被误读成"没有数据"的请求。
+            L.err = '检索需要一个关键词:图书馆的检索不接受空查询(空查询会返回全部条目,那不是检索)。';
+            if (st.tab === 'library') renderLibrary();
+            return;
+          }
+          var token = ++libSeq;
+          var off = Number(offset);
+          L.offset = Number.isFinite(off) && off >= 0 ? off : 0;
+          L.busy = true;
+          if (st.tab === 'library') renderLibrary();
+          api('/library/search?q=' + encodeURIComponent(q) + '&offset=' + L.offset + '&limit=' + L.limit)
+            .then(function (r) {
+              if (token !== libSeq) return;   // 迟到的旧应答:丢弃(不把上一次查询的结果画进这一次)
+              L.busy = false;
+              L.searchedOnce = true;
+              if (!r || !r.ok) {
+                L.items = [];
+                L.nextOffset = null;
+                L.truncated = false;
+                L.err = '检索没有成功:' + libWhy(r, '网关没有回执') + '(这不等于"图书馆是空的")';
+                if (st.tab === 'library') renderLibrary();
+                return;
+              }
+              L.items = Array.isArray(r.items) ? r.items : [];
+              L.nextOffset = r.nextOffset === null || r.nextOffset === undefined ? null : Number(r.nextOffset);
+              L.truncated = !!r.truncated;
+              L.offset = Number(r.offset === undefined ? L.offset : r.offset);
+              if (st.tab === 'library') renderLibrary();
+            })
+            .catch(function () {
+              if (token !== libSeq) return;
+              L.busy = false;
+              L.searchedOnce = true;
+              L.items = [];
+              L.nextOffset = null;
+              L.truncated = false;
+              L.err = '检索失败(网关不可达)—— 这不等于"图书馆是空的"。';
+              if (st.tab === 'library') renderLibrary();
+            });
+        }
+
+        // ---- 条目详情 + 修订链 + 核对留痕 ----
+        function libOpenItem(id, keepNotice) {
+          var L = st.lib;
+          var token = ++libDetailSeq;
+          L.view = 'item';
+          L.itemId = id;
+          L.item = null;
+          L.detailErr = '';
+          L.hist = null;
+          L.checks = null;
+          L.checkResult = null;
+          L.checkErr = '';
+          L.err = '';
+          if (!keepNotice) L.notice = '';
+          if (st.tab === 'library') renderLibrary();
+          api('/library/item?id=' + encodeURIComponent(id)).then(function (r) {
+            if (token !== libDetailSeq) return;
+            if (!r || !r.ok) L.detailErr = '读取条目失败:' + libWhy(r, '网关没有回执');
+            else if (!r.found) L.detailErr = '这条已不在库里(found=false)—— 可能已被物理处置或 id 不对。';
+            else L.item = r.item || null;
+            if (st.tab === 'library') renderLibrary();
+          }).catch(function () {
+            if (token !== libDetailSeq) return;
+            L.detailErr = '读取条目失败(网关不可达)。';
+            if (st.tab === 'library') renderLibrary();
+          });
+          libLoadHistory(id, 0, token);
+          libLoadChecks(id, 0, token);
+        }
+        function libLoadHistory(id, offset, token) {
+          var L = st.lib;
+          var t = token === undefined ? ++libDetailSeq : token;
+          api('/library/history?id=' + encodeURIComponent(id) + '&offset=' + offset + '&limit=' + L.limit)
+            .then(function (r) {
+              if (t !== libDetailSeq || L.itemId !== id) return;   // 已经切到别的条目:丢弃
+              L.hist = (r && r.ok) ? r : null;
+              if (r && !r.ok) L.detailErr = L.detailErr || ('读取修订链失败:' + libWhy(r, '网关没有回执'));
+              if (st.tab === 'library') renderLibrary();
+            })
+            .catch(function () {
+              if (t !== libDetailSeq || L.itemId !== id) return;
+              L.hist = null;
+              if (st.tab === 'library') renderLibrary();
+            });
+        }
+        function libLoadChecks(id, offset, token) {
+          var L = st.lib;
+          var t = token === undefined ? ++libDetailSeq : token;
+          api('/library/checks?id=' + encodeURIComponent(id) + '&offset=' + offset + '&limit=' + L.limit)
+            .then(function (r) {
+              if (t !== libDetailSeq || L.itemId !== id) return;
+              L.checks = (r && r.ok) ? r : null;
+              if (r && !r.ok) L.detailErr = L.detailErr || ('读取核对留痕失败:' + libWhy(r, '网关没有回执'));
+              if (st.tab === 'library') renderLibrary();
+            })
+            .catch(function () {
+              if (t !== libDetailSeq || L.itemId !== id) return;
+              L.checks = null;
+              if (st.tab === 'library') renderLibrary();
+            });
+        }
+        /** status 是**一次性缓存**(见 libLoadStatus 的 `if (L.statusLoaded && !force) return;`)。
+         *  所以**任何写动作之后都必须让它失效** —— 否则顶部「条目 / 留痕」统计会一直停在写之前的值,
+         *  同页出现"结果盒是新的、统计还是旧的"两套读数(2026-10-07 真机实测的界面缺陷)。 */
+        function libInvalidateStatus() {
+          st.lib.statusLoaded = false;
+          libLoadStatus(true);
+        }
+        /** 写动作之后把**同一条**受影响的三份读数(条目 / 修订链 / 留痕)重读一遍。
+         *  ⚠️ 代次(token)必须**共享**:libLoadHistory / libLoadChecks 在缺 token 时各自 `++libDetailSeq`,
+         *     连着调两次会让先发的那次当场作废(`t !== libDetailSeq` 直接 return)——
+         *     实测会表现为"重读了但屏幕上没变",比不重读更难查。
+         *  ⚠️ 本函数**不动** L.checkResult:那是本次操作的结果盒,清掉等于把刚做完的事从屏幕上撤了。
+         *  条目重读失败**不改写**既有视图(下一次点开即真值),不在这里编一个折中状态。 */
+        function libReloadDetail(id) {
+          var L = st.lib;
+          var token = ++libDetailSeq;
+          api('/library/item?id=' + encodeURIComponent(id)).then(function (r) {
+            if (token !== libDetailSeq || L.itemId !== id) return;   // 已经切走:丢弃
+            if (r && r.ok && r.found) L.item = r.item || null;
+            if (st.tab === 'library') renderLibrary();
+          }).catch(function () { /* 读不到就保持现有视图,不猜 */ });
+          libLoadHistory(id, 0, token);
+          libLoadChecks(id, 0, token);
+        }
+        /** 列表那张「认证:未核对」标签是从 `L.items` 画的(renderLibList → libRow),
+         *  而 `L.items` **只在 libSearch 里更新** ⇒ 重读详情/统计**不足以**让列表跟上:
+         *    · 在**列表行**上点「核对」⇒ 行上的标签仍旧;
+         *    · 从详情「← 返回列表」⇒ 返回的是一个**写之前的旧页**(撤下的还挂在列表里)。
+         *  所以两处都要重跑当前检索。详情视图里不重跑:那会把主人正在看的条目连同滚动位置换掉。 */
+        function libReloadList() {
+          var L = st.lib;
+          if (L.view === 'item') return;
+          if (String(L.q || '').trim() === '') return;   // 检索不接受空查询:不发注定失败的请求
+          libSearch(L.offset);
+        }
+
+        // ---- 核对(按钮;取消绝不伪成功)----
+        function libCheck(it) {
+          var L = st.lib;
+          if (!it || !it.id || L.checking) return;
+          var token = ++libActionSeq;
+          L.checking = true;
+          L.checkResult = null;
+          L.checkErr = '';
+          L.err = '';
+          L.notice = '';
+          if (st.tab === 'library') renderLibrary();
+          api('/library/check', { method: 'POST', body: { id: it.id } }).then(function (r) {
+            if (token !== libActionSeq) return;
+            L.checking = false;
+            if (!r) {
+              L.checkErr = '核对没有回执(网关不可达)—— 不知道有没有写入,请刷新「核对留痕」再判断,不当作已核对。';
+            } else if (r.cancelled) {
+              L.checkErr = '已取消 —— 契约保证取消不写认证;界面不把它当成功(没有伪造一个 state)。';
+            } else if (r.state === undefined || r.ok === false) {
+              // 被拒(closed / in_flight / concurrency_limit / 存储面失败):**不算一次核对**。
+              // 即使运行时给了 state(拒绝时它也是 'unknown'),也不把它当成"核对结果"渲染 ——
+              // 那会把"没查"读成"查了但没判定"。recorded=false 一并写出来。
+              L.checkErr = '核对未执行(这次没有写入任何认证):' + libWhy(r, '运行时未给出原因')
+                + ' · recorded=' + (r.recorded ? 'true' : 'false');
+            } else {
+              L.checkResult = r;
+              // 写动作之后把受影响的读数**全部**重读(2026-10-07 真机缺陷:只重读「留痕」会让同页
+              // 出现两套读数 —— 结果盒/留痕是新的,条目标签、明细 checked_state、修订链计数、顶部统计还是旧的)。
+              libReloadDetail(it.id);
+              libInvalidateStatus();
+              libReloadList();          // 在列表行上核对时:那一行的标签也要跟上(详情视图里自动跳过)
+            }
+            if (st.tab === 'library') renderLibrary();
+          }).catch(function () {
+            if (token !== libActionSeq) return;
+            L.checking = false;
+            L.checkErr = '核对失败(网关不可达)—— 不知道有没有写入,请刷新「核对留痕」再判断。';
+            if (st.tab === 'library') renderLibrary();
+          });
+        }
+        function libResultBox(r) {
+          var box = el('div', 'lib-card');
+          box.appendChild(el('div', 'm-title', '核对结果:' + libMap(LIB_CK, r.state, '未给 state')));
+          var meta = [];
+          meta.push('state=' + libShow(r.state));
+          meta.push('recorded=' + (r.recorded ? 'true' : 'false'));
+          if (r.adopted !== undefined) meta.push('adopted=' + (r.adopted ? 'true' : 'false'));
+          if (r.adoption_reason) meta.push('adoption_reason=' + r.adoption_reason);
+          if (r.reason) meta.push('reason=' + r.reason);
+          box.appendChild(el('div', 'm-meta', meta.join(' · ')));
+          box.appendChild(el('div', 'm-meta',
+            '口径:state=ok 只说明"声明的那一处比较与源一致"—— 不说明这条资料的正文、解释或结论为真。'
+            + '顶层 reason 是「这次比较」的结论(不一致时是 declared_comparison_mismatch);'
+            + '"为什么没被采纳"看 record.reason(通常是 stale_or_inactive),采纳与否另由 adopted 表示。'));
+          if (r.record && r.record.reason) {
+            box.appendChild(el('div', 'm-meta', 'record.reason=' + r.record.reason
+              + (r.record.check_sequence !== undefined ? ' · check_sequence=' + r.record.check_sequence : '')));
+          }
+          box.appendChild(el('div', 'm-meta', '核对凭据(evidence)—— 全部字段为文本,不解释执行'));
+          box.appendChild(el('div', 'lib-pre',
+            r.evidence ? JSON.stringify(r.evidence, null, 2) : '(这次没有凭据)'));
+          return box;
+        }
+
+        // ---- 新建 / 修订 ----
+        function libSaveForm() {
+          var L = st.lib;
+          var f = L.form || libBlankForm();
+          if (L.busy) return;
+          L.err = '';
+          L.notice = '';
+          var problems = libFormProblems(f);
+          var cond = libConditionsOf(f);
+          var spec = libSpecProblems(f);
+          if (!cond.ok) problems.push(cond.message);
+          if (!spec.ok) problems.push(spec.message);
+          if (problems.length) {
+            L.err = '没有发出任何请求(先在界面上改好):' + problems.join(' · ') + '。你填的内容一个字段都没动。';
+            if (st.tab === 'library') renderLibrary();
+            return;
+          }
+          var item = {
+            title: String(f.title).trim(),
+            body: String(f.body),
+            category: f.category,
+            source_kind: f.source_kind,
+            source_ref: String(f.source_ref).trim(),
+            as_of: String(f.as_of).trim(),
+            check_spec: spec.value,
+          };
+          if (String(f.version === undefined ? '' : f.version).trim() !== '') item.version = String(f.version).trim();
+          if (cond.value !== undefined) item.conditions = cond.value;
+          // ⚠️ 提交体里**只有**可编辑字段:content_hash/state/checked_state/checked_at 一个都不带
+          //   (带了会被 store 以 readonly_field 拒;旧 id 也不是"顺手覆盖"的凭据)。
+          var revising = L.formMode === 'revise' && L.formItem && L.formItem.id;
+          var id = revising ? L.formItem.id : '';
+          var expectedHash = revising ? L.formItem.content_hash : '';
+          var token = ++libActionSeq;
+          L.busy = true;
+          if (st.tab === 'library') renderLibrary();
+          var req = revising
+            ? api('/library/revise', { method: 'POST', body: { id: id, item: item, expectedHash: expectedHash } })
+            : api('/library/create', { method: 'POST', body: { item: item } });
+          req.then(function (r) {
+            if (token !== libActionSeq) return;
+            L.busy = false;
+            if (!r) {
+              L.err = '提交没有回执(网关不可达)—— 你的填写还在,可以直接重试。';
+              if (st.tab === 'library') renderLibrary();
+              return;
+            }
+            if (!r.ok) {
+              if (r.reason === 'hash_mismatch') { libStale(id, r); return; }
+              L.err = '提交被拒:' + libWhy(r, '未给出原因') + ' —— 你的填写还在,改完可以直接再提交。';
+              if (st.tab === 'library') renderLibrary();
+              return;
+            }
+            var saved = r.item || null;
+            toast(revising ? '已提交修订(新版本换了新 id,认证状态已重置)' : '已新建资料', 4800);
+            L.form = null;
+            L.formItem = null;
+            // 新建 / 修订都改变库的读数(条数、修订链、留痕)⇒ status 必须失效重读,
+            // 否则顶部「条目 / 留痕」统计会一直显示写之前的值(2026-10-07 真机实测)。
+            libInvalidateStatus();
+            if (saved && saved.id) libOpenItem(saved.id);
+            else { L.view = 'list'; libSearch(L.offset); }
+          }).catch(function () {
+            if (token !== libActionSeq) return;
+            L.busy = false;
+            L.err = '提交失败(网关不可达)—— 你的填写还在,可以直接重试。';
+            if (st.tab === 'library') renderLibrary();
+          });
+        }
+        /** 陈旧冲突:报告实情 + 重新载入当前版本,**绝不覆盖**主人填的内容、也不重发。 */
+        function libStale(id, r) {
+          var L = st.lib;
+          L.busy = false;
+          L.err = '';
+          var cur = r && r.current_hash ? ('库中当前 content_hash = ' + String(r.current_hash) + ';') : '';
+          L.notice = '陈旧冲突(hash_mismatch):提交时用的 content_hash 与库中当前值不一致 —— '
+            + '没有覆盖任何内容,也没有重发。' + cur + '已按下述方式重新载入当前版本,请对照差异后重填或重试。';
+          if (id) {
+            api('/library/item?id=' + encodeURIComponent(id)).then(function (rr) {
+              if (rr && rr.ok && rr.found && rr.item) {
+                L.formItem = rr.item;      // 只更新"当前版本是什么",不动表单里主人填的字段
+                L.item = rr.item;
+              }
+              if (st.tab === 'library') renderLibrary();
+            }).catch(function () { if (st.tab === 'library') renderLibrary(); });
+          }
+          if (st.tab === 'library') renderLibrary();
+        }
+        function libWithdraw(it) {
+          var L = st.lib;
+          var reason = String(L.withdrawReason || '').trim();
+          L.err = '';
+          L.notice = '';
+          if (!reason) {
+            L.err = '没有发出请求:撤下必须给出原因(撤下不是静默删除)。';
+            if (st.tab === 'library') renderLibrary();
+            return;
+          }
+          if (it.state !== 'active') {
+            L.err = '这条当前是「' + libMap(LIB_ST, it.state, it.state) + '」—— 只有有效最新版才能撤下。';
+            if (st.tab === 'library') renderLibrary();
+            return;
+          }
+          var ask = '撤下《' + it.title + '》?\n\n· 撤下是终态:之后不能再修订\n'
+            + '· 不物理删除:修订链与核对留痕都保留\n· 原因:' + reason;
+          var agreed = false;
+          try { agreed = (typeof window.confirm === 'function') ? !!window.confirm(ask) : false; }
+          catch (e) { agreed = false; }
+          if (!agreed) {
+            L.notice = '已取消撤下 —— 没有发出任何请求,条目一个字节都没动。'
+              + (typeof window.confirm === 'function' ? '' : '(本环境没有确认框,按取消处理。)');
+            if (st.tab === 'library') renderLibrary();
+            return;
+          }
+          var token = ++libActionSeq;
+          L.busy = true;
+          if (st.tab === 'library') renderLibrary();
+          api('/library/withdraw', { method: 'POST', body: { id: it.id, reason: reason, expectedHash: it.content_hash } })
+            .then(function (r) {
+              if (token !== libActionSeq) return;
+              L.busy = false;
+              if (!r) {
+                L.err = '撤下没有回执(网关不可达)—— 不知道有没有生效,请刷新这条再判断。';
+                if (st.tab === 'library') renderLibrary();
+                return;
+              }
+              if (!r.ok) {
+                if (r.reason === 'hash_mismatch') { libStale(it.id, r); return; }
+                L.err = '撤下被拒:' + libWhy(r, '未给出原因');
+                if (st.tab === 'library') renderLibrary();
+                return;
+              }
+              toast('已撤下《' + it.title + '》(留痕不删)', 4800);
+              L.withdrawReason = '';
+              // 撤下改变「有效 / 已撤下」计数 ⇒ 同 create / revise,status 也要失效重读。
+              libInvalidateStatus();
+              libOpenItem(it.id, false);
+            })
+            .catch(function () {
+              if (token !== libActionSeq) return;
+              L.busy = false;
+              L.err = '撤下失败(网关不可达)—— 请刷新这条再判断是否生效。';
+              if (st.tab === 'library') renderLibrary();
+            });
+        }
+
+        // ---- 三个视图 ----
+        function libPageRow(items, meta, onGo) {
+          var row = el('div', 'm-acts');
+          var prev = el('button', null, '上一页');
+          var next = el('button', null, '下一页');
+          var off = Number(meta.offset) || 0;
+          var lim = Number(meta.limit) || 20;
+          var nextOff = meta.nextOffset === null || meta.nextOffset === undefined ? null : Number(meta.nextOffset);
+          prev.disabled = off <= 0;
+          next.disabled = nextOff === null;
+          prev.onclick = function () { onGo(Math.max(0, off - lim)); };
+          next.onclick = function () { if (nextOff !== null) onGo(nextOff); };
+          row.appendChild(prev);
+          row.appendChild(next);
+          row.appendChild(el('span', 'm-meta', '本页 ' + items.length + ' 条 · 偏移 ' + off + ' · '
+            + (meta.truncated ? ('还有更多(下一批从 ' + libShow(nextOff) + ' 开始)') : '没有更多了')));
+          return row;
+        }
+        function renderLibList() {
+          var L = st.lib;
+          var tools = el('div', 'm-tools');
+          var search = document.createElement('input');
+          search.type = 'search';
+          search.placeholder = '搜索标题 / 正文 / 类目…(服务端不接受空查询)';
+          search.value = L.q;
+          search.oninput = function () { L.q = search.value; };
+          search.onkeydown = function (ev) { if (ev && ev.key === 'Enter') libSearch(0); };
+          var bGo = el('button', 'primary', '查询');
+          bGo.onclick = function () { libSearch(0); };
+          var bNew = el('button', null, '＋ 新建资料');
+          bNew.onclick = function () {
+            L.form = libBlankForm();
+            L.formItem = null;
+            L.formMode = 'create';
+            L.view = 'form';
+            L.err = '';
+            L.notice = '';
+            if (st.tab === 'library') renderLibrary();
+          };
+          var bSt = el('button', null, '刷新状态');
+          bSt.onclick = function () { libLoadStatus(true); };
+          // 导入面入口(图书馆):从"源"进来,而不是从"一条条手敲"进来。
+          var bImp = el('button', null, '⬆ 导入(粘贴 / 文件)');
+          bImp.onclick = function () { libImpOpen(); };
+          // 浏览面入口(第七面,2026-10-13):**不搜也能翻** —— 上面那张检索要求关键词,
+          // 这里按「类目 → 来源」自己走进去(服务端的检索不接受空查询,所以这一条是必需的)。
+          var bBr = el('button', null, '🗂 浏览(不搜也能翻)');
+          bBr.onclick = function () { libBrOpen(); };
+          tools.appendChild(search);
+          tools.appendChild(bGo);
+          tools.appendChild(bNew);
+          tools.appendChild(bImp);
+          tools.appendChild(bBr);
+          tools.appendChild(bSt);
+          body.appendChild(tools);
+          if (L.err) body.appendChild(el('div', 'lib-err', L.err));
+          if (L.notice) body.appendChild(el('div', 'lib-note', L.notice));
+          var items = L.items;
+          if (L.busy) {
+            // 在飞时如实说"正在检索":首查时不留"还没有查询"这种误导(那会让人以为请求没发出去),
+            // 续查时说明下面那块是**上一次**的结果(不是本次的)。
+            body.appendChild(el('div', 'm-meta', items ? '正在检索…(下面是上一次的结果)' : '正在检索…'));
+          }
+          if (!items) {
+            if (L.busy) return;
+            var total = libStat();
+            body.appendChild(el('div', 'm-empty', total === 0
+              ? '图书馆里还没有资料。这里不预置种子资料、也不从记忆库迁移 —— 资料靠「＋ 新建资料」或官方文档核对一条条进来。'
+              : (total === null
+                ? '还没有查询。填一个关键词后点「查询」。'
+                : '还没有查询。图书馆现有 ' + total + ' 条资料(含已取代/已撤下的历史版本):填关键词后点「查询」——服务端的检索不接受空查询。')));
+            return;
+          }
+          if (!items.length) {
+            body.appendChild(el('div', 'm-empty', L.searchedOnce
+              ? ('没有匹配「' + String(L.q).trim() + '」的资料 —— 这是本轮检索为空,不代表图书馆是空的(换词再查)。')
+              : '正在检索…'));
+            return;
+          }
+          for (var i = 0; i < items.length; i++) body.appendChild(libRow(items[i]));
+          body.appendChild(libPageRow(items, {
+            offset: L.offset, limit: L.limit, nextOffset: L.nextOffset, truncated: L.truncated,
+          }, function (off) { libSearch(off); }));
+          body.appendChild(el('div', 'm-meta',
+            '回执只给本页条数与"还有没有更多",不给总数 —— 所以这里不写"共 N 条"。'
+            + '默认检索只看有效最新版:已取代/已撤下的版本不出现在结果里,但它们的留痕在条目的修订链与核对历史里。'));
+        }
+        function libRow(it) {
+          var L = st.lib;
+          var row = el('div', 'm-row');
+          row.appendChild(el('div', 'm-title', libShow(it.title)));
+          var chips = el('div', null);
+          chips.appendChild(el('span', 'lib-chip', libMap(LIB_CAT, it.category, it.category)));
+          chips.appendChild(el('span', 'lib-chip', libMap(LIB_SRC, it.source_kind, it.source_kind)));
+          chips.appendChild(el('span', 'lib-chip', '认证:' + libMap(LIB_CK, it.checked_state, '未核对')));
+          chips.appendChild(el('span', 'lib-chip', libMap(LIB_ST, it.state, it.state)));
+          row.appendChild(chips);
+          row.appendChild(el('div', 'm-meta', 'r' + libShow(it.revision) + ' · as_of ' + libShow(it.as_of)
+            + ' · 核对时间 ' + libShow(it.checked_at) + ' · 更新 ' + libShow(it.updated_at)));
+          row.appendChild(el('div', 'm-meta lib-mono', 'source_ref ' + libShow(it.source_ref)));
+          row.appendChild(el('div', 'm-meta lib-mono', 'content_hash ' + libShow(it.content_hash)));
+          var acts = el('div', 'm-acts');
+          var bOpen = el('button', null, '详情 / 修订链 / 核对');
+          bOpen.onclick = function () { libOpenItem(it.id, false); };
+          var bCk = el('button', null, L.checking ? '核对中…' : '核对');
+          bCk.disabled = !!L.checking;
+          bCk.onclick = function () { libCheck(it); };
+          acts.appendChild(bOpen);
+          acts.appendChild(bCk);
+          row.appendChild(acts);
+          return row;
+        }
+        function renderLibItem() {
+          var L = st.lib;
+          var top = el('div', 'm-acts');
+          var back = el('button', null, '← 返回列表');
+          back.onclick = function () {
+            L.view = 'list';
+            L.item = null;
+            L.hist = null;
+            L.checks = null;
+            L.err = '';
+            L.notice = '';
+            if (st.tab === 'library') renderLibrary();
+            // 返回列表时重跑当前检索:否则返回的是一页**写之前**的旧数据
+            // (撤下的还挂在列表里、刚核对过的行标签还是「未核对」)。
+            libReloadList();
+          };
+          top.appendChild(back);
+          var bRefresh = el('button', null, '刷新这条');
+          bRefresh.onclick = function () { if (L.itemId) libOpenItem(L.itemId, true); };
+          top.appendChild(bRefresh);
+          if (L.item) {
+            var bRe = el('button', null, '修订这条');
+            bRe.disabled = L.item.state !== 'active';
+            bRe.onclick = function () {
+              L.form = libFormFromItem(L.item);
+              L.formItem = L.item;
+              L.formMode = 'revise';
+              L.view = 'form';
+              L.err = '';
+              L.notice = '';
+              if (st.tab === 'library') renderLibrary();
+            };
+            var bCk = el('button', 'primary', L.checking ? '核对中…' : '核对这条');
+            bCk.disabled = !!L.checking;
+            bCk.onclick = function () { libCheck(L.item); };
+            top.appendChild(bRe);
+            top.appendChild(bCk);
+          }
+          body.appendChild(top);
+          if (L.err) body.appendChild(el('div', 'lib-err', L.err));
+          if (L.notice) body.appendChild(el('div', 'lib-note', L.notice));
+          if (L.detailErr) body.appendChild(el('div', 'lib-err', L.detailErr));
+          if (!L.item) {
+            body.appendChild(el('div', 'm-empty', L.detailErr ? '' : '正在读取条目…'));
+            return;
+          }
+          var it = L.item;
+          var card = el('div', 'lib-card');
+          card.appendChild(el('div', 'm-title', libShow(it.title)));
+          var chips = el('div', null);
+          chips.appendChild(el('span', 'lib-chip', libMap(LIB_CAT, it.category, it.category)));
+          chips.appendChild(el('span', 'lib-chip', libMap(LIB_SRC, it.source_kind, it.source_kind)));
+          chips.appendChild(el('span', 'lib-chip', '状态:' + libMap(LIB_ST, it.state, it.state)));
+          chips.appendChild(el('span', 'lib-chip', '认证:' + libMap(LIB_CK, it.checked_state, '未核对')));
+          card.appendChild(chips);
+          var grid = el('div', 'lib-grid');
+          libKV(grid, '出处 source_ref', it.source_ref, true);
+          libKV(grid, '取数时间 as_of', it.as_of);
+          libKV(grid, 'content_hash', it.content_hash, true);
+          libKV(grid, 'state', libShow(it.state) + (it.superseded_by ? (' → 新版 ' + it.superseded_by) : ''));
+          libKV(grid, '修订 revision', 'r' + libShow(it.revision) + (it.previous_id ? (' · 上一版 ' + it.previous_id) : ' · 初版'));
+          libKV(grid, '认证 checked_state', libShow(it.checked_state) + ' · ' + libShow(it.checked_at));
+          libKV(grid, 'version', it.version);
+          libKV(grid, 'conditions', it.conditions === null || it.conditions === undefined
+            ? '—' : (typeof it.conditions === 'string' ? it.conditions : JSON.stringify(it.conditions)));
+          libKV(grid, 'id', it.id, true);
+          libKV(grid, 'lineage_id', it.lineage_id, true);
+          libKV(grid, 'created_at', it.created_at);
+          libKV(grid, 'updated_at', it.updated_at);
+          if (it.withdrawn_at) libKV(grid, '撤下', it.withdrawn_at + ' · 原因:' + libShow(it.withdrawn_reason));
+          card.appendChild(grid);
+          card.appendChild(el('div', 'm-meta', '正文(body)——纯文本渲染,不解释 HTML'));
+          card.appendChild(el('div', 'lib-pre', libShow(it.body)));
+          card.appendChild(el('div', 'm-meta', '核对规格(check_spec)——声明要机械比较的那一处'));
+          card.appendChild(el('div', 'lib-pre', libSpecText(it.check_spec)));
+          body.appendChild(card);
+
+          // 撤下:原因 + 确认(缺一样都不发请求)
+          var wRow = el('div', 'm-tools');
+          var wIn = document.createElement('input');
+          wIn.type = 'text';
+          wIn.placeholder = '撤下原因(必填:撤下不是静默删除)';
+          wIn.value = L.withdrawReason;
+          wIn.oninput = function () { L.withdrawReason = wIn.value; };
+          var bW = el('button', null, '撤下这条');
+          bW.disabled = it.state !== 'active';
+          bW.onclick = function () { libWithdraw(it); };
+          wRow.appendChild(wIn);
+          wRow.appendChild(bW);
+          body.appendChild(wRow);
+
+          if (L.checkErr) body.appendChild(el('div', 'lib-err', L.checkErr));
+          if (L.checkResult) body.appendChild(libResultBox(L.checkResult));
+          else if (L.checking) body.appendChild(el('div', 'm-empty', '正在核对(取源 / 定位 / 比较)…'));
+
+          // 修订链
+          var hCard = el('div', 'lib-card');
+          var hd = L.hist;
+          hCard.appendChild(el('div', 'm-title', '修订链'));
+          if (!hd) hCard.appendChild(el('div', 'm-meta', '正在读取修订链…'));
+          else {
+            var revs = Array.isArray(hd.revisions) ? hd.revisions : [];
+            hCard.appendChild(el('div', 'm-meta', '本谱系共 ' + libShow(hd.revision_count)
+              + ' 个版本(有效 ' + libShow(hd.counts && hd.counts.active) + ' / 已取代 '
+              + libShow(hd.counts && hd.counts.superseded) + ' / 已撤下 ' + libShow(hd.counts && hd.counts.withdrawn)
+              + ')—— 这是版本数,不是检索结果数。'));
+            for (var hi = 0; hi < revs.length; hi++) {
+              var rv = revs[hi];
+              var line = el('div', 'm-meta lib-mono', 'r' + libShow(rv.revision) + (rv.is_current ? ' (当前)' : '')
+                + ' · ' + libShow(rv.id) + ' · ' + libMap(LIB_ST, rv.state, rv.state)
+                + ' · 认证 ' + libShow(rv.checked_state) + ' · ' + libShow(rv.created_at)
+                + ' · 核对 ' + libShow(rv.check_count) + ' 次');
+              hCard.appendChild(line);
+              var revActs = el('div', 'm-acts');
+              var bOpenRev = el('button', null, '看这一版');
+              bOpenRev.onclick = (function (rid) {
+                return function () { libOpenItem(rid, false); };
+              })(rv.id);
+              revActs.appendChild(bOpenRev);
+              hCard.appendChild(revActs);
+            }
+            if (!revs.length) hCard.appendChild(el('div', 'm-meta', '这一页没有版本。'));
+            hCard.appendChild(libPageRow(revs, {
+              offset: hd.offset, limit: hd.limit, nextOffset: hd.nextOffset, truncated: hd.truncated,
+            }, function (off) { libLoadHistory(L.itemId, off); }));
+          }
+          body.appendChild(hCard);
+
+          // 核对留痕(checks 有精确 total,可以如实写"共 N 次")
+          var cCard = el('div', 'lib-card');
+          var ck = L.checks;
+          cCard.appendChild(el('div', 'm-title', '核对留痕'));
+          if (!ck) cCard.appendChild(el('div', 'm-meta', '正在读取核对留痕…'));
+          else {
+            var rows = Array.isArray(ck.checks) ? ck.checks : [];
+            cCard.appendChild(el('div', 'm-meta', '共 ' + libShow(ck.total) + ' 次核对(这一页 ' + rows.length
+              + ' 条)· 每次完成都留档;只有"仍是有效最新版且哈希未变"才采纳为当前认证。'));
+            for (var ci = 0; ci < rows.length; ci++) {
+              var cr = rows[ci];
+              cCard.appendChild(el('div', 'm-meta lib-mono', '第 ' + libShow(cr.check_sequence) + ' 次 · '
+                + libMap(LIB_CK, cr.state, cr.state) + ' · ' + libShow(cr.checked_at)
+                + ' · adopted=' + (cr.adopted ? 'true' : 'false')
+                + (cr.reason ? (' · reason=' + cr.reason) : '')
+                + ' · item_hash ' + libHash(cr.item_hash)));
+            }
+            if (!rows.length) cCard.appendChild(el('div', 'm-meta', '还没有核对过这条。'));
+            cCard.appendChild(libPageRow(rows, {
+              offset: ck.offset, limit: ck.limit, nextOffset: ck.nextOffset, truncated: ck.truncated,
+            }, function (off) { libLoadChecks(L.itemId, off); }));
+          }
+          body.appendChild(cCard);
+        }
+        function renderLibForm() {
+          var L = st.lib;
+          var f = L.form || (L.form = libBlankForm());
+          var editing = L.formMode === 'revise';
+          var top = el('div', 'm-acts');
+          var back = el('button', null, editing ? '← 返回这条' : '← 返回列表');
+          back.onclick = function () {
+            L.view = editing && L.formItem ? 'item' : 'list';
+            L.err = '';
+            L.notice = '';
+            if (st.tab === 'library') renderLibrary();
+          };
+          top.appendChild(back);
+          var bSave = el('button', 'primary', L.busy ? '提交中…' : (editing ? '提交修订' : '新建'));
+          bSave.disabled = !!L.busy;
+          bSave.onclick = function () { libSaveForm(); };
+          top.appendChild(bSave);
+          body.appendChild(top);
+          body.appendChild(el('div', 'm-title', editing ? ('修订《' + libShow(L.formItem && L.formItem.title) + '》') : '新建资料'));
+          body.appendChild(el('div', 'm-meta', editing
+            ? ('修订拿的是发起时观测到的 content_hash(' + libShow(L.formItem && L.formItem.content_hash)
+              + ');服务端会用它与库中当前值对账 —— 不一致就拒(hash_mismatch),不会覆盖。'
+              + '提交成功后是新 id、新版本,认证状态重置(checked_state/checked_at 不由这里写)。')
+            : '只读字段(id / revision / content_hash / state / checked_state / checked_at)由存储层与裁判员写,'
+              + '表单里不带它们;带了会被服务端以 readonly_field 拒。'));
+
+          var card = el('div', 'lib-card lib-form');
+          if (L.err) card.appendChild(el('div', 'lib-err', L.err));
+          if (L.notice) card.appendChild(el('div', 'lib-note', L.notice));
+          function label(text) { card.appendChild(el('label', null, text)); }
+          var liveCheck = null;   // 提交前即时校验的入口(在下面装配完 checkLine 后指向 refreshCheck)
+          function bindInput(node, key) {
+            node.value = f[key] === undefined || f[key] === null ? '' : String(f[key]);
+            // ⚠️ 这里只写 f 并**就地**刷新校验行,**绝不整页重绘** —— 重绘会重建输入框,
+            //   主人正在输入的字符与光标会被吃掉(本文件处处在意这件事,如 sheRefreshNode)。
+            node.oninput = function () { f[key] = node.value; if (liveCheck) liveCheck(); };
+            return node;
+          }
+          label('title(必填)');
+          var tIn = document.createElement('input');
+          tIn.type = 'text';
+          tIn.placeholder = '这条资料叫什么(一句话)';
+          card.appendChild(bindInput(tIn, 'title'));
+          label('body(必填:值本身,不是对值的解释)');
+          var taB = document.createElement('textarea');
+          taB.placeholder = '正文。核对比的是 check_spec 声明的那一处,不是这段话;但正文是给人读的,请写清"这是什么、从哪来"。';
+          card.appendChild(bindInput(taB, 'body'));
+          label('category(受控枚举)');
+          card.appendChild(makeSel([
+            { v: 'standard-value', l: '标准值' }, { v: 'boundary', l: '边界' },
+            { v: 'project-spec', l: '项目规格' }, { v: 'external-api', l: '外部接口' },
+          ], f.category, function (v) { f.category = v; }).node);
+          label('source_kind(受控枚举)');
+          card.appendChild(makeSel([
+            { v: 'standard', l: '标准' }, { v: 'official-doc', l: '官方文档(HTTPS 文档)' },
+            { v: 'manual', l: '人工' }, { v: 'our-code', l: '自有代码(绝对路径)' }, { v: 'web', l: '网页' },
+          ], f.source_kind, function (v) { f.source_kind = v; }).node);
+          label('source_ref(必填:出处。our-code = 绝对路径;official-doc = 管理员登记的精确 HTTPS URL)');
+          var refIn = document.createElement('input');
+          refIn.type = 'text';
+          refIn.placeholder = 'our-code: /abs/path/file.mjs · official-doc: https://…';
+          card.appendChild(bindInput(refIn, 'source_ref'));
+          label('as_of(必填:显式 ISO 日期或带 Z 的 UTC 时刻;不由创建时间推断)');
+          var asIn = document.createElement('input');
+          asIn.type = 'text';
+          asIn.placeholder = '2026-10-06 或 2026-10-06T00:00:00Z';
+          card.appendChild(bindInput(asIn, 'as_of'));
+          label('version(可选:显式适用版本)');
+          var verIn = document.createElement('input');
+          verIn.type = 'text';
+          verIn.placeholder = '留空 = 不声明版本';
+          card.appendChild(bindInput(verIn, 'version'));
+          label('conditions(可选:以 { 或 [ 开头按 JSON 解析,否则按纯文本)');
+          var condTa = document.createElement('textarea');
+          condTa.placeholder = '例:{"platform":"win32"} 或 纯文本条件';
+          card.appendChild(bindInput(condTa, 'conditions'));
+          label('核对规格:输入方式');
+          card.appendChild(makeSel([
+            { v: 'builder', l: '分项填写(lines / json-pointer)' }, { v: 'json', l: '完整 JSON(有限格式)' },
+          ], f.specMode, function (v) { f.specMode = v; if (st.tab === 'library') renderLibrary(); }).node);
+          if (f.specMode === 'builder') {
+            label('定位方式');
+            card.appendChild(makeSel([
+              { v: 'none', l: '不对账(不可核对,check_spec = null)' },
+              { v: 'lines', l: 'lines(UTF-8 文本行段)' },
+              { v: 'json-pointer', l: 'json-pointer(JSON 里的位置,RFC 6901)' },
+            ], f.specKind, function (v) { f.specKind = v; if (st.tab === 'library') renderLibrary(); }).node);
+            if (f.specKind === 'lines') {
+              label('起止行(1 ≤ start ≤ end;行终止符不算在选中内容里)');
+              var sIn = document.createElement('input');
+              sIn.type = 'text';
+              var eIn = document.createElement('input');
+              eIn.type = 'text';
+              card.appendChild(bindInput(sIn, 'start'));
+              card.appendChild(bindInput(eIn, 'end'));
+              label('expected(这段文本要逐字/按行尾归一比较)');
+              var exTa = document.createElement('textarea');
+              exTa.placeholder = '期望在这几行里读到的原文';
+              card.appendChild(bindInput(exTa, 'expectedText'));
+            } else if (f.specKind === 'json-pointer') {
+              label('JSON 指针(空串 = 整篇;/a/b 这样的 RFC 6901 指针)');
+              var pIn = document.createElement('input');
+              pIn.type = 'text';
+              pIn.placeholder = '/tool/version';
+              card.appendChild(bindInput(pIn, 'pointer'));
+              label('expected(JSON 值;null 也算显式给出)');
+              var ejTa = document.createElement('textarea');
+              ejTa.placeholder = '"1.2.3" 或 42 或 {"a":1} —— 这里写的是 JSON,null 必须显式写';
+              card.appendChild(bindInput(ejTa, 'expectedJson'));
+            }
+            label('comparison');
+            card.appendChild(makeSel([
+              { v: 'exact', l: 'exact(逐字节;类型敏感:数字 1 ≠ 字符串 "1")' },
+              { v: 'text-lf', l: 'text-lf(只把 CRLF/CR 归一成 LF,不 trim、不折叠大小写)' },
+            ], f.comparison, function (v) { f.comparison = v; if (liveCheck) liveCheck(); }).node);
+          } else {
+            label('完整 JSON(唯一被接受的形状;只这些键,别的键会被服务端拒,不会静默剥离)');
+            var sjTa = document.createElement('textarea');
+            sjTa.placeholder = '{\n  "locator": {"kind": "lines", "start": 1, "end": 2},\n'
+              + '  "expected": "文本…",\n  "comparison": "exact"\n}';
+            card.appendChild(bindInput(sjTa, 'specJson'));
+            card.appendChild(el('div', 'm-meta',
+              '有限格式:{"locator":{"kind":"lines","start":N,"end":M} 或 {"kind":"json-pointer","pointer":"/a/b"},'
+              + ' "expected":<文本或 JSON 值>, "comparison":"exact"|"text-lf"}。'
+              + '要"不可核对"就写 null。别的形状(未知字段、缺 expected、别的 comparison)一律被拒 —— 不会被改写后接受。'));
+          }
+          body.appendChild(card);
+
+          // 提交前的即时校验(JSON/必填错了就**在提交前**显示,并且提交时不会再发请求)。
+          // 它是**就地更新的一行**(不是每次按键整页重绘):输入时立刻说清错在哪,同时保住光标。
+          var checkLine = el('div', 'm-meta', '');
+          function refreshCheck() {
+            var problems = libFormProblems(f);
+            var cond2 = libConditionsOf(f);
+            var spec2 = libSpecProblems(f);
+            if (!cond2.ok) problems.push(cond2.message);
+            if (!spec2.ok) problems.push(spec2.message);
+            if (problems.length) {
+              checkLine.className = 'lib-err';
+              checkLine.textContent = '提交前检查(现在提交不会发出任何请求):' + problems.join(' · ');
+            } else {
+              checkLine.className = 'm-meta';
+              checkLine.textContent = '提交前检查通过。提交体只含可编辑字段;核对规格 = '
+                + (spec2.value === null ? 'null(不可核对)' : '按上面填写构造的对象') + '。';
+            }
+          }
+          liveCheck = refreshCheck;
+          refreshCheck();
+          body.appendChild(checkLine);
+          body.appendChild(el('div', 'm-meta',
+            '为什么会"提交前就有错":JSON 与必填在本地先判一次,是为了不把"我以为填了"发出去;'
+            + '服务端仍会独立再判一次(界面通过 ≠ 服务端接受)。出错时你填的字段一个都不会被抹掉。'));
+        }
+        // ---------------- 图书馆 · 导入面(源 → 候选 → 人审 → 入库) ----------------
+        // 三条口径从契约直接落下来(写在这里,免得后来的人"顺手"改掉):
+        //   ① **分析不写库**(契约 §9.1):点「分析」只换来一份候选清单;每一条都要**人勾了**才可能进库。
+        //   ② 引擎是**显式动作**(与「接入历史」那栏同一条纪律,见 2616 行注释):默认「不用模型」,
+        //      选了哪档才真调哪档;调了就必须在回执里如实说出模型名(§3:不许把"两次结果不一样"藏起来)。
+        //   ③ 上限**只许来自回执**:客户端不镜像服务端的字节/条数常量(与 fmtLimitMB 同一条命门)——
+        //      所以这里只说"当前多少字节",绝不说"上限是多少"。
+        function libImpToday() {
+          try { return new Date().toISOString().slice(0, 10); } catch (e) { return ''; }
+        }
+        // 导入面的装载口径(2026-10-13,D12;与浏览面同一套):
+        //   默认一页 = 服务端的 `importBatchMaxItems`(200 个内容单元);人往下翻就继续加载(**追加**);
+        //   但这份源的内容单元到 1000 个 ⇒ 切**分页**(只留当前页),免得一路翻下去把会话缓存撑爆。
+        //   ⚠️ 跨页**必须保住已勾的条目**:`sel` 按**全局下标**(在 `all` 里的位置)记,不跟着当前页走 ——
+        //   否则"在第 1 页勾了 3 条、翻到第 2 页再提交",那 3 条会人间蒸发。
+        var IMP_PAGE = 200;
+        var IMP_PAGE_SWITCH = 1000;
+        function libImpBlank() {
+          return {
+            kind: 'csv', name: '', text: '', path: '', table: '', engine: '',
+            category: '', source_kind: '', as_of: libImpToday(),
+            busy: false, receipt: null, commit: null, err: '', notice: '',
+            all: [], sel: {}, src: null, mode: 'append', page: 1, ranges: {}, loading: false,
+          };
+        }
+        /** 换源(改文本 / 重选文件)时把**取数账**清干净 —— 否则旧候选会跟着新源一起被提交。 */
+        function libImpReset(im) {
+          im.receipt = null;
+          im.commit = null;
+          im.all = [];
+          im.sel = {};
+          im.src = null;
+          im.mode = 'append';
+          im.page = 1;
+          im.ranges = {};
+          im.loading = false;
+        }
+        function libImpGet() {
+          var L = st.lib;
+          if (!L.imp) L.imp = libImpBlank();
+          return L.imp;
+        }
+        function libImpOpen() {
+          var L = st.lib;
+          L.imp = libImpBlank();
+          L.view = 'import';
+          L.err = '';
+          L.notice = '';
+          if (st.tab === 'library') renderLibrary();
+        }
+        function libImpPaint() { if (st.tab === 'library') renderLibrary(); }
+        /** 勾选状态:按**全局下标**(在 `im.all` 里的位置)记 —— 跨页、跨次加载都作数。
+         *  默认值**只认服务端的 `selected`**(定位没回查到 / 有阻断问题的不预设勾选)。 */
+        function libImpPickedCount() {
+          var im = libImpGet();
+          var n = 0;
+          var keys = Object.keys(im.sel || {});
+          for (var i = 0; i < keys.length; i++) if (im.sel[keys[i]] === true) n++;
+          return n;
+        }
+        /** 提交要送的是**所有勾过的**条 —— 不只是当前显示的这一页。 */
+        function libImpPickedItems() {
+          var im = libImpGet();
+          var out = [];
+          for (var i = 0; i < im.all.length; i++) if (im.sel[i] === true) out.push(im.all[i]);
+          return out;
+        }
+        /** 当前该显示哪一段:分页模式看当前页,渐进模式就是全部已取的。 */
+        function libImpView() {
+          var im = libImpGet();
+          var all = Array.isArray(im.all) ? im.all : [];
+          if (im.mode === 'page') {
+            var rg = im.ranges[im.page];
+            if (!rg) return { list: [], base: 0 };
+            return { list: all.slice(rg.base, rg.base + rg.count), base: rg.base };
+          }
+          return { list: all, base: 0 };
+        }
+        /** 分析(可带 `offset` = 从第几个内容单元开始 ⇒ "继续加载" / "翻页")。
+         *  `offset` 缺省 0 = 从头读一份新源(此时才清旧候选)。
+         *  `replaceFrom`(D11 重试用)= 成功后**先把已取候选截到这一条之前**再放本页:续页重试
+         *  走的是同一条追加路径,不截就会追加出重复候选。失败时**一个字节都不截**(重试失败不该丢东西)。 */
+        function libImpAnalyze(offset, replaceFrom) {
+          var im = libImpGet();
+          if (im.busy) return;
+          var off = Math.max(0, Math.floor(Number(offset) || 0));
+          var rf = Number.isFinite(Number(replaceFrom)) ? Math.max(0, Math.floor(Number(replaceFrom))) : null;
+          if (off > 0 && !im.src) {
+            im.err = '还没有分析过这一份源 —— 先点「① 分析」。';
+            libImpPaint();
+            return;
+          }
+          im.err = '';
+          im.notice = '';
+          im.commit = null;
+          var name = String(im.name || '').trim();
+          var text = String(im.text == null ? '' : im.text);
+          var isSqlite = im.kind === 'sqlite';
+          if (name === '') {
+            im.err = '源名必填(它是 source_ref 的前半截)—— 没有向服务端发出任何请求。';
+            libImpPaint();
+            return;
+          }
+          // SQLite 的源不是文本框里的东西 ⇒ 空文本不是错,空路径/空表名才是。
+          if (!isSqlite && text === '') {
+            im.err = '源文本是空的 —— 没有发出任何请求(空源不是"导入 0 条",是没有东西可读)。';
+            libImpPaint();
+            return;
+          }
+          if (isSqlite) {
+            if (String(im.path || '').trim() === '') {
+              im.err = 'SQLite 通道要填库文件路径 —— 没有向服务端发出任何请求。';
+              libImpPaint();
+              return;
+            }
+            if (String(im.table || '').trim() === '') {
+              im.err = 'SQLite 通道要点名一张表(服务端不替你猜哪张)—— 没有向服务端发出任何请求。';
+              libImpPaint();
+              return;
+            }
+          }
+          var payload = { kind: im.kind, name: name, text: text };
+          if (isSqlite) { payload.path = String(im.path || '').trim(); payload.table = String(im.table || '').trim(); }
+          if (String(im.as_of || '').trim() !== '') payload.as_of = String(im.as_of).trim();
+          if (im.category) payload.category = im.category;
+          if (im.source_kind) payload.source_kind = im.source_kind;
+          // ⚠️ 引擎为空 ⇒ **根本不带 model 字段**(服务端把空串判成"没选引擎")。
+          //   不要在这里补一个默认引擎顶上 —— 那等于替主人决定花不花算力/额度。
+          if (im.engine) payload.model = im.engine;
+          if (off > 0) payload.offset = off;
+          im.busy = true;
+          libImpPaint();
+          api('/library/import/analyze', { method: 'POST', body: payload }).then(function (r) {
+            im.busy = false;
+            if (!r) {
+              im.err = '分析没有回执(网关不可达)—— 你填的源还在,可以直接重试。';
+              libImpPaint();
+              return;
+            }
+            if (!r.ok) {
+              // 失败回执里**不该有**候选:有的话说明"没跑成的模型段"和规则段被搅在了一起。
+              // 首读失败 ⇒ 全清;续读失败 ⇒ **保住已取的那几页** —— 否则一次翻页失败会把你在前面
+              // 勾好的东西一起抹掉(那是最气人的一种"安全")。
+              if (off === 0) libImpReset(im);
+              im.err = '分析被拒:' + libWhy(r, '未给出原因') + ' —— 没有写任何东西进库(分析是纯读)。';
+              libImpPaint();
+              return;
+            }
+            var list = Array.isArray(r.candidates) ? r.candidates : [];
+            var st = r.stats || {};
+            // ⚠️ `units_total` 可能是 null(SQLite 大表不跑 COUNT(*)——服务端如实说"没数"):
+            //   当成 0 会让界面显示"共 0 个内容单元"、还会误判走渐进还是翻页。
+            var unitsTotal = (st.units_total === null || st.units_total === undefined)
+              ? null : Number(st.units_total || 0);
+            // 继续加载时源摘要变了(主人改过文本)⇒ 当成**新源**:旧候选全清,这一页就是第 1 页。
+            if (off > 0 && im.src && r.source_hash !== im.src.hash) {
+              libImpReset(im);
+              im.notice = '源内容变了(摘要不同)⇒ 旧候选已清,这一页当成第一页重来。';
+            }
+            // 重试(rf !== null)时**不清**:那一页占的正是原来那段下标,重新填回来即可
+            // (见下面的截断 + 剪枝)。
+            if (off === 0 && rf === null) {
+              im.all = [];
+              im.sel = {};
+              im.ranges = {};
+              im.page = 1;
+              im.mode = (unitsTotal !== null && unitsTotal > IMP_PAGE_SWITCH) ? 'page' : 'append';
+            }
+            // 重试:成功之后才截到本页起点(失败路径不截,已取候选原样保留)。
+            if (rf !== null) im.all = im.all.slice(0, rf);
+            var base = im.all.length;
+            for (var i = 0; i < list.length; i++) {
+              im.all.push(list[i]);
+              if (list[i].selected === true) im.sel[base + i] = true;
+            }
+            // 重试后按新长度剪一次勾选:本页候选数变少时,越界的勾不该留着(它们指向不存在的条)。
+            if (rf !== null) {
+              for (var kk in im.sel) { if (Number(kk) >= im.all.length) delete im.sel[kk]; }
+            }
+            // 页表**两种模式都记**(2026-10-14,D11):重试某一页时必须知道它的起点,否则续页重试
+            // 走同一条追加路径会追加出重复候选。`im.page` 只在翻页模式用于显示,记下来无副作用。
+            im.page = Math.floor(Number(st.offset || 0) / IMP_PAGE) + 1;
+            im.ranges[im.page] = { base: base, count: list.length };
+            im.receipt = r;
+            im.src = {
+              hash: r.source_hash,
+              next: st.next_offset === undefined ? null : st.next_offset,
+              unitsTotal: unitsTotal,
+              loaded: im.all.length,
+            };
+            im.notice = list.length === 0
+              ? (off > 0
+                ? '这一页没有候选(后面还有页)。'
+                : '源里没有可成为条目的东西(空文本 / 只有表头)—— 这是"没有候选",不是"导入成功 0 条"。')
+              : ((off > 0 ? '又取到 ' : '读到 ') + list.length + ' 条候选:累计 ' + im.all.length
+                + ' 条,其中 ' + libImpPickedCount() + ' 条勾着。');
+            libImpPaint();
+          }).catch(function () {
+            im.busy = false;
+            im.err = '分析失败(网关不可达)—— 你填的源还在,可以直接重试。';
+            libImpPaint();
+          });
+        }
+        /** 重试**回执里那一页**(D11)。算出它的起始下标交给 `libImpAnalyze` 的 `replaceFrom`;
+         *  取不到页表时退回"从当前累计长度续"(等价于把最后取到的东西再取一遍)。 */
+        function libImpRetry() {
+          var im = libImpGet();
+          var st = (im.receipt && im.receipt.stats) || {};
+          var off = Math.max(0, Math.floor(Number(st.offset) || 0));
+          if (off === 0) { libImpAnalyze(0, 0); return; }
+          var rg = im.ranges[Math.floor(off / IMP_PAGE) + 1];
+          var base = rg && Number.isFinite(Number(rg.base)) ? Number(rg.base) : im.all.length;
+          libImpAnalyze(off, base);
+        }
+        function libImpCommit() {
+          var im = libImpGet();
+          if (im.busy) return;
+          im.err = '';
+          im.notice = '';
+          var rec = im.receipt;
+          if (!rec || !im.src || !im.all.length) {
+            im.err = '还没有可提交的东西 —— 先点「分析」。';
+            libImpPaint();
+            return;
+          }
+          // 送的是**所有勾过的**条:跨页勾的也算(`sel` 按全局下标记,理由见 `libImpBlank` 上头那段)。
+          var items = libImpPickedItems();
+          if (!items.length) {
+            im.err = '一条都没勾 —— 没有发出任何请求(分析不会自动入库,必须由你逐条点名)。';
+            libImpPaint();
+            return;
+          }
+          var token = ++libActionSeq;
+          im.busy = true;
+          im.commit = null;
+          libImpPaint();
+          api('/library/import/commit', { method: 'POST', body: { source_hash: im.src.hash, items: items } })
+            .then(function (r) {
+              if (token !== libActionSeq) return;
+              im.busy = false;
+              if (!r) {
+                im.err = '入库没有回执(网关不可达)—— 勾选还在,可以直接重试。';
+                libImpPaint();
+                return;
+              }
+              if (!r.ok) {
+                im.err = '这批没能处理:' + libWhy(r, '未给出原因') + ' —— 勾选还在,改完可以直接重试。';
+                libImpPaint();
+                return;
+              }
+              im.commit = r;
+              // 入库改变库的读数(条数 / 留痕)⇒ status 必须失效重读,否则顶部统计停在写之前的值。
+              libInvalidateStatus();
+              var written = Number(r.committed || 0);
+              var rejectedN = Array.isArray(r.rejected) ? r.rejected.length : 0;
+              var sk = Number(r.skipped || 0);
+              im.notice = '写入 ' + written + ' 条'
+                + (sk ? ' · 跳过 ' + sk + ' 条(同一份源、同一个定位已经入过库 —— 幂等命中,这是成功不是失败)' : '')
+                + (rejectedN ? ' · 被拒 ' + rejectedN + ' 条(逐条原因见下)' : '')
+                + (written === 0 && !sk && !rejectedN ? '(这一批什么都没写)' : '');
+              toast('导入:' + im.notice, 6000);
+              libImpPaint();
+            }).catch(function () {
+              if (token !== libActionSeq) return;
+              im.busy = false;
+              im.err = '入库失败(网关不可达)—— 勾选还在,可以直接重试。';
+              libImpPaint();
+            });
+        }
+        function libImpCand(it, gi) {
+          var im = libImpGet();
+          var box = el('div', 'lib-card');
+          var head = el('div', null);
+          head.style.cssText = 'display:flex;gap:8px;align-items:flex-start;';
+          var cb = document.createElement('input');
+          cb.type = 'checkbox';
+          cb.checked = im.sel[gi] === true;
+          cb.onchange = function () { im.sel[gi] = !!cb.checked; libImpPaint(); };
+          head.appendChild(cb);
+          var main = el('div', null);
+          main.style.cssText = 'flex:1;min-width:0;';
+          main.appendChild(el('div', 'm-title', libShow(it.title)));
+          var chips = el('div', null);
+          chips.appendChild(el('span', 'lib-chip', '#' + libShow(it.index)));
+          chips.appendChild(el('span', 'lib-chip', '定位 ' + libShow(it.locator)));
+          chips.appendChild(el('span', 'lib-chip', libMap(LIB_CAT, it.category, it.category)));
+          chips.appendChild(el('span', 'lib-chip', libMap(LIB_SRC, it.source_kind, it.source_kind)));
+          chips.appendChild(el('span', 'lib-chip', it.origin === 'model' ? '模型提的' : '规则读的'));
+          chips.appendChild(el('span', 'lib-chip', it.locator_verified === true ? '定位回查通过' : '定位存疑'));
+          main.appendChild(chips);
+          main.appendChild(el('div', 'm-meta', 'as_of ' + libShow(it.as_of) + ' · source_ref ' + libShow(it.source_ref)));
+          if (it.evidence) main.appendChild(el('div', 'lib-pre', String(it.evidence)));
+          var issues = Array.isArray(it.issues) ? it.issues : [];
+          if (issues.length) {
+            main.appendChild(el('div', 'm-meta', '问题:' + issues.map(function (s) {
+              return typeof s === 'string' ? s : String((s && s.reason) || '');
+            }).join(' · ')));
+          }
+          if (it.selected !== true) {
+            main.appendChild(el('div', 'm-meta',
+              '默认不勾:这一条的定位或字段没能过闸 —— 勾它等于由你担保它(闸拦下的是"机器判不了",不是"这条一定错")。'));
+          }
+          head.appendChild(main);
+          box.appendChild(head);
+          return box;
+        }
+        function renderLibImport() {
+          var L = st.lib;
+          var im = libImpGet();
+          var tools = el('div', 'm-tools');
+          var bBack = el('button', null, '← 回到列表');
+          bBack.onclick = function () {
+            L.view = 'list';
+            L.err = '';
+            L.notice = '';
+            libImpPaint();
+          };
+          tools.appendChild(bBack);
+          body.appendChild(tools);
+          body.appendChild(el('div', 'm-meta',
+            '导入 = 源 → 候选 → 你逐条点名 → 入库。第一步「分析」一个字都不写库;'
+            + '第二条路「＋ 新建资料」是手敲一条 —— 两者写进的是同一套库、同一套闸。'));
+          if (im.err) body.appendChild(el('div', 'lib-err', im.err));
+          if (im.notice) body.appendChild(el('div', 'lib-note', im.notice));
+
+          // ① 源
+          var box = el('div', 'lib-card');
+          box.appendChild(el('div', 'm-title', '① 源(要导入什么)'));
+          var r1 = el('div', null);
+          r1.style.cssText = 'display:flex;gap:8px;flex-wrap:wrap;align-items:center;';
+          r1.appendChild(el('span', 'm-meta', '源类型'));
+          r1.appendChild(makeSel([
+            { v: 'csv', l: 'CSV 表格(第 1 行是表头)' },
+            { v: 'text', l: '粘贴文本(空行分段)' },
+            { v: 'json', l: 'JSON / JSONL(数组一元素一条)' },
+            { v: 'sqlite', l: 'SQLite 库(选一张表;填路径)' },
+          ], im.kind, function (v) { if (v !== im.kind) { im.kind = v; libImpReset(im); } libImpPaint(); }).node);
+          var inpName = document.createElement('input');
+          inpName.type = 'text';
+          inpName.placeholder = '源名(必填,如 GB-T1800.1-2020.csv / 数据集.json / 源库.db)';
+          inpName.value = im.name;
+          inpName.oninput = function () { im.name = inpName.value; };
+          inpName.style.cssText = 'flex:1;min-width:200px;padding:6px 10px;border:1px solid var(--lg-input);border-radius:9px;background:transparent;color:var(--lg-text);font-size:13px;';
+          r1.appendChild(inpName);
+          box.appendChild(r1);
+          var r2 = el('div', null);
+          r2.style.cssText = 'display:flex;gap:8px;flex-wrap:wrap;align-items:center;margin-top:6px;';
+          // SQLite 通道(路 A,2026-10-15):源在盘上 ⇒ 填路径 + 表名,不走文本框。
+          // ⚠️ 浏览器给不了真实路径(`input.files[0]` 只有 name,没有 path)⇒ 这里只能手敲 / 粘贴。
+          var isSqlite = im.kind === 'sqlite';
+          if (isSqlite) {
+            var rp = el('div', null);
+            rp.style.cssText = 'display:flex;gap:8px;flex-wrap:wrap;align-items:center;margin-top:6px;';
+            rp.appendChild(el('span', 'm-meta', '库文件路径'));
+            var inpPath = document.createElement('input');
+            inpPath.type = 'text';
+            inpPath.placeholder = '例如 D:\\资料\\源库.db(必须是插件配置里登记过的根目录下的文件)';
+            inpPath.value = im.path || '';
+            inpPath.oninput = function () { im.path = inpPath.value; };
+            inpPath.style.cssText = 'flex:1;min-width:260px;padding:6px 10px;border:1px solid var(--lg-input);border-radius:9px;background:transparent;color:var(--lg-text);font-size:13px;';
+            rp.appendChild(inpPath);
+            rp.appendChild(el('span', 'm-meta', '表'));
+            var inpTable = document.createElement('input');
+            inpTable.type = 'text';
+            inpTable.placeholder = '表名(必填:不许猜)';
+            inpTable.value = im.table || '';
+            inpTable.oninput = function () { im.table = inpTable.value; };
+            inpTable.style.cssText = 'width:180px;padding:6px 10px;border:1px solid var(--lg-input);border-radius:9px;background:transparent;color:var(--lg-text);font-size:13px;';
+            rp.appendChild(inpTable);
+            box.appendChild(rp);
+            box.appendChild(el('div', 'm-meta',
+              '源库只读打开(插件不写它一个字节),而且拒开本插件自己的库;表必须你点名 —— '
+              + '这一路不进文本框:文本量由服务端按页取(SQL 的 LIMIT/OFFSET),大表也不会一次读满。'));
+          }
+          var fileIn = document.createElement('input');
+          fileIn.type = 'file';
+          fileIn.accept = '.csv,.txt,.md,.json,.jsonl,.ndjson,text/*,application/json';
+          fileIn.onchange = function () {
+            var f = fileIn.files && fileIn.files[0];
+            if (!f) return;
+            if (typeof f.text !== 'function') {
+              im.err = '这个浏览器读不了文件内容(没有 File.text())—— 请把内容粘贴到下面的框里。';
+              libImpPaint();
+              return;
+            }
+            f.text().then(function (t) {
+              im.text = String(t == null ? '' : t);
+              if (String(im.name || '').trim() === '' && f.name) im.name = String(f.name);
+              libImpReset(im);
+              im.err = '';
+              im.notice = '已读入 ' + String(f.name || '文件') + '(' + fmtBytes(utf8Len(im.text)) + ')—— 内容还能在下面的框里改。';
+              libImpPaint();
+            }).catch(function () {
+              im.err = '读文件失败 —— 也可以直接把内容粘到下面的框里。';
+              libImpPaint();
+            });
+          };
+          r2.appendChild(fileIn);
+          r2.appendChild(el('span', 'm-meta', '选文件 = 把内容读进下面的框(不发送文件本身);读不到就粘贴'));
+          if (isSqlite) r2.style.display = 'none';   // SQLite 走路径,不走文件
+          box.appendChild(r2);
+          var ta = document.createElement('textarea');
+          ta.rows = 8;
+          ta.placeholder = '把 CSV / 一段资料原文粘在这里…';
+          ta.value = im.text;
+          // 2026-10-13 真机发现修正:原先这里只写 im.text 不刷新字节数 ⇒ 计数恒停在 0.0 KB。
+          // 只就地改那一行文字的 textContent,**不**整块重绘(textarea 重建会丢光标)。
+          ta.oninput = function () { im.text = ta.value; paintBytes(); };
+          ta.style.cssText = 'width:100%;margin-top:6px;padding:8px 10px;border:1px solid var(--lg-input);border-radius:9px;background:transparent;color:var(--lg-text);font-size:13px;box-sizing:border-box;';
+          box.appendChild(ta);
+          var byteNote = el('div', 'm-meta', '当前 ' + fmtBytes(utf8Len(im.text))
+            + ' —— 服务端按字节封顶;真超了会拒,并在回执里写明它的上限(客户端不镜像那个数字)');
+          var paintBytes = function () {
+            byteNote.textContent = '当前 ' + fmtBytes(utf8Len(im.text))
+              + ' —— 服务端按字节封顶;真超了会拒,并在回执里写明它的上限(客户端不镜像那个数字)';
+          };
+          if (isSqlite) { ta.style.display = 'none'; byteNote.style.display = 'none'; }
+          box.appendChild(byteNote);
+
+          // ② 交给谁读
+          var r3 = el('div', null);
+          r3.style.cssText = 'display:flex;gap:8px;flex-wrap:wrap;align-items:center;margin-top:6px;';
+          r3.appendChild(el('span', 'm-meta', '引擎'));
+          r3.appendChild(makeSel([
+            { v: '', l: '不用模型(只用规则段)' },
+            { v: 'assistant', l: '本机小助手(零成本)' },
+            { v: 'global', l: '当前全局大模型(会花额度)' },
+          ], im.engine, function (v) { im.engine = v; libImpPaint(); }).node);
+          r3.appendChild(el('span', 'm-meta',
+            '粘贴人话 / 乱格式时才需要模型(它只干"把散段读成条目"这一件);表格类源不必用。'
+            + '模型读出来的每一条仍要过定位回查 + 字段闸,而且照样要你勾。'));
+          box.appendChild(r3);
+          var r4 = el('div', null);
+          r4.style.cssText = 'display:flex;gap:8px;flex-wrap:wrap;align-items:center;margin-top:6px;';
+          r4.appendChild(el('span', 'm-meta', '取数时间'));
+          var inpAsOf = document.createElement('input');
+          inpAsOf.type = 'text';
+          inpAsOf.placeholder = 'YYYY-MM-DD';
+          inpAsOf.value = im.as_of;
+          inpAsOf.oninput = function () { im.as_of = inpAsOf.value; };
+          inpAsOf.style.cssText = 'width:130px;padding:6px 10px;border:1px solid var(--lg-input);border-radius:9px;background:transparent;color:var(--lg-text);font-size:13px;';
+          r4.appendChild(inpAsOf);
+          r4.appendChild(el('span', 'm-meta', '类目'));
+          r4.appendChild(makeSel([
+            { v: '', l: '不指定(用服务端默认)' },
+            { v: 'standard-value', l: '标准值' }, { v: 'boundary', l: '边界' },
+            { v: 'project-spec', l: '项目规格' }, { v: 'external-api', l: '外部接口' },
+          ], im.category, function (v) { im.category = v; }).node);
+          r4.appendChild(el('span', 'm-meta', '来源'));
+          r4.appendChild(makeSel([
+            { v: '', l: '不指定(用服务端默认)' },
+            { v: 'standard', l: '标准' }, { v: 'official-doc', l: '官方文档' },
+            { v: 'manual', l: '人工' }, { v: 'our-code', l: '自有代码' }, { v: 'web', l: '网页' },
+          ], im.source_kind, function (v) { im.source_kind = v; }).node);
+          box.appendChild(r4);
+          box.appendChild(el('div', 'm-meta',
+            'as_of 是"这份资料的取数时间",绝不由创建时间推断(契约 §4)—— 粘贴一份去年的标准就填去年那份的日期。'));
+          var btnRow = el('div', 'btnrow');
+          var bRun = el('button', 'primary', im.busy ? '分析中…' : '① 分析(不写库)');
+          bRun.disabled = !!im.busy;
+          bRun.onclick = function () { libImpAnalyze(); };
+          btnRow.appendChild(bRun);
+          box.appendChild(btnRow);
+          body.appendChild(box);
+
+          var rec = im.receipt;
+          if (!rec) return;
+
+          // ③ 候选清单的读数(只在有回执时出现)
+          var stat = rec.stats || {};
+          var card = el('div', 'lib-card');
+          card.appendChild(el('div', 'm-title', '② 候选(勾谁才进谁)'));
+          card.appendChild(el('div', 'm-meta', '源摘要 ' + libHash(rec.source_hash)
+            + ' · 数据行 ' + Number(stat.rows || 0) + ' · 候选 ' + Number(stat.candidates || 0) + ' 条'));
+          var mb = [];
+          mb.push(stat.model_used === true
+            ? ('模型段:跑了 ' + libShow(stat.model))
+            : '模型段:没跑(只用规则段)');
+          if (stat.model_used === true) {
+            mb.push('送模型 ' + Number(stat.model_rows || 0) + ' 条'
+              + (stat.model_rows_capped ? '(触到成本闸,超出的行只走规则段)' : ''));
+          }
+          if (stat.dropped_by_batch_limit) {
+            mb.push('超单批上限被丢下 ' + Number(stat.dropped_by_batch_limit) + ' 条(不静默截断,如实记账)');
+          }
+          card.appendChild(el('div', 'm-meta', mb.join(' · ')));
+          if (im.src) {
+            card.appendChild(el('div', 'm-meta', '这份源' + libImpUnitsText(im.src.unitsTotal) + ' · 已取 '
+              + im.all.length + ' 条候选' + (im.mode === 'page'
+                ? '(单元数超过 ' + IMP_PAGE_SWITCH + ' ⇒ 走翻页,一页 ' + IMP_PAGE + ' 个单元)'
+                : '(往下滚到底会自动继续加载)')));
+          }
+          if (Number(stat.rejected || 0) > 0) {
+            card.appendChild(el('div', 'm-meta', '默认未勾 ' + Number(stat.rejected)
+              + ' 条:定位没回查到 / 有阻断性问题 —— 它们不会自己进库。'));
+          }
+          // ── 降级告警(D11,2026-10-14 放行)──────────────────────────────────────────
+          // 判据:`stats.model_error` 在场就**必须有这一块**,而且**不许**是一行灰字。
+          //   ① 模型段没跑成 ≠ 分析失败(规则段候选照给),所以不能说"分析被拒";
+          //   ② 但 "model_used:true + model_error"(分批里部分成功)**同样必须告警** ——
+          //      只看 model_used 会把"半份模型结果"读成"模型全跑完了";
+          //   ③ 「重试」重发的是**这一页**(同一个 offset),不回到第一页、不动别的页的勾。
+          if (stat.model_error) {
+            var me = stat.model_error;
+            var warn = el('div', 'lib-warn');
+            warn.appendChild(el('div', 't', '⚠ 模型段没跑成'
+              + (me.engine ? '(引擎 ' + String(me.engine) + ')' : '')));
+            warn.appendChild(el('div', null, String(me.message || '未给出原因')));
+            var wf = [];
+            if (Number(me.rows_offered || 0) > 0) wf.push('本来要送模型 ' + Number(me.rows_offered) + ' 行');
+            if (Array.isArray(me.batches_failed) && me.batches_failed.length) {
+              wf.push('第 ' + me.batches_failed.join('、') + ' / ' + Number(me.batches_total || 1)
+                + ' 批炸了(已成功的批结果保留)');
+            }
+            warn.appendChild(el('div', 'm-meta', wf.join(' · ') + ' —— 规则段候选照常给你,进不进库由你勾,不由模型定。'));
+            var bRetry = el('button', null, '重试这一页(含模型段)');
+            bRetry.onclick = function () { libImpRetry(); };
+            var wrow = el('div', 'btnrow');
+            wrow.appendChild(bRetry);
+            warn.appendChild(wrow);
+            body.appendChild(warn);
+          }
+          body.appendChild(card);
+
+          // ④ 上一批的入库回执(贴在勾选区上面:提交完不用往下翻)
+          if (im.commit) {
+            var cc = el('div', 'lib-card');
+            cc.appendChild(el('div', 'm-title', '③ 入库回执'));
+            var rj = Array.isArray(im.commit.rejected) ? im.commit.rejected : [];
+            cc.appendChild(el('div', 'm-meta', '写入 ' + Number(im.commit.committed || 0)
+              + ' 条 · 跳过(幂等命中,算成功)' + Number(im.commit.skipped || 0)
+              + ' 条 · 被拒 ' + rj.length + ' 条'));
+            if (im.commit.no_key) {
+              cc.appendChild(el('div', 'm-meta', '其中 ' + Number(im.commit.no_key)
+                + ' 条没有定位 ⇒ 没有幂等键(重复导入它挡不住)—— 这是如实记账,不是失败。'));
+            }
+            rj.forEach(function (x) {
+              cc.appendChild(el('div', 'lib-err', '被拒 #' + libShow(x.index) + ':' + libShow(x.reason)
+                + (x.message ? '(' + String(x.message) + ')' : '')));
+            });
+            var ids = Array.isArray(im.commit.ids) ? im.commit.ids : [];
+            if (ids.length) cc.appendChild(el('div', 'lib-pre lib-mono', ids.join('\n')));
+            body.appendChild(cc);
+          }
+
+          var view = libImpView();
+          var list = view.list;
+          /** 装载控制条 + 滚到底自动续页(与记忆浏览同款)。空段也要出:空的是**这一页**,不是这份源。 */
+          function impTail() {
+            if (im.src) body.appendChild(libImpMoreUI(im, list.length));
+            if (body.__lingImpScroll) body.removeEventListener('scroll', body.__lingImpScroll);
+            body.__lingImpScroll = function () {
+              if (im.busy || im.mode === 'page') return;
+              if (!im.src || im.src.next === null) return;
+              if (!body.scrollHeight) return;
+              if (body.scrollTop + body.clientHeight >= body.scrollHeight - 170) libImpAnalyze(im.src.next);
+            };
+            body.addEventListener('scroll', body.__lingImpScroll);
+          }
+          if (!list.length) {
+            body.appendChild(el('div', 'm-empty',
+              '这一段没有候选 —— 源里没有可成为条目的东西(空文本 / 只有表头),或者这一页本来就是空的。'
+              + '这不是"导入成功 0 条"。'));
+            // ⚠️ 空的时候**不出现提交按钮**(没有可勾的东西就不该递一个"提交(0 条)");翻页/续页控件照给。
+            impTail();
+            return;
+          }
+          var pickRow = el('div', 'btnrow');
+          var bAll = el('button', null, '全选(这一段)');
+          bAll.onclick = function () {
+            for (var i = 0; i < list.length; i++) im.sel[view.base + i] = true;
+            libImpPaint();
+          };
+          var bNone = el('button', null, '全不选(这一段)');
+          bNone.onclick = function () {
+            for (var i = 0; i < list.length; i++) im.sel[view.base + i] = false;
+            libImpPaint();
+          };
+          var bCommit = el('button', 'primary', im.busy ? '提交中…' : ('② 提交入库(' + libImpPickedCount() + ' 条)'));
+          bCommit.disabled = !!im.busy;
+          bCommit.onclick = function () { libImpCommit(); };
+          pickRow.appendChild(bAll);
+          pickRow.appendChild(bNone);
+          pickRow.appendChild(bCommit);
+          body.appendChild(pickRow);
+          for (var i = 0; i < list.length; i++) body.appendChild(libImpCand(list[i], view.base + i));
+          body.appendChild(el('div', 'm-meta',
+            '提交只走既有的 create(与「＋ 新建资料」同一条路、同一套闸)。'
+            + '每条都带 import_key(= 源摘要 + 定位)⇒ 同一份源、同一个定位再提交两次,第二次是跳过,不会写第二行。'));
+          impTail();
+        }
+        /** 内容单元数怎么念:`null` = 服务端没数(SQLite 大表不跑 `COUNT(*)`)——
+         *  如实说"没数",不许显示成 0(那会让人以为源是空的)。 */
+        function libImpUnitsText(n) {
+          return (n === null || n === undefined) ? '内容单元数没数(SQLite 大表不跑 COUNT(*))' : ('共 ' + n + ' 个内容单元');
+        }
+        /** 装载控制条:渐进(往下翻续页)/ 分页(源太大,只留当前页)—— 与浏览面同一套口径(2026-10-13,D12)。 */
+        function libImpMoreUI(im, shownCount) {
+          var bar = el('div', 'm-acts lib-imp-more');
+          if (im.mode === 'page') {
+            var pages = Math.max(1, Math.ceil(im.src.unitsTotal / IMP_PAGE));
+            var bPrev = el('button', null, '‹ 上一页');
+            var bNext = el('button', null, '下一页 ›');
+            bPrev.disabled = !!im.busy || im.page <= 1;
+            bNext.disabled = !!im.busy || im.page >= pages;
+            bPrev.onclick = function () { libImpGoPage(im.page - 1); };
+            bNext.onclick = function () { libImpGoPage(im.page + 1); };
+            bar.appendChild(bPrev);
+            bar.appendChild(el('span', 'm-meta', '第 ' + im.page + ' / ' + pages + ' 页 · 这一段 '
+              + shownCount + ' 条 · 这份源 ' + im.src.unitsTotal + ' 个内容单元'));
+            bar.appendChild(bNext);
+          } else if (im.src.next !== null) {
+            var bMore = el('button', null, im.busy ? '读取中…' : '继续加载 ▾');
+            bMore.disabled = !!im.busy;
+            bMore.onclick = function () { libImpAnalyze(im.src.next); };
+            bar.appendChild(bMore);
+            bar.appendChild(el('span', 'm-meta', '已取 ' + im.all.length + ' 条 / 这份源'
+              + libImpUnitsText(im.src.unitsTotal) + '(往下滚到底会自动继续加载)'));
+          } else {
+            bar.appendChild(el('span', 'm-meta', '— 已到最早 —(已取 ' + im.all.length
+              + ' 条 / ' + libImpUnitsText(im.src.unitsTotal) + ')'));
+          }
+          return bar;
+        }
+        /** 翻到第 page 页:取过的页直接切(**不重复请求、不重复入列**),没取过才去取。 */
+        function libImpGoPage(page) {
+          var im = libImpGet();
+          if (im.busy || !im.src) return;
+          var pages = Math.max(1, Math.ceil(im.src.unitsTotal / IMP_PAGE));
+          var p = Math.min(pages, Math.max(1, page));
+          if (im.ranges[p]) { im.page = p; libImpPaint(); return; }
+          im.page = p;
+          libImpAnalyze((p - 1) * IMP_PAGE);
+        }
+
+        // ── 浏览面(第七面,2026-10-13):**只读** —— 不搜也能翻 ────────────────────────────
+        // 形态 A(用户 2026-10-13 拍板):左树「类目 → 来源 → 条目」+ 右侧详情(谱系链 + 核对史)。
+        // 三条自我约束:
+        //   ① **这一面一个写按钮都没有**(新建 / 修订 / 撤下 / 核对全在维护面)—— "能翻一翻看"与
+        //      "能改"是两种授权,混在同一面里迟早有人误点;
+        //   ② 树的骨架来自服务端回的 `groups`(恒定全量),**不是**从"当前这一页条目"反推的 ——
+        //      否则翻一页骨架就跟着变一次;
+        //   ③ 只有**展开某个组**时才去取那一组(懒加载):进这一面总共 1 个请求。
+        // 服务端为什么不给总数:两个列表端点都不报 total(契约禁止误导性 total)⇒ 这里只写
+        // "本页几条 / 还有更多",**不写"共 N 条"**。
+        function libBrBlank() {
+          return {
+            groups: null, loading: false, err: '',
+            catOpen: {}, node: {},
+            sel: '', detail: null, hist: null, checks: null, selErr: '', selLoading: false,
+            gen: 0, scroll: 0,
+          };
+        }
+        // 浏览面的装载口径(2026-10-13 主人定,形状沿用「记忆浏览」那一套):
+        //   默认一页 200 条;人往下翻(滚到底)就继续加载;
+        //   但某组总量到 1000 条 ⇒ 切**分页**(只留当前页,替换不累积),免得一路翻下去把会话缓存撑爆。
+        var BR_PAGE = 200;
+        var BR_PAGE_SWITCH = 1000;
+        function libBrGet() {
+          var L = st.lib;
+          if (!L.br) L.br = libBrBlank();
+          return L.br;
+        }
+        function libBrOpen() {
+          var L = st.lib;
+          var br = libBrGet();
+          L.view = 'browse';
+          L.err = '';
+          L.notice = '';
+          br.sel = '';
+          br.detail = null;
+          br.hist = null;
+          br.checks = null;
+          br.selErr = '';
+          libBrPaint();
+          if (!br.groups) libBrLoadGroups();
+        }
+        function libBrPaint() { if (st.tab === 'library') renderLibrary(); }
+        /** 迟到回画守卫(与记忆树 / 导入面同款):标签切走、视图切走、或换了对象 ⇒ 整条丢弃,
+         *  **连清都不清** —— 先画错再撤回会闪一下,而且丢的是当前视图。 */
+        function libBrAlive(br) {
+          var L = st.lib;
+          return st.tab === 'library' && L.view === 'browse' && L.br === br;
+        }
+        function libBrWhy(j, fallback) {
+          if (!j) return fallback;
+          return (j.message || j.reason || fallback);
+        }
+        function libBrLoadGroups() {
+          var br = libBrGet();
+          var gen = br.gen;
+          br.loading = true;
+          br.err = '';
+          libBrPaint();
+          api('/library/browse').then(function (j) {
+            if (!libBrAlive(br) || gen !== br.gen) return;
+            br.loading = false;
+            if (!j || j.ok !== true) {
+              br.err = '读取分组失败:' + libBrWhy(j, '网关没有回执');
+              libBrPaint();
+              return;
+            }
+            br.groups = Array.isArray(j.groups) ? j.groups : [];
+            libBrPaint();
+          }).catch(function () {
+            if (!libBrAlive(br) || gen !== br.gen) return;
+            br.loading = false;
+            br.err = '读取分组失败(网关不可达)。';
+            libBrPaint();
+          });
+        }
+        function libBrNodeKey(cat, src) { return cat + '|' + src; }
+        /** 取某一组(类目 + 来源)的一页。`replace` = 换页(替换列表);否则按 offset 追加。
+         *  `fields:'row'` 不是可选优化:**列表行不带正文** —— 单条正文上限 64 KiB,而一次响应总共
+         *  只有 256 KiB ⇒ 200 条带正文必然被字节闸截成几条,"翻到底再加载"就名存实亡。
+         *  正文由详情面按 id 单取(`/library/item`)。 */
+        function libBrLoadNode(cat, src, offset, replace) {
+          var br = libBrGet();
+          var key = libBrNodeKey(cat, src);
+          if (!br.node[key]) {
+            br.node[key] = { items: [], offset: 0, nextOffset: null, truncated: false, loading: false, err: '', total: 0, mode: 'append' };
+          }
+          var nd = br.node[key];
+          var gen = br.gen;
+          var off = Math.max(0, offset || 0);
+          nd.loading = true;
+          nd.err = '';
+          libBrPaint();
+          api('/library/browse' + qs({ category: cat, source_kind: src, limit: BR_PAGE, offset: off, fields: 'row' })).then(function (j) {
+            if (!libBrAlive(br) || gen !== br.gen) return;
+            nd.loading = false;
+            if (!j || j.ok !== true) {
+              nd.err = '读取条目失败:' + libBrWhy(j, '网关没有回执');
+              libBrPaint();
+              return;
+            }
+            var got = Array.isArray(j.items) ? j.items : [];
+            nd.items = (replace || off === 0) ? got : nd.items.concat(got);
+            nd.offset = off;
+            nd.nextOffset = (j.nextOffset === undefined ? null : j.nextOffset);
+            nd.truncated = j.truncated === true;
+            libBrPaint();
+          }).catch(function () {
+            if (!libBrAlive(br) || gen !== br.gen) return;
+            nd.loading = false;
+            nd.err = '读取条目失败(网关不可达)。';
+            libBrPaint();
+          });
+        }
+        /** 渐进模式:续下一页(追加)。 */
+        function libBrMore(cat, src) {
+          var br = libBrGet();
+          var nd = br.node[libBrNodeKey(cat, src)];
+          if (!nd || nd.loading || nd.nextOffset === null) return;
+          libBrLoadNode(cat, src, nd.nextOffset, false);
+        }
+        /** 分页模式:跳到第 page 页(替换当前页)。 */
+        function libBrGoPage(cat, src, page) {
+          var br = libBrGet();
+          var nd = br.node[libBrNodeKey(cat, src)];
+          if (!nd || nd.loading) return;
+          var pages = Math.max(1, Math.ceil((nd.total || 0) / BR_PAGE));
+          var p = Math.min(pages, Math.max(1, page));
+          libBrLoadNode(cat, src, (p - 1) * BR_PAGE, true);
+        }
+        /** 滚到底自动续页(与记忆浏览同款:距底 170px 内就续)。
+         *  树里可能同时展开好几组 ⇒ 一次只给"还没取完的第一组"续一页,不一口气砸出一串请求;
+         *  分页模式的组不在此列(它要人点页码 —— 正是为了不累积)。 */
+        function libBrAutoMore(box) {
+          if (!box || !box.scrollHeight) return;
+          if (box.scrollTop + box.clientHeight < box.scrollHeight - 170) return;
+          var br = libBrGet();
+          var keys = Object.keys(br.node);
+          for (var i = 0; i < keys.length; i++) {
+            var nd = br.node[keys[i]];
+            if (nd.mode === 'page' || nd.loading || nd.nextOffset === null) continue;
+            var parts = keys[i].split('|');
+            libBrLoadNode(parts[0], parts[1], nd.nextOffset, false);
+            return;
+          }
+        }
+        /** 选中一条:三个只读面并行取(条目本体 / 谱系链 / 核对史)。三条各自独立落地,
+         *  谁先回来先显示 —— 但不允许"旧选中"的回执盖到新选中上(比 `sel` 令牌)。 */
+        function libBrSelect(id) {
+          var br = libBrGet();
+          var gen = br.gen;
+          br.sel = id;
+          br.detail = null;
+          br.hist = null;
+          br.checks = null;
+          br.selErr = '';
+          br.selLoading = true;
+          libBrPaint();
+          api('/library/item' + qs({ id: id })).then(function (j) {
+            if (!libBrAlive(br) || gen !== br.gen || br.sel !== id) return;
+            br.selLoading = false;
+            if (!j || j.ok !== true || !j.found) {
+              br.selErr = '读取条目失败:' + libBrWhy(j, '网关没有回执');
+              libBrPaint();
+              return;
+            }
+            br.detail = j.item || null;
+            libBrPaint();
+          }).catch(function () {
+            if (!libBrAlive(br) || gen !== br.gen || br.sel !== id) return;
+            br.selLoading = false;
+            br.selErr = '读取条目失败(网关不可达)。';
+            libBrPaint();
+          });
+          api('/library/history' + qs({ id: id })).then(function (j) {
+            if (!libBrAlive(br) || gen !== br.gen || br.sel !== id) return;
+            br.hist = (j && j.ok) ? j : null;
+            libBrPaint();
+          }).catch(function () {});
+          api('/library/checks' + qs({ id: id })).then(function (j) {
+            if (!libBrAlive(br) || gen !== br.gen || br.sel !== id) return;
+            br.checks = (j && j.ok) ? j : null;
+            libBrPaint();
+          }).catch(function () {});
+        }
+        /** 类目层。计数**只**来自 groups(恒定全量);空类目不展开、也不假装能点。 */
+        function libBrCatNode(br, cat) {
+          var box = el('div', null);
+          var gs = (br.groups || []).filter(function (g) { return g.category === cat; });
+          var count = 0;
+          for (var i = 0; i < gs.length; i++) count += Number(gs[i].count || 0);
+          // 默认**展开有内容的类目**:骨架(`groups`)是一次取回的全量表,展开它不花任何请求,
+          // 而"两级都收起"会让第一次进来的人面对四个 ▶ 不知道点哪儿。真正的懒加载在**来源组**
+          // 那一层(那才是会发请求的层)。空类目照样是死的(见下面的 count 分支)。
+          var open = br.catOpen[cat] !== false;
+          var head = el('div', 'lib-br-head', (open ? '▼ ' : '▶ ') + libMap(LIB_CAT, cat, cat) + '(' + count + ' 条)');
+          head.style.cssText = 'padding:3px 4px;font-weight:700;' + (count ? 'cursor:pointer;' : 'opacity:.45;');
+          if (count) {
+            head.onclick = function () { br.catOpen[cat] = !open; libBrPaint(); };
+          } else {
+            head.title = '这个类目下还没有资料。';
+          }
+          box.appendChild(head);
+          if (!open || !count) return box;
+          for (var j = 0; j < gs.length; j++) box.appendChild(libBrSrcNode(br, cat, gs[j]));
+          return box;
+        }
+        /** 来源层(叶子组)。展开 = 取这一组第一页;收起 = 丢掉缓存(下次展开重新取,宁可新不要旧)。 */
+        function libBrSrcNode(br, cat, g) {
+          var box = el('div', null);
+          box.style.cssText = 'margin-left:14px;';
+          var key = libBrNodeKey(cat, g.source_kind);
+          var nd = br.node[key];
+          var head = el('div', 'lib-br-head', (nd ? '▼ ' : '▶ ') + libMap(LIB_SRC, g.source_kind, g.source_kind)
+            + '(' + g.count + ' 条 · 有效 ' + g.active + ')');
+          head.style.cssText = 'padding:2px 4px;cursor:pointer;opacity:.92;';
+          head.onclick = function () {
+            if (nd) { delete br.node[key]; libBrPaint(); return; }
+            var total = Number(g.count || 0);
+            br.node[key] = {
+              items: [], offset: 0, nextOffset: null, truncated: false, loading: false, err: '',
+              total: total,
+              // 装载策略在**展开这一刻**就定下来:总量超过阈值就一路走页码,不再累积。
+              mode: total > BR_PAGE_SWITCH ? 'page' : 'append',
+            };
+            libBrPaint();
+            libBrLoadNode(cat, g.source_kind, 0, true);
+          };
+          box.appendChild(head);
+          if (!nd) return box;
+          if (nd.err) box.appendChild(el('div', 'lib-err', nd.err));
+          if (nd.loading && !nd.items.length) box.appendChild(el('div', 'm-meta', '正在读取这一组…'));
+          for (var i = 0; i < nd.items.length; i++) box.appendChild(libBrLeaf(br, nd.items[i]));
+          if (!nd.items.length && !nd.loading && !nd.err) box.appendChild(el('div', 'm-meta', '这一组这一页没有条目。'));
+          var shown = nd.items.length;
+          if (nd.mode === 'page') {
+            // 分页模式:总量太大 ⇒ 只留当前页(替换,不累积)
+            var pages = Math.max(1, Math.ceil((nd.total || 0) / BR_PAGE));
+            var cur = Math.floor(nd.offset / BR_PAGE) + 1;
+            var bar = el('div', 'm-acts lib-br-page');
+            var bPrev = el('button', null, '‹ 上一页');
+            var bNext = el('button', null, '下一页 ›');
+            bPrev.disabled = !!nd.loading || cur <= 1;
+            bNext.disabled = !!nd.loading || cur >= pages;
+            bPrev.onclick = function () { libBrGoPage(cat, g.source_kind, cur - 1); };
+            bNext.onclick = function () { libBrGoPage(cat, g.source_kind, cur + 1); };
+            bar.appendChild(bPrev);
+            bar.appendChild(el('span', 'm-meta', '第 ' + cur + ' / ' + pages + ' 页 · 本页 ' + shown
+              + ' 条 · 这一组 ' + (nd.total || 0) + ' 条'));
+            bar.appendChild(bNext);
+            box.appendChild(bar);
+          } else if (nd.nextOffset !== null) {
+            // 渐进模式:往下滚到底自动续页;这里给一个明确的按钮当兜底(也让人知道还有多少没看)
+            var acts = el('div', 'm-acts lib-br-sentinel');
+            var bMore = el('button', null, nd.loading ? '读取中…' : '继续加载 ▾');
+            bMore.disabled = !!nd.loading;
+            bMore.onclick = function () { libBrMore(cat, g.source_kind); };
+            acts.appendChild(bMore);
+            acts.appendChild(el('span', 'm-meta', '已显示 ' + shown + ' / ' + (nd.total || 0)
+              + ' 条(往下滚到底会自动继续加载)'));
+            box.appendChild(acts);
+          } else if (shown) {
+            box.appendChild(el('div', 'm-meta lib-br-sentinel', '— 已到最早 —(已显示 ' + shown + ' / ' + (nd.total || 0) + ' 条)'));
+          }
+          return box;
+        }
+        function libBrLeaf(br, it) {
+          var row = el('div', 'lib-br-leaf');
+          row.style.cssText = 'margin-left:16px;padding:3px 5px;border-radius:8px;cursor:pointer;'
+            + (br.sel === it.id ? 'background:rgba(127,127,127,.18);' : '');
+          var t = el('div', null, libShow(it.title));
+          t.style.cssText = 'font-size:13px;';
+          row.appendChild(t);
+          var chips = el('div', null);
+          chips.appendChild(el('span', 'lib-chip', 'r' + libShow(it.revision)));
+          chips.appendChild(el('span', 'lib-chip', libMap(LIB_ST, it.state, it.state)));
+          chips.appendChild(el('span', 'lib-chip', '认证:' + libMap(LIB_CK, it.checked_state, '未核对')));
+          if (it.import_key) chips.appendChild(el('span', 'lib-chip', '导入的'));
+          row.appendChild(chips);
+          row.onclick = function () { libBrSelect(it.id); };
+          return row;
+        }
+        function libBrDetail(box, br) {
+          box.appendChild(el('div', 'm-title', '详情(这一面只读)'));
+          if (br.selErr) { box.appendChild(el('div', 'lib-err', br.selErr)); return; }
+          if (!br.sel) {
+            box.appendChild(el('div', 'm-meta', '点左边任意一条 —— 这里显示它的字段、谱系链(历史版本)与核对史。'));
+            return;
+          }
+          if (br.selLoading && !br.detail) { box.appendChild(el('div', 'm-empty', '正在读取这条…')); return; }
+          var it = br.detail;
+          if (!it) return;
+          var card = el('div', 'lib-card');
+          card.appendChild(el('div', 'm-title', libShow(it.title)));
+          var chips = el('div', null);
+          chips.appendChild(el('span', 'lib-chip', libMap(LIB_CAT, it.category, it.category)));
+          chips.appendChild(el('span', 'lib-chip', libMap(LIB_SRC, it.source_kind, it.source_kind)));
+          chips.appendChild(el('span', 'lib-chip', '状态:' + libMap(LIB_ST, it.state, it.state)));
+          chips.appendChild(el('span', 'lib-chip', '认证:' + libMap(LIB_CK, it.checked_state, '未核对')));
+          card.appendChild(chips);
+          var grid = el('div', 'lib-grid');
+          libKV(grid, '出处 source_ref', it.source_ref, true);
+          libKV(grid, '取数时间 as_of', it.as_of);
+          libKV(grid, '修订 revision', 'r' + libShow(it.revision)
+            + (it.previous_id ? (' · 上一版 ' + it.previous_id) : ' · 初版'));
+          libKV(grid, 'content_hash', it.content_hash, true);
+          libKV(grid, 'import_key', it.import_key ? it.import_key : '(无 —— 不是导入进来的)', true);
+          libKV(grid, '认证时间', libShow(it.checked_at));
+          libKV(grid, 'id', it.id, true);
+          libKV(grid, 'lineage_id', it.lineage_id, true);
+          libKV(grid, 'created_at', it.created_at);
+          libKV(grid, 'updated_at', it.updated_at);
+          if (it.withdrawn_at) libKV(grid, '撤下', it.withdrawn_at + ' · 原因:' + libShow(it.withdrawn_reason));
+          card.appendChild(grid);
+          card.appendChild(el('div', 'm-meta', '正文(body)——纯文本渲染,不解释 HTML'));
+          card.appendChild(el('div', 'lib-pre', libShow(it.body)));
+          box.appendChild(card);
+          var hCard = el('div', 'lib-card');
+          hCard.appendChild(el('div', 'm-title', '谱系链'));
+          var hd = br.hist;
+          if (!hd) hCard.appendChild(el('div', 'm-meta', '正在读取谱系链…'));
+          else {
+            var revs = Array.isArray(hd.revisions) ? hd.revisions : [];
+            hCard.appendChild(el('div', 'm-meta', '本谱系共 ' + libShow(hd.revision_count) + ' 个版本(有效 '
+              + libShow(hd.counts && hd.counts.active) + ' / 已取代 ' + libShow(hd.counts && hd.counts.superseded)
+              + ' / 已撤下 ' + libShow(hd.counts && hd.counts.withdrawn) + ')'));
+            for (var i = 0; i < revs.length; i++) {
+              var rv = revs[i];
+              hCard.appendChild(el('div', 'm-meta lib-mono', 'r' + libShow(rv.revision)
+                + (rv.is_current ? ' (当前)' : '') + ' · ' + libMap(LIB_ST, rv.state, rv.state)
+                + ' · 认证 ' + libShow(rv.checked_state) + ' · 核对 ' + libShow(rv.check_count)
+                + ' 次 · ' + libShow(rv.created_at)));
+            }
+            if (!revs.length) hCard.appendChild(el('div', 'm-meta', '没有版本。'));
+          }
+          box.appendChild(hCard);
+          var cCard = el('div', 'lib-card');
+          cCard.appendChild(el('div', 'm-title', '核对史'));
+          var ck = br.checks;
+          if (!ck) cCard.appendChild(el('div', 'm-meta', '正在读取核对史…'));
+          else {
+            var crows = Array.isArray(ck.checks) ? ck.checks : [];
+            cCard.appendChild(el('div', 'm-meta', '共 ' + libShow(ck.total) + ' 次(这一页 ' + crows.length + ' 条)'));
+            for (var k = 0; k < crows.length; k++) {
+              var cr = crows[k];
+              cCard.appendChild(el('div', 'm-meta lib-mono', '第 ' + libShow(cr.check_sequence) + ' 次 · '
+                + libMap(LIB_CK, cr.state, cr.state) + ' · ' + libShow(cr.checked_at)
+                + ' · adopted=' + (cr.adopted ? 'true' : 'false')
+                + (cr.reason ? (' · reason=' + cr.reason) : '')));
+            }
+            if (!crows.length) cCard.appendChild(el('div', 'm-meta', '还没有核对过这条。'));
+          }
+          box.appendChild(cCard);
+        }
+        function renderLibBrowse() {
+          var L = st.lib;
+          var br = libBrGet();
+          var tools = el('div', 'm-tools');
+          var bBack = el('button', null, '← 回到列表(维护面)');
+          bBack.onclick = function () {
+            L.view = 'list';
+            L.err = '';
+            L.notice = '';
+            libBrPaint();
+          };
+          var bRe = el('button', null, '刷新');
+          bRe.onclick = function () {
+            // 刷新 = 换一代:在飞的旧回执全部作废(否则它们会把新骨架盖回旧的)。
+            br.gen += 1;
+            br.groups = null;
+            br.node = {};
+            br.catOpen = {};
+            br.sel = '';
+            br.detail = null;
+            br.hist = null;
+            br.checks = null;
+            br.selErr = '';
+            libBrPaint();
+            libBrLoadGroups();
+          };
+          tools.appendChild(bBack);
+          tools.appendChild(bRe);
+          body.appendChild(tools);
+          body.appendChild(el('div', 'm-meta',
+            '浏览面 —— 只读:这一面没有任何写按钮(新建 / 修订 / 撤下 / 核对都在上一面的列表里)。'
+            + '左边按「类目 → 来源」分组,展开哪一组才去取哪一组;右边是选中条目的字段、谱系链与核对史。'));
+          if (br.err) body.appendChild(el('div', 'lib-err', br.err));
+          if (!br.groups) {
+            body.appendChild(el('div', 'm-empty', br.loading ? '正在读取分组…' : '还没有读到分组。'));
+            return;
+          }
+          var wrap = el('div', null);
+          wrap.style.cssText = 'display:flex;gap:10px;flex-wrap:wrap;align-items:flex-start;margin-top:6px;';
+          var treeBox = el('div', null);
+          // 重绘保持滚动位置(否则每次重建 DOM 都跳回顶部 —— 与记忆树同一条教训);
+          // 同一条 scroll 上还挂着"滚到底续页"(与记忆浏览同款)。
+          treeBox.onscroll = function () { br.scroll = treeBox.scrollTop; libBrAutoMore(treeBox); };
+          treeBox.style.cssText = 'flex:1 1 320px;min-width:280px;border:1px solid var(--lg-border);'
+            + 'border-radius:11px;padding:6px 8px;max-height:46vh;overflow:auto;';
+          var cats = Object.keys(LIB_CAT);
+          for (var i = 0; i < cats.length; i++) treeBox.appendChild(libBrCatNode(br, cats[i]));
+          wrap.appendChild(treeBox);
+          var detailBox = el('div', null);
+          detailBox.style.cssText = 'flex:1 1 380px;min-width:300px;max-height:46vh;overflow:auto;';
+          libBrDetail(detailBox, br);
+          wrap.appendChild(detailBox);
+          body.appendChild(wrap);
+          body.appendChild(el('div', 'm-meta',
+            '分组计数是服务端一次给全的真实计数;每组怎么取数:总量到 ' + BR_PAGE_SWITCH
+            + ' 条就切成页码(只留当前页),否则一页 ' + BR_PAGE + ' 条、往下滚到底自动继续加载。'
+            + '撤下与被取代的版本也会在树里出现 —— 留痕也是馆藏,靠每行那枚状态标签区分。'));
+          treeBox.scrollTop = br.scroll || 0;
+        }
+
+        function renderLibrary() {
+          var L = st.lib;
+          body.textContent = '';
+          body.appendChild(libStatusBox());
+          libLoadStatus(false);
+          if (L.view === 'item') { renderLibItem(); return; }
+          if (L.view === 'form') { renderLibForm(); return; }
+          if (L.view === 'import') { renderLibImport(); return; }
+          if (L.view === 'browse') { renderLibBrowse(); return; }
+          renderLibList();
+        }
+
         function render() {
           if (st.tab === 'overview') renderOverview();
           else if (st.tab === 'browse') renderBrowse();
           else if (st.tab === 'tree') renderTree();
+          else if (st.tab === 'library') renderLibrary();
+          else if (st.tab === 'deep') renderDeep();
           else renderAccess();
         }
+
+        // ── 结论层页签(深层库条目)──────────────────────────────────────────────
+        //   为什么要有这一面(2026-10-15,B 档,用户拍板):`deep_item` 411 条在面板里
+        //   **一条出口都没有** —— 开场注入、recall 检索、加固信号都在用它,而主人看不见
+        //   "我正在被注入什么"。他要"加一个只读页签",这一面就是它。
+        //   为什么**只读**:落条与作废的判据是"**经主人授权**"(写在工具 `deep_item` 的描述里),
+        //   面板不提供写入口 —— 少一个入口,就少一条"手滑落错一句结论、而结论直接影响开场"的路。
+        function deepLoad(force) {
+          var D = st.deep;
+          if (D.busy) return;
+          if (D.data && !force) return;
+          // 代次令牌:取号在**发请求之前**,这一号就代表"这一发请求"。
+          //   · 应答迟到(切了筛选 / 面板重开之后才回来)⇒ 号对不上,整条丢弃:不写 data、不写 err、不重绘;
+          //   · **失败那支也要挡** —— 否则一个已作废的请求会在新筛选的视图上报一个不属于它的错。
+          var token = ++D.seq;
+          D.busy = true;
+          D.err = '';
+          var q = '/deep/items?limit=' + D.limit + (D.showRetired ? '&includeSuperseded=1' : '');
+          api(q).then(function (r) {
+            if (token !== D.seq) return;   // 迟到的旧应答:丢弃(连"忙"都不动它 —— 那是新请求的状态)
+            D.busy = false;
+            if (!r || r.ok !== true) {
+              D.err = '网关回了不带 ok 的应答';
+              if (st.tab === 'deep') renderDeep();
+              return;
+            }
+            D.data = r;
+            if (st.tab === 'deep') renderDeep();
+          }).catch(function () {
+            if (token !== D.seq) return;   // 同理:作废的请求失败回来,不许凭空报错
+            D.busy = false;
+            D.err = '网关不可达(宿主重启后 GUI cookie 会失效,刷新页面即可)';
+            if (st.tab === 'deep') renderDeep();
+          });
+        }
+        // 「可能过时」标记(2026-10-15,用户问「过时条目怎么弄」之后加):判据与工具 `tools/deep-import-docs.mjs`
+        //   的 STALE_* 同源,**那边是权威**(这里只是把它摆到面板上)。WHY:结论层条目直接影响开场,
+        //   含读数/时点状态的条过时了没人提醒 —— 让它可见,比在库里躺着强。
+        function deepLooksStale(t) { return /(\d+\s*(ms|毫秒|秒|分钟|小时|天|周|个月|年|个会话|条|行|字节|KB|MB|GB|%|倍|次))|(当前|目前|现在|暂时|计划中|待做|待办|尚未|还没|即将|正在|下一步|先按|暂定)|(本次|这次|本轮|今天|昨天|今晚|刚才|明天|本周|这几天)/.test(String(t || '')); }
+        function deepRow(it) {
+          var row = el('div', 'm-row');
+          row.appendChild(el('div', 'm-title', it.text));
+          var chips = el('div', null);
+          chips.appendChild(el('span', 'lib-chip', it.kind || '未分类'));
+          chips.appendChild(el('span', 'lib-chip',
+            it.durability === 'ephemeral' ? '硬度:ephemeral(不进开场)' : ('硬度:' + (it.durability || '—'))));
+          if (it.durability !== 'ephemeral' && deepLooksStale(it.text)) chips.appendChild(el('span', 'lib-chip', '可能过时'));
+          if (Number(it.pinned)) chips.appendChild(el('span', 'lib-chip', '置顶'));
+          chips.appendChild(el('span', 'lib-chip', '加固 ' + Number(it.hit_count || 0)));
+          if (it.superseded_by) {
+            chips.appendChild(el('span', 'lib-chip', it.superseded_by === 'retracted' ? '已作废' : '已被取代'));
+          }
+          row.appendChild(chips);
+          row.appendChild(el('div', 'm-meta lib-mono',
+            it.id + ' · 来源 ' + (it.conv_id || it.src || '—')
+            + (it.at ? (' · ' + it.at) : '')
+            + (it.branch_id ? (' · 气根 ' + it.branch_id) : '')));
+          return row;
+        }
+        function renderDeep() {
+          var D = st.deep;
+          body.textContent = '';
+          var tools = el('div', 'm-tools');
+          var bR = el('button', null, D.busy ? '读取中…' : '刷新');
+          bR.disabled = !!D.busy;
+          bR.onclick = function () { deepLoad(true); };
+          var bAll = el('button', null, D.showRetired ? '只看在役' : '连已退役一起看');
+          // 换筛选 = **作废在飞的那一发**(D.seq++)、放开忙标志,再按新筛选重发。
+          //   只翻 showRetired 是不够的:老请求还在飞时 `if (D.busy) return;` 会把这次"按新筛选重发"
+          //   **挡回**,于是老应答回来写的是**旧筛选**的数据,而按钮文字已经是新状态 ⇒ 列表与按钮相反。
+          bAll.onclick = function () {
+            D.showRetired = !D.showRetired; D.data = null;
+            D.seq++; D.busy = false;                 // 作废在飞的那一发(否则下面这发会被忙标志挡回)
+            deepLoad(true);
+            if (st.tab === 'deep') renderDeep();     // 立刻按新筛选重画:不留"按钮已翻、列表还是旧的"空窗
+          };
+          tools.appendChild(bR);
+          tools.appendChild(bAll);
+          body.appendChild(tools);
+          if (D.err) body.appendChild(el('div', 'lib-err', D.err));
+          deepLoad(false);
+          var d = D.data;
+          if (!d) { body.appendChild(el('div', 'm-empty', '正在读结论层…')); return; }
+          // ⚠️ 两个计数**分开报**:把退役的算进"有多少条结论"会让人以为它们还在参与开场选择。
+          body.appendChild(el('div', 'm-meta',
+            '在役 ' + libShow(d.all) + ' 条 · 已退役 ' + libShow(d.retired)
+            + ' 条(退役 = 被取代或已作废:不再参与开场选择与检索排序,但留痕留在库里)'
+            + ' —— 这一面纯读:落条与作废走工具,面板里不写库。'));
+          var items = d.items || [];
+          if (!items.length) {
+            body.appendChild(el('div', 'm-empty', D.showRetired
+              ? '结论层是空的。'
+              : ('在役条目为空(退役的还有 ' + libShow(d.retired) + ' 条,点上面那枚按钮一起看)。')));
+            return;
+          }
+          for (var i = 0; i < items.length; i++) body.appendChild(deepRow(items[i]));
+          body.appendChild(el('div', 'm-meta',
+            '列出 ' + items.length + ' 条(上限 ' + D.limit + ')。条目是装配单元:'
+            + '开场与新会话按加权从这里挑;加固只在"真被采用"时 +1(被注入不算,否则会自我强化)。'));
+        }
+
         render();
       }
 
@@ -4520,7 +7000,7 @@
           var label = rail
             ? (auditBad ? '⚠' : (mode === 'work' ? '⚙' : '☾'))
             : ((auditBad ? '⚠ ' : '') + (mode === 'work' ? '⚙ 工作' : '☾ 生活'));
-          // ⚠️ 原生 `title` 只留**一行**(2026-09-27 尝生反馈:原来四行太罗嗦,且浏览器 tooltip 不会自动
+          // ⚠️ 原生 `title` 只留**一行**(2026-09-27 用户反馈:原来四行太罗嗦,且浏览器 tooltip 不会自动
           //   消失,悬停 1.5s 菜单一开就和它叠成两层)。完整提醒改走自绘气泡 `showTip` ——
           //   悬停即现、3s 自隐、菜单一开就收,见 `tipText`。
           var title = (isGlobal
@@ -4550,7 +7030,7 @@
               if (tipText) showTip(btnRef && btnRef.current, tipText);
               hoverTimer.current = setTimeout(function () {
                 hoverTimer.current = null;
-                hideTip();   // 菜单与气泡永不同屏(尝生反馈的"窗口叠加"就是这两层)
+                hideTip();   // 菜单与气泡永不同屏(用户反馈的"窗口叠加"就是这两层)
                 var node = btnRef && btnRef.current;
                 openMenuNear(node ? node.getBoundingClientRect() : null, store);
               }, HOVER_MS);
@@ -4626,7 +7106,7 @@
         return out.join('\n');
       }
 
-      /** 复盘解锁:跨面板共享的真值 —— 记忆中心与右侧复盘栏读同一个变量(尝生 2026-09-21)。
+      /** 复盘解锁:跨面板共享的真值 —— 记忆中心与右侧复盘栏读同一个变量(用户 2026-09-21)。
        *  「复盘模式」不是一个 UI 开关,而是"左会话 + 右侧栏"这个状态;树编辑解锁只是它的附属。*/
       var lingUnlocked = false;
       /** 解锁状态订阅者(2026-09-22 审计 C#3):侧栏是 React 组件,useState 只在**首次渲染**取值,
@@ -4660,7 +7140,7 @@ var lingCenterReload = null;   // 侧栏改完树后通知记忆中心重载(两
       /**
        * 复制文本(clipboard 不可用时回退 execCommand)。
        * silent=true 时不再单独 toast「已复制」—— 调用方自己会报一句完整的结果,
-       * 否则会出现两个 toast 叠加(2026-09-22 尝生实测:『已复制复盘开场白 —— 已复制 …』)。
+       * 否则会出现两个 toast 叠加(2026-09-22 用户实测:『已复制复盘开场白 —— 已复制 …』)。
        */
       function reviewCopy(text, silent) {
         // 审计 C#13:改成**回报是否成功**(Promise) —— clipboard 是异步的,只有 `.then` 才知道结果;
@@ -4773,7 +7253,7 @@ var lingCenterReload = null;   // 侧栏改完树后通知记忆中心重载(两
             if (i >= 0) lingUnlockSubs.splice(i, 1);
           };
         }, []);
-        // 选中态统一(2026-09-22 尝生):单选与多选共用 s8 的集合,selId 由它派生。
+        // 选中态统一(2026-09-22 用户):单选与多选共用 s8 的集合,selId 由它派生。
         // 原先 selId(蓝) 与 dragIds(橙) 是两套状态,表现为"一蓝一橙"且拖动只有橙的会动。
         var refName = React.useRef(null);
         var refRep = React.useRef(null);
@@ -4788,7 +7268,7 @@ var lingCenterReload = null;   // 侧栏改完树后通知记忆中心重载(两
         var setSnapshots = s5[1];
         var refSnap = React.useRef(null);
         // R2 会话级展开:哪些枝展开了、该枝的成员缓存(懒加载)
-        // C(2026-09-25 尝生):此前 openId 是**单个字符串** ⇒ 打开一个就把上一个关掉(独占式)。
+        // C(2026-09-25 用户):此前 openId 是**单个字符串** ⇒ 打开一个就把上一个关掉(独占式)。
         // 复盘的场景恰恰是"同时对照几条枝",独占等于逼人来回点。改用集合(每节点独立),
         // 可同时展开多个;Shift+C 一键全折叠(见下方 keydown effect)。
         var s6 = React.useState({});
@@ -4815,7 +7295,7 @@ var lingCenterReload = null;   // 侧栏改完树后通知记忆中心重载(两
         // 否则落库前的撤回信息里记不到这一项 ⇒ Ctrl+Z 报「已撤回:恢复了 0 项的位置」。
         // 用 ref 而不是 state:拖拽期间不需要重渲染,drop 时读最新值即可。
         var refDragFrom = React.useRef('');
-        // 滚动位置自保(2026-09-22 尝生:点主脉级会跳回顶部)
+        // 滚动位置自保(2026-09-22 用户:点主脉级会跳回顶部)
         // 点选节点会触发整块重渲染,内容高度变化时浏览器会把视口弹回顶部;
         // 故实时记录 scrollTop,并在每次渲染后恢复 —— 与记忆中心 st.treeScroll 同思路。
         var boxRef = React.useRef(null);
@@ -4826,7 +7306,7 @@ var lingCenterReload = null;   // 侧栏改完树后通知记忆中心重载(两
         });
         // 编辑区只在"恰好选中一个"时生效(多选时显示提示)
         var selId = (dragIds.length === 1) ? dragIds[0] : '';
-        // 复盘守门(2026-09-22 尝生:「互相复盘不应该被我绕过,动记忆树不能是随意的」):
+        // 复盘守门(2026-09-22 用户:「互相复盘不应该被我绕过,动记忆树不能是随意的」):
         // 记录"自器灵上次开口以来累积了多少笔结构改动还没交代"。未同步时:
         // ① 面板顶部红字提示 ② **拦住"退出复盘模式"** —— 改完树必须让器灵有机会看到。
         var s10 = React.useState(0);
@@ -4845,7 +7325,7 @@ var lingCenterReload = null;   // 侧栏改完树后通知记忆中心重载(两
         var veinSugs = s11[0];
         var setVeinSugs = s11[1];
         // 审计 E10(1.5.1 红蓝对抗):「这条主脉**已经**有主脉记忆了」是**采纳前**就该知道的事。
-        // 后端对同主脉的第二次采纳做的是"先把旧版归档、再覆盖"(尝生 2026-09-25 裁决),可界面
+        // 后端对同主脉的第二次采纳做的是"先把旧版归档、再覆盖"(用户 2026-09-25 裁决),可界面
         // 此前对"将要覆盖"零提示 ⇒ 唯一的发现途径是事后去翻「最近改动」。
         // 判据不靠后端加字段:`conv_overview.source='vein'` 的 `conv_id` **就是主脉 id**
         //(memory.js:1821 写入时 `conv_id: veinId`),所以查一次 `?source=vein` 就知道
@@ -4909,7 +7389,7 @@ var lingCenterReload = null;   // 侧栏改完树后通知记忆中心重载(两
           }, 8000);
           return function () { clearInterval(t); };
         }, []);
-        // Shift+C:一键折叠所有已展开的枝(2026-09-25 尝生定,暂定键位)。
+        // Shift+C:一键折叠所有已展开的枝(2026-09-25 用户定,暂定键位)。
         // ⚠️ 位置纪律:必须落在**本函数所有 early return 之前**(下方有 `if (!data) return …`)。
         // React 要求每次渲染的 hook 数量与顺序恒定;把 useEffect 放在 early return 之后会出现
         // "首次渲染 data 为空 → 提前 return(少一个 hook) → 数据到达后重渲染多一个 hook"
@@ -5206,7 +7686,7 @@ var lingCenterReload = null;   // 侧栏改完树后通知记忆中心重载(两
               userSelect: 'none', WebkitUserSelect: 'none',
               // 选中色只有一种(琥珀) —— 单选与 Ctrl 多选视觉一致,避免"一蓝一橙"
               background: on ? 'rgba(197,139,47,.22)' : 'transparent',
-              // 拖动悬停目标:青色虚线框,松手前就知道会落到哪(2026-09-22 尝生)
+              // 拖动悬停目标:青色虚线框,松手前就知道会落到哪(2026-09-22 用户)
               outline: (dropTarget === x.n.id) ? '2px dashed #3fb9a6'
                 : (on ? '1px solid rgba(197,139,47,.5)' : 'none'),
               outlineOffset: '-2px',
@@ -5221,7 +7701,7 @@ var lingCenterReload = null;   // 侧栏改完树后通知记忆中心重载(两
             },
             style: { display: 'inline-block', width: '12px', opacity: hasKids ? 0.75 : 0.25 },
           }, hasKids ? (isOpen ? '▾' : '▸') : '·'),
-          // A(2026-09-25 尝生):主脉与枝此前在列表里长得一模一样,只能靠"点开会显示 [主脉]"
+          // A(2026-09-25 用户):主脉与枝此前在列表里长得一模一样,只能靠"点开会显示 [主脉]"
           // 分辨 —— 而「零散记录」(枝) 与「零散会话」(主脉) 这类名字只差一个字,必然选错。
           // 现在行首给标记:🌱 主干 / ◆ 主脉 / · 枝。
           (x.n.kind === 'trunk' ? '🌱 ' : (x.n.kind === 'vein' ? '◆ ' : '· ')) + (x.n.name || x.n.id)
@@ -5290,7 +7770,7 @@ var lingCenterReload = null;   // 侧栏改完树后通知记忆中心重载(两
                       paddingLeft: ((x.d + 1) * 12 + 12) + 'px', fontSize: '11px', opacity: 0.85,
                       cursor: 'grab', whiteSpace: 'nowrap', overflow: 'hidden', textOverflow: 'ellipsis',
                       userSelect: 'none', WebkitUserSelect: 'none', borderRadius: '5px',
-                      // 会话级也要有选中可视化(2026-09-22 尝生:会话能拖但看不出选没选中)
+                      // 会话级也要有选中可视化(2026-09-22 用户:会话能拖但看不出选没选中)
                       background: con ? 'rgba(197,139,47,.22)' : 'transparent',
                       outline: (dropTarget === cid) ? '2px dashed #3fb9a6'
                         : (con ? '1px solid rgba(197,139,47,.5)' : 'none'),
@@ -5465,7 +7945,7 @@ var lingCenterReload = null;   // 侧栏改完树后通知记忆中心重载(两
             .catch(function (e) { toast('✗ 提炼失败:' + ((e && e.message) || '未知')); });
         };
         var resolveSug = function (id, action, text) {
-          // 尝生 2026-09-25 裁决(乙):**提炼不锁、采纳要解锁**。
+          // 用户 2026-09-25 裁决(乙):**提炼不锁、采纳要解锁**。
           //   「提炼」只往候选表写一行草稿,不碰记忆 ⇒ 不锁(锁它会抬启动成本);
           //   「采纳」会写 conv_overview(source='vein') + assignConv 改树归属 ⇒ 与改名/并脉同级,故要走同一道门。
           //   「驳回」不写任何东西 ⇒ 不锁。
@@ -5505,7 +7985,7 @@ var lingCenterReload = null;   // 侧栏改完树后通知记忆中心重载(两
             h('button', { key: 'b', type: 'button', onClick: function () { doDistill(selX.id); } }, '✦ 提炼主脉'),
           ]));
         } else if (selX && selX.kind === 'branch') {
-          // B(2026-09-25 尝生):枝上也要有提炼入口 —— 但提炼的素材是"主脉及其子枝",
+          // B(2026-09-25 用户):枝上也要有提炼入口 —— 但提炼的素材是"主脉及其子枝",
           // 对枝本身提炼没有意义。所以这里先沿 parentId 往上找它所属的主脉,
           // 按钮直接对**那条主脉**做提炼,并在文案里说清对象,省掉"自己去列表里找主脉"这一跳。
           var vAnc = null;
@@ -5531,7 +8011,7 @@ var lingCenterReload = null;   // 侧栏改完树后通知记忆中心重载(两
               '✦ 提炼 —— 这条枝还没挂在主脉下;先并脉(挂到某条主脉),再对它提炼。')]));
         }
         // ---- R7 主脉提炼审核队列(2026-09-23) ----
-        // 2026-09-25 尝生:「提炼结果放在『主脉提炼』那一条底下」—— 审核队列紧跟提炼入口,
+        // 2026-09-25 用户:「提炼结果放在『主脉提炼』那一条底下」—— 审核队列紧跟提炼入口,
         // 点完提炼往下看就是候选,不必滚到页面别处去找。
         // 设计稿 §5:提炼结果先入队、带派生来源;采纳后才写进主脉记忆,且可"改后采纳"(文本框里改完再点采纳)。
         if (veinSugs.length) {
@@ -5726,7 +8206,7 @@ var lingCenterReload = null;   // 侧栏改完树后通知记忆中心重载(两
           });
         }
         // ---- 最近改动 ----
-        // 2026-09-25 尝生:「『最近改动』块挪到『树的保存/恢复』底下」—— 它记的是"谁在什么时候
+        // 2026-09-25 用户:「『最近改动』块挪到『树的保存/恢复』底下」—— 它记的是"谁在什么时候
         // 动了树",与上面那排快照是同一件事的两面(一份是存档,一份是流水),放一起才顺。
         if (data.log.length) {
           kids.push(h('div', { key: 'lh', style: { fontWeight: 700, margin: '9px 0 2px' } }, '最近改动'));
@@ -5767,7 +8247,7 @@ var lingCenterReload = null;   // 侧栏改完树后通知记忆中心重载(两
             style: unlocked ? { borderColor: '#c58b2f', color: '#c58b2f' } : {},
             onClick: function () {
               var next = !unlocked;
-              // 复盘守门(2026-09-22 尝生:「互相复盘不应该被我绕过」):退出前必须先把
+              // 复盘守门(2026-09-22 用户:「互相复盘不应该被我绕过」):退出前必须先把
               // 未同步的改动交代给器灵 —— 不能"改完几十处直接走人",那等于假复盘。
               // 2026-09-23 修:显示值可能滞后(器灵开口才推进水位,而"发言"不触发本面板重载),
               // 所以退出前**实时查一次**服务端 —— 避免"明明已经同步了却拦着不让退"。
@@ -5793,7 +8273,7 @@ var lingCenterReload = null;   // 侧栏改完树后通知记忆中心重载(两
               }
               setUnlocked(next);
               setLingUnlocked(next, true);
-              // 进入复盘模式 = 解锁 + 备好开场白(2026-09-22 尝生:行为与总控板「一键进入复盘」对齐)
+              // 进入复盘模式 = 解锁 + 备好开场白(2026-09-22 用户:行为与总控板「一键进入复盘」对齐)
               // 审计 C#17:原来这里把 reviewCopy 当同步函数 —— 它返回 Promise,所以 try/catch
               // 根本抓不到复制失败,而且**不等结果**就先报「已复制」。改成等结果再说文案。
               if (next) {
@@ -6100,7 +8580,7 @@ var lingCenterReload = null;   // 侧栏改完树后通知记忆中心重载(两
               // ⚠️ 只等 sidebarRightTabs —— 不要把 sidebarRight 也写进来:
               //   它是 per-session 绑定的控制器,在该注入作用域里可能永不满足,
               //   回调就永远不执行 ⇒ 面板类型注册不上 ⇒ openTab 抛
-              //   'sidebarRight: no tab type is registered as "ling-review"'(尝生实测)。
+              //   'sidebarRight: no tab type is registered as "ling-review"'(用户实测)。
               //   打开面板时用 lingCtx.get('sidebarRight') 动态取即可(那时必然已挂载)。
               // 🔴 根因(2026-09-21 定位):服务必须从**回调参数**上取(scoped),
               //    不能用闭包里的 ctx —— cordis 的属性访问在未 inject 时抛
@@ -6149,14 +8629,17 @@ var lingCenterReload = null;   // 侧栏改完树后通知记忆中心重载(两
           console.warn('[dsh-ling] client apply failed', e);
         }
       };
-      // ---- 测试钩子(仅供 tests/client-batch.test.mjs 直调真实实现)----
-      // 只挂纯函数与常量,无任何副作用;生产路径不读这里。
+      // ---- 测试钩子(仅供 tests/client-batch.test.mjs、tests/library-client.test.mjs 直调真实实现)----
+      // 只挂纯函数、常量与"面板入口",无任何副作用;生产路径不读这里。
+      // `openMemoryCenter` 是给「图书馆」标签的**执行级**用例用的:测试侧用假 DOM 打开面板 → 点标签 →
+      // 点按钮,走的是与真人点击**同一条**代码路径(不是源码正则护栏)。
       exports.__test__ = {
         takeChunk: takeChunk,
         utf8Len: utf8Len,
         fmtBytes: fmtBytes,
         BATCH_MAX_BYTES: BATCH_MAX_BYTES,
         BATCH_MAX_ITEMS: BATCH_MAX_ITEMS,
+        openMemoryCenter: openMemoryCenter,
       };
       return module.exports;
     },