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

package/CHANGELOG.md

@@ -1,5 +1,76 @@
 # Changelog
 
+## 0.5.11 (2026-09-25)
+
+### 修复：doc↔symbol 链接不再物化进 entry（真实大仓库的内存与索引开销）
+
+`linkedSymbols` 是**跨实体派生关系**（一个 doc chunk 链接到哪些符号，取决于符号表的当前状态），
+旧实现却在索引时把它算好、写进 `entry` 并落盘。实测本仓库自己的 store（11698 文件 / 70119 条目）：
+
+- 17174 个 chunk 共 **3,948,420** 个链接槽位，只对应 15,456 个符号，单 chunk 最多 2231 个；
+- 唯一的消费者 `query_memory` 只读前 5 个——存了消费量的 **46 倍**；
+- 加载这个 store 的堆占用 **443MB**，链接槽位是其中最大的一块；
+- 每个索引提交点还要对整库做 O(chunks × symbols) 重扫，并靠 `markFile` 标脏追失效，
+  否则"文档先索引、符号后到"会永久丢链接。
+
+现在链接在**读取期**用每 store 的符号索引解算（`src/link.js` 的 `resolveLinkedSymbols`）：
+纯 latin 符号名走倒排表按整词查，CJK/混合名保留原有边界语义的正则回退；成本 O(本 chunk 词数)，
+与符号表规模无关。排序改为命中次数 → 名字长度 → id（旧实现交给消费者的前 5 个是符号表插入序，
+即"任意 5 个"，这是本次一并修掉的行为）。
+
+- **内存**：同一 store 的加载堆占用 **443MB → 129–196MB**，RSS **581MB → ~300MB**；
+- `linkedSymbols` 在加载时从旧 shard 剥离、写入时不再产生；磁盘上的存量 shard 会在该文件
+  下次重新索引时自然压实（不主动重写 11698 个 shard）；
+- 删除 `linkEntries` 导出，以及 `commitFileUpdates` 的 `link` 参数（它只为"中间批次跳过、
+  最后一批统一重建链接"而存在）；`enhancer` / `index-doc` 里的链接重建调用一并移除；
+- `query_memory` 的 `references` 输出格式不变，`test/run-test.mjs` 的链接用例改为断言
+  解析器行为，并新增"文档先索引、符号后到也能解出"与"limit / 排序"回归。
+
+### 修复：其余派生/中间字段与两处无界缓存（体积、内存、轮询）
+
+第一轮去掉了链接，这一轮把剩下的放大源和常驻开销一起收掉。同一个 store（11698 文件 /
+70119 条目 / 索引源码 108.5MB）实测：**落盘 361MB → 93MB**（老 store 由下面的自动压实
+收敛；再叠加 type-cache 自愈清理后是 **73MB**），加载 **1017ms → 279ms**，堆占用
+**129–196MB → 101MB**，`recallItems` p50 **53ms → 47ms**。
+
+- **`searchText` 不再落盘**（省 22.7MB）。它是 `weightedFieldText` 的纯派生结果，改成
+  `allEntries()` 在内存里按需物化；写入时与 `linkedSymbols` 一起剥离（`PERSISTED_DERIVED`）。
+  检索语义与输出不变；磁盘与加载解析变少，堆占用基本持平（物化改到首次查询时做）。
+- **符号声明限长成一行**（`oneLineDeclaration`，≤200 字符）。TypeScript enricher 之前把
+  interface 的**全部成员**拼进 `typeSig`、再整体落进 `text`/`typeSig`（实测符号条目平均
+  1.25KB，其中 `text` 648B），而这两个字段没有任何读取方。现在 interface 只留前 6 个成员 +
+  `… +N more`，`typeSig` 不再落盘。代码层 **31% → 19% 源码**，README 声称的"一行声明"
+  由此第一次成立。
+- **storeCache 按字节预算 + LRU**。原来只按个数（32），而单个大仓库 store 实测驻留
+  130–200MB；现在同时限制条数与估算驻留量（256MB，约 2.5KB/entry），命中会把条目挪到
+  队尾，热的不会先被逐出。
+- **删除 type-cache（TS 增强结果缓存）**。它按内容哈希缓存增强结果，但三个增强入口
+  （lazy 的 `fs/observed`、watch 轮询、`index_repo`）**都只在"文件已变更并重新索引"之后**
+  才触发，此时内容哈希必然是新值——这个缓存永远命中不了。实测本仓库残留 9827 个文件
+  （`du` 41MB，内容其实 9.2MB，约 31MB 是 4KB 块开销）。现在 `load()` 会自愈删除该目录；
+  文件变更照常触发增强，进程内仍由 `enhanceQueue` 按 (relPath, 内容哈希) 去重。
+- **watch 轮询空闲退避**。轮询是 O(树) 的 walkDir + 逐文件 stat（本仓库实测 58–87ms），
+  原来固定一轮、不管有没有改动都在磨 I/O。现在改成递归 `setTimeout`：无变化时翻倍
+  退避到最长 2 分钟，任何变化立即回到 `watchInterval`。基准间隔同时 **15s → 30s**
+  （仍可配置）。
+- **删除死代码** `rankEntries` / `rankEntriesMerged` / `store.searchEntries`：它们每次调用
+  都 `buildBm25` 全库分词（70k 条目实测 p50 1.4s），生产路径没有调用方；相关测试改用线上
+  真正跑的 `rankEntriesStreaming` / `rankEntriesMergedScored`。
+
+**存量 store 的压实是自动且有界的**：加载时把带派生字段的老分片放进待压实队列，此后任意一次
+`save()`（watch 轮询、索引、写入都会触发）最多补写 `COMPACT_BATCH = 200` 个分片，直到队列
+清空。升级后不需要重新索引，也不会在首次启动时一次性重写整库；想让它立刻跑完，随便索引一次
+即可。为了让压实不产生副作用，IDF 缓存的失效键也从"任何脏写"改成 entries 的变更计数
+（`_entriesVersion`）——IDF 只依赖 entries，只写经验/insight 或只做压实都不该重建它。
+
+### 文档
+
+- README 的 `npm test` 断言与实测对齐：360 → **476**（核心 184 → 205、host-contract 9 → 10；
+  补上此前漏记的 task-view 6 / root-guards 79 / store-gitignore 9）；
+- 两份 README 的"交叉链接"机制描述由"索引后挂载到条目"改为"读取期按当前符号表解算"；
+- `watchInterval` 文档补充空闲退避语义；"紧凑性"一节改用实测区间（符号稀疏项目 ~0.5%，
+  符号密集的 TS monorepo ~19%），不再把 0.5% 当普遍值。
+
 ## 0.5.10 (2026-09-24)
 
 ### 修复：共享临时目录仍然是可用的记忆根（issue #5 现场复核的补充发现）

