dsh-selfnote 0.14.0 → 0.14.2

package/README.md

@@ -10,10 +10,10 @@
 </p>
 
 <p align="center">
-  <img src="https://img.shields.io/badge/version-0.14.0-4f46e5" alt="version">
+  <img src="https://img.shields.io/badge/version-0.14.2-4f46e5" alt="version">
   <img src="https://img.shields.io/badge/license-MIT-16a34a" alt="license">
   <img src="https://img.shields.io/badge/node-%3E%3D20.13-339933" alt="node">
-  <img src="https://img.shields.io/badge/tests-285%20passed-0ea5e9" alt="tests">
+  <img src="https://img.shields.io/badge/tests-280%20passed-0ea5e9" alt="tests">
 </p>
 
 ---
@@ -109,7 +109,7 @@ plugin_manager { action: "install_bundle", target: "<该目录的绝对路径>"
 | **人格** | 三段式人格（L0 核心身份 / L1 行为规则 / L2 扩展设定），带「还能写多少」的实时字数；「从 AGENT.md 导入」只填框、不保存；下面是纠偏证据列表 —— 勾几条、改写成一条规则、加进 L1 草稿，再点「保存人格」 | 人格字数 |
 | **记忆** | 待确认候选（冲突并排）、已采纳（带热度，**正文能就地改**）、可以升成习惯的标签、已生效的习惯（能撤销） | 有待审时显示「待审 N」 |
 | **画像** | 从已采纳记忆聚合的「关于你」，可手改覆盖，每句带来源 | 画像字数 |
-| **注入** | **这一回合真的会贴进提示词的那段原文**，外加每段占了多少字、哪些条目被挤掉 | 注入字数 |
+| **注入** | **这一回合真的会贴进提示词的那段原文**，外加每段占了多少字、哪些条目被跳过、每条为什么没进 | 注入字数 |
 
 有待审候选时直接落在「记忆」页，没有就停在「概览」；页签支持 ←/→/Home/End 切换。
 
@@ -140,7 +140,7 @@ plugin_manager { action: "install_bundle", target: "<该目录的绝对路径>"
 写的时候用 `tier` 标明是哪一型（`core` / `stable` / `temp`，不写按 `stable` 算）。落盘长这样：
 
 ```
-- 2026-11-04 [核心*] 我叫鲸鲸。得意时会多说两句，但正事一律认真。
+- 2026-11-04 [核心*] 默认用中文回答，专业词顺手带一句白话解释。
 - 2026-11-04 [稳定] 回答先给结论，细节等他问。
 - 2026-11-04 [临时] 这周在查 DSH 远程主机连不上的问题。
 ```
@@ -170,7 +170,9 @@ plugin_manager { action: "install_bundle", target: "<该目录的绝对路径>"
 | 结论 | 90 字 | 同上 |
 | 习惯 | 40 字 | 同上 |
 
-被预算挤掉的条目会**列出来**，并标明「整条跳过，不截半句」—— 半句话会被当成结论读。这段文字来自 `assembleInjection()`（纯函数，不写盘、不记热度），所以设置页刷新一百次也不会把热度刷歪。
+被预算挤掉或已过期的条目会**列出来**：每段都给 `skippedDetail`，点开就能看见每条没进上下文的原因（`budget` / `expired`）；核心素材单列「素材层，不注入」，不会被误当成普通的预算竞争失败。这是**当前这一轮**的实时解释，不保存历史跳过记录 —— 实时可解释性不等于历史可追溯性。原文仍是「整条跳过，不截半句」—— 半句话会被当成结论读。这段文字来自 `assembleInjection()`（纯函数，不写盘、不记热度），所以设置页刷新一百次也不会把热度刷歪。
+
+另外，`/state` 顶层的 `injectionCount` / `lastInjectedAt` 记的是「注入文本真的返回给模型」的次数与最后时刻（缓存命中也算），与上面的 `skippedDetail` 是两条独立观测链路：一个回答「哪些没进、为什么」，一个回答「实际返回了几次」，不用 `seenCount`、预览次数或心跳计数代替。
 
 ### 注入归属：这条记忆到底有没有被用上
 
@@ -497,7 +499,7 @@ L2 为空时那句指路句也不发（不能指一条空路）。L2 有内容
 
 1. **`Host` 必须是回环地址或桌面壳（`dsh-app`）** —— 挡 DNS 重绑定；
 2. **带了 `Origin` 就必须同源** —— 跨站页面的请求根本发不出去（服务端不回 CORS 头）；
-3. **带了 `x-selfnote` 就必须等于本实例的 token** —— token 在首次启动时随机生成（或用 `DSH_SELFNOTE_TOKEN` 指定），存在 `~/.dsh/selfnote/auth-token`（权限 600）。**它不是写在文档里的固定值**，照抄 README 读不到你的记忆。
+3. **带了 `x-selfnote` 就必须等于本实例的 token** —— token 在首次启动时随机生成（或用 `DSH_SELFNOTE_TOKEN` 指定），存在 `~/.dsh/selfnote/auth-token`（POSIX 上 600；Windows 上 chmod 是空操作，靠用户目录自身的 ACL）。**它不是写在文档里的固定值**，照抄 README 读不到你的记忆。
 
 第 3 条是**可选**的：桌面壳的页面从 `dsh-app://app` 加载，拿不到注入的 token，所以页面不带也放行；脚本调用带上它更稳妥。
 
@@ -505,7 +507,7 @@ L2 为空时那句指路句也不发（不能指一条空路）。L2 有内容
 
 **拒绝和成功的破坏性操作都记进 `~/.dsh/selfnote/auth.log`**：被拒的写 `reason`，成功清空自述的写 `action: 'clear'` + 清了几条 + 归档文件名。哪天自述突然空了，翻这个文件就知道是哪一次、几点、清了多少条。
 
-想用脚本自测，读 `~/.dsh/selfnote/auth-token`（权限 600），或自己设环境变量后带上它。
+想用脚本自测，读 `~/.dsh/selfnote/auth-token`（POSIX 600，Windows 靠用户目录 ACL），或自己设环境变量后带上它。
 
 ## 和 `dsh-agent-md` 的区别
 
@@ -528,7 +530,7 @@ L2 为空时那句指路句也不发（不能指一条空路）。L2 有内容
 ## 开发
 
 ```bash
-node --run test              # 285 项，21 个文件，无外部依赖
+node --run test              # 280 项，24 个文件，无外部依赖
 node --run test:accept       # 12 项：真实 HTTP + 36 进程并发写
 ```
 

package/lib/client.js

@@ -178,6 +178,28 @@ window.__ModuleLoader__.load({
       var ruleDraftTuple = useState('')
       var ruleDraft = ruleDraftTuple[0]
       var setRuleDraft = ruleDraftTuple[1]
+      // 退役也要两步：退役不删数据，但退役之后它就不进注入了，误点一下等于凭空少一条
+      var pendingRetireTuple = useState(null)
+      var pendingRetire = pendingRetireTuple[0]
+      var setPendingRetire = pendingRetireTuple[1]
+      // 「已退役」默认收起：正常翻记忆时不该被一堆旧结论挡路
+      var showRetiredTuple = useState(false)
+      var showRetired = showRetiredTuple[0]
+      var setShowRetired = showRetiredTuple[1]
+      // 半衰期与画像上限：以前只能在 config.json 里手改，界面上看不见也就没人调
+      var halfLifeTuple = useState('')
+      var halfLife = halfLifeTuple[0]
+      var setHalfLife = halfLifeTuple[1]
+      var profileMaxTuple = useState('')
+      var profileMax = profileMaxTuple[0]
+      var setProfileMax = profileMaxTuple[1]
+      // 纠偏证据一页只给 30 条：后面还有就用「加载更多」翻，翻过的攒在 moreEvidence 里
+      var moreEvidenceTuple = useState([])
+      var moreEvidence = moreEvidenceTuple[0]
+      var setMoreEvidence = moreEvidenceTuple[1]
+      var moreCursorTuple = useState(null)
+      var moreCursor = moreCursorTuple[0]
+      var setMoreCursor = moreCursorTuple[1]
 
       function apply(data) {
         setState(data)
@@ -189,9 +211,14 @@ window.__ModuleLoader__.load({
         setNoteGuide(typeof data.noteGuide === 'string' ? data.noteGuide : '')
         setHeading(typeof data.heading === 'string' ? data.heading : '')
         setTempTtl(String(data.tempTtlDays === undefined ? 14 : data.tempTtlDays))
+        setHalfLife(String(data.halfLifeDays === undefined ? 30 : data.halfLifeDays))
+        setProfileMax(String(data.profile && data.profile.maxChars !== undefined ? data.profile.maxChars : 110))
+        setMoreEvidence([])
+        setMoreCursor(null)
         // 每次拿到新状态，列表下标都可能整体挪位：正在改/正等确认的那条已经没意义了
         setEditing(null)
         setPendingDelete(null)
+        setPendingRetire(null)
         setFactEdit(null)
       }
 
@@ -225,6 +252,28 @@ window.__ModuleLoader__.load({
         }
       }, [confirming])
 
+      // 「真的删」和「真的退役」跟「真的清空」一个口径：武装 5 秒，走开就自动放下。
+      // 之前只有清空带定时器，删自述是点开就永久武装 —— 点了「删」犹豫一下、切个页签回来再点同一格，就真删了。
+      useEffect(function () {
+        if (pendingDelete === null) return undefined
+        var timer = setTimeout(function () {
+          setPendingDelete(null)
+        }, 5000)
+        return function () {
+          clearTimeout(timer)
+        }
+      }, [pendingDelete])
+
+      useEffect(function () {
+        if (pendingRetire === null) return undefined
+        var timer = setTimeout(function () {
+          setPendingRetire(null)
+        }, 5000)
+        return function () {
+          clearTimeout(timer)
+        }
+      }, [pendingRetire])
+
       function runDoctor() {
         setBusy('doctor')
         apiGet('/doctor')
@@ -286,6 +335,76 @@ window.__ModuleLoader__.load({
           })
       }
 
+      // 半衰期与画像上限走 /config；服务端会校验范围，越界就 400 把原因带回来
+      function saveHalfLife() {
+        setBusy('config')
+        apiPost('/config', { halfLifeDays: Number(halfLife), profileMaxChars: Number(profileMax) })
+          .then(function (data) {
+            apply(data)
+            setNotice({ tone: 'ok', text: '已保存：结论按 ' + data.halfLifeDays + ' 天衰减，画像上限 ' + (data.profile && data.profile.maxChars) + ' 字。' })
+          })
+          .catch(function (error) {
+            setNotice({ tone: 'warn', text: '保存失败：' + error.message })
+          })
+          .then(function () {
+            setBusy('')
+          })
+      }
+
+      // 索引开关：启用前服务端会自己检查「在盘上 + 没过期」，不满足就 400，把原话显示出来
+      function toggleIndex(next) {
+        setBusy('index')
+        apiPost('/index', { action: next ? 'enable' : 'disable' })
+          .then(function (data) {
+            apply(data)
+            setNotice({ tone: 'ok', text: next ? '索引已启用：下一回合起检索先走索引。' : '索引已关闭：检索退回完整扫描。' })
+          })
+          .catch(function (error) {
+            setNotice({ tone: 'warn', text: next ? '启用失败：' + error.message : '关闭失败：' + error.message })
+          })
+          .then(function () {
+            setBusy('')
+          })
+      }
+
+      // 翻页：服务端按 (at, id) 给游标，翻过的追加在后面，已勾选的不会因为重新渲染丢掉
+      function loadMoreEvidence() {
+        var cursor = moreCursor !== null ? moreCursor : state && state.corrections ? state.corrections.nextCursor : null
+        if (!cursor) return
+        setBusy('corrections')
+        apiGet('/corrections?limit=30&cursor=' + encodeURIComponent(cursor))
+          .then(function (data) {
+            setMoreEvidence(moreEvidence.concat(data.items || []))
+            setMoreCursor(data.nextCursor || '')
+            if (!data.nextCursor) setNotice({ tone: 'ok', text: '证据已经翻到底了。' })
+          })
+          .catch(function (error) {
+            setNotice({ tone: 'warn', text: '翻页失败：' + error.message })
+          })
+          .then(function () {
+            setBusy('')
+          })
+      }
+
+      // 丢弃：这些原话连规则都不是，只是记录，丢掉不该有心理负担
+      function discardPicked() {
+        var ids = pickedEvidence.slice()
+        if (ids.length === 0) return
+        setBusy('corrections')
+        apiPost('/corrections/discard', { ids: ids })
+          .then(function (data) {
+            apply(data)
+            setPickedEvidence([])
+            setNotice({ tone: 'ok', text: '已丢弃 ' + ids.length + ' 条证据（它们不会再来烦你）。' })
+          })
+          .catch(function (error) {
+            setNotice({ tone: 'warn', text: '丢弃失败：' + error.message })
+          })
+          .then(function () {
+            setBusy('')
+          })
+      }
+
       function saveHeading() {
         setBusy('heading')
         apiPost('/config', { heading: heading })
@@ -364,8 +483,9 @@ window.__ModuleLoader__.load({
           h('textarea', {
             className: 'sn-input',
             rows: rows,
-            // 上限就是校验线的软提示；真拦住的是保存时那一次整份校验
-            maxLength: max > 0 ? max : undefined,
+            // 不用 maxLength：HTML 的 maxLength 按 UTF-16 单元计，一个 emoji 算 2，
+            // 会和按码点算的预算打架（emoji 多的段落会提前两个字符被拦住）。
+            // 这里只给计数与超限提示，真正拦的是保存时那一次整份校验。
             value: value,
             'data-field': key,
             onChange: function (e) { editPersona(key, e.target.value) },
@@ -591,7 +711,15 @@ window.__ModuleLoader__.load({
         apiPost('/fact', { id: id, status: status })
           .then(function (data) {
             apply(data)
-            setNotice({ tone: 'ok', text: status === 'approved' ? '已采纳，下一回合进注入。' : '已处理。' })
+            setNotice({
+              tone: 'ok',
+              text:
+                status === 'approved'
+                  ? '已采纳（原来的退役也一并恢复），下一回合进注入。'
+                  : status === 'retired'
+                    ? '已退役：不再进注入，要它回来去「已退役」里点恢复。'
+                    : '已处理。',
+            })
           })
           .catch(function (error) {
             setNotice({ tone: 'warn', text: '没改成：' + error.message })
@@ -601,6 +729,17 @@ window.__ModuleLoader__.load({
           })
       }
 
+      // 退役两步：第一次只武装，第二次才发请求。数据留在 facts.jsonl 里，随时能恢复。
+      function retireFact(id) {
+        if (pendingRetire !== id) {
+          setPendingRetire(id)
+          setNotice({ tone: 'info', text: '再点一次「真的退役」——它不进注入了，但还在「已退役」里，随时能恢复。' })
+          return
+        }
+        setPendingRetire(null)
+        setFact(id, 'retired')
+      }
+
       function setHabitState(text, status, tag) {
         setBusy('habit')
         apiPost('/habit', { text: text, status: status, tag: tag || '' })
@@ -617,10 +756,31 @@ window.__ModuleLoader__.load({
       }
 
       if (state === null) {
+        // 三态：正在读 / 读失败 / 刚进来还没读。读失败时把 refresh 里 catch 到的真实原因端出来，
+        // 别用「重启 DSH 试试」这种猜测盖掉它 —— 重启治不了 403（凭据），也治不了 404（路由）。
+        var loadFailed = busy !== 'load' && notice !== null
         return h(
           'div',
           { className: 'sn-root' },
-          h('div', { className: 'sn-loading' }, busy === 'load' ? '读取中…' : '还没有连上宿主（重启 DSH 试试）'),
+          h(
+            'div',
+            {
+              className: 'sn-loading' + (loadFailed ? ' sn-loading-error' : ''),
+              role: loadFailed ? 'alert' : 'status',
+            },
+            loadFailed ? notice.text : '读取中…',
+          ),
+          loadFailed
+            ? h(
+                'div',
+                { className: 'sn-actions' },
+                h(
+                  'button',
+                  { type: 'button', className: 'sn-btn', onClick: function () { refresh() }, disabled: busy !== '' },
+                  '重试',
+                ),
+              )
+            : null,
         )
       }
 
@@ -683,7 +843,11 @@ window.__ModuleLoader__.load({
                 'div',
                 { key: 'actions', className: 'sn-actions' },
                 h('button', { className: 'sn-btn', onClick: function () { setFact(fact.id, 'approved') }, disabled: busy !== '' }, '采纳'),
-                h('button', { className: 'sn-btn sn-btn-ghost', onClick: function () { setFact(fact.id, 'retired') }, disabled: busy !== '' }, '退役'),
+                h(
+                  'button',
+                  { className: 'sn-btn sn-btn-ghost' + (pendingRetire === fact.id ? ' sn-btn-danger' : ''), onClick: function () { retireFact(fact.id) }, disabled: busy !== '' },
+                  pendingRetire === fact.id ? '真的退役' : '退役',
+                ),
                 h('button', { className: 'sn-btn sn-btn-ghost', onClick: function () { setFactEdit({ id: fact.id, text: fact.text }) }, disabled: busy !== '' }, '改'),
               )
             : h('div', { key: 'state', className: 'sn-fact-cite' }, '状态：' + statusLabel(fact.status)),
@@ -794,6 +958,10 @@ window.__ModuleLoader__.load({
         return Math.round(hours / 24) + ' 天前'
       }
 
+      // 没调过 apply 时（或被外部刷新打断）也显示服务端的真值，别显示空白
+      var halfLifeShown = halfLife === '' ? String(state.halfLifeDays === undefined ? 30 : state.halfLifeDays) : halfLife
+      var profileMaxShown = profileMax === '' ? String((state.profile && state.profile.maxChars) || 110) : profileMax
+
       var settingsCard = h(
         'div',
         { className: 'sn-card', key: 'settings' },
@@ -829,6 +997,7 @@ window.__ModuleLoader__.load({
           h('input', {
             type: 'text',
             maxLength: 24,
+            'aria-label': '注入抬头，最多 24 个字，留空就不加抬头',
             value: heading,
             placeholder: '例：AI记忆',
             onChange: function (e) { setHeading(e.target.value) },
@@ -849,6 +1018,38 @@ window.__ModuleLoader__.load({
           h('button', { className: 'sn-btn', onClick: saveTempTtl, disabled: busy !== '' }, '保存保质期'),
         ),
         h('div', { className: 'sn-hint' }, '只对「临时」型自述生效（1–90 天，默认 14）。过了期不再自动进上下文，内容一个字都没删 —— 改成「稳定」或重写一条就回来。'),
+        h(
+          'div',
+          { className: 'sn-limits' },
+          h(
+            'label',
+            { className: 'sn-field' },
+            h('span', null, '结论半衰期（天）'),
+            h('input', {
+              type: 'number',
+              min: 1,
+              max: 365,
+              'aria-label': '结论半衰期，单位天，范围 1 到 365',
+              value: halfLifeShown,
+              onChange: function (e) { setHalfLife(e.target.value) },
+            }),
+          ),
+          h(
+            'label',
+            { className: 'sn-field' },
+            h('span', null, '画像上限（字）'),
+            h('input', {
+              type: 'number',
+              min: 20,
+              max: 120,
+              'aria-label': '画像上限，单位字，范围 20 到 120',
+              value: profileMaxShown,
+              onChange: function (e) { setProfileMax(e.target.value) },
+            }),
+          ),
+          h('button', { className: 'sn-btn', onClick: saveHalfLife, disabled: busy !== '' }, '保存这两项'),
+        ),
+        h('div', { className: 'sn-hint' }, '半衰期决定旧结论多久算「半凉」：越小越偏爱最近的。画像上限是「关于他」那段最多占多少字。'),
         h(
           'div',
           { className: 'sn-field sn-field-wide' },
@@ -856,6 +1057,7 @@ window.__ModuleLoader__.load({
           h('textarea', {
             rows: 2,
             maxLength: 80,
+            'aria-label': '什么时候该写自述，留空就用默认判据',
             value: noteGuide,
             placeholder: '例：每次改完一个插件、跑完验收之后写一条；闲聊不用写。',
             onChange: function (e) { setNoteGuide(e.target.value) },
@@ -923,6 +1125,7 @@ window.__ModuleLoader__.load({
           'div',
           { className: 'sn-kv' },
           kv('索引状态', h('span', { className: 'sn-kv-tag ' + idxTone }, idxStatus)),
+          kv('检索开关', h('span', { className: 'sn-kv-tag ' + (idx.enabled === true ? 'sn-kv-tag-ok' : 'sn-kv-tag-missing') }, idx.enabled === true ? '已启用' : '已关闭')),
           kv('已索引会话', String(idx.sessions ?? 0)),
           kv('磁盘会话', String(idx.disk ?? 0)),
           kv('待同步会话', String(idx.missing ?? 0)),
@@ -934,6 +1137,15 @@ window.__ModuleLoader__.load({
           'div',
           { className: 'sn-actions' },
           h('button', { className: 'sn-btn', onClick: rebuildIndex, disabled: busy !== '' }, busy === 'index' ? '重建中…' : '重建索引'),
+          h(
+            'button',
+            {
+              className: idx.enabled === true ? 'sn-btn sn-btn-ghost' : 'sn-btn',
+              onClick: function () { toggleIndex(idx.enabled !== true) },
+              disabled: busy !== '' || (idx.enabled !== true && idx.present !== true),
+            },
+            idx.enabled === true ? '关闭索引' : '启用索引',
+          ),
           h('span', { className: 'sn-grow' }),
           h('span', { className: 'sn-hint' }, idx.present === true && idx.fresh === false ? '过期时不会用索引查，会退回完整扫描' : '重建期间会占住几秒'),
         ),
@@ -1423,7 +1635,15 @@ window.__ModuleLoader__.load({
       var pTotalChars = p0Chars + p1Chars + pGap
       var pRestChars = Math.max(0, 320 - pTotalChars)
       var pL1Max = Math.max(0, 320 - Math.min(p0Chars, 80) - (p0Chars > 0 ? 1 : 0))
-      var correctionItems = (state.corrections && state.corrections.items) || []
+      var p2Chars = pinCount(personaValuesNow.l2)
+      // 超限不靠 maxLength 拦（它按 UTF-16 计，emoji 算两个），而是停掉「保存」并说明原因；
+      // 磁盘那关仍由服务端整份校验兜底 —— 这里只是别让人白点一次。
+      var pOver = p0Chars > 80 || pTotalChars > 320 || p0Chars + p1Chars + p2Chars > 8000
+      var firstPage = (state.corrections && state.corrections.items) || []
+      // 翻过页就把后面的接上；同一 id 只留第一条（翻页期间新证据插进来时会出现重复）
+      var correctionItems = firstPage.concat(moreEvidence).filter(function (item, at, list) {
+        return list.findIndex(function (other) { return other.id === item.id }) === at
+      })
       var pickedCount = pickedEvidence.length
 
       var personaCard = h(
@@ -1438,17 +1658,34 @@ window.__ModuleLoader__.load({
           { className: 'sn-hint' },
           'L0 ' + p0Chars + ' + L1 ' + p1Chars + (pGap ? ' + 换行 1' : '') + ' = ' + pTotalChars + ' / 320 字（余 ' + pRestChars + '）',
         ),
-        personaField('l2', 'L2 扩展设定', '外貌、服饰、世界观、兴趣。这一层不进每回合上下文；保存在同一个 persona.md 里，不占注入预算。', personaValuesNow.l2, Math.max(0, 8000 - pTotalChars), 6),
+        personaField('l2', 'L2 扩展设定', '外貌、服饰、世界观、兴趣。这一层不进每回合上下文；保存在同一个 persona.md 里，不占注入预算。', personaValuesNow.l2, (state.persona && state.persona.l2Limit) || Math.max(0, 8000 - pTotalChars), 6),
+        pOver
+          ? h(
+              'div',
+              { className: 'sn-hint-warn' },
+              '超了：'
+                + (p0Chars > 80 ? 'L0 超过 80 字；' : '')
+                + (pTotalChars > 320 ? 'L0 + L1 超过 320 字；' : '')
+                + (p0Chars + p1Chars + p2Chars > 8000 ? '整份超过 8000 字；' : '')
+                + '减到上限以内再保存，否则整份会被拒绝、一个字都不写。',
+            )
+          : null,
         h(
           'div',
           { className: 'sn-actions' },
-          h('button', { className: 'sn-btn', onClick: savePersona, disabled: busy !== '' }, '保存人格'),
+          h('button', { className: 'sn-btn', onClick: savePersona, disabled: busy !== '' || pOver }, '保存人格'),
           h('button', { className: 'sn-btn sn-btn-ghost', onClick: importPersona, disabled: busy !== '' }, '从 AGENT.md 导入'),
           h('span', { className: 'sn-grow' }),
           h('span', { className: 'sn-muted' }, '保存是整份校验：任一段不合格就一个字都不写。'),
         ),
 
-        h('div', { className: 'sn-sub' }, '纠偏候选（' + correctionItems.length + ' 条，这些只是证据）'),
+        h(
+          'div',
+          { className: 'sn-sub' },
+          '纠偏候选（' + ((state.corrections && state.corrections.total) || correctionItems.length) + ' 条，这些只是证据' +
+            (correctionItems.length < ((state.corrections && state.corrections.total) || 0) ? '，这里列了 ' + correctionItems.length + ' 条' : '') +
+            '）',
+        ),
         h(
           'div',
           { className: 'sn-hint' },
@@ -1482,10 +1719,19 @@ window.__ModuleLoader__.load({
           'div',
           { className: 'sn-actions' },
           h('button', { className: 'sn-btn sn-btn-ghost', onClick: draftRuleFromPicked, disabled: busy !== '' }, '用选中的 ' + pickedCount + ' 条写一条规则'),
+          h(
+            'button',
+            { className: 'sn-btn sn-btn-ghost', onClick: discardPicked, disabled: busy !== '' || pickedCount === 0 },
+            '丢弃选中的证据',
+          ),
+          (moreCursor !== null ? moreCursor !== '' : state.corrections && state.corrections.nextCursor)
+            ? h('button', { className: 'sn-btn sn-btn-ghost', onClick: loadMoreEvidence, disabled: busy !== '' }, busy === 'corrections' ? '翻页中…' : '加载更多')
+            : null,
         ),
         h('textarea', {
           className: 'sn-input',
           rows: 3,
+          'aria-label': '把选中的证据改写成一条规则',
           placeholder: '把上面几句改写成一条能照着做的规则，例如「回答时先举例，再给结论」。',
           value: ruleDraft,
           onChange: function (e) { setRuleDraft(e.target.value) },
@@ -1598,11 +1844,65 @@ window.__ModuleLoader__.load({
                   editingThis
                     ? null
                     : h('button', { className: 'sn-btn sn-btn-ghost', onClick: function () { setFactEdit({ id: fact.id, text: fact.text }) }, disabled: busy !== '' }, '改'),
-                  h('button', { className: 'sn-btn sn-btn-ghost', onClick: function () { setFact(fact.id, 'retired') }, disabled: busy !== '' }, '退役'),
+                  h(
+                    'button',
+                    { className: 'sn-btn sn-btn-ghost' + (pendingRetire === fact.id ? ' sn-btn-danger' : ''), onClick: function () { retireFact(fact.id) }, disabled: busy !== '' },
+                    pendingRetire === fact.id ? '真的退役' : '退役',
+                  ),
                 ),
               )
             }),
 
+        retiredFacts.length > 0
+          ? h(
+              'div',
+              null,
+              h('div', { className: 'sn-sub' }, '已退役（' + ((state.facts && state.facts.retiredCount) || retiredFacts.length) + '）'),
+              h(
+                'div',
+                { className: 'sn-hint' },
+                '退役只是不再进注入，条目本身还在文件里。想让它回来，点「恢复」。' +
+                  (retiredFacts.length < ((state.facts && state.facts.retiredCount) || 0)
+                    ? '（这里只列最近 ' + retiredFacts.length + ' 条）'
+                    : ''),
+              ),
+              h(
+                'button',
+                {
+                  type: 'button',
+                  className: 'sn-btn sn-btn-ghost',
+                  'aria-expanded': showRetired ? 'true' : 'false',
+                  onClick: function () { setShowRetired(!showRetired) },
+                },
+                showRetired ? '收起' : '展开这 ' + retiredFacts.length + ' 条',
+              ),
+              showRetired
+                ? h(
+                    'div',
+                    { className: 'sn-retired-list' },
+                    retiredFacts.map(function (fact) {
+                      return h(
+                        'div',
+                        { key: 'r-' + fact.id, className: 'sn-fact' },
+                        h('div', { className: 'sn-fact-text' }, fact.text),
+                        h(
+                          'div',
+                          { className: 'sn-actions' },
+                          h('span', { className: 'sn-heat' }, '退役于 ' + (fact.retiredAt || fact.updatedAt || '—')),
+                          h('span', { className: 'sn-grow' }),
+                          h(
+                            'button',
+                            { type: 'button', className: 'sn-btn', onClick: function () { setFact(fact.id, 'approved') }, disabled: busy !== '' },
+                            '恢复',
+                          ),
+                        ),
+                      )
+                    }),
+                  )
+                : null,
+            )
+          : null,
+
         (state.habits || []).length > 0
           ? h(
               'div',
@@ -1659,9 +1959,20 @@ window.__ModuleLoader__.load({
       var injSegments = inj.segments || []
       var skippedItems = []
       injSegments.forEach(function (seg) {
-        ;(seg.skipped || []).forEach(function (text) {
-          skippedItems.push({ seg: seg.label, text: text })
-        })
+        if (Array.isArray(seg.skippedDetail)) {
+          seg.skippedDetail.forEach(function (item) {
+            skippedItems.push({
+              seg: seg.label,
+              text: String((item && item.preview) ?? ''),
+              reason: String((item && item.reason) ?? ''),
+            })
+          })
+        } else {
+          // 兼容旧 /state：只有 skipped 字符串，没有原因，也不许白板
+          ;(seg.skipped || []).forEach(function (text) {
+            skippedItems.push({ seg: seg.label, text: String(text ?? ''), reason: '' })
+          })
+        }
       })
 
       var injectionCard = h(
@@ -1684,9 +1995,9 @@ window.__ModuleLoader__.load({
           'div',
           { className: 'sn-seg' },
           injSegments.map(function (seg) {
-            var skipped = seg.skipped || []
+            var skipped = Array.isArray(seg.skippedDetail) ? seg.skippedDetail : (seg.skipped || [])
             var stateText = seg.chars > 0 ? '全部进入' : '暂无内容'
-            if (skipped.length > 0) stateText = '挤掉 ' + skipped.length + ' 条'
+            if (skipped.length > 0) stateText = '跳过 ' + skipped.length + ' 条'
             else if (seg.chars === 0 && seg.absorbed > 0) stateText = '已被画像吸收 ' + seg.absorbed + ' 条'
             return h(
               'div',
@@ -1700,25 +2011,27 @@ window.__ModuleLoader__.load({
         h(
           'div',
           { className: 'sn-hint' },
-          '四段只算记忆本身的字数；标题、边界句、画像抬头这些框架文字另计（' + (inj.overhead || 0) + ' 字），也算在总字数里。',
+          '七段只算记忆本身的字数；标题、边界句、画像抬头这些框架文字另计（' + (inj.overhead || 0) + ' 字），也算在总字数里。',
         ),
         skippedItems.length === 0
           ? null
           : h(
-              'div',
+              'details',
               { className: 'sn-skipped' },
               h(
-                'div',
+                'summary',
                 { className: 'sn-skipped-head' },
-                '被挤掉的 ' + skippedItems.length + ' 条 —— 超出本段预算就整条跳过，不截半句（半句话会变成错结论）',
+                '被跳过的 ' + skippedItems.length + ' 条 —— 点开看每条为什么没进（每条都标了原因）',
               ),
               skippedItems.slice(0, 6).map(function (item, i) {
-                var text = item.text.length > 60 ? item.text.slice(0, 60) + '…' : item.text
+                // key 用下标：内容指纹派生 id，同段两条相同文本会撞 id（口径裁定 2）
+                var reasonLabel = { budget: '预算不足', expired: '已过期', scope: '项目不匹配', duplicate: '重复' }
                 return h(
                   'div',
                   { className: 'sn-skipped-row', key: 'sk' + i },
                   h('span', { className: 'sn-badge' }, item.seg),
-                  h('span', { className: 'sn-skipped-text' }, text),
+                  h('span', { className: 'sn-skipped-reason' }, reasonLabel[item.reason] || item.reason || '未说明'),
+                  h('span', { className: 'sn-skipped-text' }, item.text),
                 )
               }),
               skippedItems.length > 6 ? h('div', { className: 'sn-hint' }, '还有 ' + (skippedItems.length - 6) + ' 条没列出来') : null,
@@ -1854,7 +2167,13 @@ window.__ModuleLoader__.load({
           }),
         ),
 
-        h(Notice, { tone: notice && notice.tone, text: notice && notice.text }),
+        // 提示要贴顶：记忆页有二十多张卡，人在下半屏点「采纳 / 删除」，
+        // 反馈如果留在文档流顶部，就等于没反馈 —— 会重复点。
+        h(
+          'div',
+          { className: 'sn-notice-wrap', role: 'status', 'aria-live': 'polite' },
+          h(Notice, { tone: notice && notice.tone, text: notice && notice.text }),
+        ),
 
         h(
           'div',
@@ -1952,6 +2271,10 @@ window.__ModuleLoader__.load({
       '.sn-details summary{cursor:pointer;user-select:none}',
       '.sn-mono{font-family:ui-monospace,Menlo,Consolas,monospace;word-break:break-all;padding-top:4px}',
       '.sn-loading{padding:16px;font-size:12px;color:var(--dsw-alias-text-secondary,#9ca3af)}',
+      '.sn-loading-error{color:#991b1b}',
+      '.sn-notice-wrap{position:sticky;top:0;z-index:2}',
+      '.sn-notice-wrap>.sn-notice{box-shadow:0 1px 3px rgba(0,0,0,.08)}',
+      '.sn-retired-list{display:flex;flex-direction:column;gap:6px;margin-top:6px}',
       ".sn-fact-meta{display:flex;align-items:center;gap:8px;flex-wrap:wrap}",
       ".sn-badge{font-size:11px;background:#eef2ff;color:#3730a3;border-radius:999px;padding:1px 8px}",
       ".sn-fact-conflict{border-color:#fcd34d;background:#fffdf5}",
@@ -2026,8 +2349,9 @@ window.__ModuleLoader__.load({
       '.sn-seg-state{margin-left:auto;font-size:11px;color:var(--dsw-alias-text-secondary,#6b7280)}',
       '.sn-seg-state-warn{color:#b45309}',
       '.sn-skipped{display:flex;flex-direction:column;gap:6px;padding:8px 10px;border:1px dashed var(--dsw-alias-border-subtle,#e5e7eb);border-radius:8px}',
-      '.sn-skipped-head{font-size:11px;color:#92400e;line-height:1.6}',
-      '.sn-skipped-row{display:flex;align-items:flex-start;gap:8px;font-size:12px;line-height:1.6}',
+      '.sn-skipped-head{font-size:11.5px;color:#92400e;line-height:1.6;cursor:pointer}',
+      '.sn-skipped-row{display:flex;align-items:flex-start;gap:8px;font-size:12px;line-height:1.6;flex-wrap:wrap}',
+      '.sn-skipped-reason{font-size:11px;color:var(--dsw-alias-text-secondary,#6b7280);border:1px solid var(--dsw-alias-border-subtle,#e5e7eb);border-radius:999px;padding:0 6px;white-space:nowrap}',
       '.sn-skipped-text{color:var(--dsw-alias-text-secondary,#4b5563)}',
       '.sn-doc-list{display:flex;flex-direction:column;gap:8px}',
       '.sn-doc-row{display:flex;align-items:flex-start;gap:8px;font-size:12px;line-height:1.6;flex-wrap:wrap}',
@@ -2037,6 +2361,22 @@ window.__ModuleLoader__.load({
       '.sn-doc-error{background:#fef2f2;color:#b91c1c}',
       '.sn-doc-label{font-weight:600;color:var(--dsw-alias-text-primary,#111827)}',
       '.sn-doc-detail{flex:1;min-width:200px;color:var(--dsw-alias-text-secondary,#4b5563)}',
+      // —— 可读性与适配（原来是 11px + #9ca3af，在浅底上几乎要贴到屏幕上看）——
+      '.sn-hint{font-size:12px;color:var(--dsw-alias-text-secondary,#6b7280)}',
+      '.sn-hint-warn{font-size:12px}',
+      '.sn-date,.sn-file-meta,.sn-heat,.sn-evidence-meta,.sn-fact-cite,.sn-card-note{font-size:11.5px}',
+      '.sn-muted{color:var(--dsw-alias-text-secondary,#6b7280)}',
+      // 输入框以前写死 110px，抬头那种长文本被压成一条缝；宽度交给容器，只在窄屏才吃满
+      '.sn-field{flex-wrap:wrap}',
+      '.sn-field input,.sn-field textarea{width:auto;min-width:7em;max-width:100%}',
+      '.sn-field input[type=text],.sn-field textarea{min-width:14em;flex:1}',
+      // 行内操作按钮别藏到 hover 里：触屏没有 hover，键盘用户也未必摸到
+      '.sn-row-actions{opacity:.8}',
+      '@media (hover:none){.sn-row-actions{opacity:1}}',
+      '.sn-expired{color:var(--dsw-alias-text-secondary,#6b7280);border-color:var(--dsw-alias-border-subtle,#d1d5db)}',
+      '@media (max-width:520px){.sn-limits,.sn-row,.sn-actions{flex-wrap:wrap}.sn-field{width:100%}.sn-field input,.sn-field textarea{width:100%}.sn-card{padding:12px}}',
+      // 深色底：插件原先把浅色写死了，宿主切深色时这些块会白得刺眼
+      '@media (prefers-color-scheme:dark){.sn-notice-ok{background:#052e21;color:#a7f3d0}.sn-notice-warn{background:#3f1212;color:#fecaca}.sn-notice{background:var(--dsw-alias-bg-secondary,#1f2937)}.sn-badge,.sn-file-count,.sn-tab-on .sn-tab-badge{background:#1e1b4b;color:#c7d2fe}.sn-material,.sn-kv-tag-stale,.sn-pair-head,.sn-doc-next,.sn-skipped-head{background:#3b2a06;color:#fcd34d}.sn-kv-tag-ok{background:#052e21;color:#6ee7b7}.sn-doc-next{border-color:#92400e}.sn-fact-conflict{background:#2a2308;border-color:#92400e}.sn-doc-ok{background:#052e21;color:#6ee7b7}.sn-doc-error{background:#3f1212;color:#fecaca}.sn-doc-warn{background:#3b2a06;color:#fcd34d}}',
     ].join('\n')
 
     function apply(ctx) {

package/lib/explain.js

@@ -0,0 +1,73 @@
+import { createHash } from 'node:crypto'
+import { normalizeTier } from './store.js'
+
+export const SKIP_REASONS = Object.freeze(['budget', 'expired', 'scope', 'duplicate'])
+export const SKIP_PRIORITY = Object.freeze(['scope', 'expired', 'duplicate', 'budget'])
+export const CORE_PREVIEW = '素材层，不注入'
+export const PREVIEW_MAX_CHARS = 60
+
+// 六步规范（m05194）：纯函数，不含 Date / 随机 / locale。
+// ① 非字符串一律转字符串 ② NFKC 兼容等价 + 全角半角 ③ CRLF / 裸 CR → LF
+// ④ 去首尾空白（连带 BOM） ⑤ 连续空白折叠为一个空格 ⑥ 返回稳定文本
+export function normalizeForId(text) {
+  const s1 = String(text ?? '')
+  const s2 = s1.normalize('NFKC')
+  const s3 = s2.replace(/\r\n?/g, '\n')
+  const s4 = s3.trim()
+  const s5 = s4.replace(/\s+/gu, ' ')
+  return s5
+}
+
+export function contentId(text) {
+  return createHash('sha1').update(normalizeForId(text), 'utf8').digest('hex').slice(0, 12)
+}
+
+export function pickReason(flags = {}) {
+  for (const reason of SKIP_PRIORITY) {
+    if (flags[reason] === true) return reason
+  }
+  return null
+}
+
+export function skippedId(segmentKey, text) {
+  return String(segmentKey) + ':' + contentId(text)
+}
+
+// 只用于「展示预览」：按字素簇截，不切 surrogate pair / 组合字符 / ZWJ 序列。
+// 与六段预算的 countChars()（码点）是两把尺子，不许互相回灌。
+const SEGMENTER = new Intl.Segmenter('und', { granularity: 'grapheme' })
+
+export function previewOf(text, maxGraphemes = PREVIEW_MAX_CHARS) {
+  const s = String(text ?? '')
+  const parts = Array.from(SEGMENTER.segment(s), (part) => part.segment)
+  if (parts.length <= maxGraphemes) return s
+  return parts.slice(0, maxGraphemes).join('') + '…'
+}
+
+// 只读取已有打包结果做「事后分类」：绝不重新打包、不改候选集合 / 排序 / 预算 / 文本。
+// sources 与 skipped 同源、等长、逐位平行（由 packNotes() 在构造 skipped 的同一次调用里产出）。
+function flagsFor(source) {
+  return { scope: false, expired: source === 'expired', duplicate: false, budget: true }
+}
+
+export function describeSkipped({ key, skipped = [], sources = [], notes = [] } = {}) {
+  const list = Array.isArray(skipped) ? skipped : []
+  // 来源数组必须同源等长；缺一项就整批保守降级，宁可少报原因也不报错原因。
+  const src = Array.isArray(sources) && sources.length === list.length ? sources : []
+  const out = []
+  list.forEach((raw, i) => {
+    const text = String(raw ?? '')
+    const reason = pickReason(flagsFor(src[i] ?? null))
+    if (reason !== null) {
+      out.push({ id: skippedId(key, text), preview: previewOf(text), reason })
+    }
+  })
+  if (key === 'notes') {
+    const coreNotes = Array.isArray(notes) ? notes : []
+    for (const entry of coreNotes.filter((e) => normalizeTier(e?.tier) === 'core')) {
+      const text = String(entry?.text ?? '')
+      out.push({ id: skippedId(key, text), preview: CORE_PREVIEW, reason: 'budget' })
+    }
+  }
+  return out
+}

package/lib/index.js

@@ -54,6 +54,7 @@ import { discardByIds, listCorrections, readEvents, readWatermark } from './corr
 import { commitPersona, lockState, recover, runSerial } from './persona-tx.js'
 
 import { randomBytes, timingSafeEqual } from 'node:crypto'
+import { describeSkipped } from './explain.js'
 
 import { appendFileSync, existsSync, mkdirSync, readdirSync, readFileSync, statSync } from 'node:fs'
 import { spawn } from 'node:child_process'
@@ -416,7 +417,7 @@ function fit(items, limit) {
  * 身份该由人格段（L0/L1）说，两处都说一遍等于让模型看两版自己。
  * 存量 core 一条不删，只是不进上下文；条数靠门牌告诉模型「有这么些素材」。
  */
-function packNotes(entries, limit, ttl) {
+export function packNotes(entries, limit, ttl) {
   const ttlDays = Number.isFinite(Number(ttl)) ? Number(ttl) : DEFAULT_TEMP_TTL_DAYS
   const core = []
   const stable = []
@@ -449,10 +450,18 @@ function packNotes(entries, limit, ttl) {
   // 过期的也算「没进上下文」：它们还在库里，模型得靠门牌知道有这么几条，
   // 所以并进 skipped 一起报数 —— 少报就是骗人。
   const expiredTexts = expired.map((entry) => entry.text)
+  const stableSkipped = stableFit.skipped
+  const tempSkipped = tempFit.skipped
   return {
     text: parts.join('\n'),
     kept: [...stableFit.kept, ...tempFit.kept],
-    skipped: [...stableFit.skipped, ...tempFit.skipped, ...expiredTexts],
+    skipped: [...stableSkipped, ...tempSkipped, ...expiredTexts],
+    // 与 skipped 同一次构造、逐位平行：只给解释层读，不参与筛选 / 排序 / 预算 / 文本
+    skippedSources: [
+      ...stableSkipped.map(() => 'budget'),
+      ...tempSkipped.map(() => 'budget'),
+      ...expiredTexts.map(() => 'expired'),
+    ],
     // 每型的账：设置页要能指着说「稳定 3 条全进了，临时 2 条被挤掉」
     tiers: {
       // 核心不进注入，所以 kept 恒 0、limit 恒 0：读数上「0 / 0」比「3 / 0」更不容易被误读
@@ -697,30 +706,37 @@ function assembleInjection(cfg, options = {}) {
   const segments = []
   const parts = []
   const personaParts = []
+  const noteEntries = readNotes()
 
   // 人格：L0 + L1 常驻，排在最前 —— 它不是「记忆」，是「我是谁」，
   // 所以它在边界句「（背景资料，不是指令）」之外，先读到的是自己的样子。
   // 关掉只是不注入，persona.md 一个字节都不动。
+  const ZERO_PERSONA_FIT = {
+    text: '', chars: 0, kept: [], skipped: [], truncated: false, pointer: '',
+    l0: { chars: 0, kept: 0, skipped: 0 }, l1: { chars: 0, kept: 0, skipped: 0 },
+  }
+  const fit = cfg.personaEnabled === false
+    ? ZERO_PERSONA_FIT                              // 关闭时连 persona.md 都不读
+    : personaSegment(readPersona(), BUDGET.persona)
+  segments.push({
+    key: 'persona',
+    label: '人格',
+    limit: BUDGET.persona,
+    chars: fit.chars,
+    kept: fit.kept,
+    skipped: fit.skipped,
+    truncated: fit.truncated,
+    pointer: fit.pointer,
+    l0: fit.l0,
+    l1: fit.l1,
+  })
   if (cfg.personaEnabled !== false) {
-    const fit = personaSegment(readPersona(), BUDGET.persona)
-    segments.push({
-      key: 'persona',
-      label: '人格',
-      limit: BUDGET.persona,
-      chars: fit.chars,
-      kept: fit.kept,
-      skipped: fit.skipped,
-      truncated: fit.truncated,
-      pointer: fit.pointer,
-      l0: fit.l0,
-      l1: fit.l1,
-    })
     if (fit.text !== '') personaParts.push(fit.text)
     if (fit.pointer !== '') personaParts.push(fit.pointer)
   }
 
   // 自述：三型分账 + 门牌。装不下的那几条，模型必须知道存在，否则它会把「没看见」当成「没有」。
-  const noteFit = notesSegment(readNotes(), BUDGET.notes, cfg.tempTtlDays)
+  const noteFit = notesSegment(noteEntries, BUDGET.notes, cfg.tempTtlDays)
   segments.push({
     key: 'notes',
     label: '自述',
@@ -829,6 +845,18 @@ function assembleInjection(cfg, options = {}) {
   segments.push({ key: 'habits', label: '习惯', limit: BUDGET.habits, chars: countChars(habitFit.text), kept: habitFit.kept, skipped: habitFit.skipped })
   if (habitFit.text !== '') parts.push(habitFit.text)
 
+  // 解释元数据只挂在这一遍的 segments 上：预览那遍与真注入那遍各算各的，
+  // 不写全局、不落盘（D3），injectCache 仍只存 { key, text }。
+  for (const seg of segments) {
+    seg.skippedDetail = describeSkipped({
+      key: seg.key,
+      skipped: Array.isArray(seg.skipped) ? seg.skipped : [],
+      // 非 notes 段传空数组：describeSkipped 见长度不齐就整批保守降级成 budget，正是它们该有的值
+      sources: seg.key === 'notes' && Array.isArray(noteFit.skippedSources) ? noteFit.skippedSources : [],
+      notes: seg.key === 'notes' ? noteEntries : [],
+    })
+  }
+
   const heading = typeof cfg.heading === 'string' ? cfg.heading.trim() : DEFAULT_CONFIG.heading
   const body = parts.join('\n')
   // 边界句：让模型知道这一段是背景资料，不是有人在借记忆之名给它下命令。
@@ -950,6 +978,22 @@ export function readHeartbeat() {
   }
 }
 
+/**
+ * 记一次「注入文本真返回给模型」。这是与解释数据（skippedDetail）分开的独立观测口径：
+ * 同步 read-modify-write，中间没有 await，单进程内不会交错；state.json 不在 injectionKey()
+ * 的四个 stamps 里，写它不会让注入缓存失效；写失败静默，绝不影响原本的注入返回。
+ * 不用 heartbeat.injections（它有 60 秒节流，且缓存命中不写），也不用 seenCount / hitCount。
+ */
+function noteInjection(text) {
+  if (typeof text !== 'string' || text === '') return
+  try {
+    const state = readState()
+    const prev = Number(state.injectionCount)
+    const count = Number.isFinite(prev) ? prev + 1 : 1
+    writeState({ ...state, injectionCount: count, lastInjectedAt: new Date().toISOString() })
+  } catch { /* 计数失败绝不影响注入 */ }
+}
+
 function beat(extra = {}) {
   const now = Date.now()
   if (now - lastBeat < HEARTBEAT_MS) return
@@ -1115,6 +1159,8 @@ function personaStateOf(inline = false) {
     // L0 与 L1 之间那个换行也算字数（与注入、校验同一把尺子），
     // 否则界面按「320 - L0」给出上限，填满了也存不进去。
     l1Limit: Math.max(0, PERSONA_TOTAL - Math.min(l0Chars, PERSONA_L0_MAX) - (l0Chars > 0 ? 1 : 0)),
+    // L2 的上限得跟服务端同一个尺子：界面上写 8000 而这里按 chars 算，才不会两边对不上
+    l2Limit: Math.max(0, MAX_PERSONA_CHARS - (l0Chars + l1Chars + l2Chars)),
     fileLimit: MAX_PERSONA_CHARS,
     sectionless: persona.sectionless === true,
     truncated: l0Chars > PERSONA_L0_MAX,
@@ -1128,15 +1174,17 @@ function correctionsStateOf() {
   try {
     const events = readEvents()
     const watermark = readWatermark()
+    const page = listCorrections({ limit: 30 })
     return {
       total: events.length,
       unused: events.filter((entry) => !entry.used).length,
       lastScannedAt: String(watermark?.lastScannedAt ?? ''),
       // 界面靠这个列表渲染勾选区；只给计数的话「证据 → 规则」那条链路整段不可用
-      items: listCorrections({ limit: 30 }).items,
+      items: page.items,
+      nextCursor: page.nextCursor,
     }
   } catch {
-    return { total: 0, unused: 0, lastScannedAt: '', items: [] }
+    return { total: 0, unused: 0, lastScannedAt: '', items: [], nextCursor: null }
   }
 }
 
@@ -1238,7 +1286,7 @@ function doctorState(inline) {
       }
     }
     if (broken > 0 || noText > 0) {
-      push('facts', '记忆文件完整性', 'error', `${broken} 行解析不出来、${noText} 条没有正文 —— 这些记忆读不到`, '从 .bak 恢复或手工修')
+      push('facts', '记忆文件完整性', 'error', `${broken} 行解析不出来、${noText} 条没有正文 —— 这些记忆读不到`, '先复制一份 facts.jsonl，再手工删掉那几行（坏行只影响它自己）')
     } else {
       push('facts', '记忆文件完整性', 'ok', `${lines.length} 行全部可解析`)
     }
@@ -1439,6 +1487,7 @@ function buildInjection(inline, ctx) {
     const text = composeInjection(inline, { sessionId, spotlight })
     // 补偿只补一次：这一轮真贴进去了，才把标记清掉（失败的话下一轮还有机会）
     if (spotlight.length > 0) compactionPending.delete(sessionId)
+    noteInjection(text)
     return text
   } catch (error) {
     return ''
@@ -1734,6 +1783,8 @@ function stateOfInner(inline) {
   const builtNow = cfg.enabled ? assembleInjection(cfg) : null
   // facts.jsonl 也只读一次（下面候选/已采纳/退役/归属四张卡片共用）
   const factsNow = listFacts()
+  // 计数是另一条观测口径：只读一次计数文件，不参与注入解释数据的组装
+  const injectionStats = readState()
   return {
     ok: true,
     enabled: cfg.enabled,
@@ -1746,6 +1797,7 @@ function stateOfInner(inline) {
     // 每行带上「到期没有」：设置页要能把过期的临时自述标出来，而不是让人以为它这回合还在
     notes: readNotes().map((entry) => ({ ...entry, expired: isExpiredNote(entry, cfg.tempTtlDays) })),
     tempTtlDays: cfg.tempTtlDays,
+    halfLifeDays: cfg.halfLifeDays,
     noteGuide: cfg.noteGuide,
     notesLastWrite: s.lastWrite,
     notesFile: s.notesFile,
@@ -1762,6 +1814,8 @@ function stateOfInner(inline) {
     corrections: correctionsStateOf(),
     budget: budgetOf(inline),
     injection: injectionState(inline, builtNow),
+    injectionCount: Number.isFinite(Number(injectionStats.injectionCount)) ? Number(injectionStats.injectionCount) : 0,
+    lastInjectedAt: typeof injectionStats.lastInjectedAt === 'string' ? injectionStats.lastInjectedAt : '',
     attribution: attributionState(inline, builtNow, factsNow),
     profile: profileState(inline),
     facts: {

package/lib/persona.js

@@ -73,11 +73,17 @@ export function parsePersona(raw) {
 
   const blocks = { l0: [], l1: [], l2: [] }
   const orphan = []
+  const seen = new Set()
   let current = null
 
   for (const line of text.split('\n')) {
     const tier = tierOfLine(line)
-    if (tier !== null) {
+    // 分节规则：某一层第一次出现才算换节；同一层再出现且当前就在这一层，仍按合段处理
+    // （手写文件里把规则拆成两段 L1 是常见写法）。但若某一层已经出现、当前却在别的层，
+    // 那这一行是正文 —— 否则正文里一句「## L0 …」会把上一段整段抢走，round-trip 就丢层级了。
+    const isHeading = tier !== null && (!seen.has(tier) || tier === current)
+    if (isHeading) {
+      seen.add(tier)
       current = tier
       blocks[tier].push([])
       continue

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "dsh-selfnote",
-  "version": "0.14.0",
+  "version": "0.14.2",
   "type": "module",
   "description": "Self-narrative memory for DeepSeek Harness: the model writes notes to itself, which persist across sessions and are injected back. | 人格库：模型写给自己看的话，跨会话保留并每回合注入。",
   "keywords": [
@@ -27,7 +27,7 @@
     "assets"
   ],
   "scripts": {
-    "test": "node tests/smoke.mjs && node tests/memory.mjs && node tests/roles.mjs && node tests/heat.mjs && node tests/fair.mjs && node tests/capture-debug.mjs && node tests/facts-tx.mjs && node tests/crash-write.mjs && node tests/capture.mjs && node tests/capture-p1b.mjs && node tests/index.mjs && node tests/incremental.mjs && node tests/profile.mjs && node tests/warm.mjs && node tests/transfer.mjs && node tests/api.mjs && node tests/notes-tier.mjs && node tests/persona.mjs && node tests/corrections.mjs && node tests/client-state.mjs && node tests/client.mjs",
+    "test": "node tests/smoke.mjs && node tests/memory.mjs && node tests/roles.mjs && node tests/heat.mjs && node tests/fair.mjs && node tests/capture-debug.mjs && node tests/facts-tx.mjs && node tests/crash-write.mjs && node tests/capture.mjs && node tests/capture-p1b.mjs && node tests/index.mjs && node tests/incremental.mjs && node tests/profile.mjs && node tests/warm.mjs && node tests/transfer.mjs && node tests/api.mjs && node tests/explain.mjs && node tests/skipped.mjs && node tests/injection-count.mjs && node tests/notes-tier.mjs && node tests/persona.mjs && node tests/corrections.mjs && node tests/client-state.mjs && node tests/client.mjs",
     "test:accept": "node tests/acceptance-runtime.mjs"
   },
   "engines": {