dsh-memory-tiers 0.5.1 → 0.8.2

package/memory5.mjs

@@ -1,7 +1,7 @@
 /**
  * 四层记忆 v5 —— 二次重构骨架
  *
- * 与 memory4 的区别（详见 REFACTOR_PLAN.md）：
+ * 与 memory4 的区别（详见 ARCHITECTURE.md）：
  *   1. 三层活跃流水线：及时层 → 巩固层 → 长久层
  *   2. 层用单一 `layer` 字段表达，不再用 weight × tier 交叉
  *   3. 新增 heat（热度）+ 按天去重的提及计数，替代"一次性判定 importance"
@@ -58,7 +58,7 @@ const ACTIVE_ORDER = [LAYER.HOT, LAYER.CONSOLIDATE, LAYER.LONG]
 // ============================================================
 // 配置
 //
-// heat 相关参数由 tune.mjs 扫描 32 组得出，见 REFACTOR_PLAN D12。
+// heat 相关参数由 tune.mjs 扫描 32 组得出，结论见 ARCHITECTURE.md 第 4 节。
 // ============================================================
 
 export const DEFAULTS = {
@@ -79,6 +79,12 @@ export const DEFAULTS = {
   //   这个参数留着只是为了兼容旧配置，改成任何值都不影响行为。
   consolidateDays: 0,         // 已弃用（0 = 不按时间触发）
   longMaxChars: 2000,         // 长久层上限，超了往 DL3 沉
+
+  // ★ L3 视图（DL3 → L3 的排序）重算间隔，默认 30 分钟。
+  //   这是全局唯一需要节流的东西，原因见 l3View 的注释：
+  //   L3 在上下文里排最前，它一变，后面 L2 / L1 的前缀缓存全断；
+  //   而 L1 / L2 本来每轮都在变且排在末尾，节流它们没有意义。
+  viewRefreshMs: 30 * 60 * 1000,
   dl2MaxChars: 12000,         // DL2（重要原文库）上限，超了就压缩字数
   dl2CompressTarget: 400,     // 单条超过这么多字才值得压缩
   allowModelCompress: false,  // ★ 默认不许用模型压缩：实测一个字都减不掉，纯烧钱
@@ -192,7 +198,11 @@ export function dayKey(ts) {
 
 let __seq = 0
 let __idn = 0
-const nextId = () => `m5_${(++__idn).toString(36)}_${Date.now().toString(36).slice(-4)}`
+// 尾部那 4 位随机是给「多进程共享一个库」用的：__idn 是进程内计数器，
+// 两个进程（dsh + astrbot）都从 1 开始，纯计数器必然撞 id。
+// 加了随机数后同毫秒同序号撞上的概率约 1/1.7e6，可忽略。
+const nextId = () =>
+  `m5_${(++__idn).toString(36)}_${Date.now().toString(36).slice(-4)}${Math.random().toString(36).slice(2, 6)}`
 
 export function makeItem({
   text,
@@ -481,7 +491,7 @@ export function decideConsolidateRoute(item, now = Date.now(), cfg = DEFAULTS) {
 //   audit.log                  每次写入/迁移/遗忘一行
 // ============================================================
 
-import { readFileSync, writeFileSync, mkdirSync, existsSync, unlinkSync, readdirSync, renameSync } from 'node:fs'
+import { readFileSync, writeFileSync, mkdirSync, existsSync, unlinkSync, readdirSync, renameSync, statSync } from 'node:fs'
 import { join, dirname } from 'node:path'
 
 // ★ 向量分片（2026-10-31）
@@ -498,37 +508,116 @@ import { join, dirname } from 'node:path'
 //   （写分片 + 旧文件改名 .bak，保留回退，下次不再读）。
 //   这条是给已在跑的 .big / 线上库用的，不要删。
 const VEC_SHARD_SIZE = 5000
-const VEC_SHARD_RE = /^vectors-part-(\d{4})\.json$/
+const VEC_SHARD_RE = /^vectors-part-(\d{4})\.json$/          // 旧版无前缀
 const vecShardName = (i) => `vectors-part-${String(i).padStart(4, '0')}.json`
 
+// ★ 多写者（2026-11-01）：每个写者只写自己那份文件，读的时候把所有人的合并起来看。
+//   这样两个进程同时跑也不需要锁——谁也不覆盖谁。
+//   writer 名字只留 [a-z0-9_-]，因为它会进文件名。
+const VEC_ANY_RE = /^vectors-(.+)-part-(\d{4})\.json$/
+const vecOwnRe = (w) => new RegExp(`^vectors-${w}-part-(\\d{4})\\.json$`)
+const vecOwnName = (w, i) => `vectors-${w}-part-${String(i).padStart(4, '0')}.json`
+const sanitizeWriter = (w) =>
+  String(w || '').trim().replace(/[^A-Za-z0-9_-]/g, '').slice(0, 32) || 'default'
+const STORE_RE = /^store-([A-Za-z0-9_-]+)\.json$/
+const storeOwnName = (w) => `store-${w}.json`
+
 export function createStore(dir, opts = {}) {
   // ★ 向量指纹：记录这批向量是哪个 embedding 模型生成的。
   //
-  //   为什么必须有：hashEmbed、Qwen3-Embedding-0.6B、bge-m3 **都是 1024 维**。
+  //   为什么必须有：Qwen3-Embedding-0.6B、bge-m3 **都是 1024 维**。
   //   换模型时 cosine() 里 `a.length !== b.length` 这个检查不会触发，
   //   旧向量会被当成合法向量参与计算，静默算出垃圾相似度——
   //   不报错、不崩，只是"检索结果越来越怪"，最难查的那种坏。
   //
   //   指纹不符 → 隔离旧向量 + 从零重建，宁可暂时没有语义检索也不给错的结果。
   const signature = typeof opts.signature === 'string' ? opts.signature : null
+  const writer = sanitizeWriter(opts.writer)
   mkdirSync(dir, { recursive: true })
   mkdirSync(join(dir, 'archive'), { recursive: true })
   mkdirSync(join(dir, 'graveyard'), { recursive: true })
 
-  const storePath = join(dir, 'store.json')
-  const vecPath = join(dir, 'vectors.json')   // 旧版单文件：只读兼容 + 迁移用
-  const metaPath = join(dir, 'vectors.meta.json')
+  const storePath = join(dir, storeOwnName(writer))   // 自己的分片
+  const legacyStorePath = join(dir, 'store.json')     // 旧版单文件：只迁移一次
+  const vecPath = join(dir, 'vectors.json')           // 旧版单文件向量
+  const metaPath = join(dir, `vectors-${writer}.meta.json`)
+  const legacyMetaPath = join(dir, 'vectors.meta.json')
 
   let state = { version: 5, seq: 0, items: [] }
   let vectors = new Map()
 
-  if (existsSync(storePath)) {
+  const listDir = () => { try { return readdirSync(dir) } catch { return [] } }
+
+  function readShard(p) {
     try {
-      const raw = JSON.parse(readFileSync(storePath, 'utf8'))
-      if (raw && Array.isArray(raw.items)) state = raw
-    } catch { /* 坏了就当空库，不让它挡住启动 */ }
+      const raw = JSON.parse(readFileSync(p, 'utf8'))
+      return raw && Array.isArray(raw.items) ? raw : null
+    } catch { return null }   // 单个分片坏了跳过，不让别的写者连累自己
   }
 
