dsh-selfnote 0.12.1 → 0.13.0

package/README.md

@@ -266,6 +266,12 @@ DSH 的会话文件是**逐条追写**的 zstd 序列（一次写入 = 一个 fr
 
 放不下就跳过那一条、继续试后面的（不截半句）；环境条目放不下时只留一句门牌「另有 N 条环境备忘（memory_recall 查）」，让模型知道「你有这些记忆」，而不是假装没有。
 
+**环境段分账**：只按热度排会形成马太效应 —— 进过一次的条目 hitCount 更高、下一轮还进，从没进过的永远排在后面（实测 4 条吃满 292 字，另外 10 条一次没进过：记忆存了，模型不知道它存在）。所以环境段是分两笔花：先按热度装四分之三，剩下那份留给「从没进过 / 最久没进过」的条目，按 lastHit 排队、一轮轮换。四分之一只是起点，不是硬指标 —— 真实备忘动辄 80–120 字，四分之一连一条都塞不下等于没预留，所以还会自动抬高到「刚好装得下下一个该轮到的」那条，最多占一半，不把热的挤空。用不完的额度还给热的，不浪费。
+
+真的进过一次的会被记账（lastHit 更新），下一轮自然排到冷门队尾，轮到下一条 —— 这是轮转，不是加权随机。
+
+**压缩之后补一次**：上下文一压缩，刚聊过的记忆就被挤出窗口；而注入按文件变化命中缓存，不会自己重贴。所以插件记着「这个会话最近注入过哪些条目」，一旦收到 `compaction/summary` 或 `compaction/prune`（且压缩没失败），下一轮就把这些条目重新排到环境段最前面补一遍，补完即清 —— 只补一次，不会每一轮都重提旧账。补偿文本单独占一份缓存键，不会粘在普通注入的缓存上。
+
 另有可选的第六段「写自述的时机」：只有你在设置页填了自定义引导才出现，原样一行、上限 80 字，**算在 800 之外**（因为它不是记忆，是指令）。
 
 设置页显示本回合实际注入多少、各段占多少。注入文本按「三份文件的 mtime + 大小 + 配置」缓存，没变就不重算 —— 省算力，也让系统提示词前缀稳定、吃得到缓存。带上大小是因为同一毫秒里改两次时 mtime 可能没变，那样会继续用上一份旧文本，看起来就是「改了没生效」。

package/lib/index.js

@@ -214,7 +214,74 @@ function packEnv(items, limit) {
     ids.push(item.id)
     text = text === '' ? body : `${text}；${body}`
   }
