@nightpainters/dsh-ling 1.5.1 → 1.5.3

package/lib/client.js

@@ -27,14 +27,126 @@
 
       var API = '/api/dsh-ling';
 
+      // ---------------- 导入切批(纯函数,无副作用) ----------------
+      // S9(2026-09-29 导入批失败 4MiB):服务端 readBody() 按【字节】封顶 4MiB
+      // (lib/host/api.js:139),而旧客户端按【条数】切批(batch = 200)⇒ 两端判据不同单位:
+      // 186 条 / 4.89MB 被打成整批一发 ⇒ 超限 ⇒ 连接被 reset ⇒ 界面错报「批失败(网关)」。
+      // 现改为【条数 × 字节】双限:字节上限留 1MiB 余量给数组封套与 JSON 转义。
+      // ⚠️ 这两个函数必须留在 factory 作用域(不能塞进 bGo.onclick):V1 用例经
+      // tests/vm-light.mjs 的 contextify 加载本文件后,从 exports.__test__ 取名直调。
+      var BATCH_MAX_BYTES = 3 * 1024 * 1024;   // 服务端 4 MiB;留 1 MiB 余量给封套与转义
+      var BATCH_MAX_ITEMS = 200;               // 保留旧条数上限(小条目时行为与旧版一致)
+      // 精确 UTF-8 字节数。⚠️ 不许用 s.length 冒充(CJK 3 字节、emoji 代理对 4 字节),
+      // 也不许依赖 TextEncoder/TextDecoder —— 本文件要能在测试沙箱
+      // (tests/vm-light.mjs 的白名单式 sandbox,无 TextEncoder)里跑。
+      function utf8Len(s) {
+        var t = s === null || s === undefined ? '' : String(s);
+        var n = 0;
+        for (var i = 0; i < t.length; i++) {
+          var c = t.charCodeAt(i);
+          if (c < 0x80) n += 1;
+          else if (c < 0x800) n += 2;
+          else if (c >= 0xD800 && c <= 0xDBFF && i + 1 < t.length) {
+            var d = t.charCodeAt(i + 1);
+            if (d >= 0xDC00 && d <= 0xDFFF) { n += 4; i += 1; }  // 代理对(emoji 等)
+            else n += 3;                                         // 落单高代理 ⇒ U+FFFD(3 字节)
+          } else n += 3;                                         // BMP 3 字节 / 落单低代理 ⇒ U+FFFD
+        }
+        return n;
+      }
+      // 字节 ⇒ 人读口径(C2 进度文案用)
+      function fmtBytes(n) {
+        var b = Number(n) || 0;
+        if (b < 1024 * 1024) return (b / 1024).toFixed(1) + ' KB';
+        return (b / 1024 / 1024).toFixed(1) + ' MB';
+      }
+      /** 服务端**回执里的**单次上限 ⇒ 人话(B / 2026-09-29:413 文案要说清"上限是多少")。
+       *  ⚠️ 数字**只许来自回执**(`r.limit`):客户端不镜像服务端的那个常量(C5 / C-1 的同一条命门 ——
+       *  两处各写一个"4 MB",将来服务端改上限时必漂移);回执没带就如实说"没给",绝不猜一个数顶上。 */
+      function fmtLimitMB(limit) {
+        var n = Number(limit);
+        if (!(n > 0)) return '上限未随回执返回';
+        return (Math.round(n / 1024 / 1024 * 10) / 10) + ' MB';
+      }
+      // 从 from 起切一批 ⇒ { list, next, bytes }。bytes 口径 = JSON.stringify(每条)的
+      // UTF-8 字节 + 1(数组逗号),外加 2(方括号)—— 与契约一致(偏保守:末条逗号也计入)。
+      // 前进性硬保证:首条即使自己就超 BATCH_MAX_BYTES 也单独成批,绝不返回空 list
+      // (空批 ⇒ 调用方 idx 不前进 ⇒ 死循环)。
+      function takeChunk(items, from) {
+        var list = [];
+        var bytes = 2; // 数组封套 []
+        var i = from;
+        while (i < items.length && list.length < BATCH_MAX_ITEMS) {
+          var n = 0;
+          try { n = utf8Len(JSON.stringify(items[i])); } catch (e) { n = 0; } // 循环引用等:交给服务端拒
+          var cost = n + 1; // 数组逗号
+          if (list.length && bytes + cost > BATCH_MAX_BYTES) break;
+          list.push(items[i]);
+          bytes += cost;
+          i += 1;
+        }
+        return { list: list, next: i, bytes: bytes };
+      }
+
       // ---------------- 第三人称代词(跟随 persona.pronoun) ----------------
       // 界面文案里写死的「她」全部经 she() 出口 —— 用户改成「他 / TA / 自定义」后文案随之改变;
       // **只用于文案**,绝不用于用户原话或记忆数据(那会把数据改错)。
       var UI_PRONOUN = '她';
-      function she(s) { return UI_PRONOUN === '她' ? s : String(s).split('她').join(UI_PRONOUN); }
+      // she() 每吐出一个含代词的文案,就把「产出值 → 原文模板」记进这张表 —— 它是"这段文字出自
+      // she() 出口、属文案而非数据"的**唯一凭据**。换代词时只按这张表逐字重算(见 refreshPronounTexts):
+      // 表里没有的文字(主人原话、记忆正文、会话标题、后端来的习惯/自述/改法说明)**一个字节都不动**。
+      // ⚠️ 必须是 null 原型:文案里若真出现 `constructor` / `__proto__` 这种键,普通对象会经原型链
+      // 拿回 Object.prototype 上的成员(同 ownGet :409 那个坑)⇒ 会把一个函数当成模板去 split。
+      var SHE_VALS = Object.create(null);
+      function she(s) {
+        var src = String(s);
+        var out = UI_PRONOUN === '她' ? s : src.split('她').join(UI_PRONOUN);
+        if (src.indexOf('她') >= 0) SHE_VALS[out] = src;
+        return out;
+      }
+      /** 一段**已挂载**的文字 → 当前代词版本。认不出来(不在 SHE_VALS 里 = 不是 she() 写的)就
+       *  **原样返回** —— 数据面永远走这条出口,所以"顺手把界面上的她全替换掉"这种写法不存在于本文件。 */
+      function sheRederive(t) {
+        var src = SHE_VALS[t];
+        if (src !== undefined) return she(src);
+        // 多行读数(join('\n') 拼出来的那一块):逐行认,**认不出的行原样留着**。
+        if (String(t).indexOf('\n') < 0) return t;
+        var ls = String(t).split('\n');
+        for (var i = 0; i < ls.length; i++) { if (SHE_VALS[ls[i]] !== undefined) ls[i] = she(SHE_VALS[ls[i]]); }
+        return ls.join('\n');
+      }
+      /** 递归重画一个已挂载节点里的文案。**只写 Text 节点(nodeType===3)的 nodeValue** ——
+       *  输入框/文本域的 .value、自绘下拉的选中态、表单控件一律不碰 ⇒ 主人正在输入的字符、
+       *  已选中的文本、光标位置都不可能被这次重画吃掉。 */
+      function sheRefreshNode(root) {
+        var kids = root && root.childNodes;
+        if (!kids) return;
+        for (var i = 0; i < kids.length; i++) {
+          var n = kids[i];
+          if (!n) continue;
+          if (n.nodeType === 3) {
+            var t = n.nodeValue;
+            var nt = sheRederive(t);
+            if (nt !== t) n.nodeValue = nt;   // 内容真的变了才写(不变就连赋值都不做)
+          } else if (n.nodeType === 1) {
+            sheRefreshNode(n);
+          }
+        }
+      }
+      /** 代词变了 ⇒ 让**当前已挂载**的、经 she() 出口写进去的界面文案就地重画(不是只给新节点写新值)。
+       *  只遍历浮层根节点:本文件全部代词文案都在 .dsh-ling-panel / .dsh-ling-menu 里,页面其余部分
+       *  (会话正文、侧栏、Dock)本就不该被本插件改写。 */
+      function refreshPronounTexts() {
+        if (typeof document === 'undefined' || !document.querySelectorAll) return;
+        var roots = document.querySelectorAll('.dsh-ling-panel,.dsh-ling-menu');
+        for (var i = 0; i < roots.length; i++) sheRefreshNode(roots[i]);
+      }
       function setPronounFrom(persona) {
         var pn = persona && persona.pronoun ? String(persona.pronoun).slice(0, 6) : '';
-        if (pn) UI_PRONOUN = pn;
+        // **值没变 ⇒ 一拍都不多做**:既不重画(每拍重画会把面板搞卡),也不惊动主人正在输入的内容。
+        if (!pn || pn === UI_PRONOUN) return;
+        UI_PRONOUN = pn;
+        refreshPronounTexts();
       }
       var NS = 'dsh-ling';
       var STYLE_ID = 'dsh-ling-css';
@@ -50,13 +162,49 @@
         return parts.length ? '?' + parts.join('&') : '';
       }
 
+      // ── 手术门 · 本机通行票据(2026-09-30 深夜;规格 §1.2 的客户端那一半)──────────────
+      // 宿主每启动轮换一枚 32 字节票据;**只有本机直连**拿得到(带代理头的请求会被拒)。
+      // 这一半只做"取一次 + 缓存 + 随手术请求带上",**不动任何弹窗与文案结构**(Phase 1 的边界)。
+      // 取不到(经反代打开的页面 / 旧宿主)= 空串 ⇒ 手术请求照旧发,由宿主那边给出明确拒绝。
+      var surgeryTicket = '';
+      var surgeryTicketTried = false;
+      function fetchSurgeryTicket() {
+        surgeryTicketTried = true;   // 无论成败都只试一次(失败不重试,免得把拒绝变成刷屏)
+        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 '';   // 远端 / 未定型:没有票,照常走后面的拒绝路径
+          })
+          .catch(function () { return ''; });
+      }
+
       function api(path, opts) {
         opts = opts || {};
+        var headers = { 'content-type': 'application/json' };
+        if (surgeryTicket) headers['x-dsh-ling-surgery'] = surgeryTicket;
         return fetch(API + path, {
           method: opts.method || 'GET',
-          headers: { 'content-type': 'application/json' },
+          headers: headers,
           body: opts.body ? JSON.stringify(opts.body) : undefined,
-        }).then(function (res) { return res.json().catch(function () { return null; }); });
+        }).then(function (res) {
+          return res.json().catch(function () { return null; });
+        }).then(function (j) {
+          // 宿主说"票据不对/没票"⇒ 现场取一次,原样重发一次(只重发一次,不做循环)。
+          // 票据每启动轮换 ⇒ 页面放久了会遇到这一支,那时用户不必手动刷新。
+          if (j && j.ok === false && j.surgery === 'surgery-ticket' && !surgeryTicketTried) {
+            return fetchSurgeryTicket().then(function (t) {
+              if (!t) return j;
+              var h2 = { 'content-type': 'application/json', 'x-dsh-ling-surgery': t };
+              return fetch(API + path, {
+                method: opts.method || 'GET',
+                headers: h2,
+                body: opts.body ? JSON.stringify(opts.body) : undefined,
+              }).then(function (r2) { return r2.json().catch(function () { return null; }); });
+            });
+          }
+          return j;
+        });
       }
 
       // ---------------- tiny store ----------------
@@ -115,6 +263,8 @@
           '.dsh-ling-menu .mi:hover{background:var(--lg-hover-bg);color:var(--lg-hover-text);font-weight:600;}' +
           '.dsh-ling-menu .sep{height:1px;background:linear-gradient(90deg,var(--lg-border),transparent);margin:5px 10px;}' +
           '.dsh-ling-menu .hint{padding:4px 12px 7px;font-size:12px;opacity:.55;line-height:1.5;}' +
+          '.dsh-ling-tip{min-width:auto;max-width:290px;padding:0;pointer-events:none;}' +
+          '.dsh-ling-tip .mi{white-space:normal;font-size:12.5px;line-height:1.55;padding:8px 11px;}' +
           '.dsh-ling-panel{position:fixed;z-index:9999;right:18px;top:18px;width:min(480px,94vw);max-height:86vh;' +
           'overflow:auto;background:linear-gradient(var(--lg-bg),var(--lg-bg)) padding-box,var(--lg-bgrad) border-box;' +
           'border:1px solid transparent;border-radius:16px;' +
@@ -252,13 +402,66 @@
           '.ling-hist .hr button{min-height:26px;padding:1px 10px;font-size:12px;border-radius:8px;border:1px solid var(--lg-border);' +
           'background:transparent;color:var(--lg-text);cursor:pointer;flex:none;}' +
           '.ling-hist .hr button:hover{border-color:var(--lg-accent);background:var(--lg-hover);}' +
-          '.ling-hist .hr button:disabled{opacity:.45;cursor:wait;}';
+          '.ling-hist .hr button:disabled{opacity:.45;cursor:wait;}' +
+          // E3(面板只读块):「那一行」在盘上有两条 —— ①L2 本会话标题行、②E0 活行。两条必须**各自成行、各自标注**,
+          // 否则主人只会看到"同一句话印了两遍"。「看全文」默认收起:快照原文上限 8000 字符,不设限高会把面板顶出屏幕。
+          // 缺陷② 修复(2026-09-27 真机目视"字好挤、行距比旧块小还不统一"):根因是**无单位**行高 —— 它不是一个
+          // 固定的数,而是"字号 x 倍数";三套字号(12.5 / 12 / 11.5)各乘一遍 ⇒ 每类行的实际行距都不同
+          // (20.6 / 19.8 / 19.0px),且都比上面那个旧块 `.kv`(本文件 :133,13px x 1.6 = 20.8px)紧。
+          // 缺陷③ 修复(2026-09-27 真机目视"小字略显拥挤,大字行距是对的"):上一轮我把小字**并进正文那一档**换来统一,
+          // 层级就没了 ⇒ 小字挤。正解 = 行距写**绝对 px**(取旧块的计算行距 20.8px):绝对行距在子元素上继承的是
+          // **计算值**,不随各自字号相乘 ⇒ 字号可以分三档,行距仍恒等 —— "统一"与"层级"同时成立。
+          // (判据:已由一次性静态探针逐档核算实际行距,要求取值唯一、且等于旧块的计算值。)
+          '.ling-e3{margin:8px 0 2px;padding:8px 10px;border:1px solid var(--lg-border-soft);border-radius:10px;' +
+          'background:var(--lg-rowbg);font-size:13px;line-height:20.8px;}' +   // 正文档 13px(同旧块)+ **绝对**行距 = 旧块的计算行距
+          '.ling-e3 .e3-h{font-weight:700;opacity:.95;margin-bottom:3px;}' +   // 标题:正文档(继承 13px)
+          '.ling-e3 .e3-row{white-space:pre-wrap;word-break:break-word;}' +     // 正文档
+          '.ling-e3 .e3-row .lbl{opacity:.6;}' +
+          '.ling-e3 .e3-why{font-size:12px;opacity:.88;}' +            // 说明档:「为什么没变」那几行
+          '.ling-e3 .e3-why.no{color:var(--lg-danger);opacity:1;}' +   // 不另给字号 ⇒ 仍随说明档
+          '.ling-e3 .e3-fold-h{font-size:12px;cursor:pointer;margin-top:6px;}' +   // 说明档:折叠头
+          '.ling-e3 .e3-fold-h .tag{opacity:.6;}' +
+          '.ling-e3 .e3-pre{font-size:12px;max-height:220px;overflow:auto;margin:4px 0 0;padding:6px 8px;border-radius:8px;' +   // 说明档:注入面原文
+          'border:1px solid var(--lg-border-soft);background:var(--lg-bg2);white-space:pre-wrap;word-break:break-word;' +
+          'opacity:.92;}' +
+          '.ling-e3 .e3-meta{font-size:11.5px;opacity:.6;}';   // meta 档:builtAt 那类一行小字(三档都继承同一个绝对行距)
         document.head.appendChild(tag);
       }
 
       function dark() { return document.documentElement.getAttribute('data-ds-theme') === 'dark' ? '1' : '0'; }
 