package/README.md

@@ -91,7 +91,7 @@ The design follows four principles:
 
 - **Volatility** — context is ephemeral; it is lost when a session is compacted.
 - **Persistence** — the **memory** is stored on disk and survives compaction and new sessions.
-- **Compactness** — the code layer stores one declaration line per symbol, so code-heavy projects stay near **0.5% of the source** (8.8 MB of source → 49 KB of index in the example project), and **recall** replaces re-reading the full file. The document layer is heavier by design: each chunk keeps a ≤300-char injected `summary`, a bounded `terms` set covering the whole chunk for retrieval, and a precomputed `searchText`. Measured on a docs-only corpus (179 chunks / 225 KB of Markdown): `terms` ≈ **27.5%** of source and the on-disk store ≈ **166%** of source — so on doc-heavy projects budget for roughly the docs themselves, not 0.5%.
+- **Compactness** — the code layer stores one bounded declaration line per symbol (≤200 chars) and the document layer keeps a ≤300-char `summary` plus a bounded `terms` set per chunk. **Derived data is never stored**: doc→symbol links and the BM25 `searchText` are computed at read time. How small the index ends up depends on symbol density, so treat "0.5%" as the sparse end of the range, not a guarantee: a Java/Vue project measured **~0.5% of source** (8.8 MB → 49 KB), while a symbol-dense TypeScript monorepo (11.7k files / 108 MB indexed) measured **~19%** for the code layer and **~106%** for the document layer. On a docs-only corpus (179 chunks / 225 KB of Markdown) `terms` ≈ **27.5%** of source and the on-disk store ≈ **166%** of source — on doc-heavy projects budget for roughly the docs themselves.
 - **Verifiability** — **recalls** carry a `path:line` citation where applicable, so the agent can confirm details against the source.
 
 Building the **memory** does not require an upfront scan: files are memorized as the model reads them, so the **memory** grows to cover exactly what has been worked with. Re-reading a file that has not changed is a no-op (content hash), so the **memory** stays fresh with minimal ongoing overhead.
@@ -117,7 +117,7 @@ The store is per-project and follows the codebase: changed files are re-extracte
 Stores created before v0.2.0 (single `entries.json` / `index.json`) migrate automatically and idempotently on first load. Within one dsh process, all tool calls share a single in-memory store per project, so hot-path indexing writes only the shard that changed.
 
 - **Incremental** — content hash per file; only changed files are re-extracted.
-- **Cross-linking** — after indexing, doc summaries are matched against symbol names; matches are attached to the doc entry as `references` and surfaced by `query_memory`.
+- **Cross-linking** — when `query_memory` returns a doc chunk, it resolves the symbols that chunk mentions against the **current** symbol table and appends them as `references`. Links are computed at read time, so they cannot go stale and are not stored in the index (a doc indexed before its symbols still links correctly).
 - **Query expansion** — when `llmQueryExpansion` is on, `query_memory` asks `ctx.llm` to rewrite the query into several variants (synonyms, EN/CN, identifier guesses) and merges BM25 scores across variants; when off, queries never touch the LLM. Indexing itself is model-free: keywords are rule-derived (title-weighted top terms), and doc↔symbol links surface English symbol names from Chinese hits.
 - **Consistency** — the fact layer follows the codebase (hash re-extract / remove-on-delete); the experience layer is retrieval-only with supersede and `forget`. Store writes are serialized per memory directory; the lock is in-process, so avoid running multiple dsh instances against the same project store concurrently.
 