-  return { text, kept, skipped, ids }
+  return { text, kept, skipped, ids, used }
+}
+
+/**
+ * 冷门条目在环境段里预留多少份额。
+ *
+ * 只按热度排会形成马太效应：进过一次的 hitCount 就 +1、热度更高、下一轮还进；
+ * 一次没进过的永远排在后面。实测 4 条吃满了 292 字，另外 10 条一次没进过 ——
+ * 记忆存进去了，模型却不知道它存在。所以环境段不让「热的」吃满：
+ * 先按热度装 limit 的 3/4，剩下 1/4 留给「从没进过 / 最久没进过」的。
+ */
+export const ENV_RESERVE_RATIO = 0.25
+
+function lastHitOf(item) {
+  const raw = item?.lastHit
+  const parsed = raw === null || raw === undefined ? NaN : Date.parse(raw)
+  // 从没进过就用 0 当排名（比任何真实时间戳都早）。
+  // 不能用 -Infinity：两个 -Infinity 相减得 NaN，比较器一乱，冷门队列就退化成热度顺序了。
+  return Number.isFinite(parsed) ? parsed : 0
+}
+
+/**
+ * 环境段分账打包：热的先占 3/4，冷门的用剩下的（从最久没进过的开始排队）。
+ * spotlight 是这一轮要重点回顾的 id（压缩之后用），它们排在冷门队伍最前面。
+ * 冷门那份用不完就还给热的 —— 不浪费预算。
+ *
+ * 1/4 只是起点，不是硬指标：真实的备忘动辄 80–120 字，1/4 连一条都塞不下，
+ * 「预留了」却什么都没发生（实测对着真数据跑，9 条从没进过的一条也进不来）。
+ * 所以再加一条下限 —— 保证**下一个该轮到的**那条进得来（不是「最短的那条」：
+ * 打包是按队列顺序试的，队首太长就轮不到后面那些短的）。最多占到一半，别把热的挤空。
+ */
+function packEnvFair(items, limit, spotlight = new Set()) {
+  const cap = Math.max(0, limit)
+  const arrange = (reserve) => {
+    const base = packEnv(items, Math.max(0, cap - reserve))
+    const rest = items.filter((item) => !base.ids.includes(item.id))
+    const warm = rest.filter((item) => spotlight.has(item.id))
+    const cold = rest.filter((item) => !spotlight.has(item.id))
+    // 从没进过的排最前，然后是最久没进过的：进过一次就会被记账，下轮自然排到队尾
+    cold.sort((a, b) => lastHitOf(a) - lastHitOf(b) || a.heat - b.heat)
+    return { base, warm, cold }
+  }
+  let reserve = Math.floor(cap * ENV_RESERVE_RATIO)
+  let plan = arrange(reserve)
+  const head = plan.warm[0] ?? plan.cold[0]
+  if (head !== undefined) {
+    const floor = String(head.text ?? '').trim().length + 1
+    if (floor > reserve) {
+      reserve = Math.min(Math.floor(cap / 2), floor)
+      plan = arrange(reserve)
+    }
+  }
+  const { base, warm, cold } = plan
+  const extra = packEnv([...warm, ...cold], Math.max(0, cap - base.used))
+  const ids = [...base.ids, ...extra.ids]
+  const inText = new Set(ids)
+  const skipped = items
+    .filter((item) => !inText.has(item.id))
+    .map((item) => String(item.text ?? '').trim())
+    .filter((body) => body !== '')
+  return {
+    text: [base.text, extra.text].filter((part) => part !== '').join('；'),
+    kept: [...base.kept, ...extra.kept],
+    skipped,
+    ids,
+    reserve,
+    spotlit: warm.filter((item) => extra.ids.includes(item.id)).map((item) => item.id),
+  }
 }
 
 /**
@@ -266,7 +333,8 @@ function injectionKey(cfg) {
  * 组装这一回合要注入的整段文本，同时报出每段进了什么、挤掉了什么。
  * 纯函数：不写盘、不记热度 —— 设置页可以随时拿它照镜子，不会副作用。
  */