+      /** 悬停即时小气泡(2026-09-27,用户反馈"太罗嗦 + 窗口叠加"):
+       *  原生 `title` 由**浏览器**绘制 —— 既不受样式控制,也**不会自动消失**;而悬停 1.5s 会开菜单,
+       *  于是浏览器 tooltip 和菜单叠成两层。故完整提醒改走自绘:悬停瞬间出现、`TIP_MS` 后自动移除,
+       *  且菜单一开就先收掉它 ⇒ 两者永不同屏。与 `toast` 同规格(都是 dsh-ling-menu 容器 + 定时移除),
+       *  差别只在寿命与定位。 */
+      var TIP_MS = 3000;
+      var tipNode = null;
+      var tipTimer = null;
+      function hideTip() {
+        if (tipTimer) { clearTimeout(tipTimer); tipTimer = null; }
+        if (tipNode) { tipNode.remove(); tipNode = null; }
+      }
+      function showTip(node, text) {
+        hideTip();
+        if (!node || !text || typeof node.getBoundingClientRect !== 'function') return;
+        var t = el('div', 'dsh-ling-menu dsh-ling-tip');
+        t.appendChild(el('div', 'mi', text));
+        t.style.visibility = 'hidden';           // 先隐藏渲染量尺寸,再定方位(同 openMenuNear 的做法)
+        document.body.appendChild(t);
+        var r = node.getBoundingClientRect();
+        var w = t.offsetWidth, hh = t.offsetHeight;
+        var top = r.bottom + 8;
+        if (top + hh > window.innerHeight - 6) top = Math.max(6, r.top - hh - 8);   // 下方放不下就翻上去
+        t.style.top = top + 'px';
+        t.style.left = Math.max(6, Math.min(r.left, window.innerWidth - w - 6)) + 'px';
+        t.style.visibility = '';
+        tipNode = t;
+        tipTimer = setTimeout(hideTip, TIP_MS);
+      }
+
       function closeOverlays() {
+        hideTip();
         document.querySelectorAll('.dsh-ling-menu,.dsh-ling-panel').forEach(function (n) {
           if (typeof n.__lingCleanup === 'function') { try { n.__lingCleanup(); } catch (e) {} }
           n.remove();
@@ -284,14 +487,23 @@
       }
 
       /** `ms` 可选:不传时沿用原样 3.2s(既有调用全部不传)。需要长一点的是**覆盖/归档**这类
-       *  "数据已经变了"的回执 —— 3.2s 读不完一句带归档目录的话(审计 E10)。 */
-      function toast(msg, ms) {
+       *  "数据已经变了"的回执 —— 3.2s 读不完一句带归档目录的话(审计 E10)。
+       *
+       *  `wrap` 可选(B / 2026-09-29):`.dsh-ling-menu .mi` 是 `white-space:nowrap`(菜单项必须单行),
+       *  而**说得清一件事的长文案**在 nowrap 下会顶破 70vw 的盒子、文字溢到屏幕外 —— 那时"文案改好了"
+       *  反而读不到。故长文案的调用显式传 `wrap = true`:换成换行渲染 + 更宽的盒子 + 更长的寿命。
+       *  不传 = 与既有全部调用逐字同形(短文案本来就只占一行,样式分支根本不进)。 */
+      function toast(msg, ms, wrap) {
         var t = el('div', 'dsh-ling-menu');
-        t.style.cssText = 'top:16px;left:50%;transform:translateX(-50%);cursor:default;min-width:auto;max-width:70vw;text-align:center;';
+        t.style.cssText = 'top:16px;left:50%;transform:translateX(-50%);cursor:default;min-width:auto;max-width:70vw;text-align:center;'
+          + (wrap ? 'width:620px;max-width:86vw;' : '');
         // 后端回执里的 `message` 允许带 `**强调**` 标记(如「**覆盖了上一版主脉记忆**」),
         // 而 toast 是纯文本容器 ⇒ 显示层去掉标记,别把星号糊给主人。
         // (非字符串原样交给 el(),不改变任何既有调用的行为:全文件现有 toast 文案里没有 `**`。)
-        t.appendChild(el('div', 'mi', (typeof msg === 'string') ? msg.replace(/\*\*/g, '') : msg));
+        var mi = el('div', 'mi', (typeof msg === 'string') ? msg.replace(/\*\*/g, '') : msg);
+        // pre-line:只认 `\n` 换行,不动空格/缩进 —— 文案里手写的分行原样落地
+        if (wrap) mi.style.cssText = 'white-space:pre-line;line-height:1.65;text-align:left;align-items:flex-start;';
+        t.appendChild(mi);
         document.body.appendChild(t);
         setTimeout(function () { t.remove(); }, Number(ms) > 0 ? Number(ms) : 3200);
       }
@@ -472,6 +684,29 @@
         wrap.style.right = 'auto';
       }
 
+      // 全局面板(左侧栏底部那个按钮打开的面板)的默认落点。
+      // 实测:左侧栏(会话列表)右缘在 page x≈279(1920 宽、未缩放的窗口截图量得),
+      // 故左让 300 —— ①不压住左侧栏列表 ②与会话面板(CSS 默认 right:18px;top:18px)明显分开。
+      // 窄窗口按视口宽度夹取,免得比会话面板更早溢出屏幕右边。
+      var PANEL_GLOBAL_HOME_LEFT = 300;
+      var PANEL_GLOBAL_HOME_TOP = 64;
+
+      // 无保存位置时的「本视图默认锚点」:全局视图('status-global')另起落点;
+      // 其余 key 一律回老位置(右上角 18px/18px,与改动前的 CSS 默认逐字一致,行为不变)。
+      function panelHome(wrap, key) {
+        if (key !== 'status-global') {
+          wrap.style.left = 'auto';
+          wrap.style.right = '18px';
+          wrap.style.top = '18px';
+          return;
+        }
+        var vw = (typeof window !== 'undefined' && window.innerWidth) || 1280;
+        var w = wrap.offsetWidth || 480;
+        wrap.style.left = Math.max(16, Math.min(PANEL_GLOBAL_HOME_LEFT, vw - w - 16)) + 'px';
+        wrap.style.top = PANEL_GLOBAL_HOME_TOP + 'px';
+        wrap.style.right = 'auto';
+      }
+
       function initPanelDrag(wrap, key) {
         var h3 = wrap.querySelector('h3');
         if (!h3) return;
@@ -519,7 +754,7 @@
         function onDbl() {
           try { sessionStorage.removeItem('dsh-ling-pos:' + key); } catch (e) {}
           if (key === 'mc') centerPanel(wrap);
-          else { wrap.style.left = 'auto'; wrap.style.right = '18px'; wrap.style.top = '18px'; }
+          else panelHome(wrap, key);   // 全局面板双击复位回它自己的落点(左上),不再跟会话面板挤右上
         }
         h3.addEventListener('mousedown', onDown);
         window.addEventListener('mousemove', onMove);
@@ -556,28 +791,256 @@
         setPronounFrom(r.persona);
         var patch = { mode: r.mode || store.get().mode, running: !!r.running, pending: r.pending || 0 };
         if (r.sessionId) patch.sessionId = r.sessionId;
+        // C-07 访问日志健康面:搬进 store,侧栏按钮才能「不主动查也看得见」停写。
+        // 老后端没有这个字段 ⇒ undefined ⇒ 原样跳过,store 里也就没有 audit(各处一律按缺失处理)。
+        // ⚠️ 刻意**不**把它加进 pollSig:writes/lost 每拍都在变,加进去等于把轮询永久钉在快节拍上。
+        if (r.audit !== undefined) patch.audit = r.audit;
+        // E2 可见化(2026-10-01):原文表里出现**未知来源**时,后端在 /state 顶上给一句人话
+        // (`rawUnknownSources`,形状见 lib/host/api.js 的 rawUnknownSourcesOf)。
+        // 与 audit 同一条路搬进 store ⇒ 面板不必重开也看得见。
+        // ⚠️ 与 audit 的 `!== undefined` **不同**:这里显式归零(`|| null`)。audit 是新后端恒有、
+        //    老后端恒无;而这个字段**干净时就该消失**,留一个过期的"有未知来源"比不显示更坏。
+        // ⚠️ 刻意**不**进 pollSig(同 audit 的理由:它极少变,进去只会把轮询钉在快节拍上)。
+        patch.rawUnknownSources = r.rawUnknownSources || null;
         store.set(patch);
       }
 
+      // ---------------- 共享 /state 轮询器(B 后台暂停 + A 共享轮询/空闲降频) ----------------
+      // 病灶(实测):LingButton 的 useEffect(…,[]) 里**每个组件实例**各起一个 setInterval(…,3000)
+      // 直拉 /state;而同一个组件被挂到两个槽位(conversation.session.header.utilities 约 :5148
+      // + sidebar.footer.action 约 :5149)⇒ 每客户端 2 个定时器。4 个客户端 = 1.34 次/秒、
+      // 全天 46,392 次;后端每次 24.2ms 同步阻塞(3 次全表 + SHA-256)⇒ 每天 18.8 分钟卡在宿主单线程上。
+      // 且改动前全程无节流(visibilitychange / document.hidden 在该文件里 0 命中)。
+      // 这里把定时器收进**模块级**注册表,按 store 分键(本插件里一个 kind 恰好一个 store,
+      // 故等价于「同 kind 共用同一条 ticker」):一拍对每个 store 只发**一次**请求,
+      // 结果广播给该 store 的全部订阅者 ⇒ 每客户端最多 2 个请求/周期,而不是 2N。
+      // 叠两条节流:
+      //   B) document.hidden ⇒ 整条停表(一拍都不发);切回可见立即补一次并恢复节拍;
+      //   A) 连续 POLL_IDLE_STRIKES 拍「没变化」⇒ 放宽到 POLL_SLOW_MS;
+      //      一旦有变化 / running / pending>0 / store 被 set / 用户点击 ⇒ 立刻回快节拍。
+      //   C) 「全局默认」那条(store.kind === 'global',即侧栏底部那个按钮)**固定 30s**。
+      //      理由(2026-09-27 实测):A+B 上线后残留 34.5 次/分里约 1/3 来自它(5s 节拍 ⇒ 12 次/分),
+      //      而它代表的"全局默认模式"只在主人按那个按钮时才变 —— 按下按钮会经 hookStoreSet
+      //      ⇒ kickPoll 立刻补一拍,本来就不靠轮询发现变化。全局那条按 30s 走 ⇒ 该流降到 2 次/分。
+      //      代价:另一个标签页改了全局默认,本页最多 30s 后才发现(可接受)。
+      // 清理对称:退订函数里停表;订阅者归零时连记录一起撤,并摘掉 visibilitychange 监听。
+      var POLL_FAST_MS = 3000;    // 基础节拍(沿用旧值,远高于 1s 下限)
+      var POLL_SLOW_MS = 5000;    // 空闲降频后的节拍
+      var POLL_IDLE_STRIKES = 2;  // 连续这么多拍没变化就降频
+      var POLL_GLOBAL_MS = 30000; // 「全局默认」那条的固定节拍(见上面 C)条)
+      var pollers = [];           // [{ store, subs, timer, period, idle, sig, inflight, applying }]
+      var pollSubs = 0;           // 订阅者总数(visibilitychange 监听按它引用计数)
+      var visBound = false;
+
+      function findPoll(store) {
+        for (var i = 0; i < pollers.length; i++) if (pollers[i].store === store) return pollers[i];
+        return null;
+      }
+
+      function pollRec(store) {
+        var rec = findPoll(store);
+        if (rec) return rec;
+        rec = { store: store, subs: 0, timer: null, period: 0, idle: 0, sig: null, inflight: false, applying: false };
+        pollers.push(rec);
+        return rec;
+      }
+
+      function isHidden() { return typeof document !== 'undefined' && !!document.hidden; }
+
+      /** 这条 ticker 是不是「全局默认」那条(按 store.kind 判,不另建注册表)。 */
+      function isGlobalPoll(rec) {
+        try { return !!(rec && rec.store && rec.store.get && rec.store.get().kind === 'global'); }
+        catch (e) { return false; }   // 取不到就按普通节拍走,绝不因判据异常而停表
+      }
+
+      /** 只比 applyStateToStore 真会写进 store 的字段 —— 它们没变,就是「这一拍没有变化」。 */
+      function pollSig(r) {
+        r = r || {};
+        return [r.mode || '', r.running ? 1 : 0, r.pending || 0, r.sessionId || ''].join('|');
+      }
+
+      /** 按当前节拍排表;只有节拍真的变了才重建定时器(免得每拍都重置相位)。 */
+      function schedulePoll(rec) {
+        // 全局默认那条固定 POLL_GLOBAL_MS(不参与空闲降频 —— 它本来就比降频后的节拍还慢)。
+        var want = isGlobalPoll(rec) ? POLL_GLOBAL_MS
+          : (rec.idle >= POLL_IDLE_STRIKES ? POLL_SLOW_MS : POLL_FAST_MS);
+        if (rec.timer !== null && rec.period === want) return;
+        if (rec.timer !== null) clearInterval(rec.timer);
+        rec.period = want;
+        rec.timer = setInterval(function () { pollTick(rec); }, want);
+      }
+
+      function stopPoll(rec) {
+        if (rec.timer !== null) { clearInterval(rec.timer); rec.timer = null; }
+        rec.period = 0;
+      }
+
+      /** 一拍:每个 store 只发一次请求,结果广播(数据层照用 applyStateToStore,不重写)。 */
+      function pollTick(rec) {
+        if (!rec || rec.subs <= 0) return;
+        if (rec.inflight) return;  // 上一拍还没回来 ⇒ 跳过这一拍,绝不叠请求
+        if (isHidden()) return;    // B:后台一拍都不发
+        rec.inflight = true;
+        api(pollPath(rec.store)).then(function (r) {
+          rec.inflight = false;
+          // ⚠️ 旧实现在链尾挂了 `.catch(function () {})`:这里同样不让一次异常冒成
+          // unhandled rejection,而且无论成败都必须排下一拍(否则一拍出错 ticker 就静默停摆)。
+          try {
+            var sig = pollSig(r);
+            var busy = !!(r && r.ok && (r.running || r.pending));
+            if (sig !== rec.sig || busy) rec.idle = 0; else rec.idle++;
+            rec.sig = sig;
+            rec.applying = true;   // 这一段 store.set 是轮询自己写的,不算「用户动作」
+            applyStateToStore(rec.store, r);
+          } catch (e) {
+            console.warn('[dsh-ling] 应用 /state 回执失败', e);
+          } finally {
+            rec.applying = false;
+            schedulePoll(rec);
+          }
+        }, function () {
+          rec.inflight = false;
+          rec.idle++;            // 网关不可达也照样退避:别越错越急
+          schedulePoll(rec);
+        });
+      }
+
+      /** 立刻回快节拍;fire=true 时再马上补一拍(用户点击 / 可见性恢复)。 */
+      function kickPoll(store, fire) {
+        var rec = findPoll(store);
+        if (!rec || rec.subs <= 0) return;
+        rec.idle = 0;
+        if (isHidden()) return;  // 后台照旧一拍不发
+        if (fire) pollTick(rec);
+        schedulePoll(rec);       // 补拍失败也要保证表在走
+      }
+
+      /** store 被 set(模式切换回执、菜单动作、props 传来的 sessionId)⇒ 回快节拍。
+       *  刻意**不**在这里发请求:applyStateToStore 自己就往 store 里 set,
+       *  若在这里补请求会每拍自激成刷新风暴(render 期那次 set 也不该发请求)。 */
+      function hookStoreSet(store) {
+        if (store.__lingPollHooked) return;
+        store.__lingPollHooked = true;
+        var rawSet = store.set;
+        store.set = function (patch) {
+          rawSet(patch);
+          var rec = findPoll(store);
+          if (rec && !rec.applying) kickPoll(store, false);
+        };
+      }
+
+      function onVisibilityChange() {
+        var hidden = isHidden();
+        for (var i = 0; i < pollers.length; i++) {
+          var rec = pollers[i];
+          if (rec.subs <= 0) continue;
+          if (hidden) { stopPoll(rec); continue; }  // 切到后台:整条停表
+          rec.idle = 0;                             // 切回前台:回快节拍
+          pollTick(rec);                            // 立即补一次,不等下一拍
+          schedulePoll(rec);
+        }
+      }
+
+      function bindVisibility() {
+        if (visBound || typeof document === 'undefined' || !document.addEventListener) return;
+        document.addEventListener('visibilitychange', onVisibilityChange);
+        visBound = true;
+      }
+
+      function unbindVisibility() {
+        if (!visBound || typeof document === 'undefined' || !document.removeEventListener) return;
+        document.removeEventListener('visibilitychange', onVisibilityChange);
+        visBound = false;
+      }
+
+      /** 订阅共享 ticker;返回退订函数(与旧的 clearInterval 对称,React 卸载时调用)。 */
+      function subscribePoll(store) {
+        var rec = pollRec(store);
+        hookStoreSet(store);
+        rec.subs++;
+        pollSubs++;
+        if (rec.subs === 1 && !isHidden()) {
+          // ⚠️ 全局那条降到 30s 后,若首拍也等 30s,侧栏那个按钮会在页面加载后**空转 30 秒**
+          //   ⇒ 它改为挂载即补一拍(一次性成本),其余节拍保持"首拍在 3s 后"的旧行为。
+          if (isGlobalPoll(rec)) pollTick(rec);   // pollTick 成功/失败都会在 finally 里排下一拍
+          schedulePoll(rec);
+        }
+        if (pollSubs === 1) bindVisibility();
+        var done = false;
+        return function () {
+          if (done) return;  // React 可能重复调用清理函数
+          done = true;
+          rec.subs--;
+          pollSubs--;
+          if (rec.subs <= 0) {
+            rec.subs = 0;
+            stopPoll(rec);   // 订阅者归零 ⇒ ticker 停掉,不留常驻空转
+            var ix = pollers.indexOf(rec);
+            if (ix >= 0) pollers.splice(ix, 1);
+          }
+          if (pollSubs <= 0) { pollSubs = 0; unbindVisibility(); }
+        };
+      }
+
       // ---------------- actions ----------------
+      /** 请求一次 /mode/toggle;带不带 confirm 决定它是"预览"还是"真写"(后端 fail-closed)。 */
+      function postToggle(body) { return api('/mode/toggle', { method: 'POST', body: body }); }
+
+      /** 收尾:按回执决定提示语。全局那一半必须说清"改的是全局默认"——
+       *  数字全部取后端回显(applied:'default-only' 那条带 from/mode/reasoningEffort),前端不自算。 */
+      function echoToggle(r) {
+        if (r.queued) { toast('会话运行中——将在空闲后切换为 ' + modeName(r.mode) + ' 模式'); return; }
+        if (r.applied === 'default-only') {
+          var eff = r.reasoningEffort || {};
+          var detail = (eff.to != null)
+            ? '(全局默认推理等级 ' + (eff.from == null ? '未设置' : eff.from) + ' → ' + eff.to
+              + (r.globalDefault ? ';模型 ' + r.globalDefault + ' 原样保留' : '') + ')'
+            : '(新会话将跟随并同步推理等级)';
+          toast('已更新全局默认模式:' + modeName(r.mode) + detail + (r.warning ? ';' + shortErr(r.warning) : ''));
+        } else if (r.warning) {
+          toast('已切换为 ' + modeName(r.mode) + ' 模式(新会话默认跟随);推理等级未同步:' + shortErr(r.warning));
+        } else {
+          toast('已切换为 ' + modeName(r.mode) + ' 模式(新会话默认跟随)');
+        }
+      }
+
+      /** 全局默认那一下动的是**平台全局默认模型**(新会话都跟随),不是本会话 ⇒ 必须先问一句。
+       *  惯例沿用仓库既有的破坏性操作确认(window.confirm:档案回滚、导入覆盖人格、删记忆概述),
+       *  不自造 UI 组件。
+       *  ⚠️ 为什么"先问后写"、而不是"不带 confirm 先探一次预览":那道门只有**新后端**认;
+       *  宿主还跑着旧 api.js 时(页面刷新了、host 没重启),旧后端会把那次探测当成真切换
+       *  ⇒ 连写两次(切过去又切回来)。所以前端只发**一次带 confirm 的写**,数字回显全靠回执。
+       *  注意:window.confirm 是纯文本,不像 toast 会去掉 `**`,故这里不用强调标记。 */
       function toggleMode(store) {
         var st = store.get();
-        var body = st.kind === 'global' ? { defaultOnly: true } : { sessionId: st.sessionId || undefined };
-        return api('/mode/toggle', { method: 'POST', body: body }).then(function (r) {
-          if (r && r.ok) {
-            if (r.mode) store.set({ mode: r.mode, sessionId: r.sessionId || st.sessionId });
-            if (r.queued) {
-              toast('会话运行中——将在空闲后切换为 ' + modeName(r.mode) + ' 模式');
-            } else if (r.applied === 'default-only') {
-              toast('已更新默认模式:' + modeName(r.mode) + '(新会话将跟随并同步推理等级)' +
-                (r.warning ? ';' + shortErr(r.warning) : ''));
-            } else if (r.warning) {
-              toast('已切换为 ' + modeName(r.mode) + ' 模式(新会话默认跟随);推理等级未同步:' + shortErr(r.warning));
+        if (st.kind !== 'global') {
+          return postToggle({ sessionId: st.sessionId || undefined }).then(function (r) {
+            if (r && r.ok) {
+              if (r.mode) store.set({ mode: r.mode, sessionId: r.sessionId || st.sessionId });
+              echoToggle(r);
             } else {
-              toast('已切换为 ' + modeName(r.mode) + ' 模式(新会话默认跟随)');
+              toast('切换失败:' + ((r && (r.message || r.reason || r.error)) || '未知'));
             }
+            return r || {};
+          }).catch(function () { toast('切换失败(网关不可达)'); return {}; });
+        }
+        // ⚠️ 这里**故意不问一句** —— 用户 2026-09-27 裁决(原话):
+        //   「创建新会话时只能通过调全局默认来调新会话的模式,所以它的使用比想象的频繁一些」
+        //   ⇒ 全局默认不是危险开关,而是**开一个不同模式的新会话**的必经入口,属高频正常动作;
+        //     事前弹确认 = 给日常添堵,且那个按钮按下本身就是低成本可撤销动作。
+        //   改成三层,把"让你知道改了全局"交给它们,不交给拦路:
+        //     ① 悬浮提示常驻说明(LingButton 的 title,含推理等级那句)
+        //     ② 事后回显 echoToggle(from→to、推理等级、模型保留)
+        //     ③ 后端仍要 confirm:true 这道门 —— 它拦的是"不带确认的调用方",不是拦人
+        return postToggle({ defaultOnly: true, confirm: true }).then(function (r) {
+          if (r && r.ok) {
+            if (r.mode) store.set({ mode: r.mode, sessionId: null });
+            echoToggle(r);
+          } else if (r && r.reason === 'confirmation-required') {
+            // 后端这道门没被采信(理论上不该发生)→ 它一个字节都没写,如实说明,不谎报成功
+            toast('全局默认未改动:网关要求二次确认' + (r.message ? '(' + shortErr(r.message) + ')' : ''));
           } else {
-            toast('切换失败:' + ((r && (r.reason || r.error)) || '未知'));
+            toast('切换失败:' + ((r && (r.message || r.reason || r.error)) || '未知'));
           }
           return r || {};
         }).catch(function () { toast('切换失败(网关不可达)'); return {}; });
@@ -618,13 +1081,93 @@
         wrap.appendChild(h);
         var kv = el('div', 'kv', '加载中…');
         wrap.appendChild(kv);
+        // E3(2026-09-27 用户拍板):「那一行」只读块。**必须另起一个节点** —— 上面 `kv` 整块是纯
+        // textContent(一段文字),而「看全文」要一个真能展开/收起的子节点(快照原文放 <pre>,默认收起)。
+        // 这一块对模型上下文**零占用**:读的全是 `/state` 面板档(`l0Preview=1`)字段,纯读,不进 prompt。
+        var e3box = el('div', 'ling-e3');
+        wrap.appendChild(e3box);
+        // 折叠状态**存闭包,不存 DOM**:paint() 每一拍(store tick)都会重建这个块,
+        // 状态跟着 DOM 走的话,主人读着读着就被下一拍收回去。
+        var e3Open = false;
+        // 缺陷① 修复(2026-09-27 真机目视):「看全文」框手动滚过之后,会被**下一次重画弹回顶部**。
+        //   根因(行级核实,不是猜):paintE3 每拍开头 `e3box.textContent = ''` 清掉全部子节点,再 `el('pre','e3-pre',…)`
+        //   **新造**一个 <pre>;而 `.e3-pre` 正是 `max-height:220px;overflow:auto` 那个滚动盒 ⇒ 节点一换,
+        //   浏览器里 scrollTop 归零。**是"节点被重建",不是"文本被重设"**(同一个节点的 textContent 重设不会丢滚动位置)。
+        //   频率 = store 的 tick 周期(会话 3s / 全局 30s),与主人说的"一定频率"吻合。
+        //   修法 = **节点复用 + 滚动位置写回**:e3pre 与 e3Open 一样存闭包 ⇒ 同一个 <pre> 对象跨拍存活,
+        //   滚动位置、框内文本选中都不再丢;写回那一步专门兜住"摘下来再装回去时浏览器把滚动位置清掉"。
+        var e3pre = null;
+        // 两条"那一行"的常驻说明(是**分工说明**,不是读数)——
+        var E3_A = '① L2 本会话标题行 —— 概述器写进 `[记忆·开场]` 的那一条:只有标题,摘要不进这一行';
+        var E3_B = '② 活行 —— agent/pre-step 每轮重算,内容真变了才追加一条新的(#N 递增,旧的留在历史里)';
+        /** 从**活行正文**里提号码 —— ⚠️ 与后端行格式**强耦合**:正文形如
+         *  `[本次会话·进展 #N] {标题} —— 最近:{进展} · 第 T 轮 · HH:MM`(session-line.js:97 的 head)。
+         *  台账里已登记同一类耦合:「partsFromLineText 的正则与行格式强耦合 —— **改行格式必须同批改正则**」
+         *  ⇒ 后端动这个前缀时,上面这条正则**必须同批改**。
+         *  提取失败 **返回 null**(不是 undefined、更不是猜一个号)⇒ 调用方**不印号码**:号码只许来自正文,
+         *  绝不拿 `S.ordinal`(下一条的号)去顶替上一次那条的正文。 */
+        var E3_LINE_NO_RE = /^\[本次会话·进展 #(\d+)\]/;
+        var lastNoOf = function (text) { var m = E3_LINE_NO_RE.exec(String(text == null ? '' : text)); return m ? m[1] : null; };
+        var E3_TAG = '〔打开时读数〕';   // 与上面 SNAP_TAG 同理:面板档字段只在打开那一刻取一次
+        // "不追加"的判定 → 人话。词表**照抄后端真会吐的原因**(session-line.js decideSessionLine
+        // :169-177 的真值集 = dupes/empty/same,absent/ok 是"追加")+ 两个取不到会话/注入面的早退原因;
+        // 认不出来的原因**原样印出来**(绝不翻译成"正常",也绝不编一个后端不会说的词)。
+        var E3_BLOCK = {
+          same: '内容没变 ⇒ 不追加(平台永久留痕:重复内容不刷新,刷新等于再插一条)',
+          dupes: '注入面上已有 >1 条同行(脏状态)⇒ 不追加,只留痕(没有删除操作,也不作废旧副本)',
+          // `empty` 覆盖两种真情形(对方 session-line.js:463/:496 + sessionline.test.mjs :458/:466):
+          // ①候选确实为空 ②**压根算不出**(无会话 id / 读口全抛错)。不能只说"候选为空"——
+          // 那会把"算不出"误诊成"内容是空的",两种情形给主人的动作完全不同。
+          empty: '候选为空 或 压根算不出(无会话 id、标题与进展都取不到、读口抛错)⇒ 不追加 —— 绝不给模型一条空文本',
+          absent: '注入面上没有这一行(可能被折叠吞了)⇒ 会追加一条(即便与上次逐字相同)',
+          ok: '内容变了 ⇒ 会追加一条新的',
+          'no-session': '拿不到会话对象(agent.session.eventAt 不可用)⇒ 本拍不判定',
+          'no-surface': '拿不到注入面(session.surface.nodes 不是数组)⇒ 本拍不判定',
+          off: '配置里已关闭(memory.sessionProgressLine=false)⇒ 不追加',
+          disabled: '配置里已关闭(memory.sessionProgressLine=false)⇒ 不追加',
+          error: '判定过程抛错 ⇒ 退化成不追加(错误留在会话行探针里可查)',
+        };
+        // 判定读数的**三类**归类(与 E3_BLOCK 的原文一致):**不许**一律套"不追加 —— "前缀 ——
+        // 'absent'/'ok' 的原文就是"会追加一条",前缀写成"不追加"会与同一行的后半句自相矛盾
+        // (自相矛盾的读数比不显示更坏);'no-session'/'no-surface' 是"本拍不判定",也不是"不追加"。
+        var E3_APPEND = { absent: 1, ok: 1 };
+        var E3_HOLD = { 'no-session': 1, 'no-surface': 1 };
+        // 判定读数的**前提**(后端 session-line.js 的 `basis`)—— 那个读数不是无条件的事实,而是**带前提的预测**:
+        //   'title+progress' = 标题 + 面上最新真人发言首句都看得到(基准完整);
+        //   'title-only'     = HTTP 预览路径**取不到会话面** ⇒ 只看得到标题、拿上次记下的进展当基准
+        //                      ⇒ **保守**:可能把"会追加"读成 same。
+        // 规矩:**带前提的预测不能当无前提的读数显示** ⇒ basis 取不到(老后端 / 字段缺失 / 认不出 / 解析不出)
+        //   **一律按降级标注**,**绝不**默认成完整基准(那正是制造假读数的标准路径,台账 B66)。
+        // 取法**两层容错**:现在整个预览对象挂在 preview 下(后端 sessionLineState 顶层没有 basis),
+        //   将来它挪到顶层也不会哑。
+        var E3_BASIS_FULL = '〔基准:标题+最新进展〕';
+        var E3_BASIS_DOWN = '〔基准降级:只看得到标题〕';
+        var basisTagOf = function (S) {
+          var pv = (S && S.preview) || null;
+          var b = (pv && pv.basis) || (S && S.basis) || null;   // 顶层那半是"将来挪位"的兜底
+          if (b === 'title+progress') return E3_BASIS_FULL;
+          if (b === 'title-only') return E3_BASIS_DOWN;
+          if (b) return '〔基准降级:后端给了个前端未收录的基准("' + b + '")⇒ 不按完整基准算〕'; // 认不出的原样印出
+          return '〔基准降级:后端未给 basis ⇒ 按降级算〕';   // 缺失 = 降级(不默认成完整)
+        };
         var btnRow = el('div', 'btnrow');
         var close = el('button', null, '关闭');
         btnRow.appendChild(close);
         wrap.appendChild(btnRow);
         document.body.appendChild(wrap);
         armOverlays();
-        initPanelDrag(wrap, 'status');
+        // 拖拽记忆按视图分键:以前全局与会话共用一个 sessionStorage['dsh-ling-pos:status'],
+        // 互相覆盖 ⇒ 两个面板永远开在同一处。全局改走 'status-global'。
+        // 先摆本视图的默认锚点;若主人拖过、sessionStorage 里存着位置,下面会用他的覆盖掉。
+        panelHome(wrap, global ? 'status-global' : 'status');
+        initPanelDrag(wrap, global ? 'status-global' : 'status');
+        // §M(1.5.2):面板开着不动 ⇒ 那几行永远冻在打开那一刻(这里只拉一次 /state,拿到就扔)。
+        // 修法 = **复用 store 已有的 tick**(不新开 /state 轮询:全局那条刚从 5s 降到 30s,加回去等于把降频取消):
+        // 面板订阅 store ⇒ applyStateToStore 每拍写进去的字段(running/pending/mode/sessionId/audit)就能跟上;
+        // store 里**没有**的字段(快照 · 空闲刷新 · 人格 · 记忆库 · L1)只在带 l0Preview=1 的应答里,
+        // 也就是只在下面这一份 snap 里 ⇒ 只能保持打开时的值,故在渲染处逐块标注「打开时快照」。
+        var snap = null;
+        var SNAP_TAG = ' 〔打开时快照〕';   // 不标注的话,「冻住了」与「本来就这一项」在界面上长得一模一样
         api(url).then(function (r) {
           if (!r || !r.ok) {
             kv.textContent = '暂无状态: ' + JSON.stringify(r || {});
@@ -636,16 +1179,95 @@
           h.textContent = '';
           h.appendChild(document.createTextNode(disp));
           h.appendChild(el('div', 'hint', global ? '此视图无活动会话:此按钮管理新会话默认模式' : '左键=切换模式 · 悬停 1.5s=菜单 · Esc 关闭'));
+          snap = r;
+          paint();   // 打开时先画一遍(此刻 store 与这份应答同源,输出与改动前逐字一致)
+          if (r.running) toast('该会话运行中——人格/记忆更新将在空闲后生效');
+        });
+
+        /** §M 面板重画:store 覆盖得到的行跟着 store 走,其余用打开那一刻的应答(逐块标注「打开时快照」)。 */
+        function paint() {
+          var r = snap;
+          if (!r) return;            // 首份应答还没回来 ⇒ 保持「加载中…」
+          var cur = store.get();     // mode/running/pending/sessionId/audit = pollTick → applyStateToStore 每拍写(:610-620)
+          var sid = cur.sessionId || r.sessionId;
+          var lm = cur.mode || r.mode;
           var lines = [
-            global ? '全局默认(新会话跟随)' : ('当前会话: ' + (r.sessionId || '(无)')),
-            '模式: ' + (r.modeLabel || r.mode) + (r.running ? ' · 运行中(冻结)' : ' · 空闲'),
-            '待应用更新: ' + (r.pending || 0),
+            global ? '全局默认(新会话跟随)' : ('当前会话: ' + (sid || '(无)')),
+            '模式: ' + ((lm === 'work' || lm === 'life') ? modeName(lm) : (lm || '(未知)')) + (cur.running ? ' · 运行中(冻结)' : ' · 空闲'),
+            '待应用更新: ' + (cur.pending || 0),
           ];
-          if (r.snapshot) {
-            lines.push('记忆快照: 已定稿 ' + (r.snapshot.chars || 0) + ' 字符 · mode=' + (r.snapshot.mode || '?') + (r.snapshot.stale ? ' · 待刷新' : ''));
+          // 只读状态面(理念 3):把后端**已在返回里、却一个字符都没渲染**的三项显出来 ——
+          // 快照定稿时刻(snapshot.builtAt,后端是 UTC ISO,须转本地)+ 上次空闲刷新时刻与刷新次数(idleRefresh.{lastAt,count},epoch ms)。
+          // 没有这一行时「那一行冻住了」与「机制已失效」在界面上长得一模一样;刷新只发生在 运行中 → 空闲 那一刻,且距上次 ≥10 分钟,故为 0 属正常,不是坏掉。
+          var fmtClock = function (v) {
+            if (!v) return '';
+            var d = (typeof v === 'number') ? new Date(v) : new Date(String(v));
+            if (isNaN(d.getTime())) return String(v); // 脏值直接原样显示,不做自作聪明的截取
+            var p = function (n) { return (n < 10 ? '0' : '') + n; };
+            return p(d.getMonth() + 1) + '-' + p(d.getDate()) + ' ' + p(d.getHours()) + ':' + p(d.getMinutes());
+          };
+          // §N(2026-09-27):后端"没有快照"时给的是 `{ exists: false }` —— 它是**真值**,
+          // 旧判据 `if (r.snapshot)` 会让这一格打印"已定稿 0 字符",把**没有快照**说成**有一个 0 字符的快照**。
+          // 这条尤其误导:0 字符快照本身真会发生(L0 人格为空等),两者外观一致、语义相反。
+          // 与下面那一行"全局视图无会话快照"同一条原则:不说出来,"按设计没有"与"坏了"长得一模一样。
+          // §M:SNAP_TAG 逐行标出「这一格不随面板停留刷新」(这些字段 store 里没有 ⇒ 只有打开时那一份)。
+          if (r.snapshot && r.snapshot.exists === false) {
+            lines.push('记忆快照: (未定稿 —— 本会话尚无快照,通常在会话第一次定稿后出现)' + SNAP_TAG);
+          } else if (r.snapshot) {
+            lines.push('记忆快照: 已定稿 ' + (r.snapshot.chars || 0) + ' 字符 · mode=' + (r.snapshot.mode || '?') + (r.snapshot.stale ? ' · 待刷新' : '') + SNAP_TAG);
+            lines.push('快照定稿于: ' + (r.snapshot.builtAt ? fmtClock(r.snapshot.builtAt) : '(未记录)') + SNAP_TAG);
           }
+          if (r.idleRefresh) {
+            var refresh = r.idleRefresh;
+            lines.push('空闲刷新次数: ' + (refresh.count || 0) + ' · 上次滚动: ' + (refresh.lastAt ? fmtClock(refresh.lastAt) : '(从未刷新 — 只发生在 运行中→空闲 那一刻,且距上次 ≥10 分钟)') + SNAP_TAG);
+          }
+          // 全局视图的 L2 三行**必然**缺席:后端 lib/host/api.js 在 global 分支写死 snapshot: null,
+          // 而且整个返回里不带 idleRefresh 字段 ⇒ 上面两段一个字符都进不来。
+          // 不写这一行,"按设计没有"与"坏了"在界面上长得一模一样(用户 2026-09-27 反馈)。
+          // 放在 L2 本该出现的位置(待应用更新 → 这里 → 人格),两个视图的行序才对得齐。
+          if (global && !r.snapshot && !r.idleRefresh) {
+            lines.push('(全局视图无会话快照 —— 快照定稿/空闲刷新是按会话统计的,进入某个会话才显示)' + SNAP_TAG);
+          }
+          // C-07 访问日志健康面(2026-09-27「日志静默 41.6 分钟」那次的告警位):
+          // 后端老版本 / 日志器没装 ⇒ r.audit 为 null/undefined ⇒ **一个字符都不渲染** ——
+          // 绝不显示"未知/正常",那等于把"没有这个信息"伪装成"一切正常"。
+          // C-07c(2026-09-27):新后端把"没装上"也变成**有内容**的回答(`{installed:false, reason}`),
+          // 于是这里必须先分"有意关闭"与"应为但未装" —— 后者(补丁没打)是真·静默失败,必须说出来。
+          // §M:这一行改吃 store 里**每拍新写**的 audit(applyStateToStore :618)—— 它是最会误导人的一格
+          // (日志早已停写、这里还挂着「✔ 正常」,比不显示更坏)。
+          // ⚠️ 外层守卫**保持 `if (r.audit)` 字面不变**(tests/access-log.test.mjs:633 就钉着这一条):
+          //    它的语义是"打开那一刻的应答里有没有这项" ⇒ 老后端一个字符都不渲染,不拿"未知"冒充"正常"。
+          //    两个视图的 audit 出自同一个 handler,故 store 里有没有 ⇒ 这份应答里也有没有。
+          var auditLive = !!cur.audit;
+          var ah = cur.audit || r.audit;
+          if (r.audit) {
+            if (ah.installed === false) {
+              var why = { 'disabled-by-config': '已按配置关闭', 'patch-missing': '补丁未应用', 'not-mounted': '未挂载' }[ah.reason] || ('原因未知(' + ah.reason + ')');
+              lines.push('访问日志: 未启用（' + why + '）');
+            } else if (ah.state === 'degraded') {
+              var le = ah.lastError || {};
+              lines.push('访问日志: ⚠ 已停写! · 最后错误 ' + (le.code || le.message || '(无)') + (le.at ? ' @' + fmtClock(le.at) : '') + ' · 丢弃 ' + (ah.lost || 0));
+            } else if (ah.state === 'off') {
+              lines.push('访问日志: 已按配置关闭');
+            } else {
+              lines.push('访问日志: ✔ 正常 · 写入 ' + (ah.writes || 0) + ' · 丢弃 ' + (ah.lost || 0));
+            }
+            // 上面四行印的是 store 那一份(实时);store 里没有(老后端 / 首拍还没回来)才退回打开时那份 ⇒ 标快照。
+            if (!auditLive) lines[lines.length - 1] += SNAP_TAG;
+          }
+          // E2 可见化(2026-10-01):原文表里出现了**我没见过的来源**时,如实说一句人话。
+          // 后端(api.js rawUnknownSourcesOf)把 kv 里那条留痕翻成**一整句话**放在 `text` 里,
+          // 这里**原样**印出来(前面加一个 ⚠)—— **不在这里拆字段拼第二遍**:两处各拼一遍必然漂,
+          // 而"读数怎么算"的规矩是单一来源(见 guard.test.mjs 的 E2 护栏)。
+          // ⚠️ 没有告警时后端**整个字段都不给** ⇒ 这里一个字符都不渲染(与上面 audit 同一条规矩:
+          //    绝不拿"未知/正常"冒充读数)。老后端同理:字段缺失 = 静默。
+          // ⚠️ 只加这一行:不动任何既有行、不动徽标/布局/文案风格(主人原话"告诉前台到底发生啥了就行")。
+          var ru = cur.rawUnknownSources || r.rawUnknownSources;
+          if (ru && ru.text) lines.push('⚠ ' + ru.text + (cur.rawUnknownSources ? '' : SNAP_TAG));
+          // §M:以下一整块(连面板标题里那个自称)**只有打开那一刻那一份** —— 用一行分隔说明覆盖到面板末尾,
+          // 比逐行贴标签干净(标题在上面的 h3 里,同属这份应答)。
           lines = lines.concat([
-            '',
+            '—— 以下为打开时快照(标题·人格·L0 预览·记忆库·L1;面板停留期间不自动刷新)——',
             '人格: 自称=' + ((r.persona && r.persona.aiName) || '(无)') + ' 称呼=' + ((r.persona && r.persona.userTitle) || '(无)') + ' 语气=' + ((r.persona && r.persona.tone) || 'natural') +
               ' · ' + ((r.persona && r.persona.sealed) ? '🔒已定型' : '未定型'),
             'L0 注入预览:',
@@ -665,8 +1287,175 @@
             lines.push('  (无概述数据 — 待 v0 历史语料导入)');
           }
           kv.textContent = lines.join('\n');
-          if (r.running) toast('该会话运行中——人格/记忆更新将在空闲后生效');
-        });
+          paintE3(r, cur, fmtClock);   // E3:「那一行」只读块(同一份面板档应答 + store 里的 live running)
+        }
+
+        /** E3(2026-09-27):「那一行」在盘上有**两条**,长得像但不是一回事 ——
+         *  ① L2 `[记忆·开场]` 里本会话那一条(概述器写,只有标题);② E0 活行(`agent/pre-step` 追加式)。
+         *  这里两条都显示、各自标注,并把「为什么没变」拆成四类**看得见**的读数。
+         *  ⚠️ 纯渲染:不改 store、不发请求(面板内那一发请求仍只有打开时的那一发 state 面板档,这里一个都不新增 ——
+         *     加了就等于把刚降下来的轮询又加回去)。
+         *  ⚠️ 数字纪律(台账 B66):下面每个数字都来自**真实字段**(计数/字符数/时刻/轮次);
+         *     没有一处是"总数 − 写死常数"那种恒等于某值的假读数 —— 每个数都随真实发生量变。
+         *  ⚠️ 容错:后端(或老版本后端)少任何一个字段 ⇒ 那一行说"没有这个读数",**绝不崩、绝不猜**。 */
+        function paintE3(r, cur, fmtClock) {
+          try {
+            // 缺陷① 修复:清空重建**之前**先留住上一拍那个 <pre> 与它的滚动位置(见 e3pre 处的根因说明)。
+            var oldPre = e3pre;
+            var keepTop = oldPre ? (Number(oldPre.scrollTop) || 0) : 0;
+            e3box.textContent = '';   // 重建(折叠状态在闭包 e3Open 里,滚动位置在 e3pre / keepTop 里)
+            var S = r.sessionLine || null;   // 老后端 / 轮询档没有这一项 ⇒ null,下面每处都按缺失处理
+            var snap2 = r.snapshot || null;
+            var items = (r.memory && r.memory.l1 && r.memory.l1.items) || [];
+            var selfRow = null;
+            for (var k = 0; k < items.length; k++) {
+              if (items[k] && items[k].self === true) { selfRow = items[k]; break; }
+            }
+            var row = function (text, cls) { e3box.appendChild(el('div', cls || 'e3-row', text)); };
+            row('那一行(只读)—— 盘上有两条,长得像但不是一回事:一条讲"过去的自己",一条讲"这一轮的进展" · ' + E3_TAG, 'e3-h');
+            if (global) {
+              // 全局视图里这两条**必然**缺席(后端 global 分支写死 sessionId: null)⇒ 说出来,
+              // 否则"按设计没有"与"坏了"在界面上长得一模一样(与上面 L2 那三行同一条规矩)。
+              row('(全局视图无会话行 —— L2 本会话标题行与活行都是按会话统计的,进入某个会话才显示)');
+            } else {
+              // ---- ① L2:本会话那一行(**只有标题**) ----
+              // `self` 由后端标(api.js e3L1Items:conv_id === sessionId 那一项);取不到就直说 ——
+              // "本会话没进 L1"是**真读数**(L1 按权重/预算挑选),不是坏掉。
+              row(E3_A);
+              if (selfRow) {
+                row('   ' + (selfRow.line || selfRow.title || '(无正文)'));
+                var metaA = [];
+                if (selfRow.category) metaA.push('分类=' + selfRow.category);
+                if (selfRow.date) metaA.push('日期=' + selfRow.date);
+                if (typeof selfRow.score === 'number') metaA.push('评分=' + selfRow.score.toFixed(2));
+                if (metaA.length) row('   (' + metaA.join(' · ') + ')', 'e3-meta');
+              } else {
+                row('   本会话未进 L1 —— 这一轮没被选进注入面(L1 按权重/预算挑选,不是坏了)', 'e3-why');
+              }
+              // ---- ② E0:活行(正文 + 上次真追加的时间与轮次) ----
+              row(E3_B);
+              // ⚠️ 这两个**不同源**的正文必须分开取名、各自标注 —— 绝不合并成一个变量,也绝不共用一个号码。
+              //   旧写法 `S.text || (S.last && S.last.text)` 配标签 `S.ordinal` ⇒ "号码来自 A、正文来自 B":
+              //   后端 HTTP 面板路径**取不到轮次**,session-line.js:561 `out.text = hasTurn ? … : null`
+              //   ⇒ 这条路径上 `S.text` **恒为 null**,而 :529 `ordinal = appendCount + 1` 照常给 ⇒
+              //   面板上默认就是"标签 #6 + 正文 #5"这种自相矛盾的组合(而这块存在的唯一目的就是消灭歧义)。
+              var nextText = (S && typeof S.text === 'string' && S.text) ? S.text : '';              // = 下一条会长这样
+              var lastText = (S && S.last && typeof S.last.text === 'string' && S.last.text) ? S.last.text : '';   // = 上一次真追加的
+              if (nextText) {
+                // 号码 `S.ordinal` 与正文 `nextText` **同源**(都是"下一条")⇒ 这个组合是自洽的
+                row('   活行正文' + ((S && S.ordinal != null) ? '(#' + S.ordinal + ')' : '') + ' —— 下一条会长这样: ' + nextText);
+                row('   (' + nextText.length + ' 字符 · 这一条是**预测**:后端知道轮次时才给;只有内容真变了才追加,故它可能连着好几轮不动 —— 那不代表机制失效)', 'e3-meta');
+              } else {
+                row('   活行正文 —— 下一条会长这样: (后端没给 —— 面板这条路径取不到轮次,故不预测正文,也绝不用"上次那条"顶替)', 'e3-why');
+              }
+              if (lastText) {
+                // 号码**从正文里取**(同源);取不到就**不印号码**(绝不印 undefined、绝不借 S.ordinal)
+                var lastNo = lastNoOf(lastText);
+                row('   活行正文' + ((lastNo != null) ? '(#' + lastNo + ')' : '') + ' —— 上一次真追加的正文' + ((lastNo != null) ? '(号码取自正文)' : '(正文里没写号码)') + ': ' + lastText);
+                row('   (' + lastText.length + ' 字符 · 只有内容真变了才追加,故这一条可能连着好几轮不动 —— 那不代表机制失效)', 'e3-meta');
+              } else {
+                row('   活行正文 —— 上一次真追加: (无 —— 本次会话还没有真追加过活行)', 'e3-why');
+              }
+              var last = (S && S.last) || null;
+              if (last && (last.at || last.turn != null || last.chars != null)) {
+                var lp = [];
+                if (last.at) lp.push('时间 ' + fmtClock(last.at));
+                if (last.turn != null) lp.push('第 ' + last.turn + ' 轮');
+                if (last.seq != null) lp.push('注入面 seq=' + last.seq);
+                if (last.chars != null) lp.push(last.chars + ' 字符');
+                row('   上次真追加: ' + lp.join(' · '));
+                if (last.at) row('   距上次真追加: ' + Math.max(0, Math.round((Date.now() - Number(last.at)) / 60000)) + ' 分钟前(截至本次重画)', 'e3-meta');
+              } else {
+                row('   上次真追加: (无记录 —— 本次会话还没有真追加过)', 'e3-meta');
+              }
+              // ---- 判定读数:会追加 / 被什么挡下 ----
+              // 词表照抄后端**真会吐**的原因(session-line.js decideSessionLine :169-177);
+              // 认不出来的原因**原样印出**,绝不翻译成"正常"、也绝不编一个后端不会说的词。
+              var rsn = (S && S.blocked) ? String(S.blocked) : null;
+              var known = rsn ? E3_BLOCK[rsn] : null;
+              var basisTag = basisTagOf(S);   // 这条读数是**带前提的预测** ⇒ 前提**恒随行**(下面"档位"行复述同一判定,也自带)
+              var vd;
+              if (S && S.wouldAppend === true) vd = '会追加 —— 内容真变了,下一拍就多一条新的(#N 递增)';
+              else if (rsn && !known) vd = '认不出的判定("' + rsn + '")—— 后端给了这个词但前端未收录:既不说会追加、也不说不追加,原样印出';
+              else if (rsn && E3_APPEND[rsn]) vd = '会追加 —— ' + known;
+              else if (rsn && E3_HOLD[rsn]) vd = '本拍不判定 —— ' + known;
+              else if (rsn) vd = '不追加 —— ' + known;
+              else vd = '未判定(后端这一版还没带 wouldAppend / blocked 字段 ⇒ 不做任何猜测)';
+              row('   判定读数: ' + vd + ' ' + basisTag, (rsn === 'dupes') ? 'e3-why no' : 'e3-why');
+              var c = (S && S.counts) || null;
+              if (c) {
+                var ct = '   本会话累计(活行台账): 真追加 ' + (c.append || 0) + ' 次 · 被内容闸挡下 ' + (c.skippedSame || 0) + ' 次 · 脏(面上>1条) ' + (c.dupes || 0) + ' 次';
+                // `skippedTier` 已无写入点(15min/10 轮双门撤除,见 session-line.js :344)⇒ 老库里那个数是**历史值**,
+                // 只在 >0 时印出来并标明,不拿它冒充"档位还在生效"。
+                if (c.skippedTier) ct += ' · 档位闸(已撤除)历史值 ' + c.skippedTier + ' 次';
+                row(ct, 'e3-meta');
+              }
+              // ---- 为什么没变:四类判据,各一行人话(每条只印**真读数**) ----
+              row('为什么没变(逐条判据):', 'e3-h');
+              var running = (cur && cur.running !== undefined) ? !!cur.running : !!r.running;
+              row('   快照为什么没变:' + (running
+                ? '会话**运行中** ⇒ 快照不重建(人格/记忆更新要等空闲那一刻落盘;这一条**正在**挡着)'
+                : '会话空闲 ⇒ 这一条**不构成**"没变"的原因(没有在挡它)'));
+              row('   深摘:' + (r.deepDone === true
+                ? '该会话**已深摘冻结**(kv `deep:<会话id>` = done:…)⇒ 本会话那一行(只有标题那条)不再更新'
+                : (r.deepDone === false
+                  ? '未深摘 ⇒ 这一条**不构成**"没变"的原因'
+                  : '后端这一版还没带 deepDone ⇒ 不做猜测')));
+              row('   本会话标题行为什么只有标题:' + ((selfRow && selfRow.line)
+                ? '这一行**只有标题**(公式里就没有摘要),进展由②活行承担 —— 两条不同源,**不是印了两遍,也不是 bug**'
+                : '本会话那一行不在 L1 里 ⇒ L2 本会话标题行此刻为空,②活行照旧'));
+              row('   档位:' + (known
+                ? ('本拍被判定为「' + (E3_APPEND[rsn] ? '会追加' : (E3_HOLD[rsn] ? '本拍不判定' : '不追加')) + '」—— ' + known + ';另外:15 分钟 / 10 轮那道**档位门已撤除**(追加只看"内容真变了没")')
+                : ((rsn && !known)
+                  ? ('后端给了个前端未收录的原因("' + rsn + '")⇒ 不在这里翻译;另外:15 分钟 / 10 轮那道**档位门已撤除**')
+                  : '**没有档位门**了(15 分钟 / 10 轮双门已撤除:追加只看"内容真变了没")—— 所以这里没有"距下次还差多久"可算,不编一个')) + ' ' + basisTag, 'e3-why');
+              // ---- 看全文:模型那一轮真正读到的**冻结快照原文**(面板档 snapshot.text;纯读,对模型上下文零占用) ----
+              var stext = (snap2 && typeof snap2.text === 'string') ? snap2.text : null;
+              if (stext === null) {
+                row('看全文: (这一版后端 / 这一条路径没带 snapshot.text ⇒ 看不到原文;不拿别的东西冒充)', 'e3-meta');
+              } else {
+                var fh = el('div', 'e3-fold-h');
+                var tagS = el('span', 'tag', e3Open ? '  [收起]' : '  [展开]');
+                fh.appendChild(document.createTextNode('看全文 —— 模型那一轮真正读到的注入面原文(纯读:对模型上下文零占用)'));
+                fh.appendChild(tagS);
+                e3box.appendChild(fh);
+                var pre = oldPre || el('pre', 'e3-pre', stext);   // **复用**上一拍那个节点(节点换掉 = 滚动位置必丢)
+                if (pre.textContent !== stext) pre.textContent = stext;   // 只有原文真变了才写(内容没变时连文本都不动 ⇒ 框里选中的文字也不丢)
+                pre.style.display = e3Open ? 'block' : 'none';   // 默认**收起**
+                e3box.appendChild(pre);
+                pre.scrollTop = keepTop;   // 写回:节点离开过文档,浏览器会把滚动位置清掉,这里恢复
+                e3pre = pre;
+                fh.onclick = function () {
+                  e3Open = !e3Open;
+                  pre.style.display = e3Open ? 'block' : 'none';
+                  tagS.textContent = e3Open ? '  [收起]' : '  [展开]';
+                };
+                row('   这份是什么时候的: ' + (snap2.builtAt ? (fmtClock(snap2.builtAt) + ' 定稿') : '(后端未记录定稿时刻)')
+                  + ' · 正文 ' + ((snap2.chars != null) ? snap2.chars : stext.length) + ' 字符'
+                  + (snap2.truncated ? ('(⚠ 超长:这里只给前 ' + stext.length + ' 字符,上限保护)') : '')
+                  + ' · ' + (snap2.stale ? '已标待刷新(运行中不重建)' : '未标待刷新'), 'e3-meta');
+              }
+            }
+          } catch (e) {
+            // 只读块出错绝不许把面板带崩(它只是"看得见",不是面板的命脉):退化成一行自述。
+            try {
+              e3box.textContent = '';
+              e3box.appendChild(el('div', 'e3-why no', '「那一行」只读块渲染失败:' + String((e && e.message) || e) + '(面板其余部分不受影响)'));
+            } catch (e2) { /* 连退化行都写不进去就只能放弃 */ }
+          }
+        }
+
+        // 订阅 store(**不是**新轮询):面板开着就跟着 tick 重画,关掉必须退订。
+        // 「关闭」按钮 / Esc / 点面板外 / 再开别的浮层 —— **四条路全走 closeOverlays()**,
+        // 它遍历 .dsh-ling-panel 调节点上的 __lingCleanup(见 :293-301)⇒ 退订挂在那里 = 四条路都退订。
+        // ⚠️ 上面 initPanelDrag() 已在同一节点装过 __lingCleanup(卸载拖动监听,:584),必须**链式追加**,
+        //    直接赋值会把拖动监听的清理顶掉(与记忆中心那处 :1797-1804 同一个坑)。
+        var unsubscribe = store.subscribe(function () { paint(); });
+        var prevCleanup = wrap.__lingCleanup;
+        wrap.__lingCleanup = function () {
+          if (typeof prevCleanup === 'function') { try { prevCleanup(); } catch (e) { console.warn('[dsh-ling] 面板清理失败', e); } }
+          unsubscribe();
+        };
         close.onclick = closeOverlays;
       }
 
@@ -677,7 +1466,7 @@
         var wrap = el('div', 'dsh-ling-panel');
         wrap.dataset.dark = dark();
         var h = el('h3', null, '人格中心 · L0(称呼 / 自称 / 规矩·习惯·底线)');
-        h.appendChild(el('div', 'hint', '保存即对空闲会话生效;运行中会话在空闲后生效(D4)'));
+        h.appendChild(el('div', 'hint', '保存即对空闲会话生效;运行中会话在空闲后生效'));
         wrap.appendChild(h);
 
         var form = el('div', 'ling-form');
@@ -686,7 +1475,8 @@
         var sealedNow = false;   // 服务端定型状态
         var unlocked = false;    // 本次会话承诺已验证(仅存于内存)
         var unlockPhrase = '';
-        var sealPhrase = '';     // 定型承诺句明文(服务端回显用;锁只造庄重,不保密)
+        var sealPhrase = '';     // 定型承诺句明文(**服务端只对本机直连回显**;经反代/远端打开时为空)
+        var sealHidden = false;  // 服务端明说"这句只在本机显示"⇒ 解锁框走优雅退化文案,而不是报错/空白
 
         function row(label, node) {
           var r = el('div', 'row');
@@ -710,7 +1500,8 @@
           if (!value) return;
           var line = el('div', 'ling-rule-h');
           line.style.cssText = 'display:flex;gap:6px;align-items:flex-start;flex-wrap:wrap;width:100%;margin:1px 0 4px;font-size:12.5px;opacity:.92;';
-          line.appendChild(el('span', null, she('她建议 · ') + label + ':'));
+          // label 是界面字面量(名字/自述/职责)⇒ 整句一起过 she(),这一整段才会进 SHE_VALS 而在换代词时重画
+          line.appendChild(el('span', null, she('她建议 · ' + label + ':')));
           var valSpan = el('span', null, String(value));
           valSpan.style.cssText = 'flex:1 1 260px;min-width:0;word-break:break-word;white-space:pre-wrap;line-height:1.5;';
           var bFill = el('button', null, '填入');
@@ -881,6 +1672,17 @@
         bHabits.appendChild(refs.habitsBox);
         form.appendChild(bHabits);
 
+        var bDuty = el('div', 'block');
+        var dHead = el('div', 'ling-rule-h');
+        dHead.appendChild(el('span', 't', '职业 / 职责 / 责任'));
+        dHead.appendChild(el('span', null, '改变率很低的一条 · 建议写成陈述句(我承担/我擅长/我能给出),不要写"我应当/我必须"这类被别人授权的说法;空 = 不注入'));
+        bDuty.appendChild(dHead);
+        refs.duty = input('textarea', '', 4);
+        bDuty.appendChild(refs.duty);
+        form.appendChild(bDuty);
+        // 诞生仪式草稿:职责同样走"她建议…[填入]"(人审终审仍在此,机制不落盘)
+        if (prefill && prefill.duty) renderGenesisSuggest(bDuty, '职责', prefill.duty, function () { return refs.duty; });
+
         var bLore = el('div', 'block');
         bLore.appendChild(el('div', 'h', '扩展设定 / 世界观(器灵档案等,原样注入)'));
         refs.extraLore = input('textarea', '', 7);
@@ -985,6 +1787,7 @@
               language: langSel.value,
               hardRules: linesOf(refs.hardRules),
               bottomLines: linesOf(refs.bottomLines).slice(0, 5),
+              duty: refs.duty.value.trim(),
               extraLore: refs.extraLore.value.trim(),
             },
             styles: {
@@ -1018,7 +1821,7 @@
 
         function inputLock(locked) {
           [enabledBox, toneSel, toneWorkSel, toneLifeSel, langSel, refs.userTitle, refs.aiName, refs.aiTitle, refs.hardRules, refs.bottomLines,
-            refs.extraLore, refs.stylesWork, refs.stylesLife].forEach(function (n) { n.disabled = locked; });
+            refs.duty, refs.extraLore, refs.stylesWork, refs.stylesLife].forEach(function (n) { n.disabled = locked; });
           // 代词同属"契约类":定型后改动需手术(与 自称/称呼 同规格)
           pronounSel.disabled = locked;
           pronounInput.disabled = locked;
@@ -1108,7 +1911,9 @@
             sealBar.appendChild(bRelock);
             sealBar.appendChild(bUnseal);
           } else {
-            st.textContent = she('🌱 她已自由生长中 —— 若需对她做手术,亲手敲出当初的承诺句即可开启(≥10 字;输入框禁粘贴;界面会回显原句)。');
+            // §6.1(a):"界面会回显原句"只在**本机**成立 ⇒ 远端(经反代打开)时补一句说清,而不是让主人以为界面坏了
+            st.textContent = she('🌱 她已自由生长中 —— 若需对她做手术,亲手敲出当初的承诺句即可开启(≥10 字;输入框禁粘贴)。')
+              + (sealHidden ? '承诺句只在本机显示,人格手术也请在本机做。' : '');
             var bUnlock = el('button', null, '🔓 对人格做手术…');
             bUnlock.onclick = doUnlock;
             sealBar.appendChild(st);
@@ -1125,12 +1930,16 @@
         }
         function doUnlock() {
           var hintPhrase = sealPhrase;
+          // §6.1(a) 优雅退化:远端页面拿不到回显 ⇒ 说清"这是渠道问题"并给出可执行的路,
+          //   绝不因此报错或留空(旧文案会把它误说成"旧档案没记录明文"—— 那是另一回事)。
           lingAsk({
             title: '对人格做手术(仪式)',
             body: (hintPhrase
               ? '你定型时写下的承诺句是:\n「' + hintPhrase + '」\n\n手术前请郑重地亲手敲一遍以确认(输入框禁粘贴,逐字敲出)。'
-              : '档案已定型,但旧档案未记录明文承诺。输入一句 ≥10 字的新承诺,它将被采纳为定型承诺句并开启本次手术。\n\n若想重新立誓,也请在下面输入你的新承诺。'),
-            placeholder: hintPhrase ? '手动敲出上方承诺句…' : '写下新的定型承诺句…',
+              : (sealHidden
+                ? '承诺句只在本机显示 —— 这个页面是经反代/远端打开的,所以看不到提示句。\n\n人格手术也请回到运行器灵的这台电脑上做(远端一律不给)。若你人就在本机,用本机地址(如 127.0.0.1:3080)打开面板即可看到提示句。'
+                : '档案已定型,但旧档案未记录明文承诺。输入一句 ≥10 字的新承诺,它将被采纳为定型承诺句并开启本次手术。\n\n若想重新立誓,也请在下面输入你的新承诺。')),
+            placeholder: hintPhrase ? '手动敲出上方承诺句…' : (sealHidden ? '(远端页面看不到提示句 —— 请回本机操作)' : '写下新的定型承诺句…'),
             minLen: 10, noPaste: true, okLabel: '郑重解锁',
           }).then(function (v) {
             if (!v) return;
@@ -1319,6 +2128,7 @@
             refs.hardRules.value = (p.hardRules || []).join('\n');
             renderHabits(p);
             refs.bottomLines.value = (p.bottomLines || []).join('\n');
+            refs.duty.value = p.duty || '';
             refs.extraLore.value = p.extraLore || '';
             refs.stylesWork.value = p.stylesWork || '';
             refs.stylesLife.value = p.stylesLife || '';
@@ -1329,7 +2139,8 @@
             }
             var wasSealed = sealedNow;
             sealedNow = p.sealed === true;
-            sealPhrase = p.sealPhrase || '';
+            sealPhrase = p.sealPhrase || '';           // 本机直连才有值;远端为空(见下一行的标注)
+            sealHidden = p.phraseHidden === true;      // 服务端明说"这句只在本机显示"(经代理的读面)
             if (!keepSession || (sealedNow && !wasSealed)) { unlocked = false; unlockPhrase = ''; }
             blCount();
             applyLockUI();
@@ -1338,7 +2149,7 @@
           }).catch(function () { /* 状态不可达时保持表单现状 */ });
         }
 
-        var inputs = [enabledBox, toneSel, toneWorkSel, toneLifeSel, langSel, refs.userTitle, refs.aiName, refs.aiTitle, refs.hardRules, refs.bottomLines, refs.extraLore, refs.stylesWork, refs.stylesLife];
+        var inputs = [enabledBox, toneSel, toneWorkSel, toneLifeSel, langSel, refs.userTitle, refs.aiName, refs.aiTitle, refs.hardRules, refs.bottomLines, refs.duty, refs.extraLore, refs.stylesWork, refs.stylesLife];
         inputs.forEach(function (n) {
           if (n.addEventListener) n.addEventListener('input', function () { schedulePreview(); blCount(); });
         });
@@ -1374,7 +2185,7 @@
           m.appendChild(d);
         });
         m.appendChild(el('div', 'sep'));
-        m.appendChild(el('div', 'hint', st.kind === 'global' ? '无会话时管理全局默认(D2);新会话自动跟随' : 'D4 冻结:运行中的会话不应用任何人格/记忆更新'));
+        m.appendChild(el('div', 'hint', st.kind === 'global' ? '无会话时管理全局默认;新会话自动跟随' : '运行中的会话不应用任何人格/记忆更新'));
         // 先隐藏渲染量尺寸,再定方位(下方放不下自动向上翻,水平夹紧)
         m.style.visibility = 'hidden';
         document.body.appendChild(m);
@@ -1623,9 +2434,39 @@
                         (r.personaApplied ? ' · 人格已覆盖' : ''));
                     } else if (r && r.reason === 'sealed') {
                       toast('导入失败:人格已定型 — 请先到「人格中心」做手术(输入承诺句)后再覆盖导入;仅导入记忆不受影响');
-                    } else toast('导入失败:' + JSON.stringify(r || {}).slice(0, 120));
+                    } else if (r && r.reason === 'too-large') {
+                      // B(2026-09-29,主人原话「文案改成人话,说明清楚发生啥了就行」):旧代码走的是最后那条
+                      // 兜底 —— `JSON.stringify(r).slice(0,120)` 把回执原文(含 `"reason":"too-large"` 这种
+                      // 机器话)直接糊到 toast 上,看得见字段、看不出"发生了什么、上限是多少、我该干什么"。
+                      // 这条文案必须说清三件事,且三件事**各有出处、都不许猜**:
+                      //   ① 整包太大、**不是包坏了** —— 判据是服务端回的 `reason === 'too-large'`:
+                      //      它是**体量**闸门(readBody 的 4 MiB 上限),不是 JSON 解析失败/包结构坏;
+                      //   ② 上限是多少 —— 判据是回执的 `limit`,用 fmtLimitMB 换算;**绝不写死**(见该函数注释);
+                      //   ③ 怎么办 —— 换成**不含原文**的包重导:界面「⬇ 导出记忆包」走的 /export 默认
+                      //      `includeRaw` 不为 1(`exportMemory()` 不带该参数)⇒ 那条路**本来就不含原文**、
+                      //      体积小得多,是主人自己能走通的一条路;并如实说明"整包一次发不完"是**当前通道的
+                      //      结构限制**(记忆包导入是整包一 POST,没有分批 —— 分批是 1.6 的活,不在这里顺手做)。
+                      // ⚠️ 体量报的是**这份文件多大**(f.size,缩进过的 JSON),与 limit(压缩后的请求体口径)不同尺,
+                      //    所以只说"这份包 ≈X / 整包超了上限"这个方向性事实,不假装两个数能直接相减。
+                      var sizeHint = (f && f.size > 0) ? '(≈' + fmtBytes(f.size) + ')' : '';
+                      toast('导入失败:这份包' + sizeHint + '整包超过了服务端单次上限 ' + fmtLimitMB(r.limit) + ' —— 不是包坏了。\n'
+                        + '· 「导入记忆包」是把整份文件**一次**发出去,带对话原文的包很容易超过它(当前通道的结构限制:整包一次发不完)。\n'
+                        + '· 怎么办:改用「⬇ 导出记忆包」重新导出一份**不含原文**的包(那个按钮默认就不含原文,体积小得多),再导入一次即可 —— 记忆/建议/队列都在,只是不含对话原文。',
+                        12000, true);
+                    } else {
+                      // 其余失败:优先用服务端给的 `message`(它是一句中文),只有连 message 都没有时
+                      // 才退回 JSON 摘要 —— 兜底可以有,但不许当主路(旧代码就是无条件 JSON)。
+                      var whyImp = r && (r.message || r.error || r.reason);
+                      toast('导入失败:' + (whyImp ? String(whyImp) : JSON.stringify(r || {}).slice(0, 120)));
+                    }
                     if (st.tab === 'overview') renderOverview();
-                  }).catch(function () { toast('导入失败(网关不可达)'); });
+                  }).catch(function () {
+                    // 拿不到回执 ⇒ **不猜**成确定结论(网关真不可达 / 体量大到连接被直接断开,浏览器这一侧
+                    // 长得一模一样)⇒ 只说"无从判断" + 一条已知可能 + 一条主人能自己走的路。
+                    toast('导入失败(网关不可达):没拿到回执,具体原因无从判断。\n'
+                      + '已知的一种可能:这份包太大 —— 数据量大到超出服务端的排空余量时,连接会被直接断开,连说明情况的回执都送不出来。\n'
+                      + '可以先改用「⬇ 导出记忆包」重导一份不含原文的小包,再试一次。', 12000, true);
+                  });
                 } catch (e) {
                   toast('文件不是有效的记忆包 JSON');
                 }