@@ -152,7 +152,7 @@ The workflow panel is collapsible, automatically adapts to dsh and theme plugin
 | `lazyIndexing` | true | index files the moment the model reads them (`fs/observed`) |
 | `autoIndexOnFirstUse` | false | full scan of the current working directory on plugin load (opt-in) |
 | `watch` | true | enable the background refresh |
-| `watchInterval` | 15 | poll interval (seconds) |
+| `watchInterval` | 30 | base poll interval (seconds); idle polls back off up to 2 minutes and reset to this value on any change |
 | `maxScanFiles` | 20000 | hard cap on files per scan pass; a truncated pass is reported and does not remove the entries it did not reach. Set `0` to disable the cap |
 | `maxScanDepth` | 12 | hard cap on directory depth per scan pass. Set `0` to disable |
 | `allowUnsafeRoots` | false | allow **explicit** tool calls (`index_repo`/`watch_repo`/`remember` with a `root`) to target a directory on the excluded list. Automatic paths (lazy indexing, session audit, TaskBridge, `autoIndexOnFirstUse`) stay inert in these directories regardless |
@@ -211,7 +211,7 @@ Settings live in the plugin's config object. To change them, add an override ent
     autoIndexOnFirstUse: false  # off: no upfront full scan (default)
     llmQueryExpansion: false    # off: do not spend tokens on LLM query expansion (default)
     watch: true                 # on: background refresh for watched roots (default)
-    watchInterval: 15           # poll interval in seconds
+    watchInterval: 30           # base poll interval; idle polls back off to at most 2 min
     maxScanFiles: 20000         # per-scan file cap (truncation is reported, never deletes)
     maxScanDepth: 12            # per-scan directory-depth cap
     enableTypeScript: true      # on: L2 TS enhancement when TS is installed (default)
