@yolk_vat-y/dsh-project-memory 0.5.9 → 0.5.11

package/src/link.js

@@ -1,54 +1,120 @@
+// doc → symbol 交叉引用：**读取期解算**，不再物化进 entry。
+//
+// 旧实现（≤0.5.10）在每次索引提交时把「本 chunk 命中的所有符号 id」写进
+// `entry.linkedSymbols` 并落盘。实测一个真实 TypeScript 仓库（本仓库的 361MB store）：
+// 17174 个 chunk 共 3,948,420 个链接槽位，只对应 15,456 个符号，单 chunk 最多 2231 个；
+// 而唯一的消费者 `query_memory` 只读前 5 个——存了消费量的 46 倍。
+//
+// 更根本的问题是它把**跨实体派生关系**固化进了源记录：doc 链接的有效性取决于符号表的
+// 当前状态，而符号是独立写入的。于是必须追失效（`markFile` 标脏、"文档先索引、符号后到
+// 则链接丢失"），并且每个索引提交点都要对整库做 O(chunks × symbols) 全表重扫。
+//
+// 现在：entry 只存事实；链接在查询时用每 store 的符号索引解算，成本 O(本 chunk 词数)，
+// 且天然反映当前符号表——后索引的符号也能链上，`markFile` 那套失效机制随之删除。
+
 const LATIN_NAME = /^[A-Za-z0-9_]+$/
 const CJK_CHAR = /[\u3400-\u9fff\uf900-\ufaff\u3040-\u309f\u30a0-\u30ff\uac00-\ud7af]/
+/** 与 latin 边界后视 `[a-z0-9_$]` 同字符集：切出的词直接可查倒排表。 */
+const LATIN_WORD = /[a-z0-9_$]+/g
 
 function buildMatcher(name) {
   const lower = name.toLowerCase()
   if (LATIN_NAME.test(name)) {
-    return { lower, re: new RegExp(`(?<![a-z0-9_$])${lower}(?![a-z0-9_$])`) }
+    return { re: new RegExp(`(?<![a-z0-9_$])${lower}(?![a-z0-9_$])`) }
   }
   const escaped = lower.replace(/[.*+?^${}()|[\]\\]/g, '\\$&')
   // 尾部统一挡 CJK + 字母数字下划线，防止纯 CJK 名误链混合后缀、混合名误链更长后缀
-  return { lower, re: new RegExp(`${escaped}(?!${CJK_CHAR.source})(?![a-z0-9_$])`) }
+  return { re: new RegExp(`${escaped}(?!${CJK_CHAR.source})(?![a-z0-9_$])`) }
 }
 