@@ -2800,15 +3641,20 @@
           var pollTimer = null;
           var draftIntro = null;   // {aiTitle}
           var draftName = null;    // {aiName}
+          var draftDuty = null;    // {duty}(第 5 键 duties → 单选一条;仍是草稿,终审在人格中心)
           var draftHints = [];     // {label,text}(语气建议/相处观察)
           var hintBtns = [];
           var introBtns = [];
           var nameBtns = [];
-          var RUN_LABEL = she('让她读未读过的会话');
+          var dutyBtns = [];
+          // ⚠️ 必须**每次现取**:这个标签在异步流程里会被反复写回按钮(见 runBatch/poll/finishBatch)。
+          //    存成一个常量 = 把旧代词钉死在里面,重画过的按钮会被下一次赋值再写回旧代词。
+          function RUN_LABEL() { return she('让她读未读过的会话'); }
           function draftSummary() {
             var parts = [];
             if (draftIntro) parts.push('自述(1)');
             if (draftName) parts.push('名字:' + draftName.aiName);
+            if (draftDuty) parts.push('职责:' + draftDuty.duty);
             if (draftHints.length) parts.push(she('她的话:') + draftHints.map(function (h) { return h.label; }).join('+'));
             return parts.length ? parts.join(' · ') : '';
           }