@@ -297,7 +297,7 @@ These commands are for **maintaining the plugin code** — regular users do not
 
 ```bash
 npm install
-npm test                    # 360 tests (184 core + 16 TaskBridge + 12 insight-store + 9 insight-actions + 8 doc-index + 7 auto-inject + 9 host-contract + 5 reflection + 4 llm-route + 2 client-hints + 8 recall + 14 readiness + 7 insight-derive + 7 readiness-eval + 6 ops + 8 injection-audit + 5 injection-budget + 6 injection-scenarios + 18 bugfix-0.5.7 + 3 client-icons + 10 client-slash + 5 workflow-command + 7 client-session-id)
+npm test                    # 476 tests (205 core + 16 TaskBridge + 12 insight-store + 9 insight-actions + 8 doc-index + 7 auto-inject + 10 host-contract + 5 reflection + 4 llm-route + 2 client-hints + 8 recall + 14 readiness + 7 insight-derive + 7 readiness-eval + 6 ops + 8 injection-audit + 5 injection-budget + 6 injection-scenarios + 18 bugfix-0.5.7 + 3 client-icons + 10 client-slash + 5 workflow-command + 7 client-session-id + 6 task-view + 79 root-guards + 9 store-gitignore)
 npm run eval:injection      # scenario P/R on the synthetic pool: 14/14 hits, 0 false positives, control group clean
 npm run eval:injection -- --store .dsh-project-memory/insights.json   # replay on YOUR store; control group is a hard gate
 npm run selfcheck:triggers  # which entries can still push, which declarations are dead (reads your local store)

package/README.zh-CN.md

@@ -88,7 +88,7 @@ dsh plugin --profile web add /path/to/dsh-project-memory.tgz
 
 - **易失性** — 上下文是临时的，会话压缩即丢失。
 - **持久性** — **记忆**存于磁盘，跨压缩与会话保留。
-- **紧凑性** — 代码层每个符号只存一行声明，所以代码为主的项目仍约 **0.5% 源码体积**（示例项目中 8.8 MB 源码 → 49 KB 索引），**召回**替代了通读整个文件。文档层按设计更重：每个 chunk 保留 ≤300 字符的注入 `summary`、覆盖整 chunk 的 `terms`，以及预计算的 `searchText`。纯文档语料实测（179 chunk / 225 KB Markdown）：`terms` ≈ 源码 **27.5%**，整库落盘 ≈ 源码 **166%**——文档占比高的项目请按「约等于文档本身大小」估，而不是 0.5%。
+- **紧凑性** — 代码层每个符号只存一行声明（≤200 字符），文档层每个 chunk 保留 ≤300 字符的 `summary` 与有界的 `terms`。**派生数据一律不落盘**：doc→symbol 链接与 BM25 的 `searchText` 都在读取期计算。最终体积取决于符号密度，所以「0.5%」是区间里稀疏的那一端、不是承诺：Java/Vue 项目实测约 **0.5% 源码**（8.8 MB → 49 KB），而符号密集的 TypeScript monorepo（11.7k 文件 / 108 MB 索引）实测代码层约 **19%**、文档层约 **106%**。纯文档语料实测（179 chunk / 225 KB Markdown）`terms` ≈ 源码 **27.5%**、整库落盘 ≈ 源码 **166%**——文档占比高的项目请按「约等于文档本身大小」估。
 - **可核验性** — **召回**在适用时携带 `路径:行号` 引用，agent 可对照源文件核实。
 
 构建**记忆**无需预先全量扫描：文件在模型读取时被记忆，**记忆**恰好覆盖实际处理过的内容。未变更的文件重读是空操作（内容哈希），因此**记忆**的持续维护开销很低。
@@ -114,7 +114,7 @@ dsh plugin --profile web add /path/to/dsh-project-memory.tgz
 v0.2.0 之前创建的库（单文件 `entries.json` / `index.json`）在首次加载时自动幂等迁移。同一个 dsh 进程内，所有工具调用共享每个项目的单一内存 store 实例，热路径索引只写发生变化的那一个分片。
 
 - **增量** — 按文件内容哈希，仅重新抽取变更文件。
-- **交叉链接** — 索引后将文档摘要与符号名匹配，命中符号以 `references` 挂载到文档条目，由 `query_memory` 带出。
+- **交叉链接** — `query_memory` 返回文档 chunk 时，按**当前**符号表解算它提到的符号，以 `references` 带出。链接在读取期解算、不落盘，因此不会过期（文档先索引、符号后到也能链上），也不占存储。
 - **查询扩展** — `llmQueryExpansion` 开启时，`query_memory` 让 `ctx.llm` 将查询改写为多个变体（同义词、中英、符号名猜测），再跨变体合并 BM25 分数；关闭时查询完全不碰 LLM。索引本身不调用模型：keywords 由规则推导（标题加权词项），doc↔symbol 链接也会从中文命中带出英文符号名。
 - **一致性** — 事实层跟随代码库（哈希重抽 / 删除即移除）；经验层仅检索，配合覆盖与 `forget` 机制。每个记忆目录的写入走同步事务 `store.commit(fn)`：fn 内完成校验与变更、成功后才原子落盘，单进程内天然串行；请避免多个 dsh 实例同时写同一项目存储。
 
@@ -149,7 +149,7 @@ TaskPanel (Container)
 | `lazyIndexing` | true | 模型读取文件的瞬间即索引（`fs/observed`） |
 | `autoIndexOnFirstUse` | false | 插件加载时对当前工作目录做全量扫描（可选） |
 | `watch` | true | 启用后台刷新 |
-| `watchInterval` | 15 | 轮询间隔（秒） |
+| `watchInterval` | 30 | 基础轮询间隔（秒）；空闲时逐步退避到最长 2 分钟，一有变化立即回到该值 |
 | `maxScanFiles` | 20000 | 单次扫描的文件数硬上限；被截断时会在报告里说明，且不会删除没扫到的条目。设 `0` 取消上限 |
 | `maxScanDepth` | 12 | 单次扫描的目录深度硬上限。设 `0` 取消 |
 | `allowUnsafeRoots` | false | 允许**显式**工具调用（带 `root` 的 `index_repo`/`watch_repo`/`remember`）指向排除名单上的目录。自动路径（懒索引、会话审计、TaskBridge、`autoIndexOnFirstUse`）无论此项如何都不会越权 |
@@ -208,7 +208,7 @@ store 建在被索引的目录树里，并且**自我忽略**：它在自己目
     autoIndexOnFirstUse: false  # 关闭：不做加载时的全量扫描（默认）
     llmQueryExpansion: false    # 关闭：不用 LLM 扩展查询，节省 token（默认）
     watch: true                 # 开启：被监听根目录后台保持新鲜（默认）
-    watchInterval: 15           # 轮询间隔（秒）
+    watchInterval: 30           # 基础轮询间隔；空闲时退避到最长 2 分钟
     maxScanFiles: 20000         # 单次扫描文件上限（截断会报告，且不会误删旧条目）
     maxScanDepth: 12            # 单次扫描目录深度上限
     enableTypeScript: true      # 开启：装了 TS 时启用 L2 语义增强（默认）
@@ -294,7 +294,7 @@ node scripts/bench.mjs /你的/项目路径 [--json] [--samples 100] [--no-pdf]
 
 ```bash
 npm install