-export function linkEntries(store) {
-  const all = store.allEntries()
-  const symbols = all.filter((e) => e.type === 'symbol')
-  const docs = all.filter((e) => e.type === 'doc')
-  if (!symbols.length || !docs.length) return 0
-
-  const symbolByName = new Map()
-  for (const s of symbols) {
-    const name = s.keywords[0]
-    if (!name || name.length < 3) continue
-    if (!symbolByName.has(name)) symbolByName.set(name, { syms: [], ...buildMatcher(name) })
-    symbolByName.get(name).syms.push(s)
+/** 纯 latin 符号名按整词查倒排；其余（CJK / 混合 / 带 `$`）保留正则回退，语义与旧实现一致。 */
+export function buildSymbolIndex(store) {
+  const latin = new Map() // lowerName -> symbol[]
+  const other = []
+  const otherByName = new Map()
+  for (const entry of store.allEntries()) {
+    if (!entry || entry.type !== 'symbol') continue
+    const name = Array.isArray(entry.keywords) ? entry.keywords[0] : undefined
+    if (typeof name !== 'string' || name.length < 3) continue
+    const key = name.toLowerCase()
+    if (LATIN_NAME.test(name)) {
+      const bucket = latin.get(key)
+      if (bucket) bucket.push(entry)
+      else latin.set(key, [entry])
+      continue
+    }
+    const existing = otherByName.get(key)
+    if (existing) {
+      existing.syms.push(entry)
+      continue
+    }
+    const { re } = buildMatcher(name)
+    const record = { reGlobal: new RegExp(re.source, 'g'), syms: [entry] }
+    otherByName.set(key, record)
+    other.push(record)
   }
+  return { latin, other }
+}
 
-  let links = 0
-  for (const doc of docs) {
-    const linked = new Set()
-    // 结构词项也参与链接：terms 覆盖整个 chunk，符号在后半段被提及时同样能链上（与检索同源）
-    const haystack = `${doc.title || ''} ${doc.summary || ''} ${doc.terms || ''} ${doc.keywords ? doc.keywords.join(' ') : ''}`.toLowerCase()
-    for (const [, entry] of symbolByName) {
-      const hit = entry.re ? entry.re.test(haystack) : haystack.includes(entry.lower)
-      for (const s of entry.syms) {
-        if (!hit) break
-        const before = linked.size
-        linked.add(s.id)
-        if (linked.size > before) links++
-      }
-    }
-    const before = Array.isArray(doc.linkedSymbols) ? doc.linkedSymbols.join('\u0000') : ''
-    const next = [...linked]
-    if (before === next.join('\u0000')) continue
-    doc.linkedSymbols = next.length ? next : undefined
-    // 链接是在**符号**落盘那一刻算出来的，此时 doc 的 shard 往往不是脏的；不标脏就只存在于内存，
-    // 下次进程启动重新加载后链接全部丢失（"文档先索引、符号后到"的正常顺序）。
-    if (typeof store.markFile === 'function' && typeof store.fileRecord === 'function' && doc.sourcePath) {
-      const record = store.fileRecord(doc.sourcePath)
-      if (record) store.markFile(doc.sourcePath, record)
+/** 每 store 一份符号索引，按 `store.entriesVersion` 失效（任何 entry 变更即重建）。 */
+const indexCache = new WeakMap()
+
+function symbolIndexOf(store) {
+  const version = store.entriesVersion
+  const cached = indexCache.get(store)
+  if (cached && cached.version === version) return cached.index
+  const index = buildSymbolIndex(store)
+  indexCache.set(store, { version, index })
+  return index
+}
+
+/**
+ * 解算一条 doc entry 提到的符号，按相关度取前 `limit` 个。
+ *
+ * 判据与旧 linkEntries 同源（title / summary / terms / keywords 四个字段），
+ * 排序为：命中次数 → 名字长度 → id（稳定序）。旧实现交给消费者的前 5 个是符号表的
+ * 插入序，即「任意 5 个」，这也是本次一并修掉的行为。
+ *
+ * @param {object} store 带 `allEntries()` 与 `entriesVersion` 的 ProjectMemoryStore
+ * @param {object} doc 待解算的 doc entry
+ * @param {number} limit 最多返回多少个符号 entry
+ * @returns {object[]} 符号 entry 列表（可能为空）
+ */
+export function resolveLinkedSymbols(store, doc, limit = 5) {
+  if (!store || !doc || doc.type !== 'doc' || !(limit > 0)) return []
+  const haystack = `${doc.title || ''} ${doc.summary || ''} ${doc.terms || ''} ${
+    Array.isArray(doc.keywords) ? doc.keywords.join(' ') : ''
+  }`.toLowerCase()
+  if (!haystack.trim()) return []
+
+  const { latin, other } = symbolIndexOf(store)
+  const hits = new Map() // symbol entry -> 命中次数
+
+  if (latin.size) {
+    const counts = new Map() // token -> 在 haystack 中的出现次数
+    for (const token of haystack.match(LATIN_WORD) || []) counts.set(token, (counts.get(token) || 0) + 1)
+    for (const [token, n] of counts) {
+      const bucket = latin.get(token)
+      if (!bucket) continue
+      for (const symbol of bucket) hits.set(symbol, (hits.get(symbol) || 0) + n)
     }
   }
-  return links
+  for (const { reGlobal, syms } of other) {
+    reGlobal.lastIndex = 0
+    const n = haystack.match(reGlobal)?.length || 0
+    if (!n) continue
+    for (const symbol of syms) hits.set(symbol, (hits.get(symbol) || 0) + n)
+  }
+  if (!hits.size) return []
+
+  const nameOf = (e) => (Array.isArray(e.keywords) && e.keywords[0]) || e.title || ''
+  return [...hits.entries()]
+    .sort((a, b) => {
+      if (b[1] !== a[1]) return b[1] - a[1]
+      const delta = nameOf(b[0]).length - nameOf(a[0]).length
+      if (delta !== 0) return delta
+      return String(a[0].id).localeCompare(String(b[0].id))
+    })
+    .slice(0, limit)
+    .map(([entry]) => entry)
 }

package/src/store.js

@@ -1,7 +1,7 @@
 import { createHash, randomUUID } from 'node:crypto'
-import { mkdirSync, readFileSync, readdirSync, renameSync, statSync, unlinkSync, writeFileSync } from 'node:fs'
+import { mkdirSync, readFileSync, readdirSync, renameSync, rmSync, statSync, unlinkSync, writeFileSync } from 'node:fs'
 import path from 'node:path'
-import { rankEntries, rankExperience, tokenize, tokenizeRaw, extractCjkPhrases, makeSearchText } from './util/search.js'
+import { rankExperience, tokenize, tokenizeRaw, extractCjkPhrases, makeSearchText } from './util/search.js'
 import { backfillDerivedTriggers } from './readiness.js'
 
 const FORMAT_FILE = 'format.json'
@@ -13,9 +13,39 @@ const BINDING_FILE = 'binding.json'
 const WATCH_FILE = 'watch.json'
 const INSIGHTS_FILE = 'insights.json'
 const SHARDS_DIR = 'shards'
+const GITIGNORE_FILE = '.gitignore'
+/** ≤0.5.10 的 TS 增强结果缓存目录；0.5.11 起废弃并自愈清理。 */
+const LEGACY_TYPE_CACHE_DIR = 'type-cache'
 
 const storeCache = new Map()
+/** 条目数上限（兜底）。 */
 const STORE_CACHE_MAX = 32
+/**
+ * 驻留内存的估算上限。只数"几个 store"是不够的：单个大仓库 store 加载后堆占用实测
+ * 130–200MB，32 个就是几 GB。按 store 的条目数与读入文本量估算，约 2.5KB/entry。
+ */
+const STORE_CACHE_MAX_BYTES = 256 * 1024 * 1024
+/** 每轮 save 最多补写多少个待压实的老分片（有界，避免升级后一次重写整库）。 */
+const COMPACT_BATCH = 200
+
+/** 单个 store 的驻留估算（驻留文本量 vs 条目数换算，取大者）。 */
+function estimateResidentBytes(store) {
+  let entries = 0
+  for (const list of Object.values(store.entries)) entries += list.length
+  return Math.max(store._residentChars || 0, entries * 2500)
+}
+
+/** 按 LRU 逐出，直到同时满足条数与字节预算；刚加入的 keepKey 即使超预算也保留。 */
+function evictStoreCache(keepKey) {
+  let total = 0
+  for (const store of storeCache.values()) total += estimateResidentBytes(store)
+  while (storeCache.size > STORE_CACHE_MAX || total > STORE_CACHE_MAX_BYTES) {
+    const oldest = storeCache.keys().next().value
+    if (oldest === undefined || oldest === keepKey) break
+    total -= estimateResidentBytes(storeCache.get(oldest))
+    storeCache.delete(oldest)
+  }
+}
 
 /** 已就"无法迁移的旧 store"告警过的目录：避免每次 load() 都刷一行。 */
 const migrationWarned = new Set()
@@ -25,13 +55,37 @@ function isRecord(value) {
   return Boolean(value) && typeof value === 'object' && !Array.isArray(value)
 }
 
-function loadJson(filePath, fallback) {
+/**
+ * 落盘的 entry 只保留**不可推导的事实**。两个派生字段永远不写盘：
+ *  - `linkedSymbols`：跨实体派生（取决于符号表当前状态），读取期由 src/link.js 解算；
+ *  - `searchText`：自派生（只依赖本 entry），由 `allEntries()` 在内存里物化。
+ * 旧 store 里的这两个字段在加载时剥掉，于是下一次写盘自然压实。
+ * 实测两者在一个真实大仓库 store 里合计约 245MB（链接 222.8MB + searchText 22.7MB）。
+ */
+const PERSISTED_DERIVED = ['linkedSymbols', 'searchText', 'typeSig']
+
+/** 原地剥离派生字段（加载路径用，省掉一次分配）。 */
+function stripPersistedDerived(entry) {
+  if (!entry || typeof entry !== 'object') return entry
+  for (const key of PERSISTED_DERIVED) if (key in entry) delete entry[key]
+  return entry
+}
+
+/** 返回不含派生字段的副本（写盘路径用，不能动内存里的对象）。 */
+function withoutPersistedDerived(entry) {
+  const out = { ...entry }
+  for (const key of PERSISTED_DERIVED) delete out[key]
+  return out
+}
+
+function loadJson(filePath, fallback, sizeSink) {
   let raw
   try {
     raw = readFileSync(filePath, 'utf8')
   } catch {
     return fallback
   }
+  if (sizeSink) sizeSink.bytes += raw.length
   try {
     return JSON.parse(raw)
   } catch {
@@ -83,8 +137,13 @@ export class ProjectMemoryStore {
     this._dirtyBinding = false
     this._dirtyWatch = false
     this._formatWritten = false
-    this._version = 0
     this._idfCache = null
+    /** entries 的变更计数：IDF 缓存与符号索引（读取期链接）都据此失效。 */
+    this._entriesVersion = 0
+    /** 待压实的老分片（≤0.5.10 落盘时带 linkedSymbols/searchText）；save() 每轮有界补写。 */
+    this._compactQueue = new Set()
+    /** 从磁盘读入的 JSON 文本量（UTF-16 字符数），作为驻留内存的估算基数。 */
+    this._residentChars = 0
   }
 
   load() {
@@ -92,17 +151,21 @@ export class ProjectMemoryStore {
     const hot = storeCache.get(key)
     // 缓存命中即返回：`hot === this` 时再读一遍盘会静默丢弃本实例尚未 save() 的变更
     // （_loadSharded/_loadInsights 会重新赋值 experience/tasks/insights…）。
-    if (hot) return hot
+    if (hot) {
+      // LRU：命中挪到队尾，避免"热的先被逐出、冷的常驻"。
+      storeCache.delete(key)
+      storeCache.set(key, hot)
+      return hot
+    }
     this._migrateLegacyIfNeeded()
     this._loadSharded()
     this._loadInsights()
+    this._removeLegacyTypeCache()
+    // 有些路径只读不写（审计 jsonl 直接写在 store 目录里），所以这里也补一次自我忽略，
+    // 让老版本建出来的 store 在第一次 load 就补上。
+    this.ensureSelfIgnore()
     storeCache.set(key, this)
-    // 只保留最近打开的项目：长期跨多项目运行时不至于无限增长（被逐出只是下次重新读盘）
-    while (storeCache.size > STORE_CACHE_MAX) {
-      const oldest = storeCache.keys().next().value
-      if (oldest === key) break
-      storeCache.delete(oldest)
-    }
+    evictStoreCache(key)
     return this
   }
 
@@ -160,7 +223,7 @@ export class ProjectMemoryStore {
     }
     mkdirSync(path.join(this.dir, SHARDS_DIR), { recursive: true })
     for (const rel of Object.keys(files)) {
-      writeJsonAtomic(shardRelPath(this.dir, rel), { relPath: rel, record: files[rel], entries: entries[rel] || [] })
+      writeJsonAtomic(shardRelPath(this.dir, rel), { relPath: rel, record: files[rel], entries: (entries[rel] || []).map(withoutPersistedDerived) })
     }
     writeJsonAtomic(formatPath, { version: 2, layout: 'sharded' })
     for (const stale of [legacyEntriesPath, path.join(this.dir, INDEX_FILE)]) {
@@ -180,21 +243,45 @@ export class ProjectMemoryStore {
     } catch {
       shardNames = []
     }
+    const sizeSink = { bytes: 0 }
     for (const name of shardNames) {
-      const shard = loadJson(path.join(this.dir, SHARDS_DIR, name), null)
+      const shard = loadJson(path.join(this.dir, SHARDS_DIR, name), null, sizeSink)
       if (!shard || typeof shard.relPath !== 'string' || !isRecord(shard.record)) continue
       this.files[shard.relPath] = shard.record
       // 畸形 shard（entries 被写成对象/null）不能让 allEntries() 在 `for…of` 上抛错，
       // 否则一个坏文件会拖垮整个进程的每一次读取。
-      this.entries[shard.relPath] = Array.isArray(shard.entries) ? shard.entries.filter(isRecord) : []
-    }
-    this.experience = loadJson(path.join(this.dir, EXPERIENCE_FILE), [])
-    this.tasks = loadJson(path.join(this.dir, TASKS_FILE), [])
-    this.binding = loadJson(path.join(this.dir, BINDING_FILE), {})
-    this.watchlist = loadJson(path.join(this.dir, WATCH_FILE), [])
+      const list = Array.isArray(shard.entries) ? shard.entries.filter(isRecord) : []
+      // 老分片带着派生字段：内存里立刻剥掉，并排队等 save() 把磁盘上也压实。
+      if (list.some((e) => PERSISTED_DERIVED.some((k) => k in e))) this._compactQueue.add(shard.relPath)
+      this.entries[shard.relPath] = list.map(stripPersistedDerived)
+    }
+    this._entriesVersion++
+    this.experience = loadJson(path.join(this.dir, EXPERIENCE_FILE), [], sizeSink)
+    this.tasks = loadJson(path.join(this.dir, TASKS_FILE), [], sizeSink)
+    this.binding = loadJson(path.join(this.dir, BINDING_FILE), {}, sizeSink)
+    this.watchlist = loadJson(path.join(this.dir, WATCH_FILE), [], sizeSink)
+    this._residentChars = sizeSink.bytes
     this._formatWritten = existsSafe(path.join(this.dir, FORMAT_FILE))
   }
 
+  /**
+   * 清掉 ≤0.5.10 留下的 `type-cache/` 目录。
+   *
+   * 它按内容哈希缓存 TS 增强结果，但三个增强入口（lazy 的 `fs/observed`、watch 轮询、
+   * `index_repo`）**都只在"文件已变更并重新索引"之后**才触发，此时内容哈希必然是新值——
+   * 这个缓存永远命中不了。实测本仓库残留 9827 个文件（`du` 41MB，内容其实 9.2MB，约 31MB
+   * 是 4KB 块开销）。这里做一次自愈清理；删的是纯缓存，不丢任何事实。
+   */
+  _removeLegacyTypeCache() {
+    const dir = path.join(this.dir, LEGACY_TYPE_CACHE_DIR)
+    if (!existsSafe(dir)) return
+    try {
+      rmSync(dir, { recursive: true, force: true })
+    } catch {
+      // 权限/占用导致删不掉也不影响 store 本身
+    }
+  }
+
   // ---- v0.5 insights：project 级 insight 文档（任务级在 task.insights[]） ----
   // 迁移语义（旧版 store 的兼容策略）：
   // v0.4 experience.json 仍由 remember/forget/query_memory 服务，不删除；
@@ -286,11 +373,35 @@ export class ProjectMemoryStore {
     }
   }
 
+  /**
+   * store 目录**自我忽略**：在目录里放一个内容为 `*` 的 `.gitignore`。
+   *
+   * 为什么不写进用户的 `.gitignore`：那是用户的文件，插件不该改；而且"忘了加"的代价
+   * 是一次误提交。为什么这样就够：git 会读取工作区里**任意**目录下的 `.gitignore`，
+   * 而 `*` 连这个 `.gitignore` 自己一起命中，于是 `git status` / `git add -A` 里整棵树
+   * 都不出现，用户一个字都不用写（`git check-ignore -v` 可复核）。
+   *
+   * 顺带的好处：被忽略的文件不会被 `git clean -fd` 删除（未跟踪且未忽略的会被删）。
+   * 想把记忆跟着仓库提交：`git add -f .dsh-project-memory`——已跟踪的文件不受忽略规则影响。
+   */
+  ensureSelfIgnore() {
+    if (!existsSafe(this.dir)) return
+    const file = path.join(this.dir, GITIGNORE_FILE)
+    if (existsSafe(file)) return
+    try {
+      writeFileSync(file, '# dsh-project-memory: local by default. `git add -f` to commit it.\n*\n')
+    } catch {
+      // 旁路：写不进去不影响存储本身
+    }
+  }
+
   save() {
     // 没有脏数据就不落盘。watch 每轮对每个根都无条件 commit → save；照旧执行的话，
-    // 末尾的 `_version++` + `_idfCache = null` 会打在跨实例共享的 store 上，
-    // 等于每 15 秒清空一次 IDF 缓存，废掉查询侧的 IDF 复用（v0.3.4 的 20x）。
+    // 末尾的 ID 缓存失效会打在跨实例共享的 store 上，等于每轮清空一次 IDF 复用（v0.3.4 的 20x）。
+    // 待压实队列不算"脏数据"，但它需要有界推进，所以也走这条落盘路径。
+    const compacting = this._compactQueue.size > 0
     const dirty =
+      compacting ||
       this._dirtyShards.size > 0 ||
       this._removedShards.size > 0 ||
       this._dirtyExperience ||
@@ -302,15 +413,27 @@ export class ProjectMemoryStore {
     if (dirty) mkdirSync(this.dir, { recursive: true })
     // 崩溃遗留的 *.tmp 无论有没有脏数据都顺手清掉（两次 readdir，自带 try/catch）
     this.cleanStaleTmp()
+    // 自我忽略也在无脏数据时执行：老版本建出来的 store 会在下一次 save 时补上。
+    this.ensureSelfIgnore()
     if (!dirty) return
     if (!this._formatWritten) {
       writeJsonAtomic(path.join(this.dir, FORMAT_FILE), { version: 2, layout: 'sharded' })
       this._formatWritten = true
     }
+    // 存量压实：≤0.5.10 的分片带着派生字段，而那些字段只在分片被重写时才会从磁盘消失。
+    // 每轮最多补写 COMPACT_BATCH 个，让升级后的 store 在后续任意一次 save（watch 轮询、
+    // 索引、写入）里自动收敛，而不是永远停在旧体积。
+    let compactBudget = COMPACT_BATCH
+    for (const rel of this._compactQueue) {
+      if (compactBudget <= 0) break
+      compactBudget--
+      this._compactQueue.delete(rel)
+      if (this.files[rel]) this._dirtyShards.add(rel)
+    }
     for (const rel of this._dirtyShards) {
       if (this.files[rel]) {
         mkdirSync(path.join(this.dir, SHARDS_DIR), { recursive: true })
-        writeJsonAtomic(shardRelPath(this.dir, rel), { relPath: rel, record: this.files[rel], entries: this.entries[rel] || [] })
+        writeJsonAtomic(shardRelPath(this.dir, rel), { relPath: rel, record: this.files[rel], entries: (this.entries[rel] || []).map(withoutPersistedDerived) })
       } else {
         this._removedShards.add(rel)
       }
@@ -346,16 +469,16 @@ export class ProjectMemoryStore {
       writeJsonAtomic(path.join(this.dir, WATCH_FILE), this.watchlist)
       this._dirtyWatch = false
     }
-    this._version++
-    this._idfCache = null
   }
 
   getIdfCache() {
-    if (this._idfCache && this._idfCache.version === this._version) {
+    // IDF 只依赖 entries（title/keywords/summary），所以按 entries 的变更计数失效：
+    // 只写经验/insight 或只做存量压实的 save 不会再无谓地重建 IDF。
+    if (this._idfCache && this._idfCache.version === this._entriesVersion) {
       return this._idfCache.idf
     }
     const idf = this._rebuildIdf()
-    this._idfCache = { version: this._version, idf }
+    this._idfCache = { version: this._entriesVersion, idf }
     return idf
   }
 
@@ -410,11 +533,17 @@ export class ProjectMemoryStore {
 
   setEntries(relPath, entries) {
     if (entries.length) {
-      const enriched = entries.map((e) => ({ ...e, searchText: makeSearchText(e) }))
+      // searchText 在内存里物化（写入/检索都靠它），但 save() 不会把它写盘。
+      const enriched = entries.map((e) => {
+        const out = stripPersistedDerived({ ...e })
+        out.searchText = makeSearchText(out)
+        return out
+      })
       this.entries[relPath] = enriched
     } else {
       delete this.entries[relPath]
     }
+    this._entriesVersion++
     this._dirtyShards.add(relPath)
     this._removedShards.delete(relPath)
   }
@@ -423,23 +552,34 @@ export class ProjectMemoryStore {
     if (relPath in this.files) {
       delete this.files[relPath]
       delete this.entries[relPath]
+      this._entriesVersion++
       this._dirtyShards.add(relPath)
       this._removedShards.add(relPath)
     }
   }
 
+  /** entries 的变更计数：派生缓存（符号索引）据此失效。 */
+  get entriesVersion() {
+    return this._entriesVersion
+  }
+
+  /** 还有多少个老分片等着被 save() 压实（0 = 存量已收敛）。 */
+  get pendingCompaction() {
+    return this._compactQueue.size
+  }
+
   allEntries() {
     const out = []
     for (const list of Object.values(this.entries)) {
-      for (const entry of list) out.push(entry)
+      for (const entry of list) {
+        // searchText 不落盘，首次用到时按需物化并挂在对象上（同一 entry 只算一次）。
+        if (entry.searchText === undefined) entry.searchText = makeSearchText(entry)
+        out.push(entry)
+      }
     }
     return out
   }
 
-  searchEntries(query, limit = 8) {
-    return rankEntries(this.allEntries(), query, limit)
-  }
-
   addExperience({ problem, solution, sourceFile }) {
     const existing = this.findSupersede(problem)
     const now = new Date().toISOString()

package/src/symbols.js

@@ -1,4 +1,5 @@
 import { readFileSync } from 'node:fs'
+import { oneLineDeclaration } from './util/text.js'
 
 const JS_LIKE = new Set(['.js', '.mjs', '.cjs', '.ts', '.mts', '.cts', '.jsx', '.tsx'])
 const PYTHON = new Set(['.py'])
@@ -465,7 +466,8 @@ function buildSymbol(matched, relPath, rawLine, lineNo) {
     type: 'symbol',
     title: `${matched.name} (${matched.kind})`,
     keywords: [matched.name, matched.kind],
-    text: identity,
+    // interface/type 的 typeSig 可能是整个类型体；这里限长成一行，避免符号条目被撑大。
+    text: oneLineDeclaration(identity),
   }
 }
 

package/src/tools/index-doc.js

@@ -3,7 +3,6 @@ import path from 'node:path'
 import { assertIndexRoot, assertReadableFile, assertSafeRoot, findProjectRoot, memoryRootFor, sessionMemoryRootOrNull, sha256OfFile, storeKey } from '../util/fs.js'
 import { buildDocEntries } from '../doc-pipeline.js'
 import { docEntriesNeedBackfill } from '../doc-index.js'
-import { linkEntries } from '../link.js'
 import { ProjectMemoryStore } from '../store.js'
 
 export function indexDocTool(ctx, config) {
@@ -76,7 +75,6 @@ export function indexDocTool(ctx, config) {
       return store.commit((s) => {
         s.setEntries(rel, entries)
         s.markFile(rel, { sha256: hash, size, type: 'doc', indexedAt: new Date().toISOString() })
-        linkEntries(s)
         const preview = entries
           .map((e) => `  - ${e.title} @ ${rel}:${e.sourceLine}`)
           .join('\n')

package/src/tools/index-repo.js

@@ -33,8 +33,8 @@ export async function indexRepository(ctx, config, root, { reindex = false, allo
 
   const flushBatch = () => {
     if (!batch.length) return
-    // 中间批次不做 unseen 清理、不重建链接（最后一批统一做）——否则每批都要遍历整个 store。
-    commitFileUpdates(store, { updates: batch, link: false })
+    // 中间批次不做 unseen 清理（最后一批统一做）——否则每批都要遍历整个 store。
+    commitFileUpdates(store, { updates: batch })
     batch = []
   }
 
@@ -74,12 +74,11 @@ export async function indexRepository(ctx, config, root, { reindex = false, allo
     }
   }
 
-  // 收尾：写完最后一批 + 清理本轮未见到的旧条目 + 重建链接。
+  // 收尾：写完最后一批 + 清理本轮未见到的旧条目。
   // 截断时**不做 unseen 清理**：没扫到的文件不等于被删了。
   const { removed } = commitFileUpdates(store, {
     updates: batch,
     unseen: truncated ? null : seen,
-    link: true,
   })
   const stats = store.stats()
   let report =

package/src/tools/query-memory.js

@@ -6,6 +6,7 @@ import { expandQuery } from '../llm.js'
 import { resolveRoute } from '../llm-route.js'
 import { GlobalStore, cfgInsight, defaultGlobalFile, recordHit } from '../insight-store.js'
 import { recallItems } from '../recall.js'
+import { resolveLinkedSymbols } from '../link.js'
 import { truncate } from '../util/text.js'
 import { stepContent, stepStatus } from '../util/task-view.js'
 function toAbs(root, rel) {
@@ -59,10 +60,6 @@ export function queryMemoryTool(ctx, config) {
       const queries = config.llmQueryExpansion
         ? await expandQuery(ctx.llm, args.query, config.expansionCount, { route: resolveRoute(exec, config) })
         : [args.query]
-      const symbolById = new Map()
-      for (const e of store.allEntries()) {
-        if (e.type === 'symbol') symbolById.set(e.id, e)
-      }
 
       // 会话绑定决定 task 级 insight 的可见性；global 级始终可见。
       const sessionId = exec?.agent?.session?.id
@@ -121,12 +118,12 @@ export function queryMemoryTool(ctx, config) {
             // 条目状态占位（可证伪状态机落地前恒为 exact）。
             // 先立字段，后续状态机到位时只改值、不改输出契约。
             lines.push(`### ${e.title} (score: ${rel})\n- source: ${absSource}\n- status: ${e.status || 'exact'}\n${summaryLine}`)
-            if (e.type === 'doc' && Array.isArray(e.linkedSymbols) && e.linkedSymbols.length) {
-              const refs = e.linkedSymbols.slice(0, 5).map((id) => {
-                const s = symbolById.get(id)
-                return s ? `${s.title} @ ${toAbs(root, s.sourcePath)}:${s.sourceLine}` : id
-              })
-              lines.push(`- references: ${refs.join('; ')}`)
+            if (e.type === 'doc') {
+              // 读取期解算：链接不落盘，按当前符号表排序取前 5（见 src/link.js）
+              const refs = resolveLinkedSymbols(store, e, 5).map(
+                (s) => `${s.title} @ ${toAbs(root, s.sourcePath)}:${s.sourceLine}`,
+              )
+              if (refs.length) lines.push(`- references: ${refs.join('; ')}`)
             }
           }
         }