+  /** 别人的分片：只读，标上 __foreign，写回时会被排除 */
+  function loadForeign() {
+    const out = []
+    for (const f of listDir()) {
+      const m = f.match(STORE_RE)
+      if (!m || m[1] === writer) continue
+      const raw = readShard(join(dir, f))
+      if (!raw) continue
+      for (const it of raw.items) { it.__foreign = true; out.push(it) }
+    }
+    return out
+  }
+
+  /**
+   * 把别人的最新内容合并进来（他们可能刚写了新东西）。
+   *
+   * ★ 为什么需要：对方的条目是**启动时和他每次落盘时**才读进来的，
+   *   不刷新的话 dsh 会一直看不见 astrbot 刚记的东西。
+   * ★ 为什么带 TTL：全量 re-read 别人的分片有磁盘开销，
+   *   检索/注入每次都刷太浪费；15 秒一次足够"感觉是实时的"。
+   */
+  // 别人的分片"指纹"：文件名 + 修改时间 + 大小。
+  // 只要没变就不重读——比定时刷新准（对方一写就能看见），也比每次都读便宜。
+  let foreignSig = ''
+  let gen = 0            // 条目集合换过一代就 +1，上层缓存（分层索引）据此失效
+  function foreignSignature() {
+    let sig = ''
+    try {
+      for (const f of readdirSync(dir)) {
+        const m = f.match(STORE_RE)
+        if (!m || m[1] === writer) continue
+        try {
+          const st = statSync(join(dir, f))
+          sig += `${f}:${st.mtimeMs}:${st.size};`
+        } catch { sig += `${f}:?;` }
+      }
+    } catch { /* 列不出目录就当没变 */ }
+    return sig
+  }
+  function refreshForeign() {
+    const own = state.items.filter((it) => !it.__foreign)
+    state.items = own.concat(loadForeign())
+    foreignSig = foreignSignature()
+    gen++
+  }
+  /** 别人的文件动过才重读。检索 / 注入 / 统计前调一下就行，代价是几次 stat */
+  function maybeRefreshForeign() {
+    const sig = foreignSignature()
+    if (sig === foreignSig) return false
+    refreshForeign()
+    return true
+  }
+  foreignSig = foreignSignature()
+
+  // 自己的数据：优先自己的分片；没有就认领旧版 store.json（只在还没有任何
+  // store-*.json 时认领一次，否则第二个写者会把同一份数据领走变成双份）。
+  let own = readShard(storePath)
+  if (!own && existsSync(legacyStorePath) && !listDir().some((f) => STORE_RE.test(f))) {
+    own = readShard(legacyStorePath)
+  }
+  if (own) state = own
+  state.items = (state.items || []).concat(loadForeign())
+
   function readVecMeta() {
     try { return JSON.parse(readFileSync(metaPath, 'utf8')) } catch { return null }
   }