-npm test                    # 360 项测试（核心 184 + TaskBridge 16 + insight-store 12 + insight-actions 9 + doc-index 8 + auto-inject 7 + host-contract 9 + reflection 5 + llm-route 4 + client-hints 2 + recall 8 + readiness 14 + insight-derive 7 + readiness-eval 7 + ops 6 + injection-audit 8 + injection-budget 5 + injection-scenarios 6 + bugfix-0.5.7 18 + client-icons 3 + client-slash 10 + workflow-command 5 + client-session-id 7）
+npm test                    # 476 项测试（核心 205 + TaskBridge 16 + insight-store 12 + insight-actions 9 + doc-index 8 + auto-inject 7 + host-contract 10 + reflection 5 + llm-route 4 + client-hints 2 + recall 8 + readiness 14 + insight-derive 7 + readiness-eval 7 + ops 6 + injection-audit 8 + injection-budget 5 + injection-scenarios 6 + bugfix-0.5.7 18 + client-icons 3 + client-slash 10 + workflow-command 5 + client-session-id 7 + task-view 6 + root-guards 79 + store-gitignore 9）
 npm run eval:injection      # 合成池上的场景 P/R：命中 14/14、假阳性 0、对照组零注入
 npm run eval:injection -- --store .dsh-project-memory/insights.json   # 用你自己的 store 重放；对照组是硬闸门
 npm run selfcheck:triggers  # 哪些条目还推得动、哪些声明是死的（读你本地的 store）

package/cordis.patch.yml

@@ -10,7 +10,7 @@
         lazyIndexing: true
         autoIndexOnFirstUse: false
         watch: true
-        watchInterval: 15
+        watchInterval: 30
         # 危险根护栏（家目录 / 文件系统根 / 系统与包管理器前缀整体扫描会吃满内存）。
         # 自动路径永远不越权；true 只放开**显式**带 root 的工具调用。
         allowUnsafeRoots: false

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@yolk_vat-y/dsh-project-memory",
-  "version": "0.5.10",
+  "version": "0.5.11",
   "description": "Persistent project memory for dsh agents: index docs (PDF/Markdown/text) and code symbols into a searchable per-workspace store, recall them with cited sources, and keep experience entries (problems -> solutions) searchable on demand.",
   "type": "module",
   "main": "src/index.js",

package/scripts/bench-synthetic.mjs

@@ -5,7 +5,7 @@
  *   - store.js       : load / commit / addExperience(findSupersede) / removeExperience
  *   - util/search.js : buildBm25 / rankEntriesStreaming / rankExperienceScored
  *   - symbols.js     : scanSymbols（零 token 符号抽取，无 LLM）
- *   - link.js        : linkEntries（doc↔symbol 交叉链接）
+ *   - link.js        : resolveLinkedSymbols（doc↔symbol 交叉链接，读取期解算）
  *   - insight-store.js: GlobalStore read/write + saveInsight（归一化去重）
  *   - similarity.js  : normalizedTokenOverlap（去重阈值判定）
  *
@@ -21,7 +21,6 @@ import { performance } from 'node:perf_hooks'
 import { ProjectMemoryStore } from '../src/store.js'
 import { walkDir, readFileForIndex, relativePath, storeKey, isSupportedCode } from '../src/util/fs.js'
 import { scanSymbols } from '../src/symbols.js'
-import { linkEntries } from '../src/link.js'
 import { rankEntriesStreaming, rankExperienceScored, makeSearchText } from '../src/util/search.js'
 import { GlobalStore, saveInsight, normalizeInsight } from '../src/insight-store.js'
 import { normalizedTokenOverlap } from '../src/similarity.js'