-function assembleInjection(cfg) {
+function assembleInjection(cfg, options = {}) {
+  const spotlight = options.spotlight instanceof Set ? options.spotlight : new Set(options.spotlight ?? [])
   const segments = []
   const parts = []
 
@@ -312,12 +380,13 @@ function assembleInjection(cfg) {
   const envRanked = envForInjection(cfg)
   // 环境条目往往比预算长，全塞进来会把自述挤掉。所以：热的短的进上下文，
   // 剩下的只留一句门牌「另有 N 条」——告诉模型「你有这些记忆，去查」，而不是假装没有。
-  let env = packEnv(envRanked, BUDGET.env)
+  // 打分账打包而不是纯热度：热的吃 3/4，冷的吃 1/4，否则冷门条目一辈子轮不到。
+  let env = packEnvFair(envRanked, BUDGET.env, spotlight)
   // 门牌句自己也要占字，加进去以后可能又多挤掉一条 —— 所以要收敛：
   // 反复用「这次剩几条」重算门牌，直到条数不再变。不然那句「另有 N 条」会少报。
   for (let pass = 0; pass < 3 && env.skipped.length > 0; pass += 1) {
     const pointer = `另有 ${env.skipped.length} 条环境备忘（memory_recall 查）`
-    const refit = packEnv(envRanked, Math.max(0, BUDGET.env - pointer.length - 1))
+    const refit = packEnvFair(envRanked, Math.max(0, BUDGET.env - pointer.length - 1), spotlight)
     const text = refit.text === '' ? pointer : `${refit.text}；${pointer}`
     const converged = refit.skipped.length === env.skipped.length
     env = { ...refit, text }
@@ -331,6 +400,9 @@ function assembleInjection(cfg) {
     chars: env.text.length,
     kept: env.kept,
     skipped: env.skipped,
+    // 分账信息：设置页能看出「1/4 预留」有没有真的分出去、这轮回顾了哪几条
+    reserve: env.reserve,
+    spotlit: env.spotlit,
   })
   if (envLine !== '') parts.push(envLine)
 
@@ -504,14 +576,59 @@ function beat(extra = {}) {
   }
 }
 
-/** 注入文本：模型每次装配提示词都会调用。命中缓存时不读文件、不计算。 */
-function composeInjection(inline) {
+/**
+ * 压缩之后要补的话。
+ *
+ * 上下文一压缩，刚聊过的记忆就被挤出了窗口 —— 而注入按「哪几个文件变了」命中缓存，
+ * 该重新贴的事实没人提醒。所以记两样：每个会话最近一次注入过哪些条目、哪些会话刚压缩过；
+ * 压缩后的下一轮把用过的条目再提一遍（spotlight），提完就清，只补一次。
+ */
+const lastInjectedBySession = new Map()
+const compactionPending = new Map()
+const COMPACTION_EVENTS = new Set(['compaction/summary', 'compaction/prune', 'compaction/end'])
+const MAX_SESSION_TRACKED = 200
+
+function trimSessionMap(map) {
+  while (map.size > MAX_SESSION_TRACKED) map.delete(map.keys().next().value)
+}
+
+/** 压缩事件到达时按会话打个标记：下一轮照这个会话用过的东西补一遍。 */
+function noteCompaction(sessionId, event) {
+  const type = String(event?.type ?? '')
+  if (!COMPACTION_EVENTS.has(type)) return
+  // 压缩失败/中止时窗口里还有原文，补了是重复
+  const data = event?.data
+  if (data !== null && typeof data === 'object' && 'error' in data && data.error !== undefined) return
+  compactionPending.set(sessionId, { at: Date.now(), ids: [...(lastInjectedBySession.get(sessionId) ?? [])] })
+  trimSessionMap(compactionPending)
+}
+
+/** 这轮要回顾哪些条目：先看一眼，真注入成功了再清（只补一次）。 */
+function peekSpotlight(sessionId) {
+  const pending = sessionId === '' ? undefined : compactionPending.get(sessionId)
+  return pending === undefined ? [] : [...pending.ids]
+}
+
+/**
+ * 注入文本：模型每次装配提示词都会调用。命中缓存时不读文件、不计算。
+ */
+function composeInjection(inline, options = {}) {
   const cfg = currentConfig(inline)
   if (!cfg.enabled) return ''
-  const key = injectionKey(cfg)
+  const sessionId = typeof options.sessionId === 'string' ? options.sessionId : ''
+  const spotlight = Array.isArray(options.spotlight) ? options.spotlight : []
+  // 压缩补偿只对那一个会话、那一轮有效：带上会话和条目才能跟普通注入分开缓存。
+  // 这一段必须挂在写完之后的键上一起存（见下），否则补偿文本会被存成普通键，
+  // 一直粘在缓存里 —— 补一次就变成补一辈子。
+  const suffix = spotlight.length > 0 ? '|sn' + sessionId + ':' + spotlight.join(',') : ''
+  const key = injectionKey(cfg) + suffix
   if (injectCache.key === key) return injectCache.text
 
-  const built = assembleInjection(cfg)
+  const built = assembleInjection(cfg, { spotlight: new Set(spotlight) })
+  if (sessionId !== '') {
+    lastInjectedBySession.set(sessionId, [...built.factIds])
+    trimSessionMap(lastInjectedBySession)
+  }
   // 真注入过一次才打心跳：这是「插件在跑」唯一的物证
   beat({ chars: built.chars, facts: built.factIds.length })
   if (built.text === '') {
@@ -527,7 +644,7 @@ function composeInjection(inline) {
   if (built.factIds.length > 0) {
     try {
       touchFacts(built.factIds)
-      keyAfter = injectionKey(cfg)
+      keyAfter = injectionKey(cfg) + suffix
     } catch {
       /* 记账失败不影响注入 */
     }
@@ -749,6 +866,17 @@ function injectionAgentIsDelegated(ctx) {
   }
 }
 
+/** 当前这一轮是哪个会话在问 —— 压缩补偿要按会话算。 */
+function currentSessionId(ctx) {
+  try {
+    const agent = ctx?.agents?.currentInitiator?.()
+    const id = agent?.session?.header?.id ?? agent?.session?.id
+    return typeof id === 'string' ? id : ''
+  } catch {
+    return ''
+  }
+}
+
 /** 故障隔离：记忆坏了也不许拖垮对话，注入失败就当没有记忆。 */
 function buildInjection(inline, ctx) {
   try {
@@ -758,7 +886,12 @@ function buildInjection(inline, ctx) {
       delegatedSkips += 1
       return ''
     }
-    return composeInjection(inline)
+    const sessionId = currentSessionId(ctx)
+    const spotlight = peekSpotlight(sessionId)
+    const text = composeInjection(inline, { sessionId, spotlight })
+    // 补偿只补一次：这一轮真贴进去了，才把标记清掉（失败的话下一轮还有机会）
+    if (spotlight.length > 0) compactionPending.delete(sessionId)
+    return text
   } catch (error) {
     return ''
   }
@@ -1113,7 +1246,13 @@ function factsForInjection(cfg) {
 /** 环境备忘：机器路径、账号、踩过的坑 —— 与「这个人是谁」分开注入，不占画像。 */
 function envForInjection(cfg) {
   const pool = listFacts('approved').filter((fact) => fact.channel === 'env')
-  return rankByHeat(pool, { halfLifeDays: cfg.halfLifeDays }).map(({ fact, heat }) => ({ id: fact.id, text: fact.text, heat }))
+  // 带上 lastHit：冷门那 1/4 按「谁最久没进过」排队，只有热度是不够的
+  return rankByHeat(pool, { halfLifeDays: cfg.halfLifeDays }).map(({ fact, heat }) => ({
+    id: fact.id,
+    text: fact.text,
+    heat,
+    lastHit: fact.lastHit ?? null,
+  }))
 }
 
 function currentProfileText(cfg) {
@@ -1126,10 +1265,8 @@ function budgetOf(inline) {
   if (!cfg.enabled) return { total: 0, limit: TOTAL_BUDGET, notes: 0, profile: 0, env: 0, facts: 0, habits: 0, enabled: false, caps: { ...BUDGET } }
   const notes = fit(readNotes().slice().reverse().map((entry) => entry.text), BUDGET.notes)
   const profile = currentProfile(cfg)
-  const env = fit(
-    envForInjection(cfg).map((item) => item.text),
-    BUDGET.env,
-  )
+  // 和 assembleInjection 用同一套分账打包，否则设置页的读数跟真注入对不上
+  const env = packEnvFair(envForInjection(cfg), BUDGET.env).text
   const facts = fit(
     factsForInjection(cfg).map((item) => item.text),
     BUDGET.facts,
@@ -2069,6 +2206,8 @@ export function apply(ctx, config) {
       captureDebug.lastKeys = event !== null && typeof event === 'object' ? Object.keys(event).slice(0, 12) : null
       const sessionId = session?.id
       if (typeof sessionId !== 'string' || sessionId === '') return
+      // 压缩发生了就记一笔：下一轮把这个会话用过的记忆再贴一遍
+      noteCompaction(sessionId, event)
       // 同一会话按到达顺序串行，避免 seq=11 先完成把游标推到 11、把 seq=10 挤掉
       enqueue(sessionId, () =>
         handleEvent(event, {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "dsh-selfnote",
-  "version": "0.12.1",
+  "version": "0.13.0",
   "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/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/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/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/client-state.mjs && node tests/client.mjs",
     "test:accept": "node tests/acceptance-runtime.mjs"
   },
   "engines": {