@@ -2834,24 +3680,25 @@
                   resC.textContent = she('她已读过(或无需浓缩)这段历史里的所有会话 —— 让她试着介绍自己吧。');
                   return;
                 }
-                bRun.textContent = RUN_LABEL;
+                bRun.textContent = RUN_LABEL();
                 resC.textContent = '✗ ' + ((r && r.message) || '启动失败');
                 return;
               }
               poll();
             }).catch(function () {
               bRun.disabled = false;
-              bRun.textContent = RUN_LABEL;
+              bRun.textContent = RUN_LABEL();
               resC.textContent = '✗ 启动失败(网关不可达)';
             });
           }
           function poll() {
             api('/deep/run-status').then(function (st) {
-              if (!st || !st.ok) { bRun.disabled = false; bRun.textContent = RUN_LABEL; resC.textContent = '状态不可达,请重试'; return; }
+              if (!st || !st.ok) { bRun.disabled = false; bRun.textContent = RUN_LABEL(); resC.textContent = '状态不可达,请重试'; return; }
               if (st.running) {
                 var doneN = st.done ? st.done.length : 0;
                 var pct = st.total > 0 ? Math.round((doneN / st.total) * 100) : 0;
-                resC.textContent = she('她正在读这段历史… 已完成 ') + doneN + ' / 本轮共 ' + st.total + ' · ' + pct + '%(每条约几秒,请稍候)';
+                // 整句一起过 she()(中间两个是数字)⇒ 这一段进 SHE_VALS,换代词时这条读数就地重画
+                resC.textContent = she('她正在读这段历史… 已完成 ' + doneN + ' / 本轮共 ' + st.total + ' · ' + pct + '%(每条约几秒,请稍候)');
                 pollTimer = setTimeout(poll, 1500);
                 return;
               }
@@ -2862,7 +3709,7 @@
           }
           function finishBatch(st) {
             bRun.disabled = false;
-            bRun.textContent = RUN_LABEL;
+            bRun.textContent = RUN_LABEL();
             var s = statusLine(st);
             var lines = ['✓ 读完 ' + st.total + ' 条长会话:成功 ' + s.okN + ' 条' + (s.bad ? ' · ' + s.bad : '')];
             lines.push(s.okN > 0
@@ -2880,6 +3727,7 @@
             genOut.textContent = '';
             draftIntro = null;
             draftName = null;
+            draftDuty = null;
             draftHints = [];
             hintBtns = [];
             api('/persona/genesis', { method: 'POST', body: { scope: selScope.value } }).then(function (r) {
@@ -2887,8 +3735,8 @@
               bGen.textContent = old;
               if (!r || !r.ok) { resC.textContent = '✗ ' + ((r && r.message) || '仪式失败'); return; }
               resC.textContent = (r.scope === 'all'
-                ? she('她翻遍了全部记忆,按生活/情感加权选出 ') + r.sampled + she(' 条样本 —— 以下是她想对你说的话;挑中意的加入草稿,带去人格中心人审:')
-                : she('她读了刚导入的这段历史(') + r.sampled + she(' 条)—— 以下是她想对你说的话;挑中意的加入草稿,带去人格中心人审:'));
+                ? she('她翻遍了全部记忆,按生活/情感加权选出 ' + r.sampled + ' 条样本 —— 以下是她想对你说的话;挑中意的加入草稿,带去人格中心人审:')
+                : she('她读了刚导入的这段历史(' + r.sampled + ' 条)—— 以下是她想对你说的话;挑中意的加入草稿,带去人格中心人审:'));
               renderGenesis(r.result);
             }).catch(function () { bGen.disabled = false; bGen.textContent = old; resC.textContent = '✗ 仪式失败(网关)'; });
           };
@@ -2897,6 +3745,7 @@
             genOut.textContent = '';
             introBtns = [];
             nameBtns = [];
+            dutyBtns = [];
             hintBtns = [];
             var rst = result;
             function head(t) {
@@ -2973,9 +3822,44 @@
                 genOut.appendChild(line);
               });
             }