@@ -108,7 +107,6 @@ async function coldIndex(root, config) {
   const report = store.commit((s) => {
     for (const u of fileUpdates) s.applyFileUpdate(u.rel, u)
     for (const rel of Object.keys(s.files)) if (!seen.has(rel)) s.removeFile(rel)
-    linkEntries(s)
     return s.stats()
   })
   return { report, store }
@@ -146,7 +144,7 @@ async function main() {
   console.log(`\n[语料生成] ${FILES} 文件写盘耗时 ${genMs.toFixed(0)} ms`)
 
   // ---------- 1. 冷索引（完整内核管线，无 LLM）----------
-  console.log('\n--- 1. 冷索引 index_repo 内核管线（walk + sha256 + scanSymbols + linkEntries + commit）---')
+  console.log('\n--- 1. 冷索引 index_repo 内核管线（walk + sha256 + scanSymbols + commit）---')
   const idxTimes = []
   let entriesCount = 0
   for (let r = 0; r < 3; r++) {

package/src/enhancer.js

@@ -1,8 +1,8 @@
 import { createHash } from 'node:crypto'
-import { readFileSync, writeFileSync, mkdirSync, existsSync } from 'node:fs'
+import { readFileSync } from 'node:fs'
 import { join } from 'node:path'
 import { createRequire } from 'node:module'
-import { linkEntries } from './link.js'
+import { oneLineDeclaration } from './util/text.js'
 
 const require = createRequire(import.meta.url)
 
@@ -98,34 +98,11 @@ const PRIORITY = {
 const enhanceQueue = []
 let processing = false
 
-function getCacheDirForRoot(root, config) {
-  return join(root, config.memoryDir || '.dsh-project-memory', 'type-cache')
-}
-
 function getCacheKey(content) {
   const hash = createHash('sha256').update(content).digest('hex').slice(0, 16)
   return hash
 }
 
-async function loadTypeCache(cacheDir, key) {
-  const file = join(cacheDir, `${key}.json`)
-  if (!existsSync(file)) return null
-  try {
-    const data = JSON.parse(readFileSync(file, 'utf8'))
-    return data
-  } catch {
-    return null
-  }
-}
-
-async function saveTypeCache(cacheDir, key, data) {
-  try {
-    if (!existsSync(cacheDir)) mkdirSync(cacheDir, { recursive: true })
-    const file = join(cacheDir, `${key}.json`)
-    writeFileSync(file, JSON.stringify(data))
-  } catch {}
-}
-
 export function isTypeScriptFile(filePath) {
   const ext = filePath.slice(filePath.lastIndexOf('.')).toLowerCase()
   return ext === '.ts' || ext === '.tsx' || ext === '.js' || ext === '.jsx' ||
@@ -264,11 +241,14 @@ export function deepParseWithTS(filePath, content) {
         if (!m.name) return null
         const type = m.type ? getTypeStr(checker.getTypeAtLocation(m.type)) : 'any'
         return `${m.name.getText()}: ${type}`
-      }).filter(Boolean).join('; ')
+      }).filter(Boolean)
+      // 成员列表必须有界：一个大 interface 的全部成员拼起来能到几 KB，而它整条只作为
+      // "一行声明"存在。只留前 6 个，其余记数量。
+      const shown = members.slice(0, 6)
       symbols.push({
         name: node.name.getText(),
         kind: 'interface',
-        typeSig: `{ ${members} }`,
+        typeSig: `{ ${shown.join('; ')}${members.length > shown.length ? `; … +${members.length - shown.length} more` : ''} }`,
         line: getLine(node)
       })
     } else if (ts.isTypeAliasDeclaration(node)) {
@@ -326,18 +306,8 @@ export function enqueueEnhance(store, relPath, filePath, priority = PRIORITY.BAT
   const p = (async () => {
     try {
       const content = readFileSync(filePath, 'utf8')
-      const cacheKey = getCacheKey(content)
-      const cacheDir = getCacheDirForRoot(root || process.cwd(), config)
-      const cached = await loadTypeCache(cacheDir, cacheKey)
-      if (cached) {
-        // Cache hit: persist via store.commit
-        await store.commit(fn => applyEnhancedSymbols(fn, relPath, cached.symbols))
-        return
-      }
-
       const enhanced = deepParseWithTS(filePath, content)
       if (enhanced?.length) {
-        await saveTypeCache(cacheDir, cacheKey, { symbols: enhanced })
         await store.commit(fn => applyEnhancedSymbols(fn, relPath, enhanced))
       }
     } catch (err) {
@@ -396,8 +366,10 @@ function applyEnhancedSymbols(fn, relPath, enhanced) {
     if (!enh || nameOf(e) !== enh.name) return e
     return {
       ...e,
-      text: `${enh.name}${enh.typeSig} -- ${relPath}:${enh.line}`,
-      typeSig: enh.typeSig,
+      // 一行声明（限长）。typeSig 只是构建期的中间量，不落进 entry：它没有读取方，
+      // 且 interface 的 typeSig 就是整个类型体，是符号条目变胖的主因。
+      text: oneLineDeclaration(`${enh.name}${enh.typeSig} -- ${relPath}:${enh.line}`),
+      typeSig: undefined,
       enhanced: true
     }
   })
@@ -420,7 +392,7 @@ function applyEnhancedSymbols(fn, relPath, enhanced) {
       type: 'symbol',
       title: `${s.name} (${s.kind})`,
       keywords: [s.name, s.kind],
-      text: `${s.name}${s.typeSig} -- ${relPath}:${s.line}`,
+      text: oneLineDeclaration(`${s.name}${s.typeSig} -- ${relPath}:${s.line}`),
       enhanced: true
     })
   }
@@ -428,8 +400,7 @@ function applyEnhancedSymbols(fn, relPath, enhanced) {
   // Write to store.entries via setEntries so the shard is marked dirty and persisted
   fn.setEntries(relPath, [...mergedEntries, ...newEntries])
 
-  // Refresh doc<->symbol links for newly added symbols
-  if (newEntries.length) linkEntries(fn)
+  // doc<->symbol 链接不在这里维护：它是读取期解算的派生关系（见 src/link.js）
 
   // Also update fn.files metadata
   if (fn.files[relPath]) {

package/src/index-pipeline.js

@@ -10,7 +10,6 @@ import { isSupportedCode, isSupportedDoc, readFileForIndex } from './util/fs.js'
 import { buildDocEntries } from './doc-pipeline.js'
 import { docEntriesNeedBackfill } from './doc-index.js'
 import { scanSymbols } from './symbols.js'
-import { linkEntries } from './link.js'
 
 /** 不索引的后缀。 */
 export const UNSUPPORTED = 'unsupported'
@@ -88,13 +87,16 @@ export function toFileUpdate(rel, plan, record) {
 }
 
 /**
- * 一批更新一次性落盘：写入 / 移除 → 清掉本轮未见到的旧条目 → 重建链接。
+ * 一批更新一次性落盘：写入 / 移除 → 清掉本轮未见到的旧条目。
  * 单事务的好处是 store 只 save 一次，watch 每轮不会反复重写。
  *
+ * 不再重建 doc↔symbol 链接：链接是读取期解算的派生关系（见 src/link.js），
+ * 所以这里也没有了那个「中间批次跳过链接、最后一批统一做」的 `link` 参数。
+ *
  * @returns {{stale: string[], removed: number}} stale 是 CAS 失败（并发改动）的 rel，
  *   调用方应让它们保持「未落快照」状态，下一轮重试。
  */
-export function commitFileUpdates(store, { updates, unseen = null, link = true }) {
+export function commitFileUpdates(store, { updates, unseen = null }) {
   const stale = []
   let removed = 0
   store.commit((s) => {
@@ -113,7 +115,6 @@ export function commitFileUpdates(store, { updates, unseen = null, link = true }
         }
       }
     }
-    if (link) linkEntries(s)
   })
   return { stale, removed }
 }

package/src/index.js

@@ -40,7 +40,7 @@ export const Config = Schema.object({
   lazyIndexing: Schema.boolean().default(true),
   autoIndexOnFirstUse: Schema.boolean().default(false),
   watch: Schema.boolean().default(true),
-  watchInterval: Schema.number().default(15),
+  watchInterval: Schema.number().default(30),
   // 危险根护栏（issue #5）：家目录 / 文件系统根 / 系统目录 / 包管理器前缀（/opt/homebrew …）
   // 整体扫描会吃满内存，默认一律拒绝。**自动路径永不越权**——懒索引、会话审计、任务桥在
   // 这类目录里始终零副作用；这个开关只放开**显式**工具调用（index_repo / watch_repo /

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'
@@ -14,9 +14,38 @@ 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()
@@ -26,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 {
@@ -84,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() {
@@ -93,20 +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
   }
 
@@ -164,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)]) {
@@ -184,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 服务，不删除；
@@ -314,9 +397,11 @@ export class ProjectMemoryStore {
 
   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 ||
@@ -335,10 +420,20 @@ export class ProjectMemoryStore {
       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)
       }
@@ -374,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
   }
 
@@ -438,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)
   }
@@ -451,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('; ')}`)
             }
           }
         }

package/src/util/search.js

@@ -141,15 +141,10 @@ export function makeSearchText(entry) {
   return weightedFieldText(entry).toLowerCase()
 }
 
-export function rankEntries(entries, query, limit = 8) {
-  const bm25 = buildBm25(entries, weightedFieldText)
-  const scored = bm25.score(query)
-  return scored.slice(0, limit).map((r) => r.doc)
-}
-
-export function rankEntriesMerged(entries, queries, limit = 8) {
-  return rankEntriesMergedScored(entries, queries, limit).map((r) => r.entry)
-}
+// 说明：文档/符号的线上检索走 `rankEntriesStreaming`（recall.js），它不重建整库 BM25，
+// 而是用预物化的 `searchText` + 每 store 缓存的 idf。曾经存在的 `rankEntries` /
+// `rankEntriesMerged`（每次调用都 buildBm25 全库分词，70k 条目实测 p50 1.4s）已删除——
+// 它们在生产路径上没有调用方，留着只会被误用。
 
 export function rankEntriesMergedScored(entries, queries, limit = 8) {
   if (!queries.length) return entries.slice(0, limit).map((entry) => ({ entry, score: 0 }))

package/src/util/text.js

@@ -20,6 +20,22 @@ export function truncate(text, maxChars) {
 
 export const MAX_SUMMARY = 300
 
+/** 符号声明行的上限。未限长的 interface 类型体会把一行撑到几 KB。 */
+export const MAX_DECLARATION = 200
+
+/**
+ * 符号的一行声明：压平空白并限长。实测一个真实 TS 仓库里，未限长的类型体正文让
+ * 符号 `text` 字段达到 5.6MB（而它当前没有任何消费者）；限长后保住"一行声明"的语义，
+ * 又不会把代码层体积从 ~0.5% 推到 30%+。
+ * @param {unknown} text
+ * @param {number} max
+ * @returns {string}
+ */
+export function oneLineDeclaration(text, max = MAX_DECLARATION) {
+  const flat = String(text || '').replace(/\s+/g, ' ').trim()
+  return flat.length > max ? `${flat.slice(0, max - 1)}…` : flat
+}
+
 /** 注入用短摘要：压平空白，按句子边界截断到 max 字符。纯函数，无 LLM。 */
 export function summarizeText(text, max = MAX_SUMMARY) {
   const flat = String(text || '').replace(/\s+/g, ' ').trim()

package/src/watch.js

@@ -79,30 +79,54 @@ export class WatchManager {
     return this.roots.delete(root)
   }
 
-  start(intervalMs = 15000) {
+  start(intervalMs = 30000) {
     if (this.timer) return
-    // NaN/undefined 会让 setInterval 退化成 1ms 轮询（Node 只发一条 TimeoutNaNWarning），
-    // 足以打满事件循环让 agent 无法响应；非法值回退到 15s。
+    // NaN/undefined 会让定时器退化成 1ms 轮询（Node 只发一条 TimeoutNaNWarning），
+    // 足以打满事件循环让 agent 无法响应；非法值回退到默认 30s。
     const raw = Number(intervalMs)
-    const ms = Number.isFinite(raw) ? Math.max(raw, 1000) : 15000
-    this.timer = setInterval(() => this.poll(), ms)
+    this._baseInterval = Number.isFinite(raw) ? Math.max(raw, 1000) : 30000
+    // 空闲退避：连续没有变化的轮次把间隔翻倍，最长 2 分钟一轮；任何变化立刻回到 base。
+    // 轮询本身是 O(树) 的 walkDir + 逐文件 stat（本仓库一轮实测 58–87ms），
+    // 常驻 15s 一轮意味着不管有没有改动都在磨 I/O。
+    this._maxInterval = Math.max(this._baseInterval, Math.min(this._baseInterval * 8, 120000))
+    this._interval = this._baseInterval
+    this._stopped = false
+    this._schedule()
+  }
+
+  _schedule() {
+    this.timer = setTimeout(() => this._tick(), this._interval)
     if (this.timer.unref) this.timer.unref()
   }
 
+  async _tick() {
+    this.timer = null
+    let changed = false
+    try {
+      changed = await this.poll()
+    } catch {
+      // poll() 内部已逐根兜底；这里保证无论发生什么都一定排下一轮，不会静默停掉 watch。
+    }
+    if (this._stopped) return // 轮询期间被 stop() 了，不要再排下一轮
+    this._interval = changed ? this._baseInterval : Math.min(this._interval * 2, this._maxInterval)
+    this._schedule()
+  }
+
   stop() {
-    if (this.timer) clearInterval(this.timer)
+    this._stopped = true
+    if (this.timer) clearTimeout(this.timer)
     this.timer = null
   }
 
   async poll() {
-    // setInterval 不等待上一轮：大仓库/文档 LLM 摘要让一轮 >interval 时，
-    // 轮询会叠加成并发索引，最终打满事件循环。用重入锁让慢轮询自然跳过。
-    if (this._polling) return
+    // 慢轮询期间再次进入直接跳过（递归 setTimeout 下正常不会叠加，保留作防御）。
+    if (this._polling) return false
     this._polling = true
+    let changed = false
     try {
       for (const [root, state] of this.roots) {
         try {
-          await this.pollRoot(root, state)
+          if (await this.pollRoot(root, state)) changed = true
         } catch (err) {
           console.error(`[dsh-project-memory] watch poll failed for ${root}: ${err.message}`)
         }
@@ -110,6 +134,7 @@ export class WatchManager {
     } finally {
       this._polling = false
     }
+    return changed
   }
 
   async pollRoot(root, state) {
@@ -179,14 +204,15 @@ export class WatchManager {
     // 单事务写盘；CAS 失败的条目本轮不落快照，下一轮自然重试。
     // 截断时**不传 unseen**：没扫到的文件不等于被删了，否则一份被上限截掉的树每轮都会
     // 把自己的记忆删掉一半（先删再下轮重新索引，纯粹的抖动）。
-    const { stale } = commitFileUpdates(state.store, {
+    const { stale, removed } = commitFileUpdates(state.store, {
       updates,
       unseen: truncated ? null : seen,
-      link: updates.length > 0,
     })
     const failed = new Set(stale)
+    let applied = 0
     for (const update of updates) {
       if (failed.has(update.rel)) continue
+      applied++
       state.snapshot[update.rel] = signatures.get(update.rel)
       if (update.type !== 'code') continue
       const filePath = path.join(root, update.rel)
@@ -194,5 +220,7 @@ export class WatchManager {
         onFileChanged(state.store, update.rel, filePath, this.config, root)
       }
     }
+    // 有变化 → 下一轮回到 base 间隔；纯空转 → 退避。
+    return applied > 0 || removed > 0
   }
 }