dsh-macro-memory 0.0.0-stage → 0.4.0

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
Files changed (132) hide show
  1. package/LICENSE +21 -0
  2. package/README.md +506 -2
  3. package/cordis.patch.yml +6 -0
  4. package/lib/client.js +3623 -0
  5. package/lib/index.js +502 -0
  6. package/lib/macro/brand.js +82 -0
  7. package/lib/macro/bridge.js +158 -0
  8. package/lib/macro/chain.js +206 -0
  9. package/lib/macro/contract.js +471 -0
  10. package/lib/macro/cost.js +164 -0
  11. package/lib/macro/defs/admin.js +442 -0
  12. package/lib/macro/defs/dream.js +24 -0
  13. package/lib/macro/defs/link.js +257 -0
  14. package/lib/macro/defs/project.js +25 -0
  15. package/lib/macro/defs/read.js +160 -0
  16. package/lib/macro/defs/remember.js +411 -0
  17. package/lib/macro/defs/search.js +871 -0
  18. package/lib/macro/defs/update.js +161 -0
  19. package/lib/macro/dreamledger.js +1398 -0
  20. package/lib/macro/facade.js +135 -0
  21. package/lib/macro/fusion.js +182 -0
  22. package/lib/macro/linkflow.js +391 -0
  23. package/lib/macro/links.js +448 -0
  24. package/lib/macro/neighbor.js +209 -0
  25. package/lib/macro/panel.js +96 -0
  26. package/lib/macro/prompt.js +139 -0
  27. package/lib/macro/provenance.js +148 -0
  28. package/lib/macro/render.js +35 -0
  29. package/lib/macro/revisions.js +253 -0
  30. package/lib/macro/shared.js +113 -0
  31. package/lib/macro/store.js +103 -0
  32. package/lib/macro/supersede.js +197 -0
  33. package/lib/macro/tokencost.js +90 -0
  34. package/lib/macro/tools.js +67 -0
  35. package/package.json +54 -4
  36. package/vendor/VENDOR.json +23 -0
  37. package/vendor/dsh-memory-nebula/CONTRIBUTING.md +48 -0
  38. package/vendor/dsh-memory-nebula/LICENSE +21 -0
  39. package/vendor/dsh-memory-nebula/README.en.md +203 -0
  40. package/vendor/dsh-memory-nebula/README.md +253 -0
  41. package/vendor/dsh-memory-nebula/SECURITY.md +43 -0
  42. package/vendor/dsh-memory-nebula/SUPPORT.md +33 -0
  43. package/vendor/dsh-memory-nebula/cordis.patch.yml +4 -0
  44. package/vendor/dsh-memory-nebula/lib/client.js +105 -0
  45. package/vendor/dsh-memory-nebula/lib/host/adapters/index.js +279 -0
  46. package/vendor/dsh-memory-nebula/lib/host/adapters/ingest.js +230 -0
  47. package/vendor/dsh-memory-nebula/lib/host/adapters/meow.js +320 -0
  48. package/vendor/dsh-memory-nebula/lib/host/adapters/notes.js +305 -0
  49. package/vendor/dsh-memory-nebula/lib/host/adapters/sqlite.js +287 -0
  50. package/vendor/dsh-memory-nebula/lib/host/adapters/util.js +231 -0
  51. package/vendor/dsh-memory-nebula/lib/host/bridge.js +351 -0
  52. package/vendor/dsh-memory-nebula/lib/host/compress.js +97 -0
  53. package/vendor/dsh-memory-nebula/lib/host/demo.js +357 -0
  54. package/vendor/dsh-memory-nebula/lib/host/diagnostics.js +125 -0
  55. package/vendor/dsh-memory-nebula/lib/host/doctor.js +270 -0
  56. package/vendor/dsh-memory-nebula/lib/host/entities.js +230 -0
  57. package/vendor/dsh-memory-nebula/lib/host/graph.js +1762 -0
  58. package/vendor/dsh-memory-nebula/lib/host/graphcache.js +290 -0
  59. package/vendor/dsh-memory-nebula/lib/host/http.js +993 -0
  60. package/vendor/dsh-memory-nebula/lib/host/injectcfg.js +95 -0
  61. package/vendor/dsh-memory-nebula/lib/host/ledger.js +175 -0
  62. package/vendor/dsh-memory-nebula/lib/host/live.js +204 -0
  63. package/vendor/dsh-memory-nebula/lib/host/nebula.js +2105 -0
  64. package/vendor/dsh-memory-nebula/lib/host/page.js +75 -0
  65. package/vendor/dsh-memory-nebula/lib/host/path.js +83 -0
  66. package/vendor/dsh-memory-nebula/lib/host/recall.js +524 -0
  67. package/vendor/dsh-memory-nebula/lib/host/share.js +633 -0
  68. package/vendor/dsh-memory-nebula/lib/host/sources.js +266 -0
  69. package/vendor/dsh-memory-nebula/lib/host/store.js +333 -0
  70. package/vendor/dsh-memory-nebula/lib/host/text.js +410 -0
  71. package/vendor/dsh-memory-nebula/lib/host/transcripts.js +396 -0
  72. package/vendor/dsh-memory-nebula/lib/index.js +782 -0
  73. package/vendor/dsh-memory-nebula/lib/standalone.mjs +315 -0
  74. package/vendor/dsh-memory-nebula/lib/web/api.js +426 -0
  75. package/vendor/dsh-memory-nebula/lib/web/app.js +4172 -0
  76. package/vendor/dsh-memory-nebula/lib/web/i18n.js +580 -0
  77. package/vendor/dsh-memory-nebula/lib/web/index.html +174 -0
  78. package/vendor/dsh-memory-nebula/lib/web/nav.js +132 -0
  79. package/vendor/dsh-memory-nebula/lib/web/render.js +1890 -0
  80. package/vendor/dsh-memory-nebula/lib/web/space3d.js +1883 -0
  81. package/vendor/dsh-memory-nebula/lib/web/style.css +1402 -0
  82. package/vendor/dsh-memory-nebula/locale/en.json +7 -0
  83. package/vendor/dsh-memory-nebula/locale/zh.json +7 -0
  84. package/vendor/dsh-memory-nebula/market/assets/icon-180.png +0 -0
  85. package/vendor/dsh-memory-nebula/market/assets/icon.svg +40 -0
  86. package/vendor/dsh-memory-nebula/market/index.json +101 -0
  87. package/vendor/dsh-memory-nebula/package.json +87 -0
  88. package/vendor/dsh-memory-nebula/sidecar.ps1 +119 -0
  89. package/vendor/meow-memory/LICENSE +21 -0
  90. package/vendor/meow-memory/README.en.md +192 -0
  91. package/vendor/meow-memory/README.md +174 -0
  92. package/vendor/meow-memory/README.pt-br.md +180 -0
  93. package/vendor/meow-memory/cordis.patch.yml +7 -0
  94. package/vendor/meow-memory/lib/client.js +3344 -0
  95. package/vendor/meow-memory/lib/client.js.map +7 -0
  96. package/vendor/meow-memory/lib/index.js +9802 -0
  97. package/vendor/meow-memory/lib/index.js.map +7 -0
  98. package/vendor/meow-memory/lib/prompts/README.md +65 -0
  99. package/vendor/meow-memory/lib/prompts/en/dream-atomic.md +36 -0
  100. package/vendor/meow-memory/lib/prompts/en/dream-header.md +9 -0
  101. package/vendor/meow-memory/lib/prompts/en/dream-project-summary.md +12 -0
  102. package/vendor/meow-memory/lib/prompts/en/dream-topic.md +27 -0
  103. package/vendor/meow-memory/lib/prompts/en/external-memory-notice.md +8 -0
  104. package/vendor/meow-memory/lib/prompts/en/first-create-notice.md +8 -0
  105. package/vendor/meow-memory/lib/prompts/en/labels.md +98 -0
  106. package/vendor/meow-memory/lib/prompts/en/reflect.md +31 -0
  107. package/vendor/meow-memory/lib/prompts/en/system-guide.md +121 -0
  108. package/vendor/meow-memory/lib/prompts/en/tools.md +83 -0
  109. package/vendor/meow-memory/lib/prompts/en/welcome-guide.md +12 -0
  110. package/vendor/meow-memory/lib/prompts/pt-br/dream-atomic.md +36 -0
  111. package/vendor/meow-memory/lib/prompts/pt-br/dream-header.md +9 -0
  112. package/vendor/meow-memory/lib/prompts/pt-br/dream-project-summary.md +12 -0
  113. package/vendor/meow-memory/lib/prompts/pt-br/dream-topic.md +27 -0
  114. package/vendor/meow-memory/lib/prompts/pt-br/external-memory-notice.md +8 -0
  115. package/vendor/meow-memory/lib/prompts/pt-br/first-create-notice.md +8 -0
  116. package/vendor/meow-memory/lib/prompts/pt-br/labels.md +98 -0
  117. package/vendor/meow-memory/lib/prompts/pt-br/reflect.md +31 -0
  118. package/vendor/meow-memory/lib/prompts/pt-br/system-guide.md +121 -0
  119. package/vendor/meow-memory/lib/prompts/pt-br/tools.md +83 -0
  120. package/vendor/meow-memory/lib/prompts/pt-br/welcome-guide.md +12 -0
  121. package/vendor/meow-memory/lib/prompts/zh/dream-atomic.md +36 -0
  122. package/vendor/meow-memory/lib/prompts/zh/dream-header.md +9 -0
  123. package/vendor/meow-memory/lib/prompts/zh/dream-project-summary.md +19 -0
  124. package/vendor/meow-memory/lib/prompts/zh/dream-topic.md +27 -0
  125. package/vendor/meow-memory/lib/prompts/zh/external-memory-notice.md +8 -0
  126. package/vendor/meow-memory/lib/prompts/zh/first-create-notice.md +8 -0
  127. package/vendor/meow-memory/lib/prompts/zh/labels.md +98 -0
  128. package/vendor/meow-memory/lib/prompts/zh/reflect.md +30 -0
  129. package/vendor/meow-memory/lib/prompts/zh/system-guide.md +119 -0
  130. package/vendor/meow-memory/lib/prompts/zh/tools.md +83 -0
  131. package/vendor/meow-memory/lib/prompts/zh/welcome-guide.md +12 -0
  132. package/vendor/meow-memory/package.json +64 -0