+            // 第 5 类草稿:职责(1.5.2 I-5)。起草权在她,终审在你 —— 这里只做候选挑选,
+            // 选中的仍只是草稿,要带去人格中心填进「职业 / 职责 / 责任」并保存才算数(约束 A:机制不落盘)。
+            if (rst.duties && rst.duties.length) {
+              genOut.appendChild(head(she('她承担的/擅长的事(单选一条加入草稿)')));
+              var dutyPicked = [false, false, false];
+              rst.duties.forEach(function (d, i) {
+                var line = el('div', 'ling-draft-item');
+                line.style.cssText = 'display:flex;gap:8px;align-items:flex-start;margin:5px 0;font-size:13px;';
+                var txt = el('span', null, d);
+                txt.style.cssText = 'flex:1;line-height:1.6;opacity:.95;white-space:pre-wrap;';
+                var bt = el('button', null, '加入草稿');
+                bt.onclick = function () {
+                  if (dutyPicked[i]) {
+                    dutyPicked[i] = false;
+                    if (draftDuty && draftDuty.duty === d) draftDuty = null;
+                  } else {
+                    dutyPicked.forEach(function (_, j) { dutyPicked[j] = j === i; });
+                    draftDuty = { duty: d };
+                  }
+                  dutyPicked.forEach(function (p, j) {
+                    var btn = dutyBtns[j];
+                    if (btn) setPickState(btn, p);
+                  });
+                  refreshDraftBar();
+                };
+                dutyBtns.push(bt);
+                line.appendChild(txt);
+                line.appendChild(bt);
+                genOut.appendChild(line);
+              });
+              var dutyNote = el('div', 'm-meta', '');
+              dutyNote.style.cssText = 'margin:2px 0 4px;opacity:.8;';
+              dutyNote.textContent = she('若某条读起来像"我应当/我必须/我的任务/我的责任是/我被要求/请让我负责",那是授权口吻(把她写成"被授权者",不是"她自己是什么")—— 别人的话不该长在她身上,建议不选它。');
+              genOut.appendChild(dutyNote);
+            }
             function hintRow(label, text) {
               if (!text) return;
-              genOut.appendChild(head(label + she('(可加入草稿,到人格中心后作为"她的话"记入习惯)')));
+              genOut.appendChild(head(she(label + '(可加入草稿,到人格中心后作为"她的话"记入习惯)')));
               var line = el('div', 'ling-draft-item');
               line.style.cssText = 'display:flex;gap:8px;align-items:flex-start;margin:5px 0;font-size:13px;';
               var txt = el('span', null, text);
@@ -3008,6 +3892,7 @@
               openPersonaEditor({
                 aiName: draftName ? draftName.aiName : undefined,
                 aiTitle: draftIntro ? draftIntro.aiTitle : undefined,
+                duty: draftDuty ? draftDuty.duty : undefined,
                 hints: draftHints.slice(),
               });
             };