@@ -549,12 +638,13 @@ export function createStore(dir, opts = {}) {
   /** 指纹不符时把旧向量整体挪走（不删，留给用户回退/核对） */
   function quarantineVectors(reason) {
     const stamp = new Date().toISOString().replace(/[:.]/g, '-')
-    const bak = join(dir, `vectors.stale-${stamp}`)
+    const bak = join(dir, `vectors.stale-${writer}-${stamp}`)
     let moved = 0
     try {
       mkdirSync(bak, { recursive: true })
-      for (const f of readdirSync(dir)) {
-        if (!VEC_SHARD_RE.test(f) && f !== 'vectors.meta.json') continue
+      for (const f of listDir()) {
+        // 只隔离自己的：别人的向量我们没有资格动
+        if (!vecOwnRe(writer).test(f) && f !== `vectors-${writer}.meta.json`) continue
         try { renameSync(join(dir, f), join(bak, f)); moved++ } catch { /* 单个失败不阻塞 */ }
       }
     } catch { /* 建不了备份目录就原地不动，下面也不加载 */ }
@@ -562,11 +652,26 @@ export function createStore(dir, opts = {}) {
     return bak
   }
 
-  /** 读全部分片；没有任何分片返回 null（交给旧文件兼容逻辑） */
+  /** 读自己的分片；没有任何分片返回 null（交给旧文件兼容逻辑） */
   function readVecShards() {
-    let files
-    try { files = readdirSync(dir) } catch { return null }
-    const shards = files.filter((f) => VEC_SHARD_RE.test(f)).sort()
+    let files = listDir()
+    const re = vecOwnRe(writer)
+    let shards = files.filter((f) => re.test(f)).sort()
+    if (!shards.length) {
+      // 首次迁移：目录里只有旧的无前缀分片，且还没有别的写者 → 认领为自己的
+      const legacy = files.filter((f) => VEC_SHARD_RE.test(f))
+      const others = files.filter((f) => VEC_ANY_RE.test(f) && !re.test(f))
+      if (legacy.length && !others.length) {
+        for (const f of legacy) {
+          try { renameSync(join(dir, f), join(dir, vecOwnName(writer, Number(f.match(VEC_SHARD_RE)[1])))) } catch { /* 认领失败就跳过 */ }
+        }
+        if (!existsSync(metaPath) && existsSync(legacyMetaPath)) {
+          try { renameSync(legacyMetaPath, metaPath) } catch { /* 同上 */ }
+        }
+        files = listDir()
+        shards = files.filter((f) => re.test(f)).sort()
+      }
+    }
     if (!shards.length) return null
     const out = new Map()
     for (const f of shards) {
@@ -583,6 +688,9 @@ export function createStore(dir, opts = {}) {
 
   /** 全量重写分片；条目变少时把多余旧片删掉 */
   function writeVecShards() {
+    // 没有模型时不碰任何向量文件：现有向量可能是真模型生成的，
+    // 用户接回模型后还能直接用，不能被一次空表覆盖掉。
+    if (vectorsDisabled) return 0
     const entries = [...vectors.entries()]
     const shardCount = Math.ceil(entries.length / VEC_SHARD_SIZE)
     for (let i = 0; i < shardCount; i++) {
@@ -590,11 +698,12 @@ export function createStore(dir, opts = {}) {
       for (const [k, v] of entries.slice(i * VEC_SHARD_SIZE, (i + 1) * VEC_SHARD_SIZE)) {
         out[k] = Buffer.from(v.buffer, v.byteOffset, v.byteLength).toString('base64')
       }
-      writeFileSync(join(dir, vecShardName(i)), JSON.stringify(out), 'utf8')
+      writeFileSync(join(dir, vecOwnName(writer, i)), JSON.stringify(out), 'utf8')
     }
     try {
-      for (const f of readdirSync(dir)) {
-        const m = f.match(VEC_SHARD_RE)
+      const re = vecOwnRe(writer)
+      for (const f of listDir()) {
+        const m = f.match(re)
         if (m && Number(m[1]) >= shardCount) unlinkSync(join(dir, f))
       }
     } catch { /* 清不掉不影响正确性，下次再清 */ }
@@ -602,7 +711,12 @@ export function createStore(dir, opts = {}) {
     return shardCount
   }
 
-  const sharded = readVecShards()
+  // 没有模型（'none'）→ 语义层整体关闭：不读、不写向量文件，检索只走关键词。
+  // 不读是因为查询侧没有 embed，qVec 恒为 null，读了也用不上；
+  // 不写是为了保住现有的向量，等用户接上模型还能续用。
+  const vectorsDisabled = signature === 'none'
+
+  const sharded = vectorsDisabled ? null : readVecShards()
   if (sharded) {
     const meta = readVecMeta()
     // 只在新旧都明确时才判定；老库没有 meta（sig 缺失）按兼容处理，直接沿用
@@ -614,7 +728,7 @@ export function createStore(dir, opts = {}) {
       vectors = sharded
       if (!meta) writeVecMeta(sharded.size)   // 老库补写指纹
     }
-  } else if (existsSync(vecPath)) {
+  } else if (!vectorsDisabled && existsSync(vecPath)) {   // 旧版单文件，仅首次
     try {
       const raw = JSON.parse(readFileSync(vecPath, 'utf8'))
       for (const [k, v] of Object.entries(raw || {})) {
@@ -627,8 +741,24 @@ export function createStore(dir, opts = {}) {
     } catch { /* 同上 */ }
   }
 
+  /** 原子落盘：先写临时文件再改名。两个进程同时 save 不会互相撕坏文件 */
+  function atomicWrite(p, body) {
+    const tmp = `${p}.tmp-${process.pid}`
+    try {
+      writeFileSync(tmp, body, 'utf8')
+      renameSync(tmp, p)
+    } catch {
+      try { unlinkSync(tmp) } catch { /* 临时文件清不掉不影响 */ }
+      writeFileSync(p, body, 'utf8')   // 改名失败就退回直接写，别把数据丢了
+    }
+  }
+
   function save() {
-    writeFileSync(storePath, JSON.stringify(state, null, 1), 'utf8')
+    // 落盘前先看一眼别人有没有新东西，合并进内存视图
+    refreshForeign()
+    // 只写自己的条目：别人的数据在他们自己的分片里，我们没有资格替他们存
+    const mine = state.items.filter((it) => !it.__foreign)
+    atomicWrite(storePath, JSON.stringify({ ...state, items: mine }, null, 1))
     writeVecShards()
   }
 
@@ -659,9 +789,16 @@ export function createStore(dir, opts = {}) {
     get items() { return state.items },
     set items(v) { state.items = v },
     get vectors() { return vectors },
-    save, saveVectors, audit,
+    save, saveVectors, audit, refreshForeign, maybeRefreshForeign,
+    /** 条目集合的代数：变了说明别人的数据合并进来了，上层缓存要重算 */
+    get gen() { return gen },
     dumpVectors,
     dir,
+    writer,
+    /** 自己的条目（不含别人的） */
+    get ownItems() { return state.items.filter((it) => !it.__foreign) },
+    /** 是不是自己的条目——不是就不能改、不能删 */
+    isOwn: (it) => !it.__foreign,
   }
 }
 
@@ -743,7 +880,7 @@ export function createMemory5(o = {}) {
   const cfg = { ...DEFAULTS, ...(o.cfg || {}) }
   const dir = o.dir || '.memory5'
   const tick = o.now || (() => Date.now())
-  const store = createStore(dir, { signature: o.embedSignature })
+  const store = createStore(dir, { signature: o.embedSignature, writer: o.writer })
 
   // ============================================================
   // 模型调用统计
@@ -811,10 +948,16 @@ export function createMemory5(o = {}) {
   // 待摘要队列（summarizeMode === 'deferred' 时用）
   const summaryQueue = []
 
-  const byLayer = (layer) => store.items.filter((it) => it.layer === layer)
+  // ★ 默认只返回**自己的**条目：分流、遗忘、压缩、融合这些会改数据的操作，
+  //   只能动自己写的（别人的数据在别人的分片里，我们改了也存不回去）。
+  //   要看全库（检索、注入上下文、统计、列目录）就传 { all: true }。
+  const byLayer = (layer, opts) =>
+    store.items.filter((it) => it.layer === layer && ((opts && opts.all) || !it.__foreign))
   const chars = (list) => list.reduce((s, it) => s + String(it.text || '').length, 0)
   const find = (id) => store.items.find((it) => it.id === id)
   const removeItem = (id) => {
+    const it = store.items.find((x) => x.id === id)
+    if (it && it.__foreign) return false   // 别人的条目：删了也会被他的分片带回来
     store.items = store.items.filter((it) => it.id !== id)
     invalidateLayerIndex()   // 条目少了，桶要重建
   }
@@ -1008,13 +1151,15 @@ export function createMemory5(o = {}) {
   //   Map.get 是 O(1)，比重建索引便宜几个数量级。
   // ============================================================
   let _layerIndex = null
+  let _layerIndexGen = -1
 
   // 用 function 声明而不是箭头函数：让它们能提升，removeItem / moveTo
   // 这些在 createMemory5 体里更早定义的函数就能安全调用，不会有 TDZ 风险。
   function invalidateLayerIndex() { _layerIndex = null }
 
   function getLayerIndex() {
-    if (_layerIndex) return _layerIndex
+    // 别人的数据合并进来后，索引必须重建，否则会漏掉他们新写的条目
+    if (_layerIndex && _layerIndexGen === store.gen) return _layerIndex
     const m = new Map()
     for (const it of store.items) {
       let arr = m.get(it.layer)
@@ -1022,6 +1167,7 @@ export function createMemory5(o = {}) {
       arr.push(it)
     }
     _layerIndex = m
+    _layerIndexGen = store.gen
     return m
   }
 
@@ -1345,6 +1491,11 @@ export function createMemory5(o = {}) {
   // 迁移
   // ============================================================
   function moveTo(item, layer, reason, now) {
+    // ★ 别人的条目不搬层：它在别人的分片里，我们改了也存不回去，
+    //   下次读盘就被他自己的版本覆盖掉；更糟的是本次会话里它会被
+    //   当成"我方数据"参与注入和容量计算，重启前后行为不一致。
+    //   别人的层、热度、作废标记一律只读。
+    if (!item || item.__foreign) return
     const from = item.layer
     if (from === layer) return
 
@@ -1496,6 +1647,8 @@ export function createMemory5(o = {}) {
     const affected = []
     for (const it of store.items) {
       if (it.kind !== 'summary' || it.supersededBy) continue
+      // 别人的摘要不在我们的分片里，打不上作废标记（打了也存不回去）
+      if (it.__foreign) continue
       if ((it.sources || []).includes(oldItem.id)) {
         it.supersededBy = newItem.id
         affected.push(it.id)
@@ -1532,9 +1685,16 @@ export function createMemory5(o = {}) {
     if (!nv) return null
 
     // 只和 DL3 里的摘要比（摘要 vs 摘要），不碰原文
+    //
+    // ★ 只跟**自己的**摘要比。别人的摘要在别人的分片里，一旦被判成"重复"
+    //   就会被合并进来、而我们这一条会被删掉——删掉的写进了自己的分片
+    //   （永久生效），合并的结果却落在别人的对象上（存不回去，重启即失效）。
+    //   一合一删之后，这条内容两边都不剩，等于凭空丢一条记忆。
+    //   所以跨写者不做判重 / 取代 / 融合，只做检索和注入。
     const cands = []
     for (const it of store.items) {
       if (it.id === newItem.id) continue
+      if (it.__foreign) continue
       if (it.layer !== LAYER.DL_LONG || it.kind !== 'summary') continue
       if (it.supersededBy) continue
       const v = store.vectors.get(it.id)
@@ -2474,6 +2634,7 @@ export function createMemory5(o = {}) {
    * @returns 带 confidence / advice 的结果，advice 是给模型看的下一步建议
    */
   async function search(query, { depth = 'auto', ...opt } = {}) {
+    store.maybeRefreshForeign()      // 别人可能刚写了新东西，15 秒内刷一次
     const q = String(query || '').trim()
     const limit = opt.limit || 6
 
@@ -2566,6 +2727,9 @@ export function createMemory5(o = {}) {
     for (const id of list) {
       const it = find(id)
       if (!it) continue
+      // 别人的条目：热度/关注次数存在他的分片里，我们加的这一下重启就没了，
+      // 反而让本次会话的排序和重启后不一致（同一条记忆两次查询排位不同）。
+      if (it.__foreign) continue
       touchHeat(it, now, cfg)
       it.recallCount = (Number(it.recallCount) || 0) + 1
       n++
@@ -2586,6 +2750,7 @@ export function createMemory5(o = {}) {
     const win = parseTime(q, now)
     const kw = keywords(win ? q.replace(win.word, '') : q)
     const qVec = await embedOne(q)
+    const noSem = !qVec      // 没连模型（或本条查询取向量失败）→ 纯关键词/热度打分
 
     const scored = []
     // ★ 只扫目标层（2026-10-31 修）。原来这里是 `for (const it of store.items)`
@@ -2631,8 +2796,12 @@ export function createMemory5(o = {}) {
       //   没有任何一条记忆会含这个词——按老规则整段时间的记忆全被排除，
       //   结果就是"昨天"搜出 0 条，明明那天的东西都在库里。
       //   时间窗本身就是强约束，这里只需要排掉语义上明显无关的。
+      // 没有 embedding 时（qVec 为空）：时间窗查询不能被"零命中"筛掉。
+      // 「昨天发生了什么」去掉时间词只剩"发生什么"，没有任何一条会含这个词，
+      // 语义又用不上，老规则会把整段时间的记忆全排掉——明明东西都在库里。
+      // 时间窗本身就是强约束，这时按热度/重要度排就够了。
       if (win) {
-        if (hit === 0 && sem < 0.2) continue
+        if (!noSem && hit === 0 && sem < 0.2) continue
       } else if (kw.size && hit === 0 && sem < 0.45) {
         continue
       }
@@ -2769,8 +2938,31 @@ export function createMemory5(o = {}) {
   // 好处：老摘要热度掉了，分数自动掉下去，**不用搬数据**就退出上下文。
   //       不需要"L3 满了挤出去"这种逻辑，也就不会出现"冷掉的摘要赖着不走"。
   // ============================================================
-  function l3View(now = tick()) {
-    const pool = byLayer(LAYER.DL_LONG).filter((it) => !it.supersededBy)
+  // L3 是「视图」不是「层」：每次都从 DL3 现算，条目本身没有副本。
+  //
+  // ★ 这个排序是全局唯一需要节流的地方（2026-11-01 改）。
+  //   以前节流的是「整个记忆块」（L3+L2+L1 一起），那是错的：
+  //   ① L1 每轮都有新数据写入，压着不刷新 = 模型看不到刚说的话；
+  //   ② 快照是追加在末尾的，前面的历史缓存根本不受影响，没有可省的。
+  //
+  //   真正会打断缓存的只有 L3：它在注入块里排最前，L3 一变，
+  //   后面 L2 / L1 的整段前缀全部失效。而 heat 随时间连续衰减，
+  //   边界条目的分数此消彼长，入选集合时不时会变一条——必须压住。
+  //
+  //   所以：排序结果缓存 viewRefreshMs（默认 30 分钟），期间复用同一批入选条目。
+  //   L1 / L2 不缓存，每轮现算。
+  let l3Cache = null
+
+  function l3View(now = tick(), opts = {}) {
+    const refreshMs = Number(cfg.viewRefreshMs) || 0
+    // 容量变了要立刻重算：否则把 longMaxChars 调大要等一个周期才见效
+    const key = cfg.longMaxChars
+    if (!opts.force && l3Cache && l3Cache.key === key && refreshMs > 0 && now - l3Cache.at < refreshMs) {
+      return l3Cache.items
+    }
+
+    // all：全库。别人沉淀的摘要也该出现在 L3 里，这才是共享的意义
+    const pool = byLayer(LAYER.DL_LONG, { all: true }).filter((it) => !it.supersededBy)
 
     const scored = pool.map((it) => ({
       it,
@@ -2786,6 +2978,7 @@ export function createMemory5(o = {}) {
       out.push(it)
       used += len
     }
+    l3Cache = { at: now, key, items: out }
     return out
   }
 
@@ -2798,17 +2991,24 @@ export function createMemory5(o = {}) {
    *   L3←longMaxChars、L2←consolidateMaxChars、L1←hotMaxChars。
    *   > 0 时才作为最后一道闸门截断（给不信任容量的调用方兜底）。
    * @param {{includeHot?: boolean}} [opts]
-   *   includeHot 默认 true（保持旧行为）。接上下文时建议传 false：
-   *   L1 就是当前会话的对话，历史里已经有了，重复注入只会让注入块每轮变化，
-   *   把系统提示词/快照的缓存全打掉。
+   * @param {{includeHot?: boolean}} [opts]
+   *   includeHot 恒为 true：三层都注入，没有开关（2026-11-01 移除该开关）。
+   *   要调的是各层容量，不是注不注入。参数留着只为兼容旧调用。
    */
   function buildBlock(budget = 0, opts = {}) {
+    store.maybeRefreshForeign()      // 上下文里要带上别人刚记的东西
     const includeHot = opts.includeHot !== false
     // ★ L3 是视图：从 DL3 按 importance×热度 截取。
     //   截出来之后按 seq 升序排——新增加末尾，前面逐字节不变，前缀缓存能命中。
     const long = l3View().sort((a, b) => a.seq - b.seq)
-    const cons = byLayer(LAYER.CONSOLIDATE).sort((a, b) => a.seq - b.seq)
-    const hot = byLayer(LAYER.HOT).sort((a, b) => b.seq - a.seq)   // 最新的在前
+    // ★ 共享目录里别人的条目也进上下文，但排在自己人后面：
+    //   容量是我们按自己的条目维护的（enforceLimits 只动自己的），
+    //   先到先得的话，对方写得越多，我们自己的条目被挤掉得越多。
+    const ownFirst = (a, b) => (a.__foreign ? 1 : 0) - (b.__foreign ? 1 : 0)
+    const cons = byLayer(LAYER.CONSOLIDATE, { all: true })
+      .sort((a, b) => ownFirst(a, b) || (a.seq - b.seq))
+    const hot = byLayer(LAYER.HOT, { all: true })
+      .sort((a, b) => ownFirst(a, b) || (b.seq - a.seq))   // 最新的在前
 
     // 作废条不进上下文：新的那条已经在里面了，再放旧的只会让模型看到两条相反的指令。
     // 想查历史可以走 search（那里会改写成"（已作废）…"）。
@@ -2852,8 +3052,17 @@ export function createMemory5(o = {}) {
     //     L1 ← hotMaxChars（同理）
     //   以前是 bootMaxChars 当总闸门、L3 吃光后 L2 只剩零头（实测 351 字只进 55 字），
     //   结果「刚沉淀的对话」优先级反而低于「一周前的群聊」——不合理。
-    const hotLines = includeHot ? pack(visible(hot), Infinity) : []
-    const consLines = pack(visible(cons), Infinity)
+    // ★ 单写者时下面等价于直接 pack(..., Infinity)：容量本来就是硬上限，
+    //   多写者时才生效——别人的条目只能"借"剩下的空间，
+    //   自己那份已经占满时仍留 30% 给共享方（不然对方一条都进不来，共享就没意义了）。
+    const packShared = (list, limit) => {
+      const mine = pack(list.filter((it) => !it.__foreign), Infinity)
+      const used = mine.reduce((s, l) => s + l.length + 1, 0)
+      return mine.concat(pack(list.filter((it) => it.__foreign), Math.max(Math.round(limit * 0.3), limit - used)))
+    }
+
+    const hotLines = includeHot ? packShared(visible(hot), cfg.hotMaxChars) : []
+    const consLines = packShared(visible(cons), cfg.consolidateMaxChars)
 
     const parts = []
     if (longLines.length) parts.push('## 一直记得的', ...longLines)
@@ -2869,11 +3078,12 @@ export function createMemory5(o = {}) {
   // 观测 / 维护
   // ============================================================
   function stats() {
+    store.maybeRefreshForeign()
     const count = {}
     const charsBy = {}
     for (const l of Object.values(LAYER)) {
       // L3 是视图，按"当前能进上下文的条数"算，不是 DL3 的存储量
-      const list = l === LAYER.LONG ? l3View(tick()) : byLayer(l)
+      const list = l === LAYER.LONG ? l3View(tick()) : byLayer(l, { all: true })
       count[l] = list.length
       charsBy[l] = chars(list)
     }
@@ -2901,6 +3111,8 @@ export function createMemory5(o = {}) {
   function pin(id, v = true) {
     const it = find(id)
     if (!it) return { ok: false, error: '找不到' }
+    // 别人的条目改了也存不回去（save 只写自己的分片），直接拒绝，别假装成功。
+    if (!store.isOwn(it)) return { ok: false, error: '别人的条目，不能钉住' }
     it.pinned = v
     store.save()
     return { ok: true, id, pinned: v }
@@ -2909,6 +3121,9 @@ export function createMemory5(o = {}) {
   function forgetById(id) {
     const it = find(id)
     if (!it) return { ok: false, error: '找不到' }
+    // 别人的条目：删不掉条目本身，但 forget() 会写台账、删归档——
+    // 等于"没删掉还删了对方的正文"。这里必须拦。
+    if (!store.isOwn(it)) return { ok: false, error: '别人的条目，不能删' }
     const ok = forget(it, '手动删除', tick())
     store.save()
     return { ok, id }
@@ -2916,7 +3131,7 @@ export function createMemory5(o = {}) {
 
   function list(layer = null) {
     if (layer === LAYER.LONG) return l3View(tick())   // L3 是视图
-    return (layer ? byLayer(layer) : store.items).slice()
+    return (layer ? byLayer(layer, { all: true }) : store.items).slice()
   }
 
   /** 手动快进时间（测试用） */
@@ -2952,6 +3167,8 @@ export function createMemory5(o = {}) {
     flushSummaries,
     pendingSummaries,
     dumpVectors: (p) => store.dumpVectors(p),    // 合并导出向量快照（调试/分析用）
+    /** 底层 store：测试和多写者调试用 */
+    _store: store,
     fuse: consolidateFusion,                    // 手动跑一次全量融合
     fuseDL3: fuseIntoDL3,                       // 摘要入 DL3 时的融合（判重的新位置）
     _seed: (item, vec) => {                                     // 直接注入（测试用）