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,871 @@
1
+ import { TEXT_OUT, pick } from '../shared.js'
2
+ import { recallAnswerKind } from '../contract.js'
3
+ import { cardTitle } from '../panel.js'
4
+ // [macro-fusion 0.2.109] 回执成本与预算:口径全在 tokencost.js(估算不是计量,够大才报)。
5
+ import { BUDGET_MIN, COST_HINT_MIN, COST_SHOW_MIN, budgetOf, costSentence, estTokens, fmtTokens } from '../tokencost.js'
6
+ // [macro-fusion 0.2.118] 检索融合:两路名次合成一张榜,重复条目只出现一次。
7
+ import { RRF_K, fuseRanked, fusedText, graphNodesOf } from '../fusion.js'
8
+
9
+ // [macro-fusion 0.2.58] mode 不做白名单时,老代码 `String(args.mode ?? 'local')` 会把
10
+ // 所有不认识的值静默当成 local:写 `mode:"Graph"` 的人以为拿到的是沿关联扩散,其实拿到的是
11
+ // 关键词命中(读者会把它当成「图里就这么几条」);写 `mode:"similar"` 漏一个字母,
12
+ // 反过来抛「本地检索需要 query」——教他改一个他明明写过的词。
13
+ const MODE_VALUES = ['local', 'graph', 'bridge', 'similar']
14
+
15
+ /** [macro-fusion 0.2.60] 卡片上的中文名:和 memory_admin 的动作表同一套规矩(键是给机器的,名字是给人的)。 */
16
+ const MODE_LABELS = { local: '本地检索', graph: '沿关联扩散', bridge: '补邻居', similar: '相似条目' }
17
+
18
+ /**
19
+ * 只属于本地检索的那几个条件(0.2.66)。
20
+ *
21
+ * graph / bridge 走的是星图,星图侧只认 limit / hops / chars / min_weight:用户在 graph 模式
22
+ * 里给了 `project` / `level` / `days` / `k`,星图那一路把它们全丢掉——一声不吭地丢掉,
23
+ * 读者却以为结果已经按项目筛过。而星图没接上时,这一问偏偏退到本地检索,
24
+ * 同样这几个参数**又真的生效了**。同一组参数在两条路径上一进一出,尾注得跟着路径说话。
25
+ */
26
+ const LOCAL_ONLY_PARAMS = ['level', 'project', 'status', 'days', 'content_max', 'context', 'explain']
27
+
28
+ /** 归一 mode:空串/纯空格 = 没给(local),大小写不敏感;不合法时把原值留住。 */
29
+ function modeOf(args) {
30
+ const raw = args.mode
31
+ const text = typeof raw === 'string' ? raw.trim() : ''
32
+ if (text.length === 0) return { name: 'local', bad: false, raw: '' }
33
+ const name = text.toLowerCase()
34
+ return { name, bad: !MODE_VALUES.includes(name), raw: String(raw) }
35
+ }
36
+
37
+ /** 模式名对不上时:一句都不查,并把「哪种意图对应哪个词」写出来。 */
38
+ function badModeText(mode) {
39
+ return (
40
+ `mode 没生效:你给的是「${mode.raw}」,这里只认 local / graph / bridge / similar` +
41
+ '(大小写不敏感,前后空格会去掉)。这次一条都没查——这不是「记忆里没有」,是模式名没对上。\n' +
42
+ '对应关系:沿关联扩散用 graph;强相关但没读过的邻居用 bridge;相似条目用 similar + id;普通关键词检索用 local(默认)。'
43
+ )
44
+ }
45
+
46
+ /**
47
+ * 参数给在了别的模式上:改动不了结果,但必须说一句,否则读者以为它生效了。
48
+ *
49
+ * [macro-fusion 0.2.65] 尾注不许撒谎:老写法对所有非 graph/bridge 模式一律说
50
+ * 「limit 只在 graph / bridge 生效……这次没用上 limit」。可是 local 模式在「零命中自动扩散」
51
+ * 或 `expand: true` 时,扩散那次呼叫读的正是 args.limit / args.hops 原值——
52
+ * 条件被用上了,回执却告诉他没用上。于是 limit=0 的人看到「扩散没补到东西」,
53
+ * 再看到「limit 这次没用上」,两句一起读成「星图里真没有」。这里按 flags.spread 说实话。
54
+ */
55
+ function modeNotes(mode, args, flags = {}) {
56
+ const notes = []
57
+ const spread = flags.spread === true
58
+ const tried = flags.spreadTried === true && !spread
59
+ if (mode !== 'local' && args.expand === true) {
60
+ notes.push(`expand 只在 local 模式生效(这次是 ${mode}),没有额外的本地检索。`)
61
+ }
62
+ // [macro-fusion 0.2.66] 星图接上了 → 这一问走星图,本地那几个条件真的没用上;
63
+ // 星图没接上 → 这一问退到本地检索,同一批条件**真的生效了**(同一句老文案在这里说反话)。
64
+ // 连「没给 query 就没算」也要分开:那时谁都没参与,不是「星图里只有这么多」。
65
+ const fell = flags.graphFellBack === true
66
+ const absent = flags.graphAbsentNoLocal === true
67
+ if ((mode === 'graph' || mode === 'bridge') && args.k !== undefined) {
68
+ const def = mode === 'graph' ? 10 : 4
69
+ notes.push(
70
+ fell
71
+ ? `k 这次真的用上了:星图没接上,这一问退到本地检索,按你给的 k 取的结果——它不是「星图里就这么几条」。`
72
+ : absent
73
+ ? 'k 这次没参与:星图没接上、又没给 query,这一问压根没算。'
74
+ : `k 是本地检索的条数;${mode} 模式用 limit,这次按 ${def} 条算。`,
75
+ )
76
+ }
77
+ if (mode === 'graph' || mode === 'bridge') {
78
+ const localOnly = LOCAL_ONLY_PARAMS.filter((n) => args[n] !== undefined)
79
+ if (localOnly.length > 0) {
80
+ const list = localOnly.join(' / ')
81
+ notes.push(
82
+ fell
83
+ ? `${list} 这些是本地检索的条件:星图没接上,这一问退到本地检索,它们真的用上了——但结果不是星图给的。`
84
+ : absent
85
+ ? `${list} 这些是本地检索的条件:星图没接上、又没给 query,这一问压根没算,它们谁都没参与。`
86
+ : `${list} 只在本地检索生效;${mode} 走星图,这次没用上它们(星图侧认的是 limit / hops / chars / min_weight 那几个)。`,
87
+ )
88
+ }
89
+ }
90
+ if (mode === 'local' && args.limit !== undefined) {
91
+ notes.push(
92
+ spread
93
+ ? `limit 平时是 graph / bridge 的条数;这次扩散真的用了它(limit=${flags.spreadLimit})——本地检索自己的条数仍用 k。`
94
+ : tried
95
+ ? `limit 平时是 graph / bridge 的条数;这次本来要扩散(会用 limit=${flags.spreadLimit}),但星图没接上——它没参与这次结果。`
96
+ : 'limit 是 graph / bridge 的条数;这次没有扩散,limit 没用上(本地检索的条数用 k)。',
97
+ )
98
+ }
99
+ if (mode === 'local' && args.hops !== undefined) {
100
+ notes.push(
101
+ spread
102
+ ? `hops 平时是 graph / bridge 的扩散跳数;这次扩散真的用了它(hops=${flags.spreadHops})。`
103
+ : tried
104
+ ? `hops 平时是 graph / bridge 的扩散跳数;这次本来要扩散(会用 hops=${flags.spreadHops}),但星图没接上——它没参与这次结果。`
105
+ : 'hops 是 graph / bridge 的扩散跳数;这次没有扩散,hops 没用上。',
106
+ )
107
+ }
108
+ if (mode === 'similar' && args.limit !== undefined) {
109
+ notes.push('limit 只在 graph / bridge 生效;相似检索的条数用 k,这次没用上 limit。')
110
+ }
111
+ // [macro-fusion 0.2.67] 相似模式原来只有 limit 一句话,别的参数全沉默:
112
+ // 它只认 id / k / content_max(meow 的 memory_find_similar 就这三个),
113
+ // 于是 `query`(最危险——用户以为在按句子找)、level/project/status/days/explain、hops、memory_ids
114
+ // 都被丢掉且一声不吭。0.2.66 把「本地条件在星图那条路上」说明白了,这张第三张表还没人管。
115
+ if (mode === 'similar') {
116
+ if (args.query !== undefined && String(args.query).trim() !== '') {
117
+ notes.push(
118
+ 'query 在相似模式没用上:这一问是拿 id 指向的那条记忆去比,不是按你说的句子找——' +
119
+ '想按句子找请用 local(默认),相似检索只认 id / k / content_max。',
120
+ )
121
+ }
122
+ // 注意 content_max:它在 LOCAL_ONLY_PARAMS 里,但相似检索**认**它(meow 的
123
+ // memory_find_similar 收 id / k / content_max)。第一版把它算进「没用上」,
124
+ // 尾注当场自相矛盾——同一句里既说相似检索只认 content_max,又说它没参与。
125
+ // 探针 AX7 就是抓这个的(全参数下要求四句齐),第一跑 3/4。所以这里先把它摘掉。
126
+ const similarIgnored = LOCAL_ONLY_PARAMS.filter((n) => n !== 'content_max' && args[n] !== undefined)
127
+ if (similarIgnored.length > 0) {
128
+ notes.push(
129
+ `${similarIgnored.join(' / ')} 是本地检索的条件;相似检索只认 id / k / content_max,` +
130
+ '这次没用上它们——这不是「没有相似」,是这几个条件压根没算。',
131
+ )
132
+ }
133
+ if (args.hops !== undefined) {
134
+ notes.push('hops 是 graph / bridge 的扩散跳数;相似检索不扩散,这次没用上。')
135
+ }
136
+ if (args.memory_ids !== undefined) {
137
+ notes.push('memory_ids 是 graph / bridge 的起点;相似检索只看 id 指向的那一条,这次没用上。')
138
+ }
139
+ }
140
+ // [macro-fusion 0.2.69] 0.2.67 把「相似模式认不认别人」说清了,反过来还有两个口子没人管:
141
+ // ① `id` 只有 mode=similar 当基准,写在别的模式里一声不吭地被丢掉;
142
+ // ② `memory_ids` 的活是「扩散的起点」——local 模式零命中(或 expand=true)时会真的拿它起跳,
143
+ // 可一旦这次没扩散,它就完全没参与,回执里却是空的。上面 hops 那三支正是这个参数的同族。
144
+ if (mode !== 'similar' && typeof args.id === 'string' && args.id.trim() !== '') {
145
+ notes.push(
146
+ `id 只在 mode=similar 里当基准(这一问是 ${mode}),这次没用上它——这不是「这条记忆被排除了」。` +
147
+ '想拿它当基准找相似条目,用 mode=similar 再问一次。',
148
+ )
149
+ }
150
+ if (mode === 'local' && args.memory_ids !== undefined) {
151
+ notes.push(
152
+ spread
153
+ ? 'memory_ids 这次真的用上了:关联扩散就是从你给的这几个 id 起跳的。'
154
+ : tried
155
+ ? 'memory_ids 平时是扩散的起点;这次本来要扩散(会用你给的 id),但星图没接上——它没参与这次结果。'
156
+ : 'memory_ids 只在扩散时当起点(graph / bridge,或 local 加 expand);这次没有扩散,它没用上。',
157
+ )
158
+ }
159
+ const bridgeOnly = ['chars', 'min_weight'].filter((n) => args[n] !== undefined)
160
+ if (bridgeOnly.length > 0 && mode !== 'bridge') {
161
+ notes.push(`${bridgeOnly.join(' / ')} 只在 bridge 模式生效,这次没用上。`)
162
+ }
163
+ return notes
164
+ }
165
+
166
+ /**
167
+ * [macro-fusion 0.2.109] 预算不是劝告,是约束:给了 budget 就自己收缩,并如实交代缩了什么。
168
+ *
169
+ * 收缩顺序有讲究:先砍 content_max(每条的字),再砍 k(条数)。反过来会先丢掉
170
+ * 「还有别的相关记忆」这个信息,而砍字最坏只是让人自己再读一次——成本更低的那一步先动。
171
+ *
172
+ * 每一步都**真的重查一遍上游**,不是把字符串截短:截出来的半句会破坏条目结构,
173
+ * 读者拿到「看着完整、其实被腰斩」的回执,比超预算更糟。
174
+ */
175
+ async function fitBudget(flow, exec, baseArgs, main, budget) {
176
+ const first = estTokens(main.text)
177
+ if (first <= budget) return { main, note: `按 ${budget} token 预算给:实际 ≈${fmtTokens(first)} token,没缩。` }
178
+ // [macro-fusion 0.2.124] 窗口是最贵的那一块:每条命中带 2N 条邻居,N=1 就能让回执翻倍。
179
+ // 装不下时先把它关掉(context 1→0),再走「先砍字再砍条数」——关窗口只是让读者自己
180
+ // 再查一次,砍字/砍条数会让答案直接消失。
181
+ const rawCtx = Number(baseArgs.context ?? 0)
182
+ const ctx0 = Number.isFinite(rawCtx) && rawCtx > 0 ? Math.min(3, Math.floor(rawCtx)) : 0
183
+ if (ctx0 > 0) {
184
+ const noCtx = await flow.call('memory_search', { ...baseArgs, context: 0 }, exec)
185
+ const noCtxEst = estTokens(noCtx.text)
186
+ if (noCtxEst <= budget) {
187
+ return {
188
+ main: noCtx,
189
+ note: `按 ${budget} token 预算收紧了 1 次:context ${ctx0}→0(邻居先不铺开),实际 ≈${fmtTokens(noCtxEst)} token。`,
190
+ }
191
+ }
192
+ }
193
+ const rawK = Number(baseArgs.k ?? 10)
194
+ const rawCm = Number(baseArgs.content_max ?? 300)
195
+ const k0 = Number.isFinite(rawK) && rawK > 0 ? Math.floor(rawK) : 10
196
+ // content_max=0 在 meow 侧是「全文」,不是「零个字」:这里给它一个够大的起点再往下砍。
197
+ const cmLabel0 = rawCm === 0 ? '全文' : String(Number.isFinite(rawCm) && rawCm > 0 ? Math.floor(rawCm) : 300)
198
+ let k = k0
199
+ let cm = rawCm === 0 ? 2400 : Number.isFinite(rawCm) && rawCm > 0 ? Math.floor(rawCm) : 300
200
+ let best = main
201
+ let bestEst = first
202
+ let tried = 0
203
+ const take = async (args2) => {
204
+ tried += 1
205
+ const r = await flow.call('memory_search', args2, exec)
206
+ return { r, est: estTokens(r.text) }
207
+ }
208
+ for (let i = 0; i < 4; i += 1) {
209
+ if (cm > 60) cm = Math.max(60, Math.floor(cm / 2))
210
+ else if (k > 1) k = Math.max(1, Math.floor(k / 2))
211
+ else break
212
+ const { r, est } = await take({ ...baseArgs, k, content_max: cm })
213
+ if (est < bestEst) {
214
+ best = r
215
+ bestEst = est
216
+ }
217
+ if (est <= budget) {
218
+ return {
219
+ main: r,
220
+ note: `按 ${budget} token 预算收紧了 ${tried} 次:k ${k0}→${k}、content_max ${cmLabel0}→${cm},实际 ≈${fmtTokens(est)} token。`,
221
+ }
222
+ }
223
+ }
224
+ // [macro-fusion 0.2.109] 四级收紧还没装下,就把「能缩到的最小一份」真的拿一次。
225
+ // 这里曾经靠猜:说「最小一次 ≈X、再小就只剩标题」,而那次 X 是第四级的估计值——
226
+ // 也就是说,报「最小」的时候其实没试过最小。要么量到,要么不说。
227
+ const { r: smallest, est: smallestEst } = await take({ ...baseArgs, k: 1, content_max: 60 })
228
+ if (smallestEst <= budget) {
229
+ return {
230
+ main: smallest,
231
+ note: `按 ${budget} token 预算收到了最小的一份:k ${k0}→1、content_max ${cmLabel0}→60,实际 ≈${fmtTokens(smallestEst)} token(再砍就只剩标题)。`,
232
+ }
233
+ }
234
+ return {
235
+ main: smallestEst < bestEst ? smallest : best,
236
+ note: `预算 ${budget} token 装不下:最小一份(k=1、content_max=60)实测 ≈${fmtTokens(smallestEst)} token——再小就只剩标题,问不出东西;要么把预算提上去,要么换个更窄的 query。`,
237
+ }
238
+ }
239
+
240
+ /**
241
+ * [macro-fusion 0.2.110] 每条路径有它自己的旋钮。
242
+ *
243
+ * 0.2.109 只在本地这一路上落了预算,尾注老实写着「星图 / 相似两路不缩」——一句诚实的
244
+ * 缺功能。可四路回执都是要进上下文的,凭什么只有一路能被约束。
245
+ *
246
+ * 旋钮名字各不相同(星图认 limit / hops,补邻居认 chars / limit,相似认 content_max / k),
247
+ * 但收缩的道理是同一条:**先动「只是少看一点」的那个,再动「少给几条线索」的那个**。
248
+ * 所以本地先砍字再砍条数、星图先砍条数再砍跳数、补邻居先砍字符预算再砍条数、
249
+ * 相似先砍字再砍条数。min 用上游 schema 的下限,不自己发明地板。
250
+ */
251
+ const PATH_KNOBS = {
252
+ graph: [
253
+ { key: 'limit', min: 1, def: 10 },
254
+ { key: 'hops', min: 0, def: 2 },
255
+ ],
256
+ bridge: [
257
+ { key: 'chars', min: 200, def: 900 },
258
+ { key: 'limit', min: 1, def: 4 },
259
+ ],
260
+ similar: [
261
+ { key: 'content_max', min: 60, def: 300 },
262
+ { key: 'k', min: 1, def: 10 },
263
+ ],
264
+ }
265
+
266
+ /**
267
+ * [macro-fusion 0.2.110] 星图 / 补充 / 相似三路的预算:同一套「真重查、不截断」的循环。
268
+ *
269
+ * 和本地那一路(fitBudget)刻意不合并:本地那支的手感是 0.2.109 定的、有断言钉着,
270
+ * 两套旋钮抽象成一套反而会把「先砍字再砍条数」这句容易犯错的话埋进通用代码里。
271
+ * 代价是十几行重复,换来的是两条路各自说得清自己砍了什么。
272
+ */
273
+ async function fitPath(flow, exec, { tool, baseArgs, main, budget, knobs, what }) {
274
+ if (!budget || budget.value === null) return { main, note: '' }
275
+ // 预算是 {value, note} 一份东西,不是数字:这里先摊成 cap,免得把对象直接拼进文案、
276
+ // 也免得拿预算对象直接去比(那等于永远比不成立,一路滑到「装不下」)。
277
+ const cap = Number(budget.value)
278
+ if (!Number.isFinite(cap)) return { main, note: '' }
279
+ const first = estTokens(main.text)
280
+ const dials = knobs.map((kn) => {
281
+ const raw = Number(baseArgs[kn.key])
282
+ const from = Number.isFinite(raw) && raw >= kn.min ? Math.floor(raw) : kn.def
283
+ return { ...kn, from, value: from }
284
+ })
285
+ // 只报真动过的旋钮:`hops 2→2` 这种「报了但没变」只会让读者以为它被砍了。
286
+ const show = () => dials.filter((d) => d.value !== d.from).map((d) => `${d.key} ${d.from}→${d.value}`).join('、') || '没动到任何旋钮'
287
+ const argsOf = () => {
288
+ const a = { ...baseArgs }
289
+ for (const d of dials) a[d.key] = d.value
290
+ return a
291
+ }
292
+ if (first <= cap) {
293
+ return { main, note: `${what}这一路按 ${cap} token 预算给:实际 ≈${fmtTokens(first)} token,没缩。` }
294
+ }
295
+ let best = main
296
+ let bestEst = first
297
+ let tried = 0
298
+ for (let guard = 0; guard < 6; guard += 1) {
299
+ const d = dials.find((x) => x.value > x.min)
300
+ if (!d) break
301
+ d.value = Math.max(d.min, Math.floor(d.value / 2))
302
+ tried += 1
303
+ const r = await flow.call(tool, argsOf(), exec)
304
+ const est = estTokens(r.text)
305
+ if (est < bestEst) {
306
+ best = { text: r.text, value: r.value }
307
+ bestEst = est
308
+ }
309
+ if (est <= cap) {
310
+ return {
311
+ main: { text: r.text, value: r.value },
312
+ note: `${what}这一路按 ${cap} token 预算收紧了 ${tried} 次:${show()},实际 ≈${fmtTokens(est)} token。`,
313
+ }
314
+ }
315
+ }
316
+ // 「最小」也要真量到:把所有旋钮压到下限再问一次,量出来才敢说「装不下」。
317
+ for (const d of dials) d.value = d.min
318
+ const smallest = await flow.call(tool, argsOf(), exec)
319
+ const smallestEst = estTokens(smallest.text)
320
+ const floorText = dials.map((d) => `${d.key}=${d.min}`).join('、')
321
+ if (smallestEst <= cap) {
322
+ return {
323
+ main: { text: smallest.text, value: smallest.value },
324
+ note: `${what}这一路收到了最小的一份:${show()},实际 ≈${fmtTokens(smallestEst)} token(再砍就只剩标题)。`,
325
+ }
326
+ }
327
+ return {
328
+ main: smallestEst < bestEst ? { text: smallest.text, value: smallest.value } : best,
329
+ note: `预算 ${cap} token 装不下:${what}这一路最小一份(${floorText})实测 ≈${fmtTokens(smallestEst)} token——再小就只剩标题,问不出东西;要么把预算提上去,要么换个更窄的问法。`,
330
+ }
331
+ }
332
+
333
+ /**
334
+ * [macro-fusion 0.2.109] 星图那两路退回本地兜底时,预算同样要生效——
335
+ * 兜底也是一次真检索,凭什么它就能超预算。tryCall 没拿到东西就原样放过。
336
+ */
337
+ async function maybeFit(flow, exec, baseArgs, got, budget, flags) {
338
+ if (!budget || budget.value === null) return got
339
+ if (String(got.text ?? '').trim().length === 0) return got
340
+ const fit = await fitBudget(flow, exec, baseArgs, { text: got.text, value: got.value }, budget.value)
341
+ flags.budgetNote = fit.note
342
+ return { ...got, text: fit.main.text, value: fit.main.value }
343
+ }
344
+
345
+ /**
346
+ * [macro-fusion 0.2.109] 出口上的一段成本账:先说你给的条件怎么了(预算没被采纳 / 这次没东西可缩),
347
+ * 再报这一回的量级。够小就不报——省 token 的工具自己先要省。
348
+ *
349
+ * [macro-fusion 0.2.110] 那句「预算只在本地生效」的尾注删了:四路都听预算了。
350
+ * 留下的只剩真话——这一路没缩,是因为这条路上本来就没有可缩的东西。
351
+ */
352
+ function costTail(body, { budget, flags }) {
353
+ const parts = []
354
+ if (budget.note !== '') parts.push(budget.note)
355
+ if (flags.budgetNote) parts.push(flags.budgetNote)
356
+ if (budget.value !== null && !flags.budgetNote) {
357
+ parts.push(`budget ${budget.value} 这次没派上用场:这条路上没有可缩的东西(比如零命中、空图,或本来就没展开)。`)
358
+ }
359
+ const est = estTokens(body)
360
+ if (budget.value !== null || est >= COST_SHOW_MIN) {
361
+ const hint =
362
+ budget.value === null && est >= COST_HINT_MIN
363
+ ? ';只想看骨架就加 budget=400(工具会自己砍条数、砍字数,并交代砍了什么)'
364
+ : ''
365
+ parts.push(`${costSentence(body)}${hint}`)
366
+ }
367
+ return parts.length > 0 ? `${body}\n\n${parts.join(' ')}` : body
368
+ }
369
+
370
+ async function runSearch(flow, args, exec, flags = {}, budget = { value: null, note: '' }, mqConfig = {}) {
371
+ const mode = modeOf(args).name
372
+ const query = typeof args.query === 'string' ? args.query : ''
373
+
374
+ await flow.flushLinks(exec)
375
+
376
+ if (mode === 'graph' || mode === 'bridge') {
377
+ const tool = mode === 'graph' ? 'nebula_recall' : 'nebula_bridge'
378
+ const payload =
379
+ mode === 'graph'
380
+ ? pick(args, ['query', 'memory_ids', 'limit', 'hops', 'entity', 'dynamic_hops'])
381
+ : pick(args, ['query', 'memory_ids', 'limit', 'chars', 'min_weight', 'hops'])
382
+ const r = await flow.tryCall(tool, payload, exec, mode === 'graph' ? '星图检索' : '星图补充')
383
+ if (r.entry) {
384
+ // 0.2.39:空命中也背两个意思——「图里真没有」和「图还没建完」。
385
+ // 后者这一问等于没算,绝不能原样转述成「没有匹配」,那等于替用户确认了一件没算的事。
386
+ if (recallAnswerKind(r.text) === 'emptyGraph') {
387
+ const what = mode === 'graph' ? '沿关联扩散' : '补充邻居'
388
+ if (query.trim().length === 0) {
389
+ // [macro-fusion 0.2.66] 星图在、但空图 + 没 query:连本地兜底都没做。
390
+ // 尾注得说「这一问没算」,而不是替它报「星图里就这么几条」。
391
+ flags.graphAbsentNoLocal = true
392
+ return `星图现在还是空的(还没建完,约 12s 一轮巡检),${what}这一问等于没算——给个 query 我就能先用本地检索兜住;记忆本身没受影响。`
393
+ }
394
+ const fallbackArgs = pick(args, ['query', 'level', 'project', 'status', 'days', 'k', 'content_max', 'context', 'explain', 'min_rel', 'dedupe', 'band_keep'])
395
+ let local = await flow.tryCall('memory_search', fallbackArgs, exec, '本地检索')
396
+ local = await maybeFit(flow, exec, fallbackArgs, local, budget, flags)
397
+ flags.graphFellBack = true
398
+ return `星图现在还是空的(还没建完,约 12s 一轮巡检),${what}这次没算——这不是「没有这条记忆」的答案。先给本地结果:\n\n${local.text}`
399
+ }
400
+ // [macro-fusion 0.2.110] 星图这一路的回执同样进上下文:给了预算就按它自己的旋钮收紧。
401
+ const fitted = await fitPath(flow, exec, {
402
+ tool,
403
+ baseArgs: payload,
404
+ main: { text: r.text, value: r.value },
405
+ budget,
406
+ knobs: PATH_KNOBS[mode],
407
+ what: MODE_LABELS[mode],
408
+ })
409
+ if (fitted.note !== '') flags.budgetNote = fitted.note
410
+ return fitted.main.text
411
+ }
412
+ // 星图缺席(没装配 / 被配置关掉 / 引擎还没起):以 meow 为主,记忆照样要查得到。
413
+ // 这里不能把「这项能力还没就绪」原样甩给模型——它刚被告知用 mode=graph,报错等于教它别信工具面。
414
+ if (query.trim().length === 0) {
415
+ flags.graphAbsentNoLocal = true
416
+ return `星图这次没接上,而 ${mode === 'graph' ? '沿关联扩散' : '补充邻居'}只走星图;给个 query 我就能先用本地检索兜住。`
417
+ }
418
+ const localArgs = pick(args, ['query', 'level', 'project', 'status', 'days', 'k', 'content_max', 'context', 'explain', 'min_rel', 'dedupe', 'band_keep'])
419
+ let main = await flow.tryCall('memory_search', localArgs, exec, '本地检索')
420
+ main = await maybeFit(flow, exec, localArgs, main, budget, flags)
421
+ flags.graphFellBack = true
422
+ const head =
423
+ mode === 'graph'
424
+ ? '星图这次没接上,先只给本地检索结果(沿关联扩散等星图就绪后再试):'
425
+ : '星图这次没接上,先只给本地检索结果(补充邻居等星图就绪后再试):'
426
+ return `${head}\n\n${main.text}`
427
+ }
428
+ if (mode === 'similar') {
429
+ if (typeof args.id !== 'string' || args.id.length === 0) {
430
+ throw new Error('memory_search:mode=similar 需要 id(基准记忆 id)。')
431
+ }
432
+ const r = await flow.tryCall('memory_find_similar', pick(args, ['id', 'k', 'content_max']), exec, '相似检索')
433
+ const said = String(r.text ?? '')
434
+ // 0.2.46:meow 老的 render 在「一条都没有」时返回空数组,这里就只剩 `{"hits": []}`——
435
+ // 一句解释都没有,读者分不清「没有相似」和「没比」。子插件补丁在位时这句兜底不会被用到,
436
+ // 它守的是「上游把补丁冲掉」这一种情况;说的是「没算成」,不替它下「没有相似」的结论。
437
+ if (said.trim() === '' || /^\s*\{\s*"hits"\s*:\s*\[\s*\]\s*\}\s*$/.test(said)) {
438
+ // [macro-fusion 0.2.90] 末句原来写「或等下一次会话」——那是 0.2.88 及以前的行为(候选按会话整批排除)。
439
+ // 0.2.89 起本会话新写的条目也算候选,「等下一次会话」就成了过期的劝告,会把读者指向一个假原因。
440
+ return (
441
+ '相似检索这次没给出任何内容:可能是这条记忆拆不出可比的词、库里就只有这一条,' +
442
+ '或者这一轮已经端给你看过的都排除了、剩下的 k 又太小——这不是「记忆里没有相似的东西」。' +
443
+ '换一条基准、把 k 给大一点再问。'
444
+ )
445
+ }
446
+ // [macro-fusion 0.2.110] 相似这一路也是进上下文的回执,预算同样要落。
447
+ const fitted = await fitPath(flow, exec, {
448
+ tool: 'memory_find_similar',
449
+ baseArgs: pick(args, ['id', 'k', 'content_max']),
450
+ main: { text: said, value: r.value },
451
+ budget,
452
+ knobs: PATH_KNOBS.similar,
453
+ what: MODE_LABELS.similar,
454
+ })
455
+ if (fitted.note !== '') flags.budgetNote = fitted.note
456
+ return fitted.main.text
457
+ }
458
+
459
+ const localArgs = pick(args, ['query', 'level', 'project', 'status', 'days', 'k', 'content_max', 'context', 'explain', 'min_rel', 'dedupe', 'band_keep'])
460
+ // 原 memory_search 的 query 是必填。统一工具因为要兼 mode=similar/graph 没法在 schema 里写死,
461
+ // 就在这里把「本地检索必须给 query」守回来——否则会静默返回空结果,比报错更难查。
462
+ if (query.trim().length === 0) {
463
+ throw new Error('memory_search:本地检索需要 query;只想沿星图扩散请用 mode="graph",想找相似条目请用 mode="similar" + id。')
464
+ }
465
+ let main = await flow.call('memory_search', localArgs, exec)
466
+ // [macro-fusion 0.2.51] 上游一个字都不给时,空字符串会被读成「一条都没有」。
467
+ // 同 0.2.49 / 0.2.50:没有回执不等于没有结果,这里把「没说话」和「没东西」分开。
468
+ if (String(main.text ?? '').trim().length === 0) {
469
+ return (
470
+ '检索这次没有任何回执(既没有条目,也没说为什么没有)——这不是「记忆里没有这条」:' +
471
+ '换个关键词再查一次,或先用 memory_project 看一眼这个项目里到底有什么。'
472
+ )
473
+ }
474
+ // [macro-fusion 0.2.109] 预算在这里落:先按你给的条件拿一遍,超了再逐级收紧——
475
+ // 顺序上必须排在 expand 之前,否则星图扩散那一段会加在「已经超预算」的本地结果后面。
476
+ if (budget.value !== null) {
477
+ const fit = await fitBudget(flow, exec, localArgs, main, budget.value)
478
+ main = fit.main
479
+ flags.budgetNote = fit.note
480
+ }
481
+ // [macro-memory 0.4.0 P1] 查询分解:排在预算收紧之后、扩散之前——
482
+ // 收紧那一步会拿 localArgs 重查一次(补充段会被重查冲掉),而扩散要用合并后的 value.hits。
483
+ if (multiQueryMode(mqConfig) !== 'off') {
484
+ main = await augmentByDecompose({ flow, exec, main, localArgs, query, flags, budget })
485
+ }
486
+ const hits = Array.isArray(main.value?.hits) ? main.value.hits.length : 0
487
+ // [macro-fusion 0.2.133] 主人 2026-11-21 明令:默认关闭的有用能力要全开,不要急着省 token。
488
+ // 以前要 expand=true 或本地零命中才扩散——可星图那一路提供的是「跨会话、跨项目才看得见」的线索,
489
+ // 本地命中越多反而越用不上它,等于把最有用的一半藏起来。现在默认扩散,只有显式 expand:false 才关。
490
+ const wantExpand = args.expand !== false
491
+ if (!wantExpand) return main.text
492
+ if (query.length === 0 && !Array.isArray(args.memory_ids)) return main.text
493
+
494
+ // [macro-fusion 0.2.65] 这次扩散真的读了 limit / hops,把用上的值记下来——
495
+ // 尾注据此说实话(老写法在这里用上了参数,尾注却声明「没用上」)。
496
+ // 三种状态要分开:真的扩散了 / 本要扩散但星图没接上 / 根本没走到扩散。
497
+ const spreadLimit = args.limit ?? 5
498
+ const spreadHops = args.hops ?? 2
499
+ flags.spreadLimit = spreadLimit
500
+ flags.spreadHops = spreadHops
501
+ flags.spreadTried = true
502
+ const spread = await flow.tryCall(
503
+ 'nebula_recall',
504
+ { query, memory_ids: args.memory_ids, limit: spreadLimit, hops: spreadHops },
505
+ exec,
506
+ '星图扩散',
507
+ )
508
+ if (spread.entry) flags.spread = true
509
+ // 本地检索是主语,扩散只是加料。加不上就说一句「没加」,绝不把 tryCall 的失败文案
510
+ // (`星图扩散未完成:macro-memory:这项能力还没就绪…`)拼进一个本来成功的结果里
511
+ if (!spread.entry) return `${main.text}\n\n(星图这次没接上,关联扩散没做——先把本地结果给你。)`
512
+ // 空图时的「没有匹配」不是佐证,是没算:不说明的话,本地零命中 + 星图零命中
513
+ // 读起来像「两边都确认没有这条记忆」,而其实星图那边一次都没算。
514
+ if (recallAnswerKind(spread.text) === 'emptyGraph') {
515
+ return `${main.text}\n\n(星图现在还是空的(还没建完),关联扩散这次没算——上面的本地结果就是全部,这不是「确认没有」,过几分钟再搜一次。)`
516
+ }
517
+ // [macro-fusion 0.2.118] 两路都算出来了 → 先试着合成一张榜。
518
+ // 老做法是把两段文本上下拼在一起:同一堆记忆在两段里各出现一次(第二遍白花 token),
519
+ // 而「两条路都命中」这件事本身是最强的相关性证据,却没有任何人替读者指出来。
520
+ // 融合只按**名次**合(RRF),因为两路的分数不同源,拿分数线不同的两组数比大小是在编结论。
521
+ const fusedHead = await fusedPart({ localValue: main.value, graphText: spread.text, spreadLimit, budget, flags })
522
+ if (fusedHead !== null) return fusedHead
523
+ // [macro-fusion 0.2.110] 扩散这一段也在同一份回执里,预算到这儿还没花完——
524
+ // 那就按**剩余**预算去要它:整份回执的总量才是读者的成本,分段各算一遍等于自欺。
525
+ if (budget.value !== null) {
526
+ const used = estTokens(main.text)
527
+ const remain = budget.value - used
528
+ if (remain < BUDGET_MIN) {
529
+ const said = `budget ${budget.value} token 已经被本地结果用掉(≈${fmtTokens(used)} token),星图扩散这一段按剩余预算拿不出来:要扩散就用 expand=false 关掉它,或者把预算提上去。`
530
+ flags.budgetNote = flags.budgetNote ? `${flags.budgetNote} ${said}` : said
531
+ return main.text
532
+ }
533
+ const spreadFit = await fitPath(flow, exec, {
534
+ tool: 'nebula_recall',
535
+ baseArgs: { query, memory_ids: args.memory_ids, limit: spreadLimit, hops: spreadHops },
536
+ main: { text: spread.text, value: spread.value },
537
+ budget: { value: remain },
538
+ knobs: PATH_KNOBS.graph,
539
+ what: MODE_LABELS.graph,
540
+ })
541
+ if (spreadFit.note !== '') {
542
+ const said = `(星图扩散按剩余 ${remain} token 预算算:${spreadFit.note})`
543
+ flags.budgetNote = flags.budgetNote ? `${flags.budgetNote} ${said}` : said
544
+ }
545
+ return `${main.text}\n\n— 星图关联扩散 —\n${spreadFit.main.text}`
546
+ }
547
+ return `${main.text}\n\n— 星图关联扩散 —\n${spread.text}`
548
+ }
549
+
550
+ /**
551
+ * [macro-fusion 0.2.118] 两路合一张榜;合不了就返回 null,让调用方走原来的两段式。
552
+ *
553
+ * 什么时候「合不了」:本地一条没命中(那就没有榜,只有星图的关联线索,两段式更好读)、
554
+ * 星图回执解析不出节点(形状变了 / 补丁被冲掉)、或者预算紧到连本地那部分都装不下——
555
+ * 这三种都退回老路径,而不是硬凑一张半张的榜。
556
+ *
557
+ * 融合省下的是 token:同一堆记忆不再出现两遍,星图独有的只带「为什么相关」+ 摘要,
558
+ * 不带全文(全文在本地命中里已经有了)。多出来的是那句「两路都命中 N 条」——
559
+ * 两条互不相干的检索方式同时捞到同一条,是这条记忆与当前处境相关的**最硬**的证据。
560
+ */
561
+ async function fusedPart({ localValue, graphText, spreadLimit, budget, flags }) {
562
+ const localHits = Array.isArray(localValue?.hits) ? localValue.hits : []
563
+ const nodes = graphNodesOf(graphText)
564
+ if (localHits.length === 0 || nodes.length === 0) return null
565
+ const fused = fuseRanked({ localHits, graphNodes: nodes })
566
+ if (fused.rows.length === 0) return null
567
+
568
+ const asked = Number(spreadLimit)
569
+ const graphCap = Number.isFinite(asked) ? Math.max(0, asked) : 5
570
+ const noteHead = String(localValue?.note ?? '').trim()
571
+ const rankNote =
572
+ fused.both > 0
573
+ ? `融合榜(本地 # / 星图 # 两路按名次合并,RRF k=${RRF_K}):两路都命中 ${fused.both} 条、本地独有 ${fused.localOnly} 条、星图独有 ${fused.graphOnly} 条——重复的条目只出现一次,两路都命中的排在最前。`
574
+ : `融合榜(本地 # / 星图 # 两路按名次合并,RRF k=${RRF_K}):这次两路没有重叠(本地 ${localHits.length} 条、星图 ${nodes.length} 条),按名次排在一起。`
575
+ const head = [rankNote, noteHead].filter((x) => x !== '').join('\n')
576
+ const build = (shown) =>
577
+ fusedText({
578
+ note: head,
579
+ rows: fused.rows,
580
+ k: localHits.length,
581
+ graphShown: shown,
582
+ dropped: Math.max(0, fused.graphOnly - shown),
583
+ })
584
+
585
+ let graphShown = Math.min(graphCap, fused.graphOnly)
586
+ let text = build(graphShown)
587
+ if (budget.value !== null && estTokens(text) > budget.value) {
588
+ // 先砍星图的独有条目:它们只是「为什么相关」的线索,本地命中的全文是答案本身。
589
+ let shown = graphShown
590
+ while (shown > 0 && estTokens(build(shown)) > budget.value) shown -= 1
591
+ if (estTokens(build(shown)) > budget.value) return null
592
+ const said = `(融合榜按 ${budget.value} token 预算收紧:星图独有的条目从 ${graphShown} 条压到 ${shown} 条。)`
593
+ flags.budgetNote = flags.budgetNote ? `${flags.budgetNote} ${said}` : said
594
+ graphShown = shown
595
+ text = build(shown)
596
+ }
597
+ flags.fused = true
598
+ flags.fusedBoth = fused.both
599
+ return text
600
+ }
601
+
602
+ /**
603
+ * [macro-memory 0.4.0 P1] 查询分解:一句话里塞了两件事时,本地检索按整句算一次 BM25,
604
+ * 两边的词互相稀释,可能双双掉出榜——multi-hop 是四类题里最低的一类(0.5887,2026-11-20)。
605
+ *
606
+ * 这一层只做「补空位」,和「重排」一点关系都没有:
607
+ * · 原榜的条目、名次、正文一个字不动;
608
+ * · 并列焦点拆成子问句各查一次,只把原榜没给出的条目追加在末尾一段;
609
+ * · 每条都标明是哪一问捞到的,读者自己判断要不要读全文;
610
+ * · 一条都没补到就什么都不追加(连标题都不出现)——误切的代价只是多一次本地检索。
611
+ *
612
+ * 纯规则、不调模型:切错也是可复现、可复算的切错。
613
+ */
614
+ const MQ_MAX_SUBS = 3
615
+ const MQ_MAX_ROWS_PER_SUB = 2
616
+ const MQ_ROW_CHARS = 110
617
+ const MQ_MAX_CONSENSUS = 3
618
+ /** 连接词:长的在前,否则「以及」会先被「与/和」切成半截。 */
619
+ const MQ_JOINERS = ['以及', '还有', '和', '跟', '与', '、']
620
+ /** 标点/空白一律不算信息量:`A 和 B` 能不能切,取决于两侧有没有真字符,而不是汉字数。 */
621
+ const MQ_PUNCT = /[\s,,。??!!、;;::“”"'‘’()()《》〈〉【】\[\]…—--]/g
622
+ /** 子问句开头的疑问词:剥掉之后剩下的才是真正的焦点(剥完不足两个字就整段丢弃)。 */
623
+ const MQ_ASK_PREFIX = /^(?:为什么|为何|怎么|怎样|如何|什么|啥|是不是|有没有|能不能|可不可以|哪些|哪个|多少|是否|请问|我想问|那么|那|然后|所以|另外|顺便)/
624
+ /** 子问句结尾的虚词与套话:`B 有什么区别` → `B`,`A 呢` → `A`。 */
625
+ const MQ_ASK_SUFFIX = /(?:有什么区别|有区别吗|之间的区别|之间|分别是什么|是什么|分别|呢|吗|吧|啊|呀|了|的)$/
626
+
627
+ /** [macro-memory 0.4.0 P1] 开关只认 off / conservative;写别的(含大小写错的)一律 off。 */
628
+ export function multiQueryMode(config) {
629
+ const raw = config?.multiQuery
630
+ const text = typeof raw === 'string' ? raw.trim().toLowerCase() : ''
631
+ return text === 'conservative' ? 'conservative' : 'off'
632
+ }
633
+
634
+ /** 信息量 = 去掉标点空白后的字符数(汉字、字母、数字都算)。 */
635
+ function infoLen(text) {
636
+ return String(text ?? '').replace(MQ_PUNCT, '').length
637
+ }
638
+
639
+ /** 只取第一个「两侧都够长」的连接词切一刀。顿号是硬并列,单字也认(`A、B`)。 */
640
+ function cutOnce(text, joiner) {
641
+ const min = joiner === '、' ? 1 : 2
642
+ let at = text.indexOf(joiner)
643
+ while (at > 0) {
644
+ const left = text.slice(0, at).trim()
645
+ const right = text.slice(at + joiner.length).trim()
646
+ if (infoLen(left) >= min && infoLen(right) >= min) return [left, right]
647
+ at = text.indexOf(joiner, at + joiner.length)
648
+ }
649
+ return null
650
+ }
651
+
652
+ /** 贪心多刀:每个连接词过一遍,切够段数就停(`A、B 和 C` → 三段),最后截到上限。 */
653
+ function splitByJoiners(text) {
654
+ let parts = [text]
655
+ for (const joiner of MQ_JOINERS) {
656
+ const next = []
657
+ for (const part of parts) {
658
+ const cut = cutOnce(part, joiner)
659
+ if (cut !== null) next.push(...cut)
660
+ else next.push(part)
661
+ }
662
+ parts = next
663
+ if (parts.length >= MQ_MAX_SUBS) break
664
+ }
665
+ return parts.slice(0, MQ_MAX_SUBS)
666
+ }
667
+
668
+ function cleanPiece(piece) {
669
+ let text = String(piece ?? '')
670
+ .replace(/^[\s,,。??!!、;;::“”"'()()]+|[\s,,。??!!、;;::“”"'()()]+$/g, '')
671
+ .trim()
672
+ text = text.replace(MQ_ASK_PREFIX, '').trim()
673
+ text = text.replace(MQ_ASK_SUFFIX, '').trim()
674
+ // 比较句的尾巴:`反式脂肪哪个更伤心脏` → `反式脂肪`(实体是重点,比较的是问句的壳)。
675
+ text = text.replace(/(?:哪个|哪一个|谁)(?:更|最)[\u4e00-\u9fff]{0,6}$/, '').trim()
676
+ return infoLen(text) >= 2 ? text : null
677
+ }
678
+
679
+ /**
680
+ * 拆出子问句。返回 [] 表示「这句话没有并列焦点」——不猜、不硬拆。
681
+ *
682
+ * 两种切法,按可靠程度排:
683
+ * 1) 多个问号:`A?B?` 天然就是两问,不需要任何句法判断;
684
+ * 2) 连接词:`以及 / 还有 / 和 / 跟 / 与 / 、`,两侧都要有 ≥2 个真字符,
685
+ * 最多切到 3 段(再多就是在猜句子结构了)。
686
+ */
687
+ export function decomposeQuery(query) {
688
+ const text = String(query ?? '').trim()
689
+ if (infoLen(text) < 4) return []
690
+ const byAsk = text
691
+ .split(/[??]+/)
692
+ .map((one) => cleanPiece(one))
693
+ .filter((one) => one !== null)
694
+ if (byAsk.length >= 2 && byAsk.length <= MQ_MAX_SUBS) {
695
+ return byAsk.filter((one) => one !== text).slice(0, MQ_MAX_SUBS)
696
+ }
697
+ const subs = splitByJoiners(text)
698
+ .map((one) => cleanPiece(one))
699
+ .filter((one) => one !== null && one !== text)
700
+ return subs.length >= 2 ? subs.slice(0, MQ_MAX_SUBS) : []
701
+ }
702
+
703
+ function id8(id) {
704
+ const text = String(id ?? '')
705
+ return text.length > 8 ? text.slice(0, 8) : text
706
+ }
707
+
708
+ function clipBody(text) {
709
+ const one = String(text ?? '').replace(/\s+/g, ' ').trim()
710
+ return one.length > MQ_ROW_CHARS ? `${one.slice(0, MQ_ROW_CHARS)}…` : one
711
+ }
712
+
713
+ /** 补充段的正文:先说「原榜没动」,再逐条标明哪一问捞到的,最后是两问共识。 */
714
+ function supplementText(rows, subs, consensus = []) {
715
+ const head =
716
+ `— 问句拆开再查一遍(原榜一个字没动)—\n` +
717
+ `这句话有多个焦点,拆成「${subs.join('」「')}」各查了一次(子问句放宽了档位收口,才捞得到原榜压掉的条目);下面这些原榜没给出:`
718
+ const lines = rows.map((one) => {
719
+ const hit = one.hit ?? {}
720
+ const level = hit.level ?? 'memory'
721
+ const body = String(hit.title ?? '').trim() !== '' ? hit.title : clipBody(hit.content)
722
+ return `- 「${one.sub}」[${level}] ${id8(hit.id)} · ${clipBody(body)}`
723
+ })
724
+ const tail = []
725
+ if (consensus.length > 0) {
726
+ tail.push(`- 多个子问句都命中、原榜里也有的:${consensus.map(id8).join(', ')}(上面已列,这是它们真的相关的硬证据)`)
727
+ }
728
+ tail.push('(只截前一句;读全文用 memory_read(id)。)')
729
+ return [head, ...lines, ...tail].join('\n')
730
+ }
731
+
732
+ /**
733
+ * 拿原榜没给出的条目补在末尾。失败一律当「没补」(不把异常拼进一份本来成功的回执)。
734
+ * 返回新的 main;没补到东西时返回原 main(引用不变,调用方据此判断)。
735
+ */
736
+ async function augmentByDecompose({ flow, exec, main, localArgs, query, flags, budget }) {
737
+ const subs = decomposeQuery(query)
738
+ if (subs.length === 0) return main
739
+ const baseHits = Array.isArray(main.value?.hits) ? main.value.hits : []
740
+ const order = baseHits.map((hit) => String(hit?.id ?? '')).filter((one) => one !== '')
741
+ const seen = new Set(order)
742
+ const consensus = new Set()
743
+ const rows = []
744
+ for (const sub of subs) {
745
+ let got = null
746
+ try {
747
+ got = await flow.call(
748
+ 'memory_search',
749
+ // [macro-memory 0.4.0 P1] 子问句**放宽档位收口**:原榜的 min_rel / band_keep 会把
750
+ // 「分数低一档但其实对」的条目整段收掉,而子问句只需要「这一问里它在不在前排」。
751
+ // 放宽的代价由下面「每问最多两行 + score>0」两道闸门兜住。
752
+ { ...localArgs, query: sub, k: MQ_MAX_ROWS_PER_SUB + 2, content_max: MQ_ROW_CHARS, min_rel: 0, band_keep: false },
753
+ exec,
754
+ )
755
+ } catch {
756
+ continue
757
+ }
758
+ const hits = Array.isArray(got?.value?.hits) ? got.value.hits : []
759
+ let added = 0
760
+ for (const hit of hits) {
761
+ const id = String(hit?.id ?? '')
762
+ if (id === '') continue
763
+ const score = Number(hit?.score)
764
+ if (Number.isFinite(score) && score <= 0) continue
765
+ if (seen.has(id)) {
766
+ // 子问句命中了原榜里已有的条目:不是新东西,但这是「它真的相关」的硬证据(和融合层 fused.both 同一套道理)。
767
+ consensus.add(id)
768
+ continue
769
+ }
770
+ seen.add(id)
771
+ rows.push({ sub, hit })
772
+ added += 1
773
+ if (added >= MQ_MAX_ROWS_PER_SUB) break
774
+ }
775
+ }
776
+ const agree = order.filter((id) => consensus.has(id)).slice(0, MQ_MAX_CONSENSUS)
777
+ if (rows.length === 0 && agree.length === 0) return main
778
+
779
+ let shown = rows
780
+ let text = supplementText(shown, subs, agree)
781
+ if (budget.value !== null) {
782
+ const base = estTokens(main.text)
783
+ while (shown.length > 1 && base + estTokens(text) > budget.value) {
784
+ shown = shown.slice(0, shown.length - 1)
785
+ text = supplementText(shown, subs, agree)
786
+ }
787
+ if (base + estTokens(text) > budget.value) {
788
+ flags.multiQuerySkipped = true
789
+ return main
790
+ }
791
+ }
792
+ flags.multiQuery = subs.join(' | ')
793
+ flags.multiQueryRows = shown.length
794
+ flags.multiQueryAgree = agree.length
795
+ return {
796
+ ...main,
797
+ text: `${main.text}\n\n${text}`,
798
+ value:
799
+ main.value !== null && typeof main.value === 'object'
800
+ ? { ...main.value, hits: [...baseHits, ...shown.map((one) => one.hit)] }
801
+ : main.value,
802
+ }
803
+ }
804
+
805
+ export function createSearch({ flow, config = {} }) {
806
+ return {
807
+ name: 'memory_search',
808
+ description:
809
+ '查宏记忆。默认本地检索(关键词×重要度×时间衰减);默认沿星图扩散,expand:false 关;mode=graph 只在星图里按关联扩散;mode=bridge 找强相关未读邻居;mode=similar 找与某条记忆相似的条目。',
810
+ parameters: {
811
+ type: 'object',
812
+ additionalProperties: false,
813
+ properties: {
814
+ query: { type: 'string', description: '检索词/句子(similar 模式可省)。' },
815
+ mode: { type: 'string', enum: ['local', 'graph', 'bridge', 'similar'], description: '检索模式,默认 local。' },
816
+ id: { type: 'string', description: 'mode=similar 时的基准记忆 id。' },
817
+ memory_ids: { type: 'array', items: { type: 'string' }, description: '已知记忆 id(graph/bridge 用;会沿关联扩散)。' },
818
+ expand: { type: 'boolean', description: '是否追加星图扩散;默认扩散,expand:false 关。' },
819
+ level: { type: 'string', description: '限定层级,逗号多选:fact,lesson,topic,rules,project,soul,user(默认 fact,lesson,topic,rules,user;soul 与 project 不默认,要查请显式传)。' },
820
+ project: { type: 'string', description: '按项目名过滤(逗号多选)。' },
821
+ status: { type: 'string', description: '按状态过滤:active/archived/stale/all。' },
822
+ days: { type: 'integer', description: '只看最近 N 天创建的条目。' },
823
+ k: { type: 'integer', description: '返回条数上限(默认 10,1–50)。' },
824
+ content_max: { type: 'integer', description: '每条内容截断长度(默认 300,0=全文)。' },
825
+ // [macro-fusion 0.2.124] 命中常常只是「一句话」,答案在前一句或后一句里:给每条命中
826
+ // 带上同层前后各 N 条(meow 0.2.123 的 adjacentWindows)。默认 0——一个字节都不多花。
827
+ // [macro-fusion 0.2.127] 说清「什么时候值得开」:LoCoMo 1,193 题同题对照 +8.0 个百分点,
828
+ // 开 1 时回执 1.4k→3.5k 字符。多跳/时间题不给这几行的代价,比多花 300 token 大得多。
829
+ context: { type: 'integer', description: '相邻上下文:给每条命中带同层前后各 N 条(1–3,默认 0=不带)。问「什么时候」「谁先谁后」「之前/之后」,或一条命中说不清、要串两条线索时开 1–2:LoCoMo 1,193 题实测 +8.0 个百分点(26.9%→34.9%),回执 1.4k→3.5k 字符。一次最多铺 24 行,铺不下会说明剩下的用 memory_read 读。' },
830
+ budget: {
831
+ type: 'integer',
832
+ description:
833
+ `回执的 token 预算(最少 ${BUDGET_MIN},最多 20000)。四条路都听:本地先砍每条的字、再砍条数;星图先砍条数、再砍跳数;补邻居先砍字符预算、再砍条数;相似先砍字、再砍条数。砍了什么写进尾注,装不下会说最小能给多少。不给则只报成本。`,
834
+ },
835
+ min_rel: { type: 'number', description: '相关度下限(0–1,默认 0.30):只展开分数不低于榜首这个比例的条目,更弱的尾巴收掉并在尾注里报出;传 0 = 看全量。' },
836
+ dedupe: { type: 'boolean', description: '同类折叠(默认开):内容几乎一样(逐字级重复)的条目只列一条,折了几条写进尾注;传 false = 每条都列。' },
837
+ band_keep: { type: 'boolean', description: '按置信档收口(默认开):只给和榜首同一量级的命中,回执短于 k 时尾注会说明并给出出口;传 false = 连低分候选一起展开。' },
838
+ explain: { type: 'boolean', description: '附带分项得分,排查「为什么召回它」。' },
839
+ limit: { type: 'integer', description: 'graph/bridge 模式返回条数(默认 10 / 4)。' },
840
+ hops: { type: 'integer', description: 'graph/bridge 扩散跳数。' },
841
+ entity: { type: 'boolean', description: 'graph 是否按实体带邻居(默认开)。' },
842
+ dynamic_hops: { type: 'boolean', description: 'graph 第二跳是否按词面收(默认开)。' },
843
+ chars: { type: 'integer', description: 'bridge 模式文本预算(字符)。' },
844
+ min_weight: { type: 'number', description: 'bridge 模式最低关联权重。' },
845
+ },
846
+ },
847
+ output: TEXT_OUT,
848
+ // [macro-fusion 0.2.58] 模式名先过白名单(不合法就一句都不查),再把「参数给错模式」的
849
+ // 尾注统一贴在出口上——原来十个 return 各说各的,没有一个会说「你这个参数根本没用上」。
850
+ async execute(args, exec) {
851
+ const mode = modeOf(args)
852
+ if (mode.bad) return badModeText(mode)
853
+ // [macro-fusion 0.2.65] flags 让 runSearch 把「这次到底用没用上 limit / hops」告诉尾注,
854
+ // 而不是让尾注自己猜(猜的那一版对 local 自动扩散说了反话)。
855
+ const flags = {}
856
+ // [macro-fusion 0.2.109] 预算在出口解析一次、传到底:四处 return 各自解析会写出四种口径。
857
+ const budget = budgetOf(args.budget)
858
+ const text = await runSearch(flow, args, exec, flags, budget, config)
859
+ const notes = modeNotes(mode.name, args, flags)
860
+ const body = notes.length > 0 ? `${text}\n\n${notes.join('\n')}` : text
861
+ return costTail(body, { budget, flags })
862
+ },
863
+ presentCall(args) {
864
+ // [macro-fusion 0.2.60] 卡片标题不贴参数键:`检索记忆:graph` 是给机器看的。
865
+ const mode = modeOf(args)
866
+ const name = mode.bad ? '模式名没对上' : MODE_LABELS[mode.name]
867
+ const q = typeof args.query === 'string' ? args.query.trim() : ''
868
+ return { card: 'generic', title: cardTitle('检索记忆', q === '' ? name : `${name} · ${q}`), kind: 'read' }
869
+ },
870
+ }
871
+ }