@@ -3016,7 +3901,7 @@
             function refreshDraftBar() {
               var t = draftSummary();
               barTxt.textContent = t ? '草稿:' + t : '草稿:尚未选择';
-              bCarry.disabled = !(draftIntro || draftName || draftHints.length);
+              bCarry.disabled = !(draftIntro || draftName || draftDuty || draftHints.length);
             }
             var guide2 = el('div', 'm-meta', '');
             guide2.style.cssText = 'margin-top:6px;opacity:.8;';
@@ -3057,7 +3942,7 @@
                 var doc = splitDoc(String(reader.result));
                 if (doc.note) resB.textContent = doc.note + '\n';
                 pendingItems = doc.items;
-                resB.textContent = (resB.textContent || '') + '解析到会话 ' + doc.items.length + ' 条 —— 点击下方「确认导入」分批写入(200/批)。';
+                resB.textContent = (resB.textContent || '') + '解析到会话 ' + doc.items.length + ' 条 —— 点击下方「确认导入」分批写入(按体量切批,单批 ≤' + (BATCH_MAX_BYTES / 1024 / 1024) + ' MB)。';
                 bGo.textContent = '确认导入(' + doc.items.length + ' 条)';
                 bGo.disabled = false;
               } catch (e) {
@@ -3074,9 +3959,13 @@
             var old = bGo.textContent;
             var items = pendingItems;
             pendingItems = null;
-            var totals = { newRows: 0, refreshed: 0, upgraded: 0, folded: 0, removedImport: 0, accepted: 0, rejected: 0, degraded: 0, degradedReasons: {}, errors: 0 };
+            // tooBig = 单条自身超限被跳过的条数(C-1):**已知且可解释**,与 errors(意外)分开记,
+            // 但必须在 finish() 汇总里如实显示 —— 不显示就是静默丢数据。
+            // foldSkippedRaw(A,2026-09-30)= 折叠时"因为目标会话**已有原文**而**没有替换**的轮数":
+            // 同一档"已知且可解释的跳过",同样必须说出来(finish() 里有一行专门交代它)。
+            var totals = { newRows: 0, refreshed: 0, upgraded: 0, folded: 0, removedImport: 0, foldSkippedRaw: 0, accepted: 0, rejected: 0, degraded: 0, degradedReasons: {}, errors: 0, tooBig: 0 };
             var rejPreview = [];
-            var batch = 200;
+            var sentBytes = 0; // 已送字节(累计;C2 双口径进度用)
             // 一次导入 = 一条账:runId 贯穿全部批,at = 导入开始时刻(服务端固定后不再变动)
             var runId = 'imp-' + Date.now() + '-' + Math.random().toString(36).slice(2, 8);
             var startedAt = Date.now();
@@ -3087,14 +3976,33 @@
                 body: { runId: runId, at: startedAt, file: currentFileName, errors: 1 },
               }).catch(function () {});
             }
