dsh-selfnote 0.14.1 → 0.14.2

package/README.md

@@ -10,10 +10,10 @@
 </p>
 
 <p align="center">
-  <img src="https://img.shields.io/badge/version-0.14.1-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-290%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              # 290 项，21 个文件，无外部依赖
+node --run test              # 280 项，24 个文件，无外部依赖
 node --run test:accept       # 12 项：真实 HTTP + 36 进程并发写
 ```
 

package/lib/client.js

@@ -483,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) },
@@ -1634,6 +1635,10 @@ 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 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) {
@@ -1654,10 +1659,21 @@ window.__ModuleLoader__.load({
           'L0 ' + p0Chars + ' + L1 ' + p1Chars + (pGap ? ' + 换行 1' : '') + ' = ' + pTotalChars + ' / 320 字（余 ' + pRestChars + '）',
         ),
         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' }, '保存是整份校验：任一段不合格就一个字都不写。'),
@@ -1943,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(
@@ -1968,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',
@@ -1984,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,
@@ -2320,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}',

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
@@ -1242,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} 行全部可解析`)
     }
@@ -1443,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 ''
@@ -1738,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,
@@ -1767,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.1",
+  "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": {