@@ -0,0 +1,1762 @@
1
+ /**
2
+ * 记忆星图的图构建器。
3
+ *
4
+ * 核心原则:**宁可少连线,不可连错线**。
5
+ * 每条边都要能回答「凭什么连在一起」,答案必须是可复述的证据:
6
+ * - 同一个硬实体(路径 / URL / UUID / 文件名 / 邮箱 / 反引号代码)
7
+ * - 同一个项目名(跨工作区才算,因为那是真正的桥)
8
+ * - 稀有关键词重叠(Jaccard 门槛 + df 上限)
9
+ * - 高相似正文(idf 加权 Jaccard,阈值高)
10
+ * - 同一会话里被一起点亮(Hebbian 共激活,出现在 ≥2 次会话才认)
11
+ * - 手工策展(explicit,权重最高)
12
+ */
13
+ import {
14
+ tokenize,
15
+ extractEntities,
16
+ entityStrength,
17
+ idf,
18
+ jaccard,
19
+ intersect,
20
+ overlapSize,
21
+ clip,
22
+ cut,
23
+ hash32,
24
+ } from './text.js'
25
+ // [macro-fusion 0.4.0 · P4] 实体层单独一个文件:它只读节点、只产一份可序列化的 list,
26
+ // 与建边逻辑没有任何耦合。关掉它只需 `entityLayer: false`,图里就当没这回事。
27
+ import { collectEntities } from './entities.js'
28
+
29
+ /**
30
+ * 通用文件名:跨工作区时不作为「同一实体」的证据。
31
+ * 两个项目各有一个 package.json,并不代表它们讲的是同一件事。
32
+ */
33
+ const GENERIC_LEAF = /^(package\.json|package-lock\.json|pnpm-lock\.yaml|index\.(m?[jt]sx?|cjs)|app\.(html|js)|server\.(m?js|cjs)|main\.(m?js|ts)|readme\.md|tsconfig\.json|\.gitignore|styles?\.css|client\.js|lib|dist|src|node_modules|\.env)$/i
34
+
35
+ /** 边类型的展示元数据。 */
36
+ export const EDGE_META = {
37
+ explicit: { label: '策展', zh: '人工连线', rank: 0, hue: 48 },
38
+ project: { label: '同项目', zh: '项目桥', rank: 1, hue: 190 },
39
+ entity: { label: '实体', zh: '同一标识', rank: 2, hue: 280 },
40
+ keyword: { label: '关键词', zh: '稀有词重叠', rank: 3, hue: 215 },
41
+ semantic: { label: '语义', zh: '正文相似', rank: 4, hue: 150 },
42
+ hebbian: { label: '共激活', zh: '同会话点亮', rank: 5, hue: 20 },
43
+ }
44
+
45
+ /** 单条边最低权重(低于它的候选直接丢)。 */
46
+ const MIN_EDGE_WEIGHT = 0.3
47
+ /** 每个节点保留的最大边数(保留最强的)。 */
48
+ const MAX_EDGES_PER_NODE = 16
49
+ /** 关键词在语料里出现超过这个条数就不作为证据(太泛)。 */
50
+ const MAX_KEYWORD_DF_RATIO = 0.22
51
+ const MAX_KEYWORD_DF_ABS = 70
52
+
53
+ /**
54
+ * 加权 Jaccard:交集按词的 idf 计分,联盟也按 idf 计分。
55
+ * 比裸 Jaccard 更能抓住「共同拥有稀有词」这件事。
56
+ * @param {Set<string>} a
57
+ * @param {Set<string>} b
58
+ * @param {(t:string)=>number} weightOf
59
+ */
60
+ function weightedJaccard(a, b, weightOf) {
61
+ if (a.size === 0 || b.size === 0) return 0
62
+ const [small, big] = a.size <= b.size ? [a, b] : [b, a]
63
+ let inter = 0
64
+ for (const t of small) if (big.has(t)) inter += weightOf(t)
65
+ if (inter <= 0) return 0
66
+ let union = 0
67
+ for (const t of a) union += weightOf(t)
68
+ for (const t of b) if (!a.has(t)) union += weightOf(t)
69
+ return union <= 0 ? 0 : inter / union
70
+ }
71
+
72
+ /**
73
+ * 概率式 OR 合并:多条证据指向同一对节点时,权重接近 1 但永不超 1。
74
+ * @param {number[]} parts
75
+ */
76
+ function combine(parts) {
77
+ let rest = 1
78
+ for (const p of parts) rest *= 1 - Math.max(0, Math.min(0.99, p))
79
+ return Math.min(0.99, 1 - rest)
80
+ }
81
+
82
+ /**
83
+ * 计算节点热度:重要度 + 被检索次数 + 新鲜度。
84
+ * @param {object} node
85
+ * @param {number} now
86
+ */
87
+ function heatOf(node, now) {
88
+ const imp = Math.max(0, Math.min(4, node.importance || 0)) / 4
89
+ const hits = Math.min(1, Math.log2(1 + (node.hits || 0)) / 4)
90
+ const stamp = node.accessedAt || node.updatedAt || node.createdAt || 0
91
+ const days = stamp > 0 ? Math.max(0, (now - stamp) / 86400000) : 365
92
+ const fresh = Math.exp(-days / 30)
93
+ return Math.round((0.34 + 0.32 * imp + 0.18 * hits + 0.16 * fresh) * 1000) / 1000
94
+ }
95
+
96
+ /**
97
+ * 去掉「被更长实体包含」的短实体:`d:\a\b` 已经出现时,
98
+ * `d:\a` 这种前缀不该再单独当证据(它只是同一个东西的截断)。
99
+ * @param {Map<string,string>} entities
100
+ */
101
+ function pruneEntities(entities) {
102
+ const items = [...entities.entries()].map(([key, type]) => [key, type, key.slice(key.indexOf('|') + 1)])
103
+ items.sort((a, b) => b[2].length - a[2].length)
104
+ const out = new Map()
105
+ const kept = []
106
+ for (const [key, type, value] of items) {
107
+ if (value.length < 4) continue
108
+ let covered = false
109
+ for (const other of kept) {
110
+ if (other.type === type && other.value !== value && other.value.startsWith(value)) {
111
+ covered = true
112
+ break
113
+ }
114
+ }
115
+ if (covered) continue
116
+ kept.push({ type, value })
117
+ out.set(key, type)
118
+ }
119
+ return out
120
+ }
121
+
122
+ /**
123
+ * 构建整张记忆星云。
124
+ *
125
+ * @param {object} input
126
+ * @param {object[]} input.nodes 来自适配器层(lib/host/adapters/*)扫描出的所有节点
127
+ * @param {{sessionId:string,kind:string,ids:string[],ws:string}[]} input.ledgers 每会话活动
128
+ * @param {{a:string,b:string,type?:string,weight?:number,note?:string,createdAt?:number}[]} [input.manual] 手工策展边
129
+ * @param {{a:string,b:string}[]} [input.mutes] 被人工屏蔽的关联对(重建时永不连接)
130
+ * @param {{sessionWorkspaces?:Record<string,string>}} [input.meta]
131
+ * @returns {{nodes:object[],edges:object[],clusters:object[],stats:object,builtAt:number}}
132
+ */
133
+ /** 同步建图:一口气跑完(测试、脚本、小库直接用它,行为与 1.11.3 一致)。 */
134
+ export function buildGraph(input) {
135
+ const it = buildGraphSteps(input)
136
+ let step = it.next()
137
+ while (!step.done) step = it.next()
138
+ return step.value
139
+ }
140
+
141
+ /**
142
+ * 异步建图:每 128 条记忆 / 1024 个候选就让出一次事件循环。
143
+ *
144
+ * 为什么要有它:2 万条的库上建图 3.7 秒(节点准备 2.5s + 打分剪枝 0.5s + 其余 0.7s)。
145
+ * 这条路径挂在宿主 web server 的事件循环上,同步跑就是「每次写记忆都卡三秒」。
146
+ * 分片之后总时长不变,最长静默降到几十毫秒。
147
+ */
148
+ export async function buildGraphAsync(input) {
149
+ const it = buildGraphSteps(input)
150
+ // 过程反馈:建图那几秒里界面要能说清走到哪一阶段,而不是一直转圈。
151
+ // 回调是可选的——同步版 buildGraph 与所有老调用方都照旧。
152
+ const onStep = typeof input.onStep === 'function' ? input.onStep : null
153
+ for (;;) {
154
+ const step = it.next()
155
+ if (step.done) return step.value
156
+ if (onStep) onStep(step.value)
157
+ await new Promise((resolve) => setImmediate(resolve))
158
+ }
159
+ }
160
+
161
+ // 取「最稀有的 top 个词」。等价于:
162
+ // const arr = [...tokens]; arr.sort((a, b) => weightOf(b) - weightOf(a)); arr.slice(0, top)
163
+ // 包括等权重时的先后(先来的排在前面,与稳定排序一致),但不排序整张词表。
164
+ // 5 万条库上这一步原来是 5 万次排序、约 2.4 秒,改完 1.1 秒;
165
+ // 单独拿出来做纯函数,也是为了让单测能把它和参考实现逐例钉死。
166
+ export function topRareTokens(tokens, weightOf, top = 26) {
167
+ const vals = []
168
+ const picked = []
169
+ for (const t of tokens) {
170
+ const w = weightOf(t)
171
+ if (vals.length === top && w <= vals[top - 1]) continue
172
+ let at = vals.length
173
+ while (at > 0 && vals[at - 1] < w) at--
174
+ vals.splice(at, 0, w)
175
+ picked.splice(at, 0, t)
176
+ if (vals.length > top) {
177
+ vals.pop()
178
+ picked.pop()
179
+ }
180
+ }
181
+ return new Set(picked)
182
+ }
183
+
184
+ export function* buildGraphSteps(input) {
185
+ // 时间会影响热度(heat)与取样顺序,于是同一份库连跑两次边数可能差几条。
186
+ // 允许调用方冻结它:测试与等价性比对需要「同一把尺子」,默认仍是当下。
187
+ const now = Number.isFinite(input.now) ? input.now : Date.now()
188
+ // 阶段计时:只在 NEBULA_GRAPH_TIMING=1 时打印,用来决定大图取样的窗口大小,不进正常输出。
189
+ const __tm = process.env.NEBULA_GRAPH_TIMING ? { t: Date.now(), marks: [] } : null
190
+ const mark = (label) => {
191
+ if (!__tm) return
192
+ const cur = Date.now()
193
+ __tm.marks.push(label + ':' + (cur - __tm.t))
194
+ __tm.t = cur
195
+ }
196
+ const rawNodes = (input.nodes || []).filter((n) => n && n.id)
197
+ const manual = Array.isArray(input.manual) ? input.manual : []
198
+ const ledgers = Array.isArray(input.ledgers) ? input.ledgers : []
199
+ const mutes = Array.isArray(input.mutes) ? input.mutes : []
200
+ // 屏蔽对用「小 id + 0x00 + 大 id」做键;建边时直接跳过,等于人工否掉这条推断
201
+ const muteSet = new Set(mutes.map((m) => (m.a < m.b ? m.a + '\u0000' + m.b : m.b + '\u0000' + m.a)))
202
+
203
+ /** @type {Map<string,number>} nodeId -> index */
204
+ const index = new Map()
205
+ // 节点准备(分词 + 抽实体 + 算热度)在 2 万条库上要 2.5 秒,占整次建图的七成。
206
+ // 切成 128 条一片,异步版本在片与片之间把事件循环让出去:总时长不变,
207
+ // 但宿主界面不再跟着停住。同步版本(buildGraph)照旧一口气跑完。
208
+ const nodes = []
209
+ let sliceAt = Date.now()
210
+ // 让出事件循环的节奏:按「用了多久」而不是「做了多少条」判断。
211
+ // 单条记忆的代价差别能到两个数量级(超长正文的分词与两两比对),
212
+ // 按条数切片会切出秒级的一片,等于没让出去。
213
+ let budgetTick = 0
214
+ const budgetSpent = (mask) => {
215
+ budgetTick++
216
+ if ((budgetTick & mask) !== 0) return false
217
+ return Date.now() - sliceAt >= 6
218
+ }
219
+ for (let base = 0; base < rawNodes.length; base += 128) {
220
+ const chunk = rawNodes.slice(base, base + 128)
221
+ for (let k = 0; k < chunk.length; k++) {
222
+ const n = chunk[k]
223
+ const i = base + k
224
+ index.set(n.id, i)
225
+ const text = [n.title, n.content, n.project, n.goal, ...(n.keywords || [])].filter(Boolean).join('\n')
226
+ const tokens = tokenize(text)
227
+ const entities = pruneEntities(extractEntities(text))
228
+ nodes.push({
229
+ ...n,
230
+ kind: n.kind || 'memory',
231
+ i,
232
+ tokens,
233
+ blob: text.toLowerCase(),
234
+ sigIds: null,
235
+ entities,
236
+ keywords: new Set((n.keywords || []).map((x) => String(x).toLowerCase())),
237
+ heat: heatOf(n, now),
238
+ })
239
+ }
240
+ yield 'nodes'
241
+ }
242
+ const n = nodes.length
243
+ if (n === 0) {
244
+ return {
245
+ nodes: [],
246
+ edges: [],
247
+ clusters: [],
248
+ stats: { nodes: 0, edges: 0, workspaces: 0, byType: {}, byWorkspace: {}, byLevel: {}, orphans: 0, entities: 0 },
249
+ entityLayer: null,
250
+ builtAt: now,
251
+ }
252
+ }
253
+
254
+ // ---------- 文档频次 ----------
255
+ // ---------- 文档频次 ----------
256
+ // 词频原来是 Map<string, count>:367 万个词次,每次都要哈希一遍字符串再装箱。
257
+ // 换成「词 -> 编号 + Int32Array 计数」之后,热循环里只剩一次查表加一次自增,
258
+ // 权重仍按编号取(同一个词在打分里会被问上万次,编号比字符串便宜得多)。
259
+ const tokenId = new Map()
260
+ const idTokens = [] // id -> 词:签名最后要还原成字符串,下游一行都不用改
261
+ let dfCap = 1 << 14
262
+ let tokenDF = new Int32Array(dfCap)
263
+ const dfOfToken = (t) => {
264
+ const id = tokenId.get(t)
265
+ return id === undefined ? 0 : tokenDF[id]
266
+ }
267
+ const entityDF = new Map()
268
+ const keywordDF = new Map()
269
+ for (const node of nodes) {
270
+ const tids = new Int32Array(node.tokens.size)
271
+ let ti = 0
272
+ for (const t of node.tokens) {
273
+ let id = tokenId.get(t)
274
+ if (id === undefined) {
275
+ id = tokenId.size
276
+ if (id >= dfCap) {
277
+ dfCap *= 2
278
+ const bigger = new Int32Array(dfCap)
279
+ bigger.set(tokenDF)
280
+ tokenDF = bigger
281
+ }
282
+ tokenId.set(t, id)
283
+ idTokens.push(t)
284
+ }
285
+ tokenDF[id] += 1
286
+ tids[ti++] = id
287
+ }
288
+ node.tids = tids
289
+ for (const k of node.entities.keys()) entityDF.set(k, (entityDF.get(k) || 0) + 1)
290
+ for (const k of node.keywords) keywordDF.set(k, (keywordDF.get(k) || 0) + 1)
291
+ if (budgetSpent(255)) {
292
+ sliceAt = Date.now()
293
+ yield 'df'
294
+ }
295
+ }
296
+ // ---------- 大图取样(5 万条级) ----------
297
+ // 词表是有上限的:5 万条记忆里,一个常用词会出现几百上千次。旧规则(关键词 df > 70
298
+ // 或 token df > 160 就整条跳过)在小库里是对的,到 5 万条会把几乎所有词滤掉,
299
+ // 实测只剩 280 条边、99.1% 的节点是孤岛 —— 那不是一个能看的图。
300
+ // 抬上限的老原型把 1 万条拖慢了近一倍,却仍没把 5 万条带进预算,所以这里换一种做法:
301
+ // **按重要度取样配对**。稀有词照旧全量配对,高频词只让最重要的若干条记忆互相配对,
302
+ // 建边成本随词数线性增长,孤岛回到可浏览范围。
303
+ const BIG_GRAPH = n > 20000
304
+ const BIG_TERM_WINDOW = 3
305
+ const BIG_TOKEN_WINDOW = 2
306
+ const BIG_ENTITY_WINDOW = 3
307
+ // 取样要「按重要度」,所以大图的倒排索引按重要度顺序插入;小图保持原顺序,行为不变。
308
+ const postNodes = BIG_GRAPH
309
+ ? nodes
310
+ .slice()
311
+ .sort((a, b) => (b.importance || 0) - (a.importance || 0) || (b.heat || 0) - (a.heat || 0) || a.i - b.i)
312
+ : nodes
313
+
314
+ // idf 只跟 df 有关;同一条 token 在打分里会被反复问,缓存一次省掉大量 Math.log。
315
+ // idf 只跟 df 有关:一次算成「按编号索引的 Float64Array」,别再每次查表 + 算 log。
316
+ const idfById = new Float64Array(tokenId.size)
317
+ for (let id = 0; id < idfById.length; id++) idfById[id] = idf(tokenDF[id] || 1, n)
318
+ const idfOfUnknown = idf(1, n)
319
+ const tokenWeight = (t) => {
320
+ const id = tokenId.get(t)
321
+ return id === undefined ? idfOfUnknown : idfById[id]
322
+ }
323
+
324
+ // 「语义签名」:每个节点最稀有的 26 个词。
325
+ // 长文本词多、短文本词少,直接比全集永远是短的那条吃亏;取稀有词签名更公平。
326
+ // 有界插入:只维护 26 个「最稀有」的位置,不再把每个节点的整张词表排序。
327
+ // 权重是 df 的单调函数,等权重时保持「先来的排前面」——与整表排序 + slice(0, 26) 逐位等价,
328
+ // 但 5 万条库上省掉 5 万次排序(实测 2.6s -> 0.3s)。
329
+ const SIG_TOP = 26
330
+ const pickI = new Int32Array(SIG_TOP)
331
+ const pickW = new Float64Array(SIG_TOP)
332
+ for (const node of nodes) {
333
+ // 和 topRareTokens 逐位等价:权重相等时不插到前面(先来的排前面)
334
+ const tids = node.tids
335
+ let pickLen = 0
336
+ for (let i = 0; i < tids.length; i++) {
337
+ const id = tids[i]
338
+ const w = idfById[id]
339
+ if (pickLen === SIG_TOP && w <= pickW[SIG_TOP - 1]) continue
340
+ let at = pickLen
341
+ while (at > 0 && pickW[at - 1] < w) {
342
+ pickW[at] = pickW[at - 1]
343
+ pickI[at] = pickI[at - 1]
344
+ at--
345
+ }
346
+ pickW[at] = w
347
+ pickI[at] = id
348
+ if (pickLen < SIG_TOP) pickLen++
349
+ }
350
+ // 签名存成「按编号升序的 Int32Array」:交集靠双指针合并,不再一个个哈希字符串。
351
+ const ids = pickI.slice(0, pickLen)
352
+ ids.sort()
353
+ node.sigIds = ids
354
+ if (budgetSpent(127)) {
355
+ sliceAt = Date.now()
356
+ yield 'sig'
357
+ }
358
+ }
359
+ const EMPTY_IDS = new Int32Array(0)
360
+
361
+ // 每个节点签名的总权重只算一次;scorePair 里每对候选都要用它,重复遍历是纯浪费。
362
+ const sigWeight = new Float64Array(n)
363
+ for (const node of nodes) {
364
+ let sum = 0
365
+ const ids = node.sigIds
366
+ for (let k = 0; k < ids.length; k++) sum += idfById[ids[k]]
367
+ sigWeight[node.i] = sum
368
+ if (budgetSpent(511)) {
369
+ sliceAt = Date.now()
370
+ yield 'sig'
371
+ }
372
+ }
373
+
374
+ mark('nodes')
375
+ // ---------- 倒排索引(候选生成,避免 O(n²)) ----------
376
+ /** @type {Map<string, number[]>} */
377
+ const tokenPost = new Map()
378
+ /** @type {Map<string, number[]>} */
379
+ const entityPost = new Map()
380
+ /** @type {Map<string, number[]>} */
381
+ const keywordPost = new Map()
382
+ const push = (map, key, i) => {
383
+ const arr = map.get(key)
384
+ if (arr) arr.push(i)
385
+ else map.set(key, [i])
386
+ }
387
+ for (const node of postNodes) {
388
+ const tokenLimit = BIG_GRAPH ? n : Math.max(6, Math.floor(n * 0.2))
389
+ // 小图(≤1000 条)用全量 token 保召回;大图只用「最稀有的 26 个词」做候选。
390
+ // 1 万条时全量 token 会把同一段模板文字里的常见 bigram 也拿去两两配对,
391
+ // 是平方级浪费,而稀有词签名已经足够把真正相似的两条连起来。
392
+ if (n <= 1000) {
393
+ // 小图用全量 token;倒排按编号分组(键只用于分组,没人按 key 查)
394
+ for (const t of node.tokens) {
395
+ const id = tokenId.get(t)
396
+ if (id === undefined || tokenDF[id] > tokenLimit) continue
397
+ push(tokenPost, id, node.i)
398
+ }
399
+ } else {
400
+ // 大图只拿签名里的词做候选;编号在手,df 直接读数组,不用再哈希一遍字符串
401
+ const ids = node.sigIds
402
+ for (let k = 0; k < ids.length; k++) {
403
+ const id = ids[k]
404
+ if (tokenDF[id] > tokenLimit) continue
405
+ push(tokenPost, id, node.i)
406
+ }
407
+ }
408
+ for (const key of node.entities.keys()) {
409
+ const df = entityDF.get(key) || 0
410
+ if (df < 2) continue
411
+ if (df > Math.max(12, n * 0.12)) continue
412
+ push(entityPost, key, node.i)
413
+ }
414
+ for (const k of node.keywords) {
415
+ const df = keywordDF.get(k) || 0
416
+ if (df < 2) continue
417
+ // 大图不再整条丢弃高频词,改由后面的「取样配对」限制它的两两组合数。
418
+ if (!BIG_GRAPH && (df > MAX_KEYWORD_DF_ABS || df > n * MAX_KEYWORD_DF_RATIO)) continue
419
+ push(keywordPost, k, node.i)
420
+ }
421
+ if (budgetSpent(255)) {
422
+ sliceAt = Date.now()
423
+ yield 'postings'
424
+ }
425
+ }
426
+
427
+ mark('postings')
428
+ // ---------- 候选对累加 ----------
429
+ // 候选对的键原来是字符串 "123:456":每凑一对就要 allocate 一个字符串,再把整串哈希一遍。
430
+ // 5 万条库上有 27.5 万个候选、上百万次 slot() 调用,这笔账几乎全花在分配上。
431
+ // 改成数字键 a * PAIR_BASE + b(a < b):索引上界 5.2 万,2^20 做基数,乘积 ≤ 5.5e10,
432
+ // 在 2^53 以内可以精确表示;Map 的插入顺序与字符串键时完全一致,所以边的产出顺序也不变。
433
+ const PAIR_BASE = 1 << 20
434
+ const pairKey = (a, b) => (a < b ? a * PAIR_BASE + b : b * PAIR_BASE + a)
435
+ const pairA = (key) => Math.floor(key / PAIR_BASE)
436
+ const pairB = (key, a) => key - a * PAIR_BASE
437
+ /** @type {Map<number, {kwCount:number, ent:string[]|null, tok:number}>} */
438
+ const cand = new Map()
439
+ const slot = (a, b) => {
440
+ const key = pairKey(a, b)
441
+ let s = cand.get(key)
442
+ if (!s) {
443
+ s = { kwCount: 0, ent: null, tok: 0 }
444
+ cand.set(key, s)
445
+ }
446
+ return s
447
+ }
448
+ // ent 是「这一对共享了哪些硬实体」,只有少数候选会用到。
449
+ // 27.5 万个候选各开一个空数组就是 27.5 万个对象头,改成用到时才建。
450
+ const addEnt = (s, key) => {
451
+ if (s.ent) s.ent.push(key)
452
+ else s.ent = [key]
453
+ }
454
+
455
+ // 大图的取样配对:倒排表已按重要度排序,只让每个节点和它邻近的 W 条配对。
456
+ // 取「前 N 条互相配对」会让排在后面的节点永远轮不到(实测 5 万条仍有 89.6% 孤岛),
457
+ // 滑动窗口保证每个节点都被覆盖,代价仍随词频线性增长。
458
+ const sampleWindow = (list, w, cb) => {
459
+ const L = list.length
460
+ const win = Math.min(w, L - 1)
461
+ for (let x = 0; x < L; x++) {
462
+ for (let y = x + 1; y <= x + win && y < L; y++) cb(list[x], list[y])
463
+ }
464
+ }
465
+
466
+ for (const [kw, list] of keywordPost) {
467
+ if (budgetSpent(15)) {
468
+ sliceAt = Date.now()
469
+ yield 'cand'
470
+ }
471
+ if (list.length < 2) continue
472
+ if (BIG_GRAPH) {
473
+ sampleWindow(list, BIG_TERM_WINDOW, (a, b) => slot(a, b).kwCount++)
474
+ continue
475
+ }
476
+ for (let x = 0; x < list.length; x++) {
477
+ for (let y = x + 1; y < list.length; y++) slot(list[x], list[y]).kwCount++
478
+ }
479
+ }
480
+ for (const [key, list] of entityPost) {
481
+ if (budgetSpent(15)) {
482
+ sliceAt = Date.now()
483
+ yield 'cand'
484
+ }
485
+ if (list.length < 2) continue
486
+ // 一个标识出现在上百条记忆里就不再是「同一实体」的证据,只是公共路径/版本号。
487
+ // 不设上限时,1 万条库里的共享路径会生成上千万对候选,建图直接掉到秒级以外。
488
+ // 2 万条以上时,同一个通用标识出现在几百条记忆里只是公共路径/模板;
489
+ // 把配对上限从 120 收到 60,候选对从 1,180 万降到 300 万,20k 建图回到 3s 内。
490
+ // 5 万条级:通用标识(package.json 之类)出现在几千条里,整条丢弃会让图失去仅剩的
491
+ // 硬证据;改成滑动窗口取样。
492
+ const entityPairCap = n > 12000 ? 60 : 120
493
+ if (BIG_GRAPH) {
494
+ sampleWindow(list, BIG_ENTITY_WINDOW, (a, b) => addEnt(slot(a, b), key))
495
+ continue
496
+ }
497
+ if (list.length > entityPairCap) continue
498
+ for (let x = 0; x < list.length; x++) {
499
+ for (let y = x + 1; y < list.length; y++) addEnt(slot(list[x], list[y]), key)
500
+ }
501
+ }
502
+ const sharedTokenCount = new Map()
503
+ for (const [, list] of tokenPost) {
504
+ if (budgetSpent(15)) {
505
+ sliceAt = Date.now()
506
+ yield 'cand'
507
+ }
508
+ if (list.length < 2) continue
509
+ if (BIG_GRAPH) {
510
+ // 5 万条级:900 个词分摊到 5 万条,每个词都超过 160 条,旧规则让 tokenPost 全空。
511
+ // 只取邻近的 6 条互相配对:这是「按重要度取样」,不是「召回全部相似对」。
512
+ sampleWindow(list, BIG_TOKEN_WINDOW, (a, b) => {
513
+ const key = pairKey(a, b)
514
+ sharedTokenCount.set(key, (sharedTokenCount.get(key) || 0) + 1)
515
+ })
516
+ continue
517
+ }
518
+ if (list.length > 160) continue // 太常见的词不做语义候选
519
+ for (let x = 0; x < list.length; x++) {
520
+ for (let y = x + 1; y < list.length; y++) {
521
+ const key = pairKey(list[x], list[y])
522
+ sharedTokenCount.set(key, (sharedTokenCount.get(key) || 0) + 1)
523
+ }
524
+ }
525
+ }
526
+ for (const [key, count] of sharedTokenCount) {
527
+ if (budgetSpent(1023)) {
528
+ sliceAt = Date.now()
529
+ yield 'cand'
530
+ }
531
+ // 短笔记(签名 ≤12 个词)放宽到共享 2 个稀有词:新接入的笔记目录/小记忆库
532
+ // 天然短,按长记忆的标准永远连不上,接进来就是一串孤岛。
533
+ const a = pairA(key)
534
+ const b = pairB(key, a)
535
+ const minSig = Math.min(nodes[a].sigIds.length, nodes[b].sigIds.length)
536
+ const need = minSig <= 12 ? 2 : 4
537
+ if (count < need) continue
538
+ const s = cand.get(key)
539
+ if (s) s.tok = count
540
+ else cand.set(key, { kwCount: 0, ent: [], tok: count })
541
+ }
542
+
543
+ // ---------- 共激活(Hebbian):按会话统计 ----------
544
+ const coAct = new Map()
545
+ const uidToIndex = new Map()
546
+ for (const node of nodes) {
547
+ const key = node.ws + '\u0000' + node.uid
548
+ if (!uidToIndex.has(key)) uidToIndex.set(key, [])
549
+ uidToIndex.get(key).push(node.i)
550
+ }
551
+ const coKey = pairKey // 同一个键协议,别名保留给读到这里的旧注释
552
+ // 同一会话里被同时注入/检索/写下的记忆,视为「一起点亮」
553
+ const bySession = new Map()
554
+ for (const ledger of ledgers) {
555
+ const ws = ledger.ws || ''
556
+ const bucketKey = ws + '\u0000' + ledger.sessionId
557
+ let bucket = bySession.get(bucketKey)
558
+ if (!bucket) {
559
+ bucket = new Set()
560
+ bySession.set(bucketKey, bucket)
561
+ }
562
+ for (const uid of ledger.ids) {
563
+ const list = uidToIndex.get(ws + '\u0000' + uid)
564
+ if (!list) continue
565
+ for (const i of list) bucket.add(i)
566
+ }
567
+ }
568
+ for (const set of bySession.values()) {
569
+ if (budgetSpent(31)) {
570
+ sliceAt = Date.now()
571
+ yield 'cand'
572
+ }
573
+ const arr = [...set]
574
+ if (arr.length < 2 || arr.length > 80) continue
575
+ const damp = 1 / Math.log2(2 + arr.length) // 大会话里「都出现过」的证据更弱
576
+ for (let x = 0; x < arr.length; x++) {
577
+ for (let y = x + 1; y < arr.length; y++) {
578
+ const key = coKey(arr[x], arr[y])
579
+ // 证据按「几次会话」计:一次会话里出现再多次也只算一次(同一场对话里的两条记忆,
580
+ // 在场一次就是一次)。阻尼只作为质量折扣,不再充当分子——原来是「分子按大小打折、
581
+ // 门槛按绝对分」,六十条记忆的会话只加 0.17 分,十次会话才够 1.6,等于永远连不上。
582
+ const rec = coAct.get(key)
583
+ if (rec) {
584
+ rec.n += 1
585
+ rec.d += damp
586
+ } else {
587
+ coAct.set(key, { n: 1, d: damp })
588
+ }
589
+ }
590
+ }
591
+ }
592
+
593
+ // 共激活本身也是候选来源。
594
+ // 之前只在「文本已经相似」的候选对里读 coAct,于是注释写的「两次以上会话共激活也算数」
595
+ // 其实永远不成立:两段正文毫无重叠、但每次都被同一条对话一起想起来的记忆,一条边都长不出来。
596
+ // 现在把够强的共激活单独补成候选(parts 里只有 hebbian,权重由 scorePair 统一算)。
597
+ for (const [key, rec] of coAct) {
598
+ if (budgetSpent(1023)) {
599
+ sliceAt = Date.now()
600
+ yield 'cand'
601
+ }
602
+ // 「一起点亮过两次以上才算证据」——这里是唯一的口径,权重在 scorePair 里统一算。
603
+ if (rec.n < 2) continue
604
+ if (cand.has(key)) continue
605
+ cand.set(key, { kwCount: 0, ent: null, tok: 0 })
606
+ }
607
+
608
+ mark('candidates')
609
+ // ---------- 打分 ----------
610
+ /** @type {{s:number,t:number,type:string,w:number,why:string[],parts:Record<string,number>}[]} */
611
+ const edges = []
612
+ const nSessions = bySession.size || 1
613
+
614
+ // 实体 key 形如 "file|package.json",拆出来只为了判断「通用叶子名」和给人看。
615
+ // 同一个 key 会在几十万个候选里被反复拆,缓存一次就够。
616
+ const leafCache = new Map()
617
+ const leafOf = (key) => {
618
+ let v = leafCache.get(key)
619
+ if (v === undefined) {
620
+ v = String(key).split('|')[1] || ''
621
+ leafCache.set(key, v)
622
+ }
623
+ return v
624
+ }
625
+
626
+ // 实体的稀有度分只跟 key 与 df 有关,而 df 这时候已经定了;27 万个候选对
627
+ // 每对最多查 12 个实体,逐个算 splitEntity + log2 是白花钱。缓存一次。
628
+ const entScoreCache = new Map()
629
+ const entScoreOf = (key) => {
630
+ let rec = entScoreCache.get(key)
631
+ if (rec === undefined) {
632
+ rec = { s: entityStrength(key, entityDF.get(key) || 1, n), g: GENERIC_LEAF.test(leafOf(key)) }
633
+ entScoreCache.set(key, rec)
634
+ }
635
+ return rec
636
+ }
637
+
638
+ const scorePair = (a, b, s) => {
639
+ const A = nodes[a]
640
+ const B = nodes[b]
641
+ let kwW = 0
642
+ let entW = 0
643
+ let projW = 0
644
+ let semW = 0
645
+ let hebW = 0
646
+ let semInter = 0
647
+ let semSim = 0
648
+ let co = 0
649
+ const kwCount = s.kwCount || 0
650
+
651
+ // 1) 关键词。共享词数在候选生成时已累计,不再为每个候选保存字符串数组。
652
+ if (kwCount > 0) {
653
+ const jac = kwCount / Math.max(1, A.keywords.size + B.keywords.size - kwCount)
654
+ let rare = 0
655
+ for (const k of A.keywords) {
656
+ if (!B.keywords.has(k)) continue
657
+ if ((keywordDF.get(k) || 0) <= Math.max(3, n * 0.05)) rare++
658
+ }
659
+ let w = 0
660
+ if (kwCount >= 2 && jac >= 0.16) w = 0.3 + 0.4 * Math.min(1, jac * 1.7)
661
+ else if (kwCount >= 2) w = 0.26 + 0.12 * Math.min(1, jac * 2)
662
+ else if (rare >= 1) w = 0.3
663
+ else w = 0.2
664
+ if (w > 0.2) kwW = w
665
+ }
666
+
667
+ // 2) 硬实体(最可信)
668
+ // 跨工作区时,通用文件名(package.json / index.ts / app.html…)不算证据 ——
669
+ // 两个项目各有一个 package.json,不代表它们说的是同一件事。
670
+ if (s.ent && s.ent.length > 0) {
671
+ let best = 0
672
+ const crossWs = A.ws !== B.ws
673
+ for (let i = 0; i < s.ent.length && i < 12; i++) {
674
+ const rec = entScoreOf(s.ent[i])
675
+ if (crossWs && rec.g) continue
676
+ if (rec.s > best) best = rec.s
677
+ }
678
+ if (best > 0.18) entW = Math.min(0.86, 0.26 + 0.68 * best)
679
+ }
680
+
681
+ // 3) 同项目(只在跨工作区时当桥用;同库同项目不连,否则一团糊)
682
+ if (A.project && A.project === B.project && A.project !== '全局' && A.ws !== B.ws) {
683
+ projW = 0.52
684
+ }
685
+
686
+ // 4) 语义相似:稀有词签名的「重叠系数」(交集权重 / 较小一侧权重)
687
+ const aIds = A.sigIds
688
+ const bIds = B.sigIds
689
+ const minSig = Math.min(aIds.length, bIds.length)
690
+ const needInter = minSig <= 12 ? 2 : 4
691
+ const needSim = minSig <= 12 ? 0.12 : 0.18
692
+ if (s.tok >= needInter) {
693
+ // 两边都是升序编号:双指针合并,交集一次走完,不哈希也不查表
694
+ let inter = 0
695
+ let iw = 0
696
+ let xa = 0
697
+ let yb = 0
698
+ while (xa < aIds.length && yb < bIds.length) {
699
+ const av = aIds[xa]
700
+ const bv = bIds[yb]
701
+ if (av === bv) {
702
+ inter++
703
+ iw += idfById[av]
704
+ xa++
705
+ yb++
706
+ } else if (av < bv) xa++
707
+ else yb++
708
+ }
709
+ if (inter >= needInter) {
710
+ const sim = iw / Math.max(1e-9, Math.min(sigWeight[a], sigWeight[b]))
711
+ if (sim >= needSim) {
712
+ semInter = inter
713
+ semSim = sim
714
+ semW = Math.min(0.58, 0.12 + 0.6 * sim)
715
+ }
716
+ }
717
+ }
718
+
719
+ // 5) 共激活:证据 =「几次会话里一起点亮」,会话越大越当参考(不是判决)
720
+ const coRec = coAct.get(coKey(a, b))
721
+ if (coRec && coRec.n >= 2) {
722
+ co = coRec.n
723
+ const avgDamp = coRec.d / coRec.n
724
+ // 两条记忆的小会话 damp=0.5:那是满分质量;几百条的会话质量只剩零头。
725
+ const quality = Math.min(1, avgDamp / 0.5)
726
+ // 上限 0.44 是刻意的:体检里 STRONG_W = 0.45 指「实体/项目级的硬关系」,
727
+ // 共激活只是「一起被想起过」——它可以很频繁,但不该冒充硬关系。
728
+ const w = Math.min(
729
+ 0.44,
730
+ 0.12 * Math.log2(1 + co * 2) * (1 + 0.25 * Math.log2(1 + co)) * (0.75 + 0.25 * quality)
731
+ )
732
+ if (w > 0) hebW = w
733
+ }
734
+
735
+ // 与 combine() 同语义:概率式 OR,只在确定要产出边时才分配 parts/why。
736
+ const weight = Math.min(0.99, 1 - (1 - kwW) * (1 - entW) * (1 - projW) * (1 - semW) * (1 - hebW))
737
+ if (weight < MIN_EDGE_WEIGHT) return null
738
+ // 只有共激活一条证据也认——前提是它真的过了 MIN_EDGE_WEIGHT(口径在权重里,不在别处)。
739
+ // 原来这里还写了一道 co < 1.6,而权重公式在 co=1.6 时只给 0.28,两个门槛互相否掉,
740
+ // 结果「只靠一起点亮长出来的边」一条都不可能存在。
741
+
742
+ const parts = {}
743
+ const why = []
744
+ if (kwW > 0) {
745
+ parts.keyword = kwW
746
+ const shared = []
747
+ for (const k of A.keywords) {
748
+ if (B.keywords.has(k) && shared.length < 4) shared.push(k)
749
+ }
750
+ why.push('共享关键词:' + shared.join('、'))
751
+ }
752
+ if (entW > 0) {
753
+ const shown = []
754
+ const crossWs = A.ws !== B.ws
755
+ for (let i = 0; i < s.ent.length && i < 12 && shown.length < 3; i++) {
756
+ const key = s.ent[i]
757
+ const leaf = leafOf(key)
758
+ if (crossWs && GENERIC_LEAF.test(leaf)) continue
759
+ shown.push(leaf)
760
+ }
761
+ parts.entity = entW
762
+ why.push('同一标识:' + shown.join('、'))
763
+ }
764
+ if (projW > 0) {
765
+ parts.project = projW
766
+ why.push('跨工作区同项目:' + A.project)
767
+ }
768
+ if (semW > 0) {
769
+ parts.semantic = semW
770
+ why.push('正文共享 ' + semInter + ' 个稀有词(覆盖 ' + semSim.toFixed(2) + ')')
771
+ }
772
+ if (hebW > 0) {
773
+ parts.hebbian = hebW
774
+ why.push('在 ' + co + ' 次会话里一起被点亮')
775
+ }
776
+
777
+ const keys = Object.keys(parts)
778
+ keys.sort((x, y) => parts[y] - parts[x])
779
+ return { s: a, t: b, type: keys[0], w: Math.round(weight * 1000) / 1000, why, parts }
780
+ }
781
+
782
+ // 人工否掉的关联对:先把「记忆 id 对」翻译成「索引对」,打分循环里只查一张数字集合,
783
+ // 不再为 27 万个候选各拼一次字符串。
784
+ const mutePairs = new Set()
785
+ for (const m of mutes) {
786
+ const ia = index.get(m.a)
787
+ const ib = index.get(m.b)
788
+ if (ia === undefined || ib === undefined) continue
789
+ mutePairs.add(pairKey(ia, ib))
790
+ }
791
+ for (const [key, s] of cand) {
792
+ const a = pairA(key)
793
+ const b = pairB(key, a)
794
+ // 人工否掉的关联对:无论证据多强都不连
795
+ if (mutePairs.size && mutePairs.has(key)) continue
796
+ const edge = scorePair(a, b, s)
797
+ if (edge) edges.push(edge)
798
+ // 按时间切片,不按条数:个别区域一条边要 1–2ms(超长记忆两两比对),
799
+ // 按 1024 条切会切出 1.7 秒的一片,等于没让出事件循环。
800
+ if (budgetSpent(63)) {
801
+ sliceAt = Date.now()
802
+ yield 'score'
803
+ }
804
+ }
805
+
806
+ // 手工策展边优先,权重 1
807
+ for (const m of manual) {
808
+ const a = index.get(m.a)
809
+ const b = index.get(m.b)
810
+ if (a === undefined || b === undefined || a === b) continue
811
+ edges.push({
812
+ s: Math.min(a, b),
813
+ t: Math.max(a, b),
814
+ type: 'explicit',
815
+ w: 1,
816
+ why: [m.note ? '策展:' + m.note : '人工策展关联'],
817
+ parts: { explicit: 1 },
818
+ })
819
+ }
820
+
821
+ // ---------- 剪枝:严格每节点上限 ----------
822
+ // 贪心:按「权重 + 跨工作区加成」全局排序,一条边只有在两端都还有额度时才收。
823
+ // 这样任何节点的度数都不会超过 MAX_EDGES_PER_NODE,跨工作区的桥优先保留。
824
+ const priority = (edge) => edge.w + (nodes[edge.s].ws !== nodes[edge.t].ws ? 0.16 : 0)
825
+ // 优先级先算成数组再排序。原来把 priority() 直接放进比较函数,11 万条边要算
826
+ // 上百万次(排序比较次数 ≈ n log n,每次都查两遍节点对象);预算是 O(n),快得多。
827
+ const prio = new Float64Array(edges.length)
828
+ for (let i = 0; i < edges.length; i++) {
829
+ prio[i] = priority(edges[i])
830
+ if ((i & 8191) === 0) yield 'prune'
831
+ }
832
+ const order = edges.map((_, i) => i).sort((i, j) => prio[j] - prio[i])
833
+ const keep = new Set()
834
+ // 大图把每节点上限收到 8:5 万条时 16 条上限会产出 39 万条边(快照 50MB),
835
+ // 而它们的收益主要在「看起来密」;8 条已经能把孤岛清零,包体积和绘制成本都砍半。
836
+ const degreeLimit = BIG_GRAPH ? 8 : MAX_EDGES_PER_NODE
837
+ const degreeCap = new Uint16Array(n)
838
+ let pruned = 0
839
+ for (const i of order) {
840
+ if ((++pruned & 4095) === 0) yield 'prune'
841
+ const edge = edges[i]
842
+ if (edge.type === 'explicit') {
843
+ keep.add(i)
844
+ degreeCap[edge.s]++
845
+ degreeCap[edge.t]++
846
+ continue
847
+ }
848
+ if (degreeCap[edge.s] >= degreeLimit || degreeCap[edge.t] >= degreeLimit) continue
849
+ keep.add(i)
850
+ degreeCap[edge.s]++
851
+ degreeCap[edge.t]++
852
+ }
853
+ const finalEdges = edges.filter((_, i) => keep.has(i))
854
+ mark('score+prune')
855
+ if (__tm) {
856
+ console.error('[graph] n=' + n + ' cand=' + cand.size + ' edges=' + edges.length + ' kept=' + finalEdges.length + ' ' + __tm.marks.join(' '))
857
+ }
858
+
859
+ // ---------- 孤立自举:新接入来源的第一条记忆不该是孤岛 ----------
860
+ // 新来的笔记 / 小库通常只有几十个 token,稀有词签名与老记忆的交集常常只有 1 个,
861
+ // 达不到语义门槛。不给它一条弱边,它接进来就是一颗看不见的孤星 ——
862
+ // 页面上找不到、bridge 也扩散不到,等于没接。
863
+ // 只对「非内置来源、且剪枝后仍然零度」的节点补一条,权重压在 0.32,不会污染主图。
864
+ {
865
+ const BOOT_W = 0.32
866
+ const BUILTIN = new Set(['meow-memory', 'inventory'])
867
+ const deg = new Uint8Array(n)
868
+ for (const e of finalEdges) {
869
+ deg[e.s] = 1
870
+ deg[e.t] = 1
871
+ }
872
+ const lonely = (i) => deg[i] === 0 && !BUILTIN.has(nodes[i].provider || 'meow-memory')
873
+ // 每个孤岛留前两条候选:一条经常不够 —— 唯一的邻居如果是 stale/archived,
874
+ // 下游(bridge / 注入)会把它整条过滤掉,等于白连。
875
+ const best = new Map()
876
+ const pushHit = (i, other, count) => {
877
+ const arr = best.get(i) || []
878
+ const boost = nodes[other].status === 'active' ? 1 : nodes[other].status === 'archived' ? -2 : 0
879
+ arr.push({ other, count, rank: count + boost })
880
+ arr.sort((x, y) => y.rank - x.rank)
881
+ if (arr.length > 2) arr.length = 2
882
+ best.set(i, arr)
883
+ }
884
+ for (const [key, count] of sharedTokenCount) {
885
+ if (count < 1) continue
886
+ const a = pairA(key)
887
+ const b = pairB(key, a)
888
+ const la = lonely(a)
889
+ const lb = lonely(b)
890
+ if (!la && !lb) continue
891
+ if (la) pushHit(a, b, count)
892
+ if (lb) pushHit(b, a, count)
893
+ }
894
+ let bootCount = 0
895
+ for (const [i, hits] of best) {
896
+ if (bootCount >= 80) break
897
+ for (const hit of hits) {
898
+ if (hit.rank <= 0) continue
899
+ // 只共享一个词、而对面还是 stale 的,宁可不连:这种边只会把不相关的记忆
900
+ // 拉进注入,比孤岛更有害。
901
+ if (hit.count < 2 && nodes[hit.other].status !== 'active') continue
902
+ const ia = nodes[i].id
903
+ const ib = nodes[hit.other].id
904
+ if (muteSet.size && muteSet.has(ia < ib ? ia + '\u0000' + ib : ib + '\u0000' + ia)) continue
905
+ finalEdges.push({
906
+ s: Math.min(i, hit.other),
907
+ t: Math.max(i, hit.other),
908
+ type: 'semantic',
909
+ w: BOOT_W,
910
+ why: ['新来源自举:与最近的一条记忆共享 ' + hit.count + ' 个稀有词'],
911
+ parts: { semantic: BOOT_W },
912
+ boot: true,
913
+ })
914
+ bootCount++
915
+ }
916
+ }
917
+ }
918
+
919
+ // ---------- 来源节点:技能 / MCP / 插件 ----------
920
+ // 只有「记忆正文里原样出现了这个名字」才连一条 mentions 边。
921
+ // 不靠关键词猜、不靠语义推 —— 名字没出现就不算用过它,宁可不连也不误连。
922
+ const SRC_ZH = { skill: '技能', mcp: 'MCP', plugin: '插件' }
923
+ const SRC_LISTS = [
924
+ ['mcp', input.inventory && input.inventory.mcp, 4],
925
+ ['skill', input.inventory && input.inventory.skills, 4],
926
+ ['plugin', input.inventory && input.inventory.plugins, 6],
927
+ ]
928
+ // 同一个名字可能既是 MCP 又是插件(例如 meow-memory),只做一个节点,按 mcp > 技能 > 插件的顺序认领
929
+ const srcSeen = new Set()
930
+ for (const [kind, list, minLen] of SRC_LISTS) {
931
+ for (const item of Array.isArray(list) ? list : []) {
932
+ const name = String((item && item.name) || '').trim()
933
+ // 框架自带包不算「记忆来源」,短名字容易和普通英文词撞车
934
+ if (name.length < minLen || name.startsWith('@deepseek-ai/')) continue
935
+ const needle = name.toLowerCase()
936
+ if (srcSeen.has(needle)) continue
937
+ // 边界匹配:huashu-design 不该被 huashu-design-lite 的正文误判成出现
938
+ const re = new RegExp('(^|[^a-z0-9_-])' + needle.replace(/[.*+?^${}()|[\]\\]/g, '\\$&') + '([^a-z0-9_-]|$)')
939
+ const hitIdx = []
940
+ for (const node of nodes) {
941
+ // 先做一次廉价的 includes 预筛:正则要在 5 万条正文上跑,比字符串查找慢一个数量级,
942
+ // 而绝大多数名字一次都不出现。这一层预筛把整段从 322ms 压到几十毫秒。
943
+ if (node.blob && node.blob.includes(needle) && re.test(node.blob)) hitIdx.push(node.i)
944
+ if (hitIdx.length >= 24) break
945
+ if (budgetSpent(1023)) {
946
+ sliceAt = Date.now()
947
+ yield 'sources'
948
+ }
949
+ }
950
+ if (hitIdx.length === 0) continue
951
+ srcSeen.add(needle)
952
+ const idx = nodes.length
953
+ const desc = cut(String((item && item.description) || ''), 200)
954
+ // 来源节点不是一个独立「工作区」:它挂在最常提到它的那条记忆所在的工作区里,
955
+ // 这样一眼就能看出「这个技能是被哪个项目在用的」。
956
+ const wsTally = new Map()
957
+ for (const i of hitIdx) {
958
+ const key = nodes[i].ws || ''
959
+ const cur = wsTally.get(key)
960
+ if (cur) cur.n++
961
+ else wsTally.set(key, { n: 1, title: nodes[i].wsTitle || key })
962
+ }
963
+ let bestWs = ''
964
+ let bestTitle = ''
965
+ let bestN = -1
966
+ for (const [key, v] of wsTally) {
967
+ if (v.n > bestN) {
968
+ bestN = v.n
969
+ bestWs = key
970
+ bestTitle = v.title
971
+ }
972
+ }
973
+ nodes.push({
974
+ id: 'src:' + kind + ':' + needle,
975
+ i: idx,
976
+ kind: 'source',
977
+ sourceKind: kind,
978
+ provider: 'inventory',
979
+ ws: bestWs,
980
+ wsTitle: bestTitle,
981
+ level: 'source',
982
+ title: name,
983
+ label: name,
984
+ content: desc,
985
+ preview: desc,
986
+ importance: 1,
987
+ status: 'active',
988
+ project: SRC_ZH[kind],
989
+ subcategory: null,
990
+ goal: null,
991
+ keywords: new Set(),
992
+ entities: new Map(),
993
+ tokens: new Set(),
994
+ sigIds: EMPTY_IDS,
995
+ heat: 0.2,
996
+ hits: 0,
997
+ createdAt: now,
998
+ updatedAt: now,
999
+ accessedAt: null,
1000
+ sessionId: null,
1001
+ blob: '',
1002
+ })
1003
+ index.set(nodes[idx].id, idx)
1004
+ for (const i of hitIdx) {
1005
+ finalEdges.push({
1006
+ s: Math.min(i, idx),
1007
+ t: Math.max(i, idx),
1008
+ type: 'mentions',
1009
+ w: 0.92,
1010
+ why: ['正文原样提到' + SRC_ZH[kind] + ':' + name],
1011
+ })
1012
+ }
1013
+ }
1014
+ }
1015
+
1016
+ // ---------- 聚类(弱连通分量,按边权加权) ----------
1017
+ const parent = new Int32Array(nodes.length).map((_, i) => i)
1018
+ const find = (x) => {
1019
+ let r = x
1020
+ while (parent[r] !== r) r = parent[r]
1021
+ while (parent[x] !== r) {
1022
+ const nx = parent[x]
1023
+ parent[x] = r
1024
+ x = nx
1025
+ }
1026
+ return r
1027
+ }
1028
+ const union = (x, y) => {
1029
+ const rx = find(x)
1030
+ const ry = find(y)
1031
+ if (rx !== ry) parent[rx] = ry
1032
+ }
1033
+ for (const edge of finalEdges) {
1034
+ // 来源节点不参与「记忆簇」合并:技能/MCP 是横跨所有簇的标签,不是记忆的一部分
1035
+ if (edge.type === 'mentions') continue
1036
+ if (edge.w < 0.34) continue
1037
+ union(edge.s, edge.t)
1038
+ if (budgetSpent(2047)) {
1039
+ sliceAt = Date.now()
1040
+ yield 'cluster'
1041
+ }
1042
+ }
1043
+ const clusterMap = new Map()
1044
+ for (let i = 0; i < nodes.length; i++) {
1045
+ const r = find(i)
1046
+ let c = clusterMap.get(r)
1047
+ if (!c) clusterMap.set(r, (c = []))
1048
+ c.push(i)
1049
+ }
1050
+ const clusters = []
1051
+ for (const [, members] of clusterMap) {
1052
+ if (members.length < 3) continue
1053
+ const projectCount = new Map()
1054
+ for (const i of members) {
1055
+ const p = nodes[i].project || nodes[i].wsTitle
1056
+ projectCount.set(p, (projectCount.get(p) || 0) + 1)
1057
+ if (budgetSpent(1023)) {
1058
+ sliceAt = Date.now()
1059
+ yield 'cluster'
1060
+ }
1061
+ }
1062
+ // 取最大项不必排序:一个簇可能有几万成员,[...entries()].sort() 在 5 万条库上
1063
+ // 是单片 263ms 的元凶(排序 + 展开两个临时数组),换成一次扫描即可,顺手也让路。
1064
+ let topProject = ''
1065
+ let topCount = -1
1066
+ for (const [p, c] of projectCount) {
1067
+ if (c > topCount) {
1068
+ topProject = p
1069
+ topCount = c
1070
+ }
1071
+ if (budgetSpent(1023)) {
1072
+ sliceAt = Date.now()
1073
+ yield 'cluster'
1074
+ }
1075
+ }
1076
+ const wsCount = new Map()
1077
+ for (const i of members) {
1078
+ wsCount.set(nodes[i].ws, (wsCount.get(nodes[i].ws) || 0) + 1)
1079
+ if (budgetSpent(1023)) {
1080
+ sliceAt = Date.now()
1081
+ yield 'cluster'
1082
+ }
1083
+ }
1084
+ clusters.push({
1085
+ id: 'c' + hash32(topProject + members.length + members[0]).toString(36),
1086
+ label: topProject || '记忆簇',
1087
+ size: members.length,
1088
+ members,
1089
+ workspaces: [...wsCount.keys()],
1090
+ hue: (hash32(topProject) % 360),
1091
+ })
1092
+ }
1093
+ clusters.sort((a, b) => b.size - a.size)
1094
+
1095
+ // ---------- 输出 ----------
1096
+ const byType = {}
1097
+ const degree = new Map()
1098
+ for (const edge of finalEdges) {
1099
+ byType[edge.type] = (byType[edge.type] || 0) + 1
1100
+ degree.set(edge.s, (degree.get(edge.s) || 0) + 1)
1101
+ degree.set(edge.t, (degree.get(edge.t) || 0) + 1)
1102
+ if (budgetSpent(2047)) {
1103
+ sliceAt = Date.now()
1104
+ yield 'output'
1105
+ }
1106
+ }
1107
+ const byWorkspace = {}
1108
+ const byLevel = {}
1109
+ for (const node of nodes) {
1110
+ byWorkspace[node.wsTitle] = (byWorkspace[node.wsTitle] || 0) + 1
1111
+ byLevel[node.level] = (byLevel[node.level] || 0) + 1
1112
+ if (budgetSpent(2047)) {
1113
+ sliceAt = Date.now()
1114
+ yield 'output'
1115
+ }
1116
+ }
1117
+ const orphans = nodes.filter((node) => !degree.has(node.i)).length
1118
+
1119
+ const outNodes = []
1120
+ for (let oc = 0; oc < nodes.length; oc += 512) {
1121
+ for (const node of nodes.slice(oc, oc + 512)) outNodes.push({
1122
+ id: node.id,
1123
+ i: node.i,
1124
+ kind: node.kind || 'memory',
1125
+ sourceKind: node.sourceKind || null,
1126
+ provider: node.provider || 'meow-memory',
1127
+ adapter: node.adapter || null,
1128
+ ws: node.ws,
1129
+ wsTitle: node.wsTitle,
1130
+ level: node.level,
1131
+ title: node.title || clip(node.label, 60),
1132
+ label: node.label,
1133
+ preview: clip(node.content, 260),
1134
+ importance: node.importance,
1135
+ status: node.status,
1136
+ project: node.project,
1137
+ subcategory: node.subcategory,
1138
+ goal: clip(node.goal, 120),
1139
+ keywords: [...node.keywords],
1140
+ entities: [...node.entities.keys()].map((k) => String(k).split('|')[1]).slice(0, 8),
1141
+ hits: node.hits,
1142
+ heat: node.heat,
1143
+ degree: degree.get(node.i) || 0,
1144
+ createdAt: node.createdAt,
1145
+ updatedAt: node.updatedAt,
1146
+ accessedAt: node.accessedAt,
1147
+ sessionId: node.sessionId,
1148
+ seed: hash32(node.id) / 4294967296,
1149
+ })
1150
+ sliceAt = Date.now()
1151
+ yield 'output'
1152
+ }
1153
+
1154
+ const outEdges = []
1155
+ for (let ec = 0; ec < finalEdges.length; ec += 4096) {
1156
+ for (const edge of finalEdges.slice(ec, ec + 4096)) {
1157
+ outEdges.push({
1158
+ s: edge.s,
1159
+ t: edge.t,
1160
+ w: edge.w,
1161
+ type: edge.type,
1162
+ why: edge.why.slice(0, 4),
1163
+ })
1164
+ }
1165
+ sliceAt = Date.now()
1166
+ yield 'output'
1167
+ }
1168
+
1169
+ // [macro-fusion 0.4.0 · P4] 实体层:从「同一项目/路径/工具/版本」这四类硬事实里
1170
+ // 抽出锚点,供召回按实体找「关于 X 的一切」。它不进 nodes、不进 edges:
1171
+ // 度数、聚类、孤岛、面板条数全按「记忆」算,混进实体节点会把这些读数一起改写。
1172
+ // 只留可序列化的 `list`:图的缓存是 JSON,Map 存不住,读回来用 indexOf() 现建索引。
1173
+ const entityLayer = input.entityLayer === false
1174
+ ? null
1175
+ : (() => {
1176
+ const layer = collectEntities(nodes, { minMembers: input.entityMinMembers })
1177
+ return layer.list.length ? { list: layer.list, stats: layer.stats } : null
1178
+ })()
1179
+
1180
+ return {
1181
+ nodes: outNodes,
1182
+ edges: outEdges,
1183
+ clusters: clusters.slice(0, 60),
1184
+ entityLayer,
1185
+ stats: {
1186
+ nodes: nodes.length,
1187
+ edges: finalEdges.length,
1188
+ workspaces: Object.keys(byWorkspace).length,
1189
+ sessions: nSessions,
1190
+ byType,
1191
+ byWorkspace,
1192
+ byLevel,
1193
+ orphans,
1194
+ avgDegree: Math.round((finalEdges.length * 2 * 100) / Math.max(1, nodes.length)) / 100,
1195
+ // 实体数单独报:想知道「这一层到底抽出了多少东西」,不用再翻列表
1196
+ entities: entityLayer ? entityLayer.list.length : 0,
1197
+ },
1198
+ builtAt: now,
1199
+ }
1200
+ }
1201
+
1202
+ /**
1203
+ * 抽一个节点的完整正文(详情面板用)。
1204
+ * @param {object[]} nodes
1205
+ * @param {string} id
1206
+ */
1207
+ export function findNode(nodes, id) {
1208
+ return nodes.find((x) => x.id === id) || null
1209
+ }
1210
+
1211
+ export { overlapSize, intersect }
1212
+
1213
+ /* ------------------------------------------------------------------ *
1214
+ * 记忆体检(memory hygiene)
1215
+ *
1216
+ * 思路来自 luanyujia-workbench 的「记忆机制」:那里把失效模式列成一张表——
1217
+ * 越写越肥没人读 / 两份数字打架 / 体积正常但没用 / 关系是凑的。
1218
+ * 星图手里有全量正文和度数,这些病可以直接查出来,而不是等人自觉。
1219
+ *
1220
+ * 这里只诊断、不改任何记忆。
1221
+ * ------------------------------------------------------------------ */
1222
+
1223
+ const DAY = 86400000
1224
+
1225
+ export const HYGIENE_META = {
1226
+ dup: { label: '疑似重复', hint: '两条记忆几乎在说同一件事,留着会各写一半、互相打脸' },
1227
+ oversize: { label: '超重', hint: '单条正文超过 4000 字,读它一次就吃掉一大截上下文' },
1228
+ stale: { label: '该更新了', hint: '还挂着 active,但同一项目里有更新、更重要的记忆覆盖了它' },
1229
+ unread: { label: '没人读过', hint: '写下一周以上、一次都没被检索命中过' },
1230
+ thin: { label: '关系是凑的', hint: '边很多,但没有一条强关系(实体/项目级),全是关键词撞出来的' },
1231
+ orphan: { label: '孤立', hint: '一条边都没有:要么是独特知识,要么是没人会再想起的碎片' },
1232
+ // [macro-fusion 0.4.0] 写入端通胀三连:这三条看的不是「记忆写错了」,而是
1233
+ // 「检索与写入被同一批词反复喂」——写入方(包括我自己)会针对召回机制优化自己。
1234
+ selfecho: {
1235
+ label: '关键词自证',
1236
+ hint: 'keywords 里超过七成逐字出现在正文里:这些词靠 BM25 本来就能命中,堆上去等于没扩召回面(自证,不是扩展)',
1237
+ },
1238
+ unused: {
1239
+ label: '召回过没人读',
1240
+ hint: '被检索命中过、却一次都没被 memory_read 打开过:排进了候选,但没人真去读。注意记账从 0.4.0 起,更早的读没有被记(老库这一格会偏大)',
1241
+ },
1242
+ inflate: {
1243
+ label: '写得多收得少',
1244
+ hint: '近 30 天 fact 层条数增速是结论层(rules / lesson)的 3 倍以上:原子事实在堆,没人把它收成结论',
1245
+ },
1246
+ }
1247
+
1248
+ const HY_MAX = 40
1249
+
1250
+ function hyJaccard(a, b) {
1251
+ if (!a.length || !b.length) return 0
1252
+ const s = new Set(a)
1253
+ let inter = 0
1254
+ for (const x of b) if (s.has(x)) inter++
1255
+ return inter / (s.size + b.length - inter)
1256
+ }
1257
+
1258
+ /**
1259
+ * 超过阈值才返回 Jaccard,否则 0。重复检测对每对候选都做一次,提前退出能省掉
1260
+ * 绝大多数「共享两个词」的无意义比较。
1261
+ */
1262
+ // 关键词去重 + 小写:体检里到处都按这个口径比词
1263
+ function kwOf(m) {
1264
+ return [...new Set((m.keywords || []).map((x) => String(x).toLowerCase()))]
1265
+ }
1266
+
1267
+ // 集合 set 里命中 list 至少 t 个就早退(list 通常 3–8 个词,比求交还便宜)
1268
+ function overlapAtLeast(set, list, t) {
1269
+ if (!set || !set.size) return false
1270
+ let hit = 0
1271
+ for (const k of list) {
1272
+ if (set.has(k)) {
1273
+ hit++
1274
+ if (hit >= t) return true
1275
+ }
1276
+ }
1277
+ return false
1278
+ }
1279
+
1280
+ function hyJaccardAtLeast(a, b, min) {
1281
+ if (!a || !b || !a.size || !b.size) return 0
1282
+ const total = a.size + b.size
1283
+ const need = Math.ceil((min * total) / (1 + min))
1284
+ const small = a.size <= b.size ? a : b
1285
+ const big = small === a ? b : a
1286
+ let inter = 0
1287
+ let seen = 0
1288
+ for (const x of small) {
1289
+ if (big.has(x)) inter++
1290
+ seen++
1291
+ if (inter + (small.size - seen) < need) return 0
1292
+ }
1293
+ return inter >= need ? inter / (total - inter) : 0
1294
+ }
1295
+
1296
+ /**
1297
+ * 边的两端统一成「节点 id」。
1298
+ *
1299
+ * 图里为了省包体,边用的是节点下标(`{s,d,t,w}`,buildGraph 产出的则是 `{s,t}`);
1300
+ * 早期版本这里直接读 `e.a / e.b`,于是「孤立」把每一条记忆都算了进去、
1301
+ * 「关系是凑的」永远是空的——体检报告看着有数字,其实那两格是假的。
1302
+ * 现在两种形状都认:有 id(a/b)就用 id,只有下标就借 nodeIds 还原。
1303
+ *
1304
+ * @param {object} e 边
1305
+ * @param {string[]|null} nodeIds 下标 -> id(与建图时 nodes 的顺序一致)
1306
+ */
1307
+ function edgeEnds(e, nodeIds) {
1308
+ if (e.a != null || e.b != null) return [e.a, e.b]
1309
+ if (!nodeIds) return [undefined, undefined]
1310
+ // 内部边第二端叫 t,公开图(v2)叫 d —— 两个都认
1311
+ return [nodeIds[e.s], nodeIds[e.d != null ? e.d : e.t]]
1312
+ }
1313
+
1314
+ /**
1315
+ * @param {{nodes:object[], edges:object[], nodeIds?:string[]}} input
1316
+ */
1317
+ /** 同步跑完体检:纯函数,测试与小库直接用它(行为与 1.11.3 完全一致)。 */
1318
+ export function auditHygiene(args) {
1319
+ const it = auditHygieneSteps(args)
1320
+ let step = it.next()
1321
+ while (!step.done) step = it.next()
1322
+ return step.value
1323
+ }
1324
+
1325
+ /**
1326
+ * 异步体检:每做完一小片就把事件循环让出去。
1327
+ *
1328
+ * 为什么要这样:2 万条的库上体检要 2.9 秒(分词签名 1.1s + 重复检测 1.5s),
1329
+ * 同步跑等于让整个 HTTP 服务停三秒。在 DSH 里这条路由挂在宿主自己的 web server 上,
1330
+ * 「停三秒」就是主界面的按钮三秒没反应。生成器把活切成片,await setImmediate 让 ping、
1331
+ * 静态资源、其它请求都能插进来;总时长不变,最长静默从秒级降到几十毫秒。
1332
+ */
1333
+ export async function auditHygieneAsync(args) {
1334
+ const it = auditHygieneSteps(args)
1335
+ for (;;) {
1336
+ const step = it.next()
1337
+ if (step.done) return step.value
1338
+ await new Promise((resolve) => setImmediate(resolve))
1339
+ }
1340
+ }
1341
+
1342
+ export function* auditHygieneSteps({ nodes, edges, nodeIds = null, tokensById = null }) {
1343
+ const profile = process.env.NEBULA_HY_PROFILE === '1'
1344
+ const t0 = performance.now()
1345
+ const laps = []
1346
+ const mark = (name) => { if (profile) laps.push([name, Math.round(performance.now() - t0)]) }
1347
+ const now = Date.now()
1348
+ const memories = nodes.filter((n) => n.level !== 'source')
1349
+ const byId = new Map(nodes.map((n) => [n.id, n]))
1350
+
1351
+ // 每条记忆只分词一次:df 和签名共用;建图侧若已算过 token,可以整批传进来复用。
1352
+ const toks = new Map()
1353
+ // 这一支是生成器:每做完一小片就 yield 一次,异步版本据此把事件循环让出去。
1354
+ // 2 万条库上体检要 2.9 秒(分词签名 1.1s + 重复检测 1.5s),整段同步跑等于让
1355
+ // HTTP 服务(在 DSH 里就是宿主自己的事件循环)停三秒:/ping 不回声、按钮没反应。
1356
+ const SLICE = 2048
1357
+ let slice = 0
1358
+ for (const n of memories) {
1359
+ toks.set(n.id, tokensById?.get(n.id) || tokenize(n.content || ''))
1360
+ if (++slice >= SLICE) {
1361
+ slice = 0
1362
+ yield 'tokens'
1363
+ }
1364
+ }
1365
+ mark('tok')
1366
+ // ① 词频:给每个词一个内部编号,计数走 Int32Array。
1367
+ // 旧写法每个词要 df.get + df.set 两次字符串哈希;5 万条库上 260 万个词次,
1368
+ // 这两次哈希就是 973ms 里的大头。编号只哈希一次,之后都是数组下标。
1369
+ const wordId = new Map()
1370
+ // 每个词的字符串也要留一份:签名最后要交回「词」,比对时只需要编号。
1371
+ const words = []
1372
+ // 每个节点的词表存成 Int32Array(编号)。签名阶段因此不必再对每个词做一次
1373
+ // 字符串哈希——5 万条库上 367 万个词次,那就是 780ms 里免掉的一大半。
1374
+ const idsOf = new Map()
1375
+ let wordCount = 0
1376
+ let cap = 1 << 12
1377
+ let dfCount = new Int32Array(cap)
1378
+ for (const n of memories) {
1379
+ let set = toks.get(n.id)
1380
+ if (!(set instanceof Set)) set = new Set(set)
1381
+ const ids = new Int32Array(set.size)
1382
+ let k = 0
1383
+ for (const t of set) {
1384
+ let id = wordId.get(t)
1385
+ if (id === undefined) {
1386
+ id = wordCount++
1387
+ wordId.set(t, id)
1388
+ words[id] = t
1389
+ if (id >= cap) {
1390
+ cap = cap << 1
1391
+ const bigger = new Int32Array(cap)
1392
+ bigger.set(dfCount)
1393
+ dfCount = bigger
1394
+ }
1395
+ }
1396
+ dfCount[id] += 1
1397
+ ids[k++] = id
1398
+ }
1399
+ idsOf.set(n.id, ids)
1400
+ if ((++slice & 2047) === 0) yield 'df'
1401
+ }
1402
+ mark('df')
1403
+ const sig = new Map()
1404
+ const sigSets = new Map()
1405
+ // ② 签名:每个节点只要「最稀有的 24 个词」。
1406
+ // 旧写法把整份词表排一次序(每节点 50–100 次比较,每次两次 Map 查表),
1407
+ // 5 万条库上 1,684ms。改成 24 个位置的有界插入:比当前第 24 名还常见就直接跳过。
1408
+ // 平局按 Set 的迭代顺序排在后面 —— 和 Array#sort(V8 稳定排序)的结果一致。
1409
+ const SIG_N = 24
1410
+ for (const n of memories) {
1411
+ const ids = idsOf.get(n.id)
1412
+ const pickC = []
1413
+ const pickI = []
1414
+ for (let k = 0; k < ids.length; k++) {
1415
+ const id = ids[k]
1416
+ // 「«短语»」是整段 CJK 短词,相似度不该看它(旧实现也是先滤掉再挑)。
1417
+ if (words[id].charCodeAt(0) === 171) continue
1418
+ const c = dfCount[id]
1419
+ if (c <= 1) continue
1420
+ if (pickC.length === SIG_N && c >= pickC[SIG_N - 1]) continue
1421
+ let i = pickC.length
1422
+ pickC.push(c)
1423
+ pickI.push(id)
1424
+ while (i > 0 && pickC[i - 1] > c) {
1425
+ pickC[i] = pickC[i - 1]
1426
+ pickI[i] = pickI[i - 1]
1427
+ i--
1428
+ }
1429
+ pickC[i] = c
1430
+ pickI[i] = id
1431
+ if (pickC.length > SIG_N) {
1432
+ pickC.length = SIG_N
1433
+ pickI.length = SIG_N
1434
+ }
1435
+ }
1436
+ const sigWords = pickI.map((wid) => words[wid])
1437
+ sig.set(n.id, sigWords)
1438
+ // 每对候选都 new Set 一次是 1 万条库上重复检测的主要开销;每个节点只建一次,
1439
+ // 之后所有比较都直接 has()。
1440
+ sigSets.set(n.id, new Set(sigWords))
1441
+ if ((++slice & 2047) === 0) yield 'sig'
1442
+ }
1443
+
1444
+ mark('sig')
1445
+ mark('tokens+df+sig')
1446
+ // 重复检测两段,缺一段就会漏:
1447
+ // ① 正文一字不差的分桶(O(n))——同一段记忆被抄进几个工作区是最常见的重复形态,
1448
+ // 而这类副本共享的词在库里出现几百次,靠倒排反而容易漏;
1449
+ // ② 近似重复用「稀有词倒排 → 共享数下界 → Jaccard」。
1450
+ //
1451
+ // 5 万条库上实测:旧写法 907 万次候选迭代、去重后 58 万对,每对都真的算 24 词 Jaccard,
1452
+ // 还要为每一对拼一个 "a\0b" 字符串键——这一段占体检九成。两处改动都不损召回:
1453
+ // · 候选对用下标数值做键(i * base + j),不再分配字符串;
1454
+ // · 先数这对共享了多少词,连 Jaccard 阈值需要的下界都够不着就不算 Jaccard。
1455
+ // need 是按两边签名长度算出来的,共享数不到 need 就一定过不了 0.86。
1456
+ //
1457
+ // 抽样上限(这是 O(n²) 不可行的原因,写在这里免得下次又以为是全对):
1458
+ // 每个词最多进 60 条进倒排、每个正文桶最多取前 60 条。
1459
+ const POST_CAP = 60
1460
+ const BUCKET_MAX = 60
1461
+ const base = memories.length
1462
+ const idx = new Map()
1463
+ for (let i = 0; i < memories.length; i++) idx.set(memories[i].id, i)
1464
+
1465
+ const bucket = new Map()
1466
+ for (let i = 0; i < memories.length; i++) {
1467
+ const body = (memories[i].content || '').trim()
1468
+ if (body.length < 24) continue
1469
+ let arr = bucket.get(body)
1470
+ if (!arr) bucket.set(body, (arr = []))
1471
+ if (arr.length < BUCKET_MAX) arr.push(i)
1472
+ if ((++slice & 2047) === 0) yield 'dup'
1473
+ }
1474
+ const exact = new Set()
1475
+ for (const [, ids] of bucket) {
1476
+ if (ids.length < 2) continue
1477
+ for (let i = 0; i < ids.length; i++) {
1478
+ for (let j = i + 1; j < ids.length; j++) exact.add(ids[i] * base + ids[j])
1479
+ }
1480
+ if ((++slice & 511) === 0) yield 'dup'
1481
+ }
1482
+ mark('dup-exact')
1483
+
1484
+ const post = new Map()
1485
+ for (const n of memories) {
1486
+ for (const t of sig.get(n.id) || []) {
1487
+ let arr = post.get(t)
1488
+ if (!arr) post.set(t, (arr = []))
1489
+ if (arr.length < POST_CAP) arr.push(idx.get(n.id))
1490
+ }
1491
+ if ((++slice & 2047) === 0) yield 'postings'
1492
+ }
1493
+ mark('postings')
1494
+
1495
+ const shared = new Map()
1496
+ for (const [, ids] of post) {
1497
+ for (let i = 0; i < ids.length; i++) {
1498
+ for (let j = i + 1; j < ids.length; j++) {
1499
+ const key = ids[i] < ids[j] ? ids[i] * base + ids[j] : ids[j] * base + ids[i]
1500
+ if (exact.has(key)) continue
1501
+ shared.set(key, (shared.get(key) || 0) + 1)
1502
+ }
1503
+ }
1504
+ if ((++slice & 1023) === 0) yield 'dup'
1505
+ }
1506
+ mark('dup-count')
1507
+
1508
+ const dupPairs = []
1509
+ for (const key of exact) {
1510
+ const ia = Math.floor(key / base)
1511
+ const ib = key - ia * base
1512
+ const na = memories[ia]
1513
+ const nb = memories[ib]
1514
+ if (na && nb) dupPairs.push({ a: na.id, b: nb.id, j: 1 })
1515
+ }
1516
+ // 试过在这之前加一道「共享词数够不着阈值就别算 Jaccard」的预筛:倒排每条只留
1517
+ // 60 条,共享词会被截断,`inter` 是低估,于是真重复被判成无关(5 万条实测漏 8.8 万对)。
1518
+ // 无损的提速只有上面那两条:数值键、正文分桶。
1519
+ for (const key of shared.keys()) {
1520
+ const ia = Math.floor(key / base)
1521
+ const ib = key - ia * base
1522
+ const na = memories[ia]
1523
+ const nb = memories[ib]
1524
+ if (!na || !nb) continue
1525
+ const la = (na.content || '').length
1526
+ const lb = (nb.content || '').length
1527
+ if (Math.min(la, lb) / Math.max(1, Math.max(la, lb)) < 0.6) continue
1528
+ const j2 = hyJaccardAtLeast(sigSets.get(na.id), sigSets.get(nb.id), 0.86)
1529
+ if ((++slice & 4095) === 0) yield 'dup'
1530
+ if (j2 > 0) dupPairs.push({ a: na.id, b: nb.id, j: j2 })
1531
+ }
1532
+ mark('dup-pairs')
1533
+ dupPairs.sort((x, y) => y.j - x.j)
1534
+
1535
+ // 阈值不写死:跟这批记忆的实际体量比,取「最重的 3%」,但不低于 1200 字
1536
+ const lens = memories.map((m) => (m.content || '').length).sort((a, b) => a - b)
1537
+ const overLimit = Math.max(600, lens[Math.floor(lens.length * 0.97)] || 600)
1538
+ const oversizeAll = memories
1539
+ .filter((n) => (n.content || '').length > overLimit)
1540
+ .sort((a, b) => (b.content || '').length - (a.content || '').length)
1541
+ const oversize = oversizeAll
1542
+ .slice(0, HY_MAX)
1543
+ .map((n) => ({ id: n.id, label: n.label, ws: n.wsTitle, level: n.level, size: (n.content || '').length }))
1544
+
1545
+ const byWs = new Map()
1546
+ for (const n of memories) {
1547
+ if (n.status !== 'active') continue
1548
+ let arr = byWs.get(n.ws)
1549
+ if (!arr) byWs.set(n.ws, (arr = []))
1550
+ arr.push(n)
1551
+ }
1552
+ mark('oversize')
1553
+ const stale = []
1554
+ for (const [, list] of byWs) {
1555
+ // 倒排:keyword → 该工作区里含这个词的记忆(按 updatedAt 从新到旧)。
1556
+ // 旧写法对每条记忆都扫一遍整个工作区,1 万条时是平方级;倒排后只看
1557
+ // 「更新 + 更重要」的少量候选,命中 3 个共同关键词就停。
1558
+ // 先把工作区按 updatedAt 从新到旧排一遍,再建倒排:倒排表天生就是有序的。
1559
+ // 旧写法在建完倒排之后对**每个关键词**各排一次序(每张表还要按 updatedAt 重排几千条),
1560
+ // 5 万条库上这部分占了 stale 那一秒里的三分之一。等价性:原来每张表的降序排列,
1561
+ // 与「按 updatedAt 降序遍历、依次 push」得到的顺序一致(同 updatedAt 时保持原顺序)。
1562
+ const ordered = [...list].sort((x, y) => (y.updatedAt || 0) - (x.updatedAt || 0))
1563
+ const kwPost = new Map()
1564
+ const kwSets = new Map()
1565
+ for (const m of ordered) {
1566
+ const kws = kwOf(m)
1567
+ kwSets.set(m.id, new Set(kws))
1568
+ for (const k of kws) {
1569
+ let arr = kwPost.get(k)
1570
+ if (!arr) kwPost.set(k, (arr = []))
1571
+ arr.push(m)
1572
+ }
1573
+ }
1574
+ for (const n of list) {
1575
+ if ((++slice & 2047) === 0) yield 'stale'
1576
+ const ageDays = (now - (n.updatedAt || n.createdAt || now)) / DAY
1577
+ if (ageDays < 14) continue
1578
+ const kws = kwOf(n)
1579
+ // 要「3 个共同关键词」才对得上:先把 n 的词按倒排链长(≈全局稀有度)从短到长排,
1580
+ // 只在前 |kws|-2 个词里找候选就够了 —— 若某个 m 与 n 共享 ≥3 个词,那 3 个词不可能
1581
+ // 全落在最后 2 个位置。这一步把 5 万条库上的候选从几十万压到 4 万,stale 段 910ms → 328ms。
1582
+ if (kws.length < 3) continue
1583
+ const prefix = kws
1584
+ .map((k) => ({ k, len: (kwPost.get(k) || []).length }))
1585
+ .sort((a, b) => a.len - b.len)
1586
+ .slice(0, kws.length - 2)
1587
+ let cover = null
1588
+ const seen = new Set()
1589
+ for (const { k } of prefix) {
1590
+ for (const m of kwPost.get(k) || []) {
1591
+ if ((m.updatedAt || 0) <= (n.updatedAt || 0)) break
1592
+ if (m.id === n.id || seen.has(m.id)) continue
1593
+ seen.add(m.id)
1594
+ if ((m.importance || 0) < (n.importance || 0)) continue
1595
+ if (overlapAtLeast(kwSets.get(m.id), kws, 3)) {
1596
+ cover = m
1597
+ break
1598
+ }
1599
+ }
1600
+ if (cover) break
1601
+ }
1602
+ if (cover) {
1603
+ stale.push({
1604
+ id: n.id,
1605
+ label: n.label,
1606
+ ws: n.wsTitle,
1607
+ level: n.level,
1608
+ days: Math.round(ageDays),
1609
+ by: { id: cover.id, label: cover.label },
1610
+ })
1611
+ }
1612
+ }
1613
+ }
1614
+ stale.sort((a, b) => b.days - a.days)
1615
+ // 「该更新了」在 2 万条的库里能有一万多条:全塞进 /overview 会让首屏多出 4.5MB,
1616
+ // 而界面一次只显示前 5 条。所以列表截到 HY_MAX,计数用下面的全量数字。
1617
+ const staleTotal = stale.length
1618
+ if (stale.length > HY_MAX) stale.length = HY_MAX
1619
+
1620
+ mark('stale')
1621
+ const unreadAll = memories
1622
+ .filter((n) => !n.hits && (now - (n.createdAt || now)) / DAY > 3 && n.status === 'active')
1623
+ .sort((a, b) => (a.createdAt || 0) - (b.createdAt || 0))
1624
+ const unread = unreadAll
1625
+ .slice(0, HY_MAX)
1626
+ .map((n) => ({ id: n.id, label: n.label, ws: n.wsTitle, level: n.level, days: Math.round((now - (n.createdAt || now)) / DAY) }))
1627
+
1628
+ mark('unread')
1629
+ const sum = new Map()
1630
+ const cnt = new Map()
1631
+ const strong = new Map()
1632
+ // 强关系门槛:实体边中位数 0.62、项目边 0.52,关键词边绝大多数钉在 0.30 —— 0.45 正好把「撞词」和「真关系」分开
1633
+ const STRONG_W = 0.45
1634
+ for (const e of edges) {
1635
+ const w = e.w || 0
1636
+ for (const id of edgeEnds(e, nodeIds)) {
1637
+ if (id == null) continue
1638
+ sum.set(id, (sum.get(id) || 0) + w)
1639
+ cnt.set(id, (cnt.get(id) || 0) + 1)
1640
+ if (w >= STRONG_W) strong.set(id, (strong.get(id) || 0) + 1)
1641
+ }
1642
+ }
1643
+ mark('edges')
1644
+ const thin = []
1645
+ for (const n of memories) {
1646
+ // 只看「边很多、却一条强边都没有」:均值会被大量 0.30 的关键词边拖低,
1647
+ // 单看均值会把有实体关系的节点也误判进来(实测 326 条里 202 条其实有硬关系)。
1648
+ const c = cnt.get(n.id) || 0
1649
+ if (c < 10) continue
1650
+ if (strong.get(n.id) || 0) continue
1651
+ const avg = (sum.get(n.id) || 0) / c
1652
+ thin.push({ id: n.id, label: n.label, ws: n.wsTitle, level: n.level, degree: c, avg: Number(avg.toFixed(2)) })
1653
+ }
1654
+ thin.sort((a, b) => a.avg - b.avg)
1655
+ const thinTotal = thin.length
1656
+ if (thin.length > HY_MAX) thin.length = HY_MAX
1657
+
1658
+ mark('thin')
1659
+ const orphanAll = memories
1660
+ .filter((n) => !(cnt.get(n.id) || 0))
1661
+ .sort((a, b) => (b.importance || 0) - (a.importance || 0))
1662
+ const orphan = orphanAll
1663
+ .slice(0, HY_MAX)
1664
+ .map((n) => ({ id: n.id, label: n.label, ws: n.wsTitle, level: n.level, importance: n.importance || 0 }))
1665
+
1666
+ const dup = dupPairs.slice(0, HY_MAX).map((p) => ({
1667
+ a: { id: p.a, label: byId.get(p.a)?.label || '', ws: byId.get(p.a)?.wsTitle || '' },
1668
+ b: { id: p.b, label: byId.get(p.b)?.label || '', ws: byId.get(p.b)?.wsTitle || '' },
1669
+ sim: Number(p.j.toFixed(3)),
1670
+ }))
1671
+
1672
+ // [macro-fusion 0.4.0] 写入端通胀三连(P2.5)。这三条不是「记忆写错了」,
1673
+ // 而是「检索与写入被同一批词反复喂」——写入方(包括 AI 自己)会针对召回机制优化自己:
1674
+ // 关键词挑能命中自己的词、正文写成关键词的复读、事实一条条堆而结论不增。
1675
+ mark('inflate')
1676
+ const SELF_ECHO_MIN_KW = 3
1677
+ const SELF_ECHO_RATE = 0.7
1678
+ const selfechoAll = []
1679
+ for (const n of memories) {
1680
+ const kws = kwOf(n)
1681
+ // 只有 1–2 个关键词的条目,1/2 = 50% 也能算「高」——样本太小的比例不是信号。
1682
+ if (kws.length < SELF_ECHO_MIN_KW) continue
1683
+ const body = String(n.content || '').toLowerCase()
1684
+ if (!body) continue
1685
+ let echo = 0
1686
+ for (const k of kws) if (k && body.includes(k)) echo++
1687
+ const rate = echo / kws.length
1688
+ if (rate <= SELF_ECHO_RATE) continue
1689
+ selfechoAll.push({ id: n.id, label: n.label, ws: n.wsTitle, level: n.level, rate: Number(rate.toFixed(2)), echo, kws: kws.length })
1690
+ }
1691
+ // 自证率高的先吵:1.00 才是「关键词全是正文的复读机」,0.75 只是偏。
1692
+ selfechoAll.sort((a, b) => b.rate - a.rate || b.kws - a.kws)
1693
+ const selfechoTotal = selfechoAll.length
1694
+ const selfecho = selfechoAll.slice(0, HY_MAX)
1695
+
1696
+ // 「召回过没人读」:命中过(排进过候选)却一次都没被 memory_read 打开。
1697
+ // 只对真记了 read_count 的源成立(meow 从 0.4.0 起);别的适配器没这个数就不参与,
1698
+ // 否则 hits 一有就全部假阳。老库这一格偏大是必然的——以前的读没被记过。
1699
+ const unusedAll = memories
1700
+ .filter((n) => typeof n.reads === 'number' && n.status === 'active' && (n.hits || 0) > 0 && !n.reads)
1701
+ .sort((a, b) => (b.hits || 0) - (a.hits || 0))
1702
+ const unusedTotal = unusedAll.length
1703
+ const unused = unusedAll
1704
+ .slice(0, HY_MAX)
1705
+ .map((n) => ({ id: n.id, label: n.label, ws: n.wsTitle, level: n.level, hits: n.hits || 0 }))
1706
+
1707
+ // 层通胀:近 30 天 fact 条数 vs 结论层(rules / lesson)。看增速比值、不看绝对量,
1708
+ // 所以要有最小样本——新库里 fact 3 条、结论层 0 条也是「无限倍」,那不是病。
1709
+ const INFLATE_DAYS = 30
1710
+ const INFLATE_RATIO = 3
1711
+ const INFLATE_MIN = 6
1712
+ const inflateSince = now - INFLATE_DAYS * DAY
1713
+ let factNew = 0
1714
+ let semNew = 0
1715
+ for (const n of memories) {
1716
+ if ((n.createdAt || 0) < inflateSince) continue
1717
+ if (n.level === 'fact') factNew++
1718
+ else if (n.level === 'rules' || n.level === 'lesson') semNew++
1719
+ }
1720
+ const inflateX = semNew > 0 ? factNew / semNew : factNew
1721
+ const inflateTotal = factNew >= INFLATE_MIN && factNew > semNew * INFLATE_RATIO ? 1 : 0
1722
+ // 这一类是「整库一个判断」,不是逐条清单:命中就给一行汇总,id 留空(面板别当记忆跳)。
1723
+ const inflate = inflateTotal
1724
+ ? [
1725
+ {
1726
+ id: '',
1727
+ label: `近 ${INFLATE_DAYS} 天:fact ${factNew} 条 / 结论层 ${semNew} 条(${Number(inflateX.toFixed(1))}×)`,
1728
+ ws: '',
1729
+ level: 'fact',
1730
+ fact: factNew,
1731
+ semantic: semNew,
1732
+ },
1733
+ ]
1734
+ : []
1735
+
1736
+ const items = { dup, oversize, stale, unread, thin, orphan, selfecho, unused, inflate }
1737
+ // 计数用「全部命中」,列表只留前 HY_MAX 条:payload 有上限,数字不失真。
1738
+ const full = {
1739
+ dup: dupPairs.length,
1740
+ oversize: oversizeAll.length,
1741
+ stale: staleTotal,
1742
+ unread: unreadAll.length,
1743
+ thin: thinTotal,
1744
+ orphan: orphanAll.length,
1745
+ selfecho: selfechoTotal,
1746
+ unused: unusedTotal,
1747
+ inflate: inflateTotal,
1748
+ }
1749
+ const counts = {}
1750
+ const shown = {}
1751
+ let total = 0
1752
+ let totalShown = 0
1753
+ for (const k of Object.keys(items)) {
1754
+ counts[k] = full[k] || 0
1755
+ shown[k] = items[k].length
1756
+ total += counts[k]
1757
+ totalShown += shown[k]
1758
+ }
1759
+ mark('orphan')
1760
+ if (profile) console.error('[hygiene]', laps.map(([n, t]) => `${n}:${t}ms`).join(' '))
1761
+ return { generatedAt: now, counts, shown, total, totalShown, items, meta: HYGIENE_META }
1762
+ }