+            // #10(2026-09-29):被跳过的"单条过大"要进**持久账本**(「接入历史 → 导入记录」)。
+            //   ⚠️ 语义:它记的是"**跳过**"、不是"失败" —— 所以这一笔**不带 `errors`**
+            //   (端点里 `errors` 的旧语义是 `max(1, ...)`:带上它就等于把"已知跳过"混成"失败批";
+            //   而当初正是因为那条通路只认 errors,C-1 只能**故意不报** ⇒ 账本上完全看不出有东西被跳过)。
+            //   名字与界面点名**同源**(同一个三级退路 title → name →「未命名」),最多 5 条(端点还会再截一次)。
+            //   收尾时发**一次**(不是每条一发);失败不重试、不影响界面 —— 与 reportError 同款"尽力而为"。
+            var skippedNames = [];
+            function reportTooBig() {
+              if (!totals.tooBig) return;
+              api('/import/log', {
+                method: 'POST',
+                body: {
+                  runId: runId, at: startedAt, file: currentFileName,
+                  tooBig: totals.tooBig, tooBigNames: skippedNames.slice(0, 5),
+                },
+              }).catch(function () {});
+            }
             function next() {
-              var chunk = items.slice(idx, idx + batch);
-              if (!chunk.length) return finish();
-              idx += batch;
-              resB.textContent = '导入中…' + Math.min(idx, items.length) + '/' + items.length;
+              var chunk = takeChunk(items, idx); // C1:条数 × 字节双限(字节口径见 takeChunk 注释)
+              if (!chunk.list.length) return finish();
+              var chunkStart = idx; // C4:本批起始下标(0-based)⇒ 拒绝序号 = chunkStart + rj.i + 1
+              idx = chunk.next;
+              sentBytes += chunk.bytes;
+              resB.textContent = '导入中…' + Math.min(idx, items.length) + '/' + items.length + ' 条 · 已送 ' + fmtBytes(sentBytes);
               api('/import/file/batch', {
                 method: 'POST',
-                body: { items: chunk, file: currentFileName, runId: runId, at: startedAt },
+                body: { items: chunk.list, file: currentFileName, runId: runId, at: startedAt },
               }).then(function (r) {
                 if (r && r.ok) {
                   totals.accepted += r.accepted || 0;
@@ -3103,6 +4011,8 @@
                   totals.upgraded += r.upgraded || 0;
                   totals.folded += r.folded || 0;
                   totals.removedImport += r.removedImport || 0;
+                  // A(2026-09-30):折叠时"目标已有原文 ⇒ 这一轮没替换"的计数,照 upgraded/folded 同一写法累加
+                  totals.foldSkippedRaw += r.foldSkippedRaw || 0;
                   totals.degraded += r.degraded || 0;
                   if (r.degradedReasons) {
                     Object.keys(r.degradedReasons).forEach(function (k) {
@@ -3112,14 +4022,46 @@
                   if (r.rejected && r.rejected.length) {
                     totals.rejected += r.rejected.length;
                     r.rejected.slice(0, 3).forEach(function (rj) {
-                      var at = idx - batch + rj.i + 1;
+                      var at = chunkStart + rj.i + 1; // C4:以【本批起始下标】为准(batch 已不存在)
                       if (rejPreview.length < 5) rejPreview.push('第 ' + at + ' 条:' + rj.reason);
                     });
                   }
                 } else {
-                  totals.errors += 1;
-                  reportError();
-                  if (rejPreview.length < 5) rejPreview.push('批失败:' + ((r && (r.message || r.error || r.reason)) || '未知'));
+                  // C5:超限是可自愈的确定性失败,给可执行的人话(而不是让它烂成「(网关)」)。
+                  // 上限数字**取自服务端回执**(413 体里带 limit),不在这边再写死一个 ——
+                  // 两个地方各写一个"4 MB",将来改上限时必漂移;`4` 只作回执缺 limit 时的兜底。
+                  var limMb = Number(r && r.limit) > 0 ? Math.round(Number(r.limit) / 1024 / 1024) : 4;
+                  // C-1(2026-09-29):同一个 413 其实有两种,必须分开说 ——
+                  //   ① 本批**只有 1 条** ⇒ 是【这一条自己】太大:takeChunk 已保证超限条单独成批,
+                  //      所以"再切细一点"物理上不存在(单条不可再分)。它是**已知且可解释**的,
+                  //      不是意外 ⇒ 记 totals.tooBig,不混进 errors;并且要点名报到哪一条、多大,
+                  //      再说清"这条跳过、其余照常导入"(后面照常 next(),绝不因一条太大中止整次导入)。
+                  //   ② 本批**多于 1 条** ⇒ 是切批没生效(真异常)⇒ 沿用旧文案,计入 errors。
+                  // 判据只用**服务端回执**(reason==='too-large' + limit)与本批条数;
+                  // 客户端**不镜像**服务端的字节上限(将来放宽上限不用改这里)。
+                  if (r && r.reason === 'too-large' && chunk.list.length === 1) {
+                    var one = chunk.list[0] || {};
+                    var oneTitle = String(one.title || one.name || '').trim() || '未命名';
+                    var oneBytes = chunk.bytes; // 退路:本批自报字节(含封套近似)
+                    try { oneBytes = utf8Len(JSON.stringify(one)); } catch (e) { /* 循环引用等:用退路 */ }
+                    totals.tooBig += 1;
+                    if (skippedNames.length < 5) skippedNames.push(oneTitle);   // #10:账本点名用(最多 5 条)
+                    if (rejPreview.length < 5) {
+                      rejPreview.push('单条过大跳过:「' + oneTitle + '」这一条 ' + fmtBytes(oneBytes) + '(' + oneBytes + ' B)'
+                        + ' —— 它自己就在单次上限 ' + limMb + ' MB 之上,导入通道装不下(不是文件坏了,是这条太长,拆文件也拆不开它);'
+                        + '这条已跳过,其余会话照常导入');
+                    }
+                  } else {
+                    totals.errors += 1;
+                    reportError();
+                    if (rejPreview.length < 5) {
+                      if (r && r.reason === 'too-large') {
+                        rejPreview.push('批失败:这一批太大(服务端单次上限 ' + limMb + ' MB),请把导出文件拆小后再导');
+                      } else {
+                        rejPreview.push('批失败:' + ((r && (r.message || r.error || r.reason)) || '未知'));
+                      }
+                    }
+                  }
                 }
                 next();
               }).catch(function () {
@@ -3134,7 +4076,12 @@
               bGo.textContent = old;
               // S5(2026-09-17 导入诚实化):「有壳无肉」时绝不说"✓ 导入完成"。
               // 旧文案把"对话解析不出来"说成"降级为轻量",用户以为导入成功了,其实正文一条没进。
+              // C-1(2026-09-29)按同一口径补一档:**有会话因单条过长被跳过**时,同样绝不说"✓ 导入完成"。
               var shell = totals.degraded || 0;
+              var skipped = totals.tooBig || 0;
+              // A(2026-09-30):折叠时"因为目标会话已有原文而**没有替换**的轮数"。
+              // 它不是失败、也没有丢东西(保住的是对方原有的真原文),但**必须说出来** —— 静默不可接受。
+              var notReplaced = totals.foldSkippedRaw || 0;
               var why = Object.keys(totals.degradedReasons).map(function (k) {
                 return k + ' ×' + totals.degradedReasons[k];
               }).join(';');
@@ -3144,19 +4091,37 @@
                   shell + ' 条只有标题、没有对话正文');
                 lines.push('  原因:' + (why || '文件里的对话格式没能认出来') +
                   ' —— 这些记忆暂时只有壳,深摘也补不出内容。');
+              } else if (skipped) {
+                lines.push('⚠ 导入不完全:写入新记忆 ' + totals.newRows + ' 条 · 刷新已有 ' + totals.refreshed + ' 条,另有 ' +
+                  skipped + ' 条会话单条太长、没能通过导入通道(已跳过,见下)');
+                lines.push('  这不是文件坏了:是那几条会话**自己**就超过了单次上限 —— 拆小导出文件也拆不开单条。');
               } else {
                 lines.push('✓ 导入完成:写入新记忆 ' + totals.newRows + ' 条 · 刷新已有 ' + totals.refreshed + ' 条' +
                   (totals.upgraded ? ' · 补全对话原文 ' + totals.upgraded + ' 条' : '') +
                   (totals.folded ? ' · 并入网页端历史 ' + totals.folded + ' 条(含对话原文)' : '') +
                   (totals.removedImport ? ' · 清理重复副本 ' + totals.removedImport + ' 条' : ''));
               }
-              lines.push('  校验通过 ' + totals.accepted + ' · 拒绝 ' + totals.rejected + (totals.errors ? ' · 批错误 ' + totals.errors : ''));
+              lines.push('  校验通过 ' + totals.accepted + ' · 拒绝 ' + totals.rejected + (totals.errors ? ' · 批错误 ' + totals.errors : '') + (skipped ? ' · 单条过大跳过 ' + skipped : ''));
+              // A(2026-09-30):折叠时"没替换"的那几轮必须有一行人话(静默不可接受)。
+              // 措辞要点:① 说清**为什么**(该会话在网页端旧库里已经有原文);② 说清**不是失败、也没丢东西**
+              // (保住的是原有的真原文,是**更安全**的那一边);③ 与 `⚠` 那两档分开 —— 那两档是真的不完全,这档不是。
+              if (notReplaced) {
+                lines.push('  ⓘ 另有 ' + notReplaced + ' 轮原文没有替换:这些会话在网页端旧库里**已经有原文**了 —— '
+                  + '保留原有的那份、不覆盖它(不是失败,也没有丢东西)。');
+              }
               rejPreview.forEach(function (x) { lines.push('  ⚠ ' + x); });
-              if (!totals.errors && totals.accepted && !shell) {
-                lines.push(she('她开始读这些日子了 —— 深摘要会在后台按热度慢慢补齐。'));
+              // 收尾句只在"全好"时打(S5/C-1 的诚实化口径)。
+              // A(2026-09-30):有"没替换"的轮次同样不算全好 —— 那几轮的正文确实没进这一侧的库,
+              // 不能一边少进一边说"她开始读这些日子了"。⚠️ 这一层**写成内层判断**而不是往上面那行
+              // 守卫里再加一个 `&&`:那一行的字面形态被 `tests/client-batch.test.mjs:219` 的 T7 源码护栏
+              // 逐字盯着(`!totals.errors && !skipped && totals.accepted && !shell`),往里塞条件会让那条
+              // 既有断言变红 —— 而它守的正是同一个口径(有跳过就不打"全都好"的收尾句)。
+              if (!totals.errors && !skipped && totals.accepted && !shell) {
+                if (!notReplaced) lines.push(she('她开始读这些日子了 —— 深摘要会在后台按热度慢慢补齐。'));
               }
               resB.textContent = lines.join('\n');
               renderImportLog();
+              reportTooBig();   // #10:有跳过就记一笔账(不带 errors;见 reportTooBig 上方的注释)
             }
             next();
           };
@@ -3344,7 +4309,14 @@
                 row.appendChild(yes); row.appendChild(no);
               }
               c.appendChild(row);
-              if (amended && p.amendNote) c.appendChild(el('div', 'm-meta', she('她的话:') + String(p.amendNote).slice(0, 80)));
+              if (amended && p.amendNote) {
+                // 界面前缀与**数据尾巴**(她自己的改法说明,后端来的原文)必须分成两个文本节点:
+                // 前缀能被 she() 重画、尾巴永远进不了 SHE_VALS ⇒ 换代词时数据一个字都不动。
+                // (混在同一个节点里就只能二选一:要么数据被改,要么前缀永远停在旧代词。)
+                var amLine = el('div', 'm-meta', she('她的话:'));
+                amLine.appendChild(document.createTextNode(String(p.amendNote).slice(0, 80)));
+                c.appendChild(amLine);
+              }
               frag.appendChild(c);
             });
 
@@ -3512,13 +4484,15 @@
 
           useEffect(function () {
             var unsub = store.subscribe(function () { bump(function (x) { return x + 1; }); });
-            var timer = setInterval(function () {
-              api(pollPath(store)).then(function (r) { applyStateToStore(store, r); }).catch(function () {});
-            }, 3000);
+            // A+B:不再「一个组件实例一个 setInterval」—— 改订模块级共享 ticker
+            // (同一个 store 一拍只发一次请求;后台停表、空闲降频都在那里)。
+            // 退订即停表,与 mount 对称。
+            var unpoll = subscribePoll(store);
             return function () {
               unsub();
-              clearInterval(timer);
+              unpoll();
               if (hoverTimer.current) { clearTimeout(hoverTimer.current); hoverTimer.current = null; }
+              hideTip();
             };
           }, []);
 
@@ -3528,24 +4502,55 @@
 
           st = store.get();
           var mode = st.mode || 'life';
-          // 侧栏窄轨(收起)时官方只给极窄的一格:按 { wide } 切换为方图标态,避免溢出
+          // C-07 访问日志**停写**时的常驻警示 —— 唯一「不主动查也看得见」的形态(2026-09-27 静默 41.6 分钟那次)。
+          // 只动 label 文本 / 文字颜色 / title / aria-label:不新增 DOM、不加动画、不改尺寸(这一格挤不起)。
+          // audit 缺失(老后端)⇒ false ⇒ 与改动前逐字节相同。
+          // C-07c(2026-09-27):判据从"只有 degraded"扩成两类 ——
+          //   ① state==='degraded'(写了但停写);
+          //   ② installed===false **且** reason 是 patch-missing / not-mounted(应为但未装 = 静默失败)。
+          //   ⚠️ 'disabled-by-config' **不染红**:那是主人有意关的。天天挂个假警报,红点就没人看了。
+          var auditOffBad = !!(st.audit && st.audit.installed === false
+            && (st.audit.reason === 'patch-missing' || st.audit.reason === 'not-mounted'));
+          var auditBad = !!((st.audit && st.audit.state === 'degraded') || auditOffBad);
+          // 侧栏窄轨(收起)时官方只给极窄的一格:按 { wide } 切换为方图标态,避免溢出。
+          // ⚠️ 窄轨是 34px 定宽方图标(padding:0;white-space:nowrap),"⚠ + 模式图标"两个字形会溢出格子
+          //    ⇒ 窄轨下**用 ⚠ 顶替模式图标**(模式仍由 title / aria-label / 悬停菜单给出);
+          //    宁可暂时少一个字形,也不把侧栏挤坏。
           var rail = !!(props && props.wide === false);
           var label = rail
