dsh-selfnote 0.14.1 → 0.14.3

package/lib/explain.js

@@ -0,0 +1,77 @@
+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 的同一次调用里产出）。
+// 旧版这里恒给 budget:true，pickReason() 就永远有结果、下面的 if 永远进不去 else ——
+// 一个不可达分支。现在按来源如实展开：认不出的（含缺失）才回落 budget。
+function flagsFor(source) {
+  return {
+    scope: source === 'scope',
+    expired: source === 'expired',
+    duplicate: source === 'duplicate',
+    budget: source === 'budget' || !SKIP_REASONS.includes(source),
+  }
+}
+
+export function describeSkipped({ key, skipped = [], sources = [], notes = [] } = {}) {
+  const list = Array.isArray(skipped) ? skipped : []
+  // 来源数组必须同源等长；缺一项就整批保守降级，宁可少报原因也不报错原因。
+  // 降级在这里显式做，调用方不必靠「故意传空数组触发长度不齐」这种暗号。
+  const src = Array.isArray(sources) && sources.length === list.length ? sources : null
+  const out = list.map((raw, i) => {
+    const text = String(raw ?? '')
+    return { id: skippedId(key, text), preview: previewOf(text), reason: pickReason(flagsFor(src === null ? null : (src[i] ?? null))) }
+  })
+  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-store.js

@@ -326,9 +326,9 @@ export function ensureIndex(options = {}) {
 export function queryIndex(index, terms) {
   const buckets = []
   for (const term of terms) {
-    const hits = index.postings?.[term]
-    if (hits === undefined) buckets.push([])
-    else buckets.push(hits)
+    const postings = index.postings ?? {}
+    const hits = Object.hasOwn(postings, term) && Array.isArray(postings[term]) ? postings[term] : []
+    buckets.push(hits)
   }
   if (buckets.length === 0) return { ids: [], degraded: false }
 
@@ -365,7 +365,7 @@ export function indexStats(sessions = listSessions()) {
   const disk = sessions.length
   // 优先走门牌文件：几十 KB，免得为了报数字去解析 10 MB 索引
   const meta = readIndexMeta()
-  if (meta !== null) {
+  if (meta !== null && existsSync(indexPath())) {
     const state = freshnessOfSessions(meta.sessions ?? {}, sessions)
     return {
       present: true,

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'
@@ -93,7 +94,7 @@ import { buildProfile } from './profile.js'
 import { writeAtomic } from './atomic.js'
 import { cursorPath, enqueue, isDelegatedSession, readCursor } from './capture.js'
 import { searchWarm, warmStats, writeSummary } from './warm.js'
-import { buildBundle, mergeBundle, mergePersona, validateBundle } from './transfer.js'
+import { buildBundle, mergeBundle, mergeConfig, mergePersona, validateBundle } from './transfer.js'
 import { handleEvent } from './capture-run.js'
 
 export const name = 'selfnote'
@@ -239,7 +240,7 @@ function currentConfig(inline) {
     maxEntries: Number.isFinite(maxEntries) && maxEntries > 0 ? Math.min(maxEntries, 200) : DEFAULT_MAX_ENTRIES,
     profileEnabled: merged.profileEnabled !== false,
     personaEnabled: merged.personaEnabled !== false,
-    profileOverride: typeof merged.profileOverride === 'string' ? merged.profileOverride.trim().slice(0, 240) : '',
+    profileOverride: typeof merged.profileOverride === 'string' ? [...merged.profileOverride.trim()].slice(0, 240).join('') : '',
     profileMaxChars: Number.isFinite(Number(merged.profileMaxChars))
       ? Math.max(20, Math.min(Number(merged.profileMaxChars), 120))
       : DEFAULT_CONFIG.profileMaxChars,
@@ -249,7 +250,7 @@ function currentConfig(inline) {
     // 老版本把这句 28 字的抬头写进了 config.json。它只干一件事，现在默认 6 字。
     // 存的正好是老默认 → 跟着换代；用户自己改过的（不等于老默认）一个字都不动。
     heading: merged.heading === LEGACY_HEADING ? DEFAULT_CONFIG.heading : merged.heading,
-    noteGuide: typeof merged.noteGuide === 'string' ? merged.noteGuide.trim().slice(0, GUIDE_LIMIT) : '',
+    noteGuide: typeof merged.noteGuide === 'string' ? [...merged.noteGuide.trim()].slice(0, GUIDE_LIMIT).join('') : '',
     tempTtlDays: Number.isFinite(Number(merged.tempTtlDays))
       ? Math.max(1, Math.min(Math.round(Number(merged.tempTtlDays)), 90))
       : DEFAULT_TEMP_TTL_DAYS,
@@ -299,11 +300,11 @@ function packEnv(items, limit) {
   for (const item of items) {
     const body = String(item.text ?? '').trim()
     if (body === '') continue
-    if (used + body.length > limit) {
+    if (used + countChars(body) > limit) {
       skipped.push(body)
       continue
     }
-    used += body.length + 1
+    used += countChars(body) + 1
     kept.push(body)
     ids.push(item.id)
     text = text === '' ? body : `${text}；${body}`
@@ -354,7 +355,7 @@ function packEnvFair(items, limit, spotlight = new Set()) {
   let plan = arrange(reserve)
   const head = plan.warm[0] ?? plan.cold[0]
   if (head !== undefined) {
-    const floor = String(head.text ?? '').trim().length + 1
+    const floor = countChars(String(head.text ?? '').trim()) + 1
     if (floor > reserve) {
       reserve = Math.min(Math.floor(cap / 2), floor)
       plan = arrange(reserve)
@@ -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」更不容易被误读
@@ -491,8 +500,8 @@ function notesSegment(entries, limit, ttl) {
   let pointer = ''
   for (let pass = 0; pass < 3; pass += 1) {
     const next = `另有 ${current.skipped.length} 条自述没装进来（self_note read）`
-    if (next.length + 1 >= room) break
-    const refit = packNotes(entries, Math.max(0, room - next.length - 1), ttl)
+    if (countChars(next) + 1 >= room) break
+    const refit = packNotes(entries, Math.max(0, room - countChars(next) - 1), ttl)
     const converged = refit.skipped.length === current.skipped.length
     pointer = next
     const joined = { ...refit, text: refit.text === '' ? next : `${refit.text} ${next}` }
@@ -656,8 +665,8 @@ function factsSegment(ranked, limit) {
   let pointer = ''
   for (let pass = 0; pass < 3; pass += 1) {
     const next = `另有 ${current.skipped.length} 条结论（memory_recall 查）`
-    if (next.length + 1 >= limit) break
-    const refit = packFacts(ranked, Math.max(0, limit - next.length - 1))
+    if (countChars(next) + 1 >= limit) break
+    const refit = packFacts(ranked, Math.max(0, limit - countChars(next) - 1))
     const converged = refit.skipped.length === current.skipped.length
     pointer = next
     current = { ...refit, text: refit.text === '' ? next : `${refit.text} ${next}` }
@@ -680,12 +689,13 @@ function injectionKey(cfg) {
       return file + ':-'
     }
   })
-  const profileKey = [cfg.profileEnabled, cfg.profileMaxChars, cfg.profileOverride.length, cfg.profileOverride].join('~')
+  const profileKey = [cfg.profileEnabled, cfg.profileMaxChars, countChars(cfg.profileOverride), cfg.profileOverride].join('~')
   // 临时自述会自己到期：文件一个字没改，跨过保质期那天注入也得重算。
   // 按「天」进键就够了，不必精确到毫秒 —— 一天最多重算一次。
-  const dayKey = 'd' + Math.floor(Date.now() / 86400000)
+  const now = new Date()
+  const dayKey = 'd' + now.getFullYear() + '-' + (now.getMonth() + 1) + '-' + now.getDate()
   // 半衰期也影响排序（facts / env 段按热度排），不改文件只改它时也得重算
-  return stamps.join('|') + '|' + cfg.enabled + '|' + cfg.personaEnabled + '|' + cfg.heading + '|' + profileKey + '|hl' + cfg.halfLifeDays + '|ttl' + cfg.tempTtlDays + '|' + dayKey
+  return stamps.join('|') + '|' + cfg.enabled + '|' + cfg.personaEnabled + '|' + cfg.heading + '|' + profileKey + '|hl' + cfg.halfLifeDays + '|ttl' + cfg.tempTtlDays + '|guide' + cfg.noteGuide + '|' + dayKey
 }
 
 /**
@@ -697,30 +707,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: '自述',
@@ -740,7 +757,7 @@ function assembleInjection(cfg, options = {}) {
     key: 'guide',
     label: '写自述的时机',
     limit: GUIDE_LIMIT,
-    chars: guideText.length,
+    chars: countChars(guideText),
     kept: guideText === '' ? [] : [guideText],
     skipped: [],
   })
@@ -755,7 +772,7 @@ function assembleInjection(cfg, options = {}) {
     key: 'profile',
     label: '画像',
     limit: BUDGET.profile,
-    chars: profileText.length,
+    chars: countChars(profileText),
     kept: profileText === '' ? [] : [profileText],
     skipped: [],
   })
@@ -771,7 +788,7 @@ function assembleInjection(cfg, options = {}) {
   // 反复用「这次剩几条」重算门牌，直到条数不再变。不然那句「另有 N 条」会少报。
   for (let pass = 0; pass < 3 && env.skipped.length > 0; pass += 1) {
     const pointer = `另有 ${env.skipped.length} 条环境备忘没装进来（memory_recall 查）`
-    const refit = packEnvFair(envRanked, Math.max(0, BUDGET.env - pointer.length - 1), spotlight)
+    const refit = packEnvFair(envRanked, Math.max(0, BUDGET.env - countChars(pointer) - 1), spotlight)
     const text = refit.text === '' ? pointer : `${refit.text}；${pointer}`
     const converged = refit.skipped.length === env.skipped.length
     env = { ...refit, text }
@@ -829,6 +846,20 @@ 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 段没有逐条来源：显式给等长的 budget 数组，不再靠「传空触发长度不齐」这种暗号
+      sources: seg.key === 'notes' && Array.isArray(noteFit.skippedSources)
+        ? noteFit.skippedSources
+        : (Array.isArray(seg.skipped) ? seg.skipped : []).map(() => 'budget'),
+      notes: seg.key === 'notes' ? noteEntries : [],
+    })
+  }
+
   const heading = typeof cfg.heading === 'string' ? cfg.heading.trim() : DEFAULT_CONFIG.heading
   const body = parts.join('\n')
   // 边界句：让模型知道这一段是背景资料，不是有人在借记忆之名给它下命令。
@@ -950,6 +981,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 +1289,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 +1490,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 +1786,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 +1817,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: {
@@ -1800,7 +1852,7 @@ function currentProfile(cfg) {
   const config = cfg ?? currentConfig()
   if (config.profileEnabled !== true) return { text: '', parts: [], conflicts: [], sources: [], chars: 0, manual: false }
   if (config.profileOverride !== '') {
-    return { text: config.profileOverride, parts: [], conflicts: [], sources: [], chars: config.profileOverride.length, manual: true }
+    return { text: config.profileOverride, parts: [], conflicts: [], sources: [], chars: countChars(config.profileOverride), manual: true }
   }
   const built = buildProfile(listFacts(), { maxChars: config.profileMaxChars })
   return { ...built, manual: false }
@@ -1867,22 +1919,42 @@ const TIER_WORD = { core: '核心身份', stable: '稳定偏好', temp: '临时
 function noteCapacityWarning(tier, text, inline) {
   const cfg = currentConfig(inline)
   if (cfg.enabled === false) return '注入已关闭，这条暂时不会进上下文。'
-  const key = normalizeTier(tier)
-  const body = String(text ?? '')
+  const entries = readNotes()
+  // 调用点在 appendNote 之后：最后一条就是刚写的。旧版在这里又凭空补一条，
+  // 等于把新条试装了两遍、额度算得偏紧；现在直接用落盘后的真实列表。
+  const last = entries.at(-1)
+  const key = normalizeTier(last?.tier ?? tier)
+  const body = String(last?.text ?? text ?? '')
   // 核心是素材，不进注入：这时候说「超了额度」是骗人，得直接说清楚它去哪儿了
   if (key === 'core') {
     return '核心身份不再参与注入（它是提炼人格的素材）—— 想让它每回合生效，写进人格段：self_note action:"persona"。'
   }
-  // 拿真实额度试装一次：把这条当成已经写进去，看它自己进不进得来。
+  // 拿真实额度试装一次：看这条自己进不进得来。
   // 光比「整段 200 字」不够 —— 稳定先占一份、临时只留 1/4 保底，
   // 一条 110 字的临时自述会顺利通过 200 字的检查，然后每回合被静默跳过。
-  const probe = packNotes([...readNotes(), { tier: key, text: body }], BUDGET.notes, cfg.tempTtlDays)
-  if (probe.kept.includes(body)) return ''
-  const info = probe.tiers[key]
-  if (body.length > info.limit) {
-    return `这条 ${body.length} 字，超过${TIER_WORD[key]}段这轮实际能用的 ${info.limit} 字（整段 ${BUDGET.notes} 字，别的型先占了位），模型每回合都看不到它 —— 要么写短，要么拆成几条。`
+  const probe = packNotes(entries, BUDGET.notes, cfg.tempTtlDays)
+  if (!probe.kept.includes(body)) {
+    const info = probe.tiers[key]
+    if (countChars(body) > info.limit) {
+      return `这条 ${countChars(body)} 字，超过${TIER_WORD[key]}段这轮实际能用的 ${info.limit} 字（整段 ${BUDGET.notes} 字，别的型先占了位），模型每回合都看不到它 —— 要么写短，要么拆成几条。`
+    }
+    return `${TIER_WORD[key]}现在共 ${info.total} 条，这轮有 ${info.skipped} 条被挤掉（排在前面的才进上下文）。`
+  }
+  // 自己进来了，不等于没出事：线上翻过一次 —— 一条 95 字长条自己进得来，
+  // 却把原本全进的短规则挤了出去；旧版只问「这条进不进得来」，于是一声不吭。
+  // 拿「写入前」的列表打包做基线，按文本多重集比少了哪些条（同文重复也算得清）。
+  const before = packNotes(entries.slice(0, -1), BUDGET.notes, cfg.tempTtlDays)
+  const pool = new Map()
+  for (const kept of probe.kept) pool.set(kept, (pool.get(kept) ?? 0) + 1)
+  pool.set(body, (pool.get(body) ?? 0) - 1) // 新写的那一份本来就不在基线里
+  let displaced = 0
+  for (const kept of before.kept) {
+    const left = pool.get(kept) ?? 0
+    if (left > 0) pool.set(kept, left - 1)
+    else displaced += 1
   }
-  return `${TIER_WORD[key]}现在共 ${info.total} 条，这轮有 ${info.skipped} 条被挤掉（排在前面的才进上下文）。`
+  if (displaced === 0) return ''
+  return `这条 ${countChars(body)} 字自己进了上下文，但把 ${displaced} 条自述挤掉了（排在前面的才进上下文）—— 写短些，或先把旧规则整理归档。`
 }
 
 function renderText(args, value) {
@@ -2169,7 +2241,7 @@ export function currentAuthInjection() {
 function injectTokenScript(html) {
   if (authToken === '') return html
   if (html.includes('__DSH_SELFNOTE_TOKEN__')) return html
-  const script = `<script>window.__DSH_SELFNOTE_TOKEN__=${JSON.stringify(authToken)}</script>`
+  const script = `<script>window.__DSH_SELFNOTE_TOKEN__=${JSON.stringify(authToken).replace(/</g, '\\u003c')}</script>`
   if (html.includes('</head>')) {
     authInjected = 'head'
     return html.replace('</head>', `${script}</head>`)
@@ -2394,7 +2466,7 @@ export function apply(ctx, config) {
             return {
               action,
               entries: entries.length,
-              chars: renderNotes(entries).length,
+              chars: countChars(renderNotes(entries)),
               maxChars: limits.maxChars,
               text: renderNotes(entries),
             }
@@ -2613,7 +2685,7 @@ export function apply(ctx, config) {
               if (typeof body.heading === 'string') {
                 const value = body.heading.trim()
                 // 抬头是注入的第一行，长度不设限等于让人用一句话吃掉整个预算
-                if (value.length > HEADING_LIMIT) {
+                if (countChars(value) > HEADING_LIMIT) {
                   return sendJson(res, 400, { ok: false, error: `抬头不能超过 ${HEADING_LIMIT} 字` })
                 }
                 next.heading = value
@@ -2622,7 +2694,7 @@ export function apply(ctx, config) {
                 if (typeof body.noteGuide !== 'string') {
                   return sendJson(res, 400, { ok: false, error: 'noteGuide 要是字符串' })
                 }
-                if (body.noteGuide.trim().length > GUIDE_LIMIT) {
+                if (countChars(body.noteGuide.trim()) > GUIDE_LIMIT) {
                   return sendJson(res, 400, { ok: false, error: `noteGuide 不能超过 ${GUIDE_LIMIT} 字` })
                 }
                 next.noteGuide = body.noteGuide.trim()
@@ -2632,7 +2704,7 @@ export function apply(ctx, config) {
                 if (typeof body.profileOverride !== 'string') {
                   return sendJson(res, 400, { ok: false, error: 'profileOverride 要是字符串' })
                 }
-                next.profileOverride = body.profileOverride.slice(0, 240)
+                next.profileOverride = [...body.profileOverride].slice(0, 240).join('')
               }
               if (body.halfLifeDays !== undefined) {
                 const value = Number(body.halfLifeDays)
@@ -2663,7 +2735,7 @@ export function apply(ctx, config) {
               const text = typeof body?.text === 'string' ? body.text.trim() : ''
               if (text === '') return sendJson(res, 400, { ok: false, error: '内容不能为空' })
               const result = appendNote(text, limitsOf(currentConfig(inline)), { tier: body?.tier, pin: body?.pin })
-              auditAction('note-add', { tier: result.tier, pin: result.pin, chars: text.length }, req)
+              auditAction('note-add', { tier: result.tier, pin: result.pin, chars: countChars(text) }, req)
               return sendJson(res, 200, {
                 ...stateOf(inline),
                 noteAdd: { tier: result.tier, pin: result.pin, warning: noteCapacityWarning(result.tier, text, inline) },
@@ -2752,7 +2824,8 @@ export function apply(ctx, config) {
                   return sendJson(res, 400, { ok: false, error: `导入包里的人格用不了：${verdict.error}` })
                 }
               }
-              const limits = limitsOf(currentConfig(inline))
+              const configPlan = mergeConfig(incoming, readConfig())
+              const limits = limitsOf({ ...currentConfig(inline), ...configPlan.config })
               const before = { notes: readNotes().length, facts: listFacts().length, habits: readHabits().length }
               const merged = mergeBundle(
                 incoming,
@@ -2765,6 +2838,7 @@ export function apply(ctx, config) {
               const { kept: trimmedNotes } = trim(merged.notes, limits)
               writeNotes(trimmedNotes)
               writeHabits(merged.habits)
+              if (configPlan.applied.length > 0) writeConfig({ ...readConfig(), ...configPlan.config })
               // 人格：目标空就采用，一模一样就跳过，两边都有且不同就落旁路文件 —— 不覆盖
               let personaFile = ''
               if (personaPlan.action === 'adopt') {
@@ -2786,6 +2860,7 @@ export function apply(ctx, config) {
                 after: { notes: trimmedNotes.length, facts: merged.facts.length, habits: merged.habits.length },
                 persona: { action: personaPlan.action, file: personaFile },
                 indexStale: true,
+                configApplied: configPlan.applied.length,
               }
               auditAction('import', { added: merged.added, keepStatus: merged.keepStatus }, req)
               return sendJson(res, 200, { ...stateOf(inline), import: report })

package/lib/memory.js

@@ -25,6 +25,7 @@ import { join } from 'node:path'
 import { zstdDecompressSync } from 'node:zlib'
 
 import { writeAtomic, writeJsonAtomic } from './atomic.js'
+import { countChars } from './store.js'
 
 const SESSION_FILE = 'session.v4.jsonl.zstd'
 /** 缓存格式版本：解析规则变了就 +1，旧缓存自动作废。 */
@@ -759,7 +760,7 @@ export function mutateFacts(mutate, attempts = 5, deadlineMs = 150) {
 export function stageFact(input = {}) {
   const text = String(input.text ?? '').trim()
   if (text === '') return { ok: false, error: 'text 不能为空' }
-  if (text.length > 240) return { ok: false, error: '一条事实最多 240 字，拆成两条' }
+  if (countChars(text) > 240) return { ok: false, error: '一条事实最多 240 字，拆成两条' }
   const check = checkCitation(input.citation)
   if (!check.ok) return { ok: false, error: check.error }
 
@@ -798,7 +799,7 @@ export function stageFact(input = {}) {
 export function setFactText(id, text, meta = {}) {
   const clean = String(text ?? '').replace(/\s+/g, ' ').trim()
   if (clean === '') return { ok: false, error: '内容不能为空' }
-  if (clean.length > 240) return { ok: false, error: '一条事实最多 240 字，拆成两条' }
+  if (countChars(clean) > 240) return { ok: false, error: '一条事实最多 240 字，拆成两条' }
   let before = ''
   let updated = null
   const outcome = mutateFacts((facts) => {
@@ -885,8 +886,9 @@ export function touchFacts(ids, now = Date.now()) {
   // 而 'YYYY-MM-DD' 解析出来是当天 00:00 —— 过了午夜那一小时窗口就永远失效，
   // 每装配一次都会 +1（实测 25 分钟能连涨 3 次，把「进过几次」记成「算过几次」）。
   const stamp = new Date(now).toISOString()
-  // 热度是软数据：抢不到锁就这回合先不记（lastHit 没变，下一回合还会再试），
-  // 别为了记一次点击把事件循环卡住 —— 所以给它的重试窗口比别的写入短。
+  // 热度是软数据：抢不到锁就这回合先不记（lastHit 没变，下一回合还会再试）。
+  // 机会比硬写少（2 次 vs 5 次），但每次等锁的窗口给足：20ms 在 16 并发下几乎必输，
+  // test:accept 曾因此偶发「热度没落下：t2（返回 0）」。
   const outcome = mutateFacts((facts) => {
     let changed = 0
     for (const fact of facts) {
@@ -898,7 +900,7 @@ export function touchFacts(ids, now = Date.now()) {
       changed += 1
     }
     return { changed: changed > 0, count: changed }
-  }, 2, 20)
+  }, 2, 150)
   return outcome.count ?? 0
 }
 
@@ -915,7 +917,7 @@ export function seenFacts(ids, now = Date.now()) {
   const wanted = new Set(ids ?? [])
   if (wanted.size === 0) return 0
   const stamp = new Date(now).toISOString()
-  // 和 touchFacts 一样是软写入：抢不到锁就这次先不记，别为一次记账卡住事件循环。
+  // 和 touchFacts 一样是软写入：2 次机会、每次等锁 150ms，抢不到就这次先不记。
   const outcome = mutateFacts((facts) => {
     let changed = 0
     for (const fact of facts) {
@@ -927,7 +929,7 @@ export function seenFacts(ids, now = Date.now()) {
       changed += 1
     }
     return { changed: changed > 0, count: changed }
-  }, 2, 20)
+  }, 2, 150)
   return outcome.count ?? 0
 }
 
@@ -978,7 +980,7 @@ export function setHabit(text, status, tag) {
   const wanted = String(status ?? '')
   const clean = String(text ?? '').trim()
   if (clean === '') return { ok: false, error: 'text 不能为空' }
-  if (clean.length > 80) return { ok: false, error: '一条习惯最多 80 字' }
+  if (countChars(clean) > 80) return { ok: false, error: '一条习惯最多 80 字' }
   if (!['active', 'retired'].includes(wanted)) return { ok: false, error: 'status 只能是 active / retired' }
 
   const habits = readHabits()

package/lib/persona-tx.js

@@ -7,7 +7,7 @@
  * 恢复时只是「把文件写成目标状态」，重放多少次结果都一样。
  */
 import { createHash, randomBytes } from 'node:crypto'
-import { closeSync, existsSync, openSync, readFileSync, renameSync, statSync, unlinkSync, writeSync } from 'node:fs'
+import { closeSync, existsSync, openSync, readFileSync, renameSync, statSync, unlinkSync, writeFileSync, writeSync } from 'node:fs'
 import { join } from 'node:path'
 import { selfnoteRoot } from './store.js'
 import { writeAtomic, writeJsonAtomic } from './atomic.js'
@@ -111,7 +111,8 @@ export function lockState(now = Date.now()) {
   } catch {
     return { exists: true, stale: true, pid: 0, ageMs: 0 }
   }
-  const stale = !pidAlive(pid) || !Number.isFinite(ageMs) || ageMs > STALE_LOCK_MS
+  const empty = (() => { try { return readFileSync(LOCK_PATH, 'utf8').trim() === '' } catch { return false } })()
+  const stale = !empty && (!pidAlive(pid) || !Number.isFinite(ageMs) || ageMs > STALE_LOCK_MS)
   return { exists: true, stale, pid: Number.isInteger(pid) ? pid : 0, ageMs }
 }
 
@@ -128,29 +129,19 @@ function clearStaleLock() {
 
 /** 跨进程互斥：O_EXCL 建锁，拿不到就是「有人正在保存」，直接报错而不是排队等死。 */
 export async function withPersonaLock(job) {
-  let fd
   try {
-    fd = openSync(LOCK_PATH, 'wx')
+    writeFileSync(LOCK_PATH, String(process.pid), { flag: 'wx' })
   } catch (error) {
     if (error?.code !== 'EEXIST') throw error
     // 上次被强杀的残留锁：清掉再试一次，否则「保存人格」会永久 409
     if (!clearStaleLock()) throw new LockedError()
     try {
-      fd = openSync(LOCK_PATH, 'wx')
+      writeFileSync(LOCK_PATH, String(process.pid), { flag: 'wx' })
     } catch (retryError) {
       if (retryError?.code === 'EEXIST') throw new LockedError()
       throw retryError
     }
   }
-  try {
-    try {
-      writeSync(fd, String(process.pid))
-    } catch {
-      // 写不进去不影响互斥本身
-    }
-  } finally {
-    closeSync(fd)
-  }
   try {
     return await job()
   } finally {

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