-            ? (mode === 'work' ? '⚙' : '☾')
-            : (mode === 'work' ? '⚙ 工作' : '☾ 生活');
-          var title = isGlobal
-            ? ('器灵默认模式:' + modeName(mode) + '(新会话跟随)。左键切换;悬停 1.5s 菜单。进入会话后请用右上角按钮切换该会话')
-            : ('器灵 · ' + (st.running ? '运行中(冻结):' : '') + '左键切换为' + modeName(otherMode(mode)) + '模式;悬停 1.5 秒打开菜单');
+            ? (auditBad ? '⚠' : (mode === 'work' ? '⚙' : '☾'))
+            : ((auditBad ? '⚠ ' : '') + (mode === 'work' ? '⚙ 工作' : '☾ 生活'));
+          // ⚠️ 原生 `title` 只留**一行**(2026-09-27 用户反馈:原来四行太罗嗦,且浏览器 tooltip 不会自动
+          //   消失,悬停 1.5s 菜单一开就和它叠成两层)。完整提醒改走自绘气泡 `showTip` ——
+          //   悬停即现、3s 自隐、菜单一开就收,见 `tipText`。
+          var title = (isGlobal
+            ? ('器灵默认模式:' + modeName(mode) + '(新会话跟随) ｜ 左键切换 · 悬停 1.5s 菜单')
+            : ('器灵 · ' + (st.running ? '运行中(冻结):' : '') + '左键切换为' + modeName(otherMode(mode)) + '模式;悬停 1.5 秒打开菜单'))
+            + (auditBad ? (auditOffBad ? ' ｜ ⚠ 访问日志未启用(应为但没装上)' : ' ｜ ⚠ 访问日志已停写') : '');   // 只在真出故障时追加,平时 title 仍是一行
+          var tipText = isGlobal
+            ? '⚠ 这是全局默认,新会话都跟随(推理等级同步推进,模型不变)。想只切一个会话,用该会话右上角的按钮。'
+            : '';
           return h('button', {
             ref: btnRef,
             className: 'dsh-ling-btn' + (isGlobal ? ' dim' : '') + (rail ? ' rail' : ''),
+            // 只有真出故障才染红(走既有主题变量 --lg-danger,明/暗两套都在);style:null = 不设内联样式
+            style: auditBad ? { color: 'var(--lg-danger)' } : null,
             title: title,
-            'aria-label': '器灵控制器:' + (isGlobal ? '默认' : '当前') + modeName(mode) + '模式',
-            onClick: function () { clearHover(); toggleMode(store); },
+            'aria-label': '器灵控制器:' + (isGlobal ? '默认' : '当前') + modeName(mode) + '模式'
+              + (auditOffBad ? '(⚠ 访问日志未启用:应为但没装上)' : (auditBad ? '(⚠ 访问日志已停写)' : '')),
+            onClick: function () {
+              clearHover(); hideTip();
+              // 点击后**立即**补一次 /state(不等共享 ticker 的下一拍 —— 空闲时它可能正在 5s 慢节拍上)。
+              // 刻意等这一发 POST 落定再补:抢在写入前面发 GET 会读回旧模式,把刚设好的标签盖回去。
+              var p = toggleMode(store);
+              if (p && typeof p.then === 'function') p.then(function () { kickPoll(store, true); });
+            },
             onMouseEnter: function () {
               clearHover();
+              if (tipText) showTip(btnRef && btnRef.current, tipText);
               hoverTimer.current = setTimeout(function () {
                 hoverTimer.current = null;
+                hideTip();   // 菜单与气泡永不同屏(用户反馈的"窗口叠加"就是这两层)
                 var node = btnRef && btnRef.current;
                 openMenuNear(node ? node.getBoundingClientRect() : null, store);
               }, HOVER_MS);
@@ -3557,7 +4562,11 @@
               if (e && e.stopPropagation) e.stopPropagation();
             },
             onKeyDown: function (e) {
-              if (e.key === 'Enter' && !e.shiftKey) { clearHover(); toggleMode(store); }
+              if (e.key === 'Enter' && !e.shiftKey) {
+                clearHover();
+                var pk = toggleMode(store);   // 键盘等价于左键点击:同样落定后立即补一拍
+                if (pk && typeof pk.then === 'function') pk.then(function () { kickPoll(store, true); });
+              }
               else if (e.key === 'Enter' && e.shiftKey) {
                 var node = btnRef && btnRef.current;
                 openMenuNear(node ? node.getBoundingClientRect() : null, store);
@@ -3684,6 +4693,52 @@ var lingCenterReload = null;   // 侧栏改完树后通知记忆中心重载(两
       }
 
       /** 侧栏正文组件。React 不可用时返回 null 而非崩溃。 */
+      // ---- M1(2026-09-27 修):侧栏「最近改动」的溢出自报 ----------------------------------
+      // 缺陷:取数写死 limit=6、渲染再钉 slice(0,6),溢出时**一个字都不说** ⇒ 主人看到的现象
+      // 是"正好少一条"。对照:注入面**会自报**「…另有 N 笔改动」(host/memory.js:1190-1195)。
+      // 主人裁决(逐字):「保留 6 行 + 加一行『…另有 N 笔』」。
+      var LOG_SHOWN = 6;          // 列表只列这么多行(= 下方 slice(0, 6);探针断言两者同值)
+      // 取数页大小:端点默认就是 100、上限 500(host/memory.js:1206;api.js:684)⇒ 客户端不再
+      // 自己传 6 把列表掐住。**只放大取数,不放大渲染**(仍只列 LOG_SHOWN 行)。
+      var LOG_FETCH_LIMIT = 100;
+
+      /** 「最近改动」溢出笔数(纯函数 —— 抽出来是为了能在假 DOM 上真跑,
+       *  已由一次性运行时探针在假 DOM 上实跑核对过)。
+       *
+       *  主路:用**服务端真计数**。`/branch-log/pending` 的 `pending` 就是
+       *  `COUNT(id > 水位 AND action <> 'snapshot')`(host/memory.js:1257-1263),再把列表里
+       *  **已经列出来**的那几笔(水位之上、且不是"保存快照")减掉 ⇒ N 精确;它与同一块里那句
+       *  红字「有 N 笔改动还没跟器灵说过」是**同一个数、同一个界**,两块永远不会互相打脸。
+       *
+       *  ⚠️ 为什么不按"页面条数 − 6"算(那样更省事,原计划也是这么写的):侧栏只取**一页**
+       *  (`ORDER BY id DESC`),而 branch_log 是**全量留痕** —— 2026-09-27 只读实测已有 **404 行**
+       *  ⇒ 页面恒满,`data.log.length - 6` 恒等于 `limit - 6`(limit=100 ⇒ 恒 94),与主人看到的
+       *  改动笔数无关。那正是 1.5.1 在注入面修掉的"两个写死上限的差值"
+       *  (作者的开发台账 §A,该台账不随包公开;host/memory.js:1016-1029 明写"不需要把 limit 调大去凑数")。
+       *
+       *  退路(真计数问不到时 `pend` 为 null):退回页面口径;页面满(`log.length >= limit`)
+       *  说明可能还有更多行没取到 ⇒ 只说「N 笔**以上**」,不冒充确切数。
+       *  @returns {{n:number, atLeast:boolean}} n<=0 ⇒ 调用方**整行不渲染**(与注入面"零明细
+       *  不渲染任何东西"同口径)。 */
+      function branchLogMore(log, pend, shown, limit) {
+        var rows = Array.isArray(log) ? log : [];
+        var top = rows.slice(0, shown);
+        if (pend && Number.isFinite(Number(pend.pending)) && Number.isFinite(Number(pend.watermark))) {
+          var wm = Number(pend.watermark) || 0;
+          var listed = 0;
+          top.forEach(function (l) {
+            // 与 pending 同口径:水位之上的、且不是"保存快照"(保存不改树,不计债)。
+            // ⚠️ id 读不出来的行**当作"已列出"**:宁可少报一笔,也不谎报"另有"
+            //   (与 host/memory.js:1029「摘要宁可少报,也不能整段消失」同向)。
+            var id = Number(l && l.id);
+            if ((!Number.isFinite(id) || id > wm) && String((l && l.action) || '') !== 'snapshot') listed += 1;
+          });
+          return { n: Math.max(0, Number(pend.pending) - listed), atLeast: false };
+        }
+        var extra = rows.length - top.length;
+        return { n: extra > 0 ? extra : 0, atLeast: extra > 0 && rows.length >= limit };
+      }
+
       function LingReviewBody() {
         if (!React) return null;
         var h = React.createElement;
@@ -3777,6 +4832,13 @@ var lingCenterReload = null;   // 侧栏改完树后通知记忆中心重载(两
         var s10 = React.useState(0);
         var pendingChanges = s10[0];
         var setPendingChanges = s10[1];
+        // M1(2026-09-27):与 pendingChanges **同一份应答**里的水位(watermark = 哪一笔之后算
+        // "还没交代")—— 「最近改动」据此把"没列出来的未交代笔数"算准。**不加任何新请求**:
+        // 它随 `/branch-log/pending` 一起回来(api.js:697 原样透出 memory.js 的 branchLogPending)。
+        // null = 没问到 ⇒ branchLogMore 退回页面口径(宁可加"以上",也不冒充确切数)。
+        var s13 = React.useState(null);
+        var logPending = s13[0];
+        var setLogPending = s13[1];
         // R7 主脉提炼(2026-09-23):候选队列。设计稿 §5 —— 提炼结果**先进审核队列**,
         // 采纳后才写入主脉自己的记忆(conv_overview source='vein'),且带派生来源。
         var s11 = React.useState([]);
@@ -3797,9 +4859,10 @@ var lingCenterReload = null;   // 侧栏改完树后通知记忆中心重载(两
           Promise.all([
             api('/tree').catch(function () { return null; }),
             api('/conflicts').catch(function () { return null; }),
-            api('/branch-log?limit=6').catch(function () { return null; }),
+            api('/branch-log?limit=' + LOG_FETCH_LIMIT).catch(function () { return null; }),
             api('/tree/snapshots?limit=30').catch(function () { return null; }),
-            api('/branch-log/pending').catch(function () { return null; }),
+            // 1.5.3(主会话校正:本批未发布,不叫 1.5.4):该端点进了服务端 `POST_ONLY`(它会一次性补种水位 = 真写),GET 现在回 405。
+            api('/branch-log/pending', { method: 'POST', body: {} }).catch(function () { return null; }),
             api('/vein/suggestions?status=new&limit=100').catch(function () { return null; }),
             // E10:主脉记忆清单(只读,limit 上限就是 500,见 memory.js:1951)
             api('/memories?source=vein&limit=500').catch(function () { return null; }),
@@ -3807,6 +4870,10 @@ var lingCenterReload = null;   // 侧栏改完树后通知记忆中心重载(两
             if (!alive) return;
             setSnapshots((rs[3] && rs[3].ok) ? (rs[3].snapshots || []) : []);
             setPendingChanges((rs[4] && rs[4].ok) ? Number(rs[4].pending || 0) : 0);
+            // M1:水位与 pending **同一份应答、同一拍**(不多一个请求);问不到就置 null 退回页面口径
+            setLogPending((rs[4] && rs[4].ok)
+              ? { pending: Number(rs[4].pending || 0), watermark: Number(rs[4].watermark || 0) }
+              : null);
             setVeinSugs((rs[5] && rs[5].ok) ? (rs[5].suggestions || []) : []);
             var vm = {};
             if (rs[6] && rs[6].ok) {
@@ -3828,8 +4895,16 @@ var lingCenterReload = null;   // 侧栏改完树后通知记忆中心重载(两
         // 侧栏还写着"有 N 笔没说"。加轻量轮询让它跟上(8s 一次小请求,值不变时 React 不重渲染)。
         React.useEffect(function () {
           var t = setInterval(function () {
-            api('/branch-log/pending').then(function (r) {
-              if (r && r.ok) setPendingChanges(Number(r.pending || 0));
+            api('/branch-log/pending', { method: 'POST', body: {} }).then(function (r) {
+              if (!r || !r.ok) return;
+              var p = Number(r.pending || 0);
+              var w = Number(r.watermark || 0);
+              setPendingChanges(p);
+              // M1:水位跟着刷新(仍是同一发请求,不新增轮询)。**值不变时返回同一个对象** ——
+              // 否则每 8s 造一个新对象 ⇒ React 每次都重渲染整个侧栏(原文"值不变不重渲染"就废了)。
+              setLogPending(function (prev) {
+                return (prev && prev.pending === p && prev.watermark === w) ? prev : { pending: p, watermark: w };
+              });
             }).catch(function () { /* 轮询失败不影响复盘 */ });
           }, 8000);
           return function () { clearInterval(t); };
@@ -4660,6 +5735,17 @@ var lingCenterReload = null;   // 侧栏改完树后通知记忆中心重载(两
               '· ' + String(l.at || '').slice(5, 16).replace('T', ' ') + '  '
               + (l.branchName || l.branchId) + '  ' + l.action));
           });
+          // M1(2026-09-27 修):上面只列 6 行,**溢出必须自报**(改前静默丢行)。措辞与注入面那句
+          // 「…另有 N 笔改动」(host/memory.js:1190-1195)对齐 —— 同一句主语、同一个"没交代的改动"
+          // 集合;零笔则整行不渲染。括号里**不写**「点开复盘模式看全部」:本面板**就是**复盘模式,
+          // 且全仓只有这一处渲染 branch_log(客户端 4 个 /branch-log 消费点全在本面板内)⇒ 那句话
+          // 会指向不存在的地方;这里改用注入面同款的"披露"式(对照 memory.js:1192 的括号写法)。
+          var logMore = branchLogMore(data.log, logPending, LOG_SHOWN, LOG_FETCH_LIMIT);
+          if (logMore.n > 0) {
+            kids.push(h('div', { key: 'lm', style: { opacity: 0.7 } },
+              '…另有 ' + logMore.n + (logMore.atLeast ? ' 笔以上改动' : ' 笔改动')
+              + '(此处只列最近 ' + LOG_SHOWN + ' 笔)'));
+          }
         }
         if (pendingChanges > 0) {
           kids.push(h('div', {
@@ -4686,7 +5772,7 @@ var lingCenterReload = null;   // 侧栏改完树后通知记忆中心重载(两
               // 2026-09-23 修:显示值可能滞后(器灵开口才推进水位,而"发言"不触发本面板重载),
               // 所以退出前**实时查一次**服务端 —— 避免"明明已经同步了却拦着不让退"。
               if (!next) {
-                api('/branch-log/pending').then(function (r) {
+                api('/branch-log/pending', { method: 'POST', body: {} }).then(function (r) {
                   var p = (r && r.ok) ? Number(r.pending || 0) : pendingChanges;
                   setPendingChanges(p);
                   if (p > 0) {
@@ -5063,6 +6149,15 @@ var lingCenterReload = null;   // 侧栏改完树后通知记忆中心重载(两
           console.warn('[dsh-ling] client apply failed', e);
         }
       };
+      // ---- 测试钩子(仅供 tests/client-batch.test.mjs 直调真实实现)----
+      // 只挂纯函数与常量,无任何副作用;生产路径不读这里。
+      exports.__test__ = {
+        takeChunk: takeChunk,
+        utf8Len: utf8Len,
+        fmtBytes: fmtBytes,
+        BATCH_MAX_BYTES: BATCH_MAX_BYTES,
+        BATCH_MAX_ITEMS: BATCH_MAX_ITEMS,
+      };
       return module.exports;
     },
   });