dsh-macro-memory 0.0.0-stage → 0.3.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.
- package/LICENSE +21 -0
- package/README.md +457 -2
- package/cordis.patch.yml +6 -0
- package/lib/client.js +3623 -0
- package/lib/index.js +469 -0
- package/lib/macro/brand.js +82 -0
- package/lib/macro/bridge.js +158 -0
- package/lib/macro/chain.js +206 -0
- package/lib/macro/contract.js +471 -0
- package/lib/macro/cost.js +164 -0
- package/lib/macro/defs/admin.js +439 -0
- package/lib/macro/defs/dream.js +24 -0
- package/lib/macro/defs/link.js +257 -0
- package/lib/macro/defs/project.js +25 -0
- package/lib/macro/defs/read.js +145 -0
- package/lib/macro/defs/remember.js +213 -0
- package/lib/macro/defs/search.js +661 -0
- package/lib/macro/defs/update.js +161 -0
- package/lib/macro/dreamledger.js +1398 -0
- package/lib/macro/facade.js +135 -0
- package/lib/macro/fusion.js +182 -0
- package/lib/macro/linkflow.js +391 -0
- package/lib/macro/links.js +448 -0
- package/lib/macro/neighbor.js +209 -0
- package/lib/macro/panel.js +96 -0
- package/lib/macro/prompt.js +139 -0
- package/lib/macro/provenance.js +148 -0
- package/lib/macro/render.js +35 -0
- package/lib/macro/revisions.js +253 -0
- package/lib/macro/shared.js +113 -0
- package/lib/macro/store.js +103 -0
- package/lib/macro/tokencost.js +90 -0
- package/lib/macro/tools.js +67 -0
- package/package.json +54 -4
- package/vendor/VENDOR.json +23 -0
- package/vendor/dsh-memory-nebula/CONTRIBUTING.md +48 -0
- package/vendor/dsh-memory-nebula/LICENSE +21 -0
- package/vendor/dsh-memory-nebula/README.en.md +203 -0
- package/vendor/dsh-memory-nebula/README.md +253 -0
- package/vendor/dsh-memory-nebula/SECURITY.md +43 -0
- package/vendor/dsh-memory-nebula/SUPPORT.md +33 -0
- package/vendor/dsh-memory-nebula/cordis.patch.yml +4 -0
- package/vendor/dsh-memory-nebula/lib/client.js +105 -0
- package/vendor/dsh-memory-nebula/lib/host/adapters/index.js +279 -0
- package/vendor/dsh-memory-nebula/lib/host/adapters/ingest.js +230 -0
- package/vendor/dsh-memory-nebula/lib/host/adapters/meow.js +317 -0
- package/vendor/dsh-memory-nebula/lib/host/adapters/notes.js +305 -0
- package/vendor/dsh-memory-nebula/lib/host/adapters/sqlite.js +287 -0
- package/vendor/dsh-memory-nebula/lib/host/adapters/util.js +231 -0
- package/vendor/dsh-memory-nebula/lib/host/bridge.js +351 -0
- package/vendor/dsh-memory-nebula/lib/host/compress.js +97 -0
- package/vendor/dsh-memory-nebula/lib/host/demo.js +357 -0
- package/vendor/dsh-memory-nebula/lib/host/diagnostics.js +125 -0
- package/vendor/dsh-memory-nebula/lib/host/doctor.js +270 -0
- package/vendor/dsh-memory-nebula/lib/host/graph.js +1663 -0
- package/vendor/dsh-memory-nebula/lib/host/graphcache.js +282 -0
- package/vendor/dsh-memory-nebula/lib/host/http.js +993 -0
- package/vendor/dsh-memory-nebula/lib/host/injectcfg.js +95 -0
- package/vendor/dsh-memory-nebula/lib/host/ledger.js +175 -0
- package/vendor/dsh-memory-nebula/lib/host/live.js +204 -0
- package/vendor/dsh-memory-nebula/lib/host/nebula.js +2105 -0
- package/vendor/dsh-memory-nebula/lib/host/page.js +75 -0
- package/vendor/dsh-memory-nebula/lib/host/path.js +83 -0
- package/vendor/dsh-memory-nebula/lib/host/recall.js +451 -0
- package/vendor/dsh-memory-nebula/lib/host/share.js +633 -0
- package/vendor/dsh-memory-nebula/lib/host/sources.js +266 -0
- package/vendor/dsh-memory-nebula/lib/host/store.js +333 -0
- package/vendor/dsh-memory-nebula/lib/host/text.js +410 -0
- package/vendor/dsh-memory-nebula/lib/host/transcripts.js +396 -0
- package/vendor/dsh-memory-nebula/lib/index.js +759 -0
- package/vendor/dsh-memory-nebula/lib/standalone.mjs +315 -0
- package/vendor/dsh-memory-nebula/lib/web/api.js +426 -0
- package/vendor/dsh-memory-nebula/lib/web/app.js +4159 -0
- package/vendor/dsh-memory-nebula/lib/web/i18n.js +580 -0
- package/vendor/dsh-memory-nebula/lib/web/index.html +174 -0
- package/vendor/dsh-memory-nebula/lib/web/nav.js +132 -0
- package/vendor/dsh-memory-nebula/lib/web/render.js +1890 -0
- package/vendor/dsh-memory-nebula/lib/web/space3d.js +1883 -0
- package/vendor/dsh-memory-nebula/lib/web/style.css +1402 -0
- package/vendor/dsh-memory-nebula/locale/en.json +7 -0
- package/vendor/dsh-memory-nebula/locale/zh.json +7 -0
- package/vendor/dsh-memory-nebula/market/assets/icon-180.png +0 -0
- package/vendor/dsh-memory-nebula/market/assets/icon.svg +40 -0
- package/vendor/dsh-memory-nebula/market/index.json +101 -0
- package/vendor/dsh-memory-nebula/package.json +87 -0
- package/vendor/dsh-memory-nebula/sidecar.ps1 +119 -0
- package/vendor/meow-memory/LICENSE +21 -0
- package/vendor/meow-memory/README.en.md +192 -0
- package/vendor/meow-memory/README.md +174 -0
- package/vendor/meow-memory/README.pt-br.md +180 -0
- package/vendor/meow-memory/cordis.patch.yml +7 -0
- package/vendor/meow-memory/lib/client.js +3344 -0
- package/vendor/meow-memory/lib/client.js.map +7 -0
- package/vendor/meow-memory/lib/index.js +9567 -0
- package/vendor/meow-memory/lib/index.js.map +7 -0
- package/vendor/meow-memory/lib/prompts/README.md +65 -0
- package/vendor/meow-memory/lib/prompts/en/dream-atomic.md +36 -0
- package/vendor/meow-memory/lib/prompts/en/dream-header.md +9 -0
- package/vendor/meow-memory/lib/prompts/en/dream-project-summary.md +12 -0
- package/vendor/meow-memory/lib/prompts/en/dream-topic.md +27 -0
- package/vendor/meow-memory/lib/prompts/en/external-memory-notice.md +8 -0
- package/vendor/meow-memory/lib/prompts/en/first-create-notice.md +8 -0
- package/vendor/meow-memory/lib/prompts/en/labels.md +98 -0
- package/vendor/meow-memory/lib/prompts/en/reflect.md +31 -0
- package/vendor/meow-memory/lib/prompts/en/system-guide.md +121 -0
- package/vendor/meow-memory/lib/prompts/en/tools.md +83 -0
- package/vendor/meow-memory/lib/prompts/en/welcome-guide.md +12 -0
- package/vendor/meow-memory/lib/prompts/pt-br/dream-atomic.md +36 -0
- package/vendor/meow-memory/lib/prompts/pt-br/dream-header.md +9 -0
- package/vendor/meow-memory/lib/prompts/pt-br/dream-project-summary.md +12 -0
- package/vendor/meow-memory/lib/prompts/pt-br/dream-topic.md +27 -0
- package/vendor/meow-memory/lib/prompts/pt-br/external-memory-notice.md +8 -0
- package/vendor/meow-memory/lib/prompts/pt-br/first-create-notice.md +8 -0
- package/vendor/meow-memory/lib/prompts/pt-br/labels.md +98 -0
- package/vendor/meow-memory/lib/prompts/pt-br/reflect.md +31 -0
- package/vendor/meow-memory/lib/prompts/pt-br/system-guide.md +121 -0
- package/vendor/meow-memory/lib/prompts/pt-br/tools.md +83 -0
- package/vendor/meow-memory/lib/prompts/pt-br/welcome-guide.md +12 -0
- package/vendor/meow-memory/lib/prompts/zh/dream-atomic.md +36 -0
- package/vendor/meow-memory/lib/prompts/zh/dream-header.md +9 -0
- package/vendor/meow-memory/lib/prompts/zh/dream-project-summary.md +19 -0
- package/vendor/meow-memory/lib/prompts/zh/dream-topic.md +27 -0
- package/vendor/meow-memory/lib/prompts/zh/external-memory-notice.md +8 -0
- package/vendor/meow-memory/lib/prompts/zh/first-create-notice.md +8 -0
- package/vendor/meow-memory/lib/prompts/zh/labels.md +98 -0
- package/vendor/meow-memory/lib/prompts/zh/reflect.md +30 -0
- package/vendor/meow-memory/lib/prompts/zh/system-guide.md +119 -0
- package/vendor/meow-memory/lib/prompts/zh/tools.md +83 -0
- package/vendor/meow-memory/lib/prompts/zh/welcome-guide.md +12 -0
- package/vendor/meow-memory/package.json +64 -0
|
@@ -0,0 +1,661 @@
|
|
|
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: '' }) {
|
|
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'])
|
|
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
|
+
const hits = Array.isArray(main.value?.hits) ? main.value.hits.length : 0
|
|
482
|
+
// [macro-fusion 0.2.133] 主人 2026-11-21 明令:默认关闭的有用能力要全开,不要急着省 token。
|
|
483
|
+
// 以前要 expand=true 或本地零命中才扩散——可星图那一路提供的是「跨会话、跨项目才看得见」的线索,
|
|
484
|
+
// 本地命中越多反而越用不上它,等于把最有用的一半藏起来。现在默认扩散,只有显式 expand:false 才关。
|
|
485
|
+
const wantExpand = args.expand !== false
|
|
486
|
+
if (!wantExpand) return main.text
|
|
487
|
+
if (query.length === 0 && !Array.isArray(args.memory_ids)) return main.text
|
|
488
|
+
|
|
489
|
+
// [macro-fusion 0.2.65] 这次扩散真的读了 limit / hops,把用上的值记下来——
|
|
490
|
+
// 尾注据此说实话(老写法在这里用上了参数,尾注却声明「没用上」)。
|
|
491
|
+
// 三种状态要分开:真的扩散了 / 本要扩散但星图没接上 / 根本没走到扩散。
|
|
492
|
+
const spreadLimit = args.limit ?? 5
|
|
493
|
+
const spreadHops = args.hops ?? 2
|
|
494
|
+
flags.spreadLimit = spreadLimit
|
|
495
|
+
flags.spreadHops = spreadHops
|
|
496
|
+
flags.spreadTried = true
|
|
497
|
+
const spread = await flow.tryCall(
|
|
498
|
+
'nebula_recall',
|
|
499
|
+
{ query, memory_ids: args.memory_ids, limit: spreadLimit, hops: spreadHops },
|
|
500
|
+
exec,
|
|
501
|
+
'星图扩散',
|
|
502
|
+
)
|
|
503
|
+
if (spread.entry) flags.spread = true
|
|
504
|
+
// 本地检索是主语,扩散只是加料。加不上就说一句「没加」,绝不把 tryCall 的失败文案
|
|
505
|
+
// (`星图扩散未完成:macro-memory:这项能力还没就绪…`)拼进一个本来成功的结果里
|
|
506
|
+
if (!spread.entry) return `${main.text}\n\n(星图这次没接上,关联扩散没做——先把本地结果给你。)`
|
|
507
|
+
// 空图时的「没有匹配」不是佐证,是没算:不说明的话,本地零命中 + 星图零命中
|
|
508
|
+
// 读起来像「两边都确认没有这条记忆」,而其实星图那边一次都没算。
|
|
509
|
+
if (recallAnswerKind(spread.text) === 'emptyGraph') {
|
|
510
|
+
return `${main.text}\n\n(星图现在还是空的(还没建完),关联扩散这次没算——上面的本地结果就是全部,这不是「确认没有」,过几分钟再搜一次。)`
|
|
511
|
+
}
|
|
512
|
+
// [macro-fusion 0.2.118] 两路都算出来了 → 先试着合成一张榜。
|
|
513
|
+
// 老做法是把两段文本上下拼在一起:同一堆记忆在两段里各出现一次(第二遍白花 token),
|
|
514
|
+
// 而「两条路都命中」这件事本身是最强的相关性证据,却没有任何人替读者指出来。
|
|
515
|
+
// 融合只按**名次**合(RRF),因为两路的分数不同源,拿分数线不同的两组数比大小是在编结论。
|
|
516
|
+
const fusedHead = await fusedPart({ localValue: main.value, graphText: spread.text, spreadLimit, budget, flags })
|
|
517
|
+
if (fusedHead !== null) return fusedHead
|
|
518
|
+
// [macro-fusion 0.2.110] 扩散这一段也在同一份回执里,预算到这儿还没花完——
|
|
519
|
+
// 那就按**剩余**预算去要它:整份回执的总量才是读者的成本,分段各算一遍等于自欺。
|
|
520
|
+
if (budget.value !== null) {
|
|
521
|
+
const used = estTokens(main.text)
|
|
522
|
+
const remain = budget.value - used
|
|
523
|
+
if (remain < BUDGET_MIN) {
|
|
524
|
+
const said = `budget ${budget.value} token 已经被本地结果用掉(≈${fmtTokens(used)} token),星图扩散这一段按剩余预算拿不出来:要扩散就用 expand=false 关掉它,或者把预算提上去。`
|
|
525
|
+
flags.budgetNote = flags.budgetNote ? `${flags.budgetNote} ${said}` : said
|
|
526
|
+
return main.text
|
|
527
|
+
}
|
|
528
|
+
const spreadFit = await fitPath(flow, exec, {
|
|
529
|
+
tool: 'nebula_recall',
|
|
530
|
+
baseArgs: { query, memory_ids: args.memory_ids, limit: spreadLimit, hops: spreadHops },
|
|
531
|
+
main: { text: spread.text, value: spread.value },
|
|
532
|
+
budget: { value: remain },
|
|
533
|
+
knobs: PATH_KNOBS.graph,
|
|
534
|
+
what: MODE_LABELS.graph,
|
|
535
|
+
})
|
|
536
|
+
if (spreadFit.note !== '') {
|
|
537
|
+
const said = `(星图扩散按剩余 ${remain} token 预算算:${spreadFit.note})`
|
|
538
|
+
flags.budgetNote = flags.budgetNote ? `${flags.budgetNote} ${said}` : said
|
|
539
|
+
}
|
|
540
|
+
return `${main.text}\n\n— 星图关联扩散 —\n${spreadFit.main.text}`
|
|
541
|
+
}
|
|
542
|
+
return `${main.text}\n\n— 星图关联扩散 —\n${spread.text}`
|
|
543
|
+
}
|
|
544
|
+
|
|
545
|
+
/**
|
|
546
|
+
* [macro-fusion 0.2.118] 两路合一张榜;合不了就返回 null,让调用方走原来的两段式。
|
|
547
|
+
*
|
|
548
|
+
* 什么时候「合不了」:本地一条没命中(那就没有榜,只有星图的关联线索,两段式更好读)、
|
|
549
|
+
* 星图回执解析不出节点(形状变了 / 补丁被冲掉)、或者预算紧到连本地那部分都装不下——
|
|
550
|
+
* 这三种都退回老路径,而不是硬凑一张半张的榜。
|
|
551
|
+
*
|
|
552
|
+
* 融合省下的是 token:同一堆记忆不再出现两遍,星图独有的只带「为什么相关」+ 摘要,
|
|
553
|
+
* 不带全文(全文在本地命中里已经有了)。多出来的是那句「两路都命中 N 条」——
|
|
554
|
+
* 两条互不相干的检索方式同时捞到同一条,是这条记忆与当前处境相关的**最硬**的证据。
|
|
555
|
+
*/
|
|
556
|
+
async function fusedPart({ localValue, graphText, spreadLimit, budget, flags }) {
|
|
557
|
+
const localHits = Array.isArray(localValue?.hits) ? localValue.hits : []
|
|
558
|
+
const nodes = graphNodesOf(graphText)
|
|
559
|
+
if (localHits.length === 0 || nodes.length === 0) return null
|
|
560
|
+
const fused = fuseRanked({ localHits, graphNodes: nodes })
|
|
561
|
+
if (fused.rows.length === 0) return null
|
|
562
|
+
|
|
563
|
+
const asked = Number(spreadLimit)
|
|
564
|
+
const graphCap = Number.isFinite(asked) ? Math.max(0, asked) : 5
|
|
565
|
+
const noteHead = String(localValue?.note ?? '').trim()
|
|
566
|
+
const rankNote =
|
|
567
|
+
fused.both > 0
|
|
568
|
+
? `融合榜(本地 # / 星图 # 两路按名次合并,RRF k=${RRF_K}):两路都命中 ${fused.both} 条、本地独有 ${fused.localOnly} 条、星图独有 ${fused.graphOnly} 条——重复的条目只出现一次,两路都命中的排在最前。`
|
|
569
|
+
: `融合榜(本地 # / 星图 # 两路按名次合并,RRF k=${RRF_K}):这次两路没有重叠(本地 ${localHits.length} 条、星图 ${nodes.length} 条),按名次排在一起。`
|
|
570
|
+
const head = [rankNote, noteHead].filter((x) => x !== '').join('\n')
|
|
571
|
+
const build = (shown) =>
|
|
572
|
+
fusedText({
|
|
573
|
+
note: head,
|
|
574
|
+
rows: fused.rows,
|
|
575
|
+
k: localHits.length,
|
|
576
|
+
graphShown: shown,
|
|
577
|
+
dropped: Math.max(0, fused.graphOnly - shown),
|
|
578
|
+
})
|
|
579
|
+
|
|
580
|
+
let graphShown = Math.min(graphCap, fused.graphOnly)
|
|
581
|
+
let text = build(graphShown)
|
|
582
|
+
if (budget.value !== null && estTokens(text) > budget.value) {
|
|
583
|
+
// 先砍星图的独有条目:它们只是「为什么相关」的线索,本地命中的全文是答案本身。
|
|
584
|
+
let shown = graphShown
|
|
585
|
+
while (shown > 0 && estTokens(build(shown)) > budget.value) shown -= 1
|
|
586
|
+
if (estTokens(build(shown)) > budget.value) return null
|
|
587
|
+
const said = `(融合榜按 ${budget.value} token 预算收紧:星图独有的条目从 ${graphShown} 条压到 ${shown} 条。)`
|
|
588
|
+
flags.budgetNote = flags.budgetNote ? `${flags.budgetNote} ${said}` : said
|
|
589
|
+
graphShown = shown
|
|
590
|
+
text = build(shown)
|
|
591
|
+
}
|
|
592
|
+
flags.fused = true
|
|
593
|
+
flags.fusedBoth = fused.both
|
|
594
|
+
return text
|
|
595
|
+
}
|
|
596
|
+
|
|
597
|
+
export function createSearch({ flow }) {
|
|
598
|
+
return {
|
|
599
|
+
name: 'memory_search',
|
|
600
|
+
description:
|
|
601
|
+
'查宏记忆。默认本地检索(关键词×重要度×时间衰减);默认沿星图扩散,expand:false 关;mode=graph 只在星图里按关联扩散;mode=bridge 找强相关未读邻居;mode=similar 找与某条记忆相似的条目。',
|
|
602
|
+
parameters: {
|
|
603
|
+
type: 'object',
|
|
604
|
+
additionalProperties: false,
|
|
605
|
+
properties: {
|
|
606
|
+
query: { type: 'string', description: '检索词/句子(similar 模式可省)。' },
|
|
607
|
+
mode: { type: 'string', enum: ['local', 'graph', 'bridge', 'similar'], description: '检索模式,默认 local。' },
|
|
608
|
+
id: { type: 'string', description: 'mode=similar 时的基准记忆 id。' },
|
|
609
|
+
memory_ids: { type: 'array', items: { type: 'string' }, description: '已知记忆 id(graph/bridge 用;会沿关联扩散)。' },
|
|
610
|
+
expand: { type: 'boolean', description: '是否追加星图扩散;默认扩散,expand:false 关。' },
|
|
611
|
+
level: { type: 'string', description: '限定层级,逗号多选:fact,lesson,topic,rules,project,soul,user(默认 fact,lesson,topic,rules,user;soul 与 project 不默认,要查请显式传)。' },
|
|
612
|
+
project: { type: 'string', description: '按项目名过滤(逗号多选)。' },
|
|
613
|
+
status: { type: 'string', description: '按状态过滤:active/archived/stale/all。' },
|
|
614
|
+
days: { type: 'integer', description: '只看最近 N 天创建的条目。' },
|
|
615
|
+
k: { type: 'integer', description: '返回条数上限(默认 10,1–50)。' },
|
|
616
|
+
content_max: { type: 'integer', description: '每条内容截断长度(默认 300,0=全文)。' },
|
|
617
|
+
// [macro-fusion 0.2.124] 命中常常只是「一句话」,答案在前一句或后一句里:给每条命中
|
|
618
|
+
// 带上同层前后各 N 条(meow 0.2.123 的 adjacentWindows)。默认 0——一个字节都不多花。
|
|
619
|
+
// [macro-fusion 0.2.127] 说清「什么时候值得开」:LoCoMo 1,193 题同题对照 +8.0 个百分点,
|
|
620
|
+
// 开 1 时回执 1.4k→3.5k 字符。多跳/时间题不给这几行的代价,比多花 300 token 大得多。
|
|
621
|
+
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 读。' },
|
|
622
|
+
budget: {
|
|
623
|
+
type: 'integer',
|
|
624
|
+
description:
|
|
625
|
+
`回执的 token 预算(最少 ${BUDGET_MIN},最多 20000)。四条路都听:本地先砍每条的字、再砍条数;星图先砍条数、再砍跳数;补邻居先砍字符预算、再砍条数;相似先砍字、再砍条数。砍了什么写进尾注,装不下会说最小能给多少。不给则只报成本。`,
|
|
626
|
+
},
|
|
627
|
+
min_rel: { type: 'number', description: '相关度下限(0–1,默认 0.30):只展开分数不低于榜首这个比例的条目,更弱的尾巴收掉并在尾注里报出;传 0 = 看全量。' },
|
|
628
|
+
dedupe: { type: 'boolean', description: '同类折叠(默认开):内容几乎一样(逐字级重复)的条目只列一条,折了几条写进尾注;传 false = 每条都列。' },
|
|
629
|
+
band_keep: { type: 'boolean', description: '按置信档收口(默认开):只给和榜首同一量级的命中,回执短于 k 时尾注会说明并给出出口;传 false = 连低分候选一起展开。' },
|
|
630
|
+
explain: { type: 'boolean', description: '附带分项得分,排查「为什么召回它」。' },
|
|
631
|
+
limit: { type: 'integer', description: 'graph/bridge 模式返回条数(默认 10 / 4)。' },
|
|
632
|
+
hops: { type: 'integer', description: 'graph/bridge 扩散跳数。' },
|
|
633
|
+
chars: { type: 'integer', description: 'bridge 模式文本预算(字符)。' },
|
|
634
|
+
min_weight: { type: 'number', description: 'bridge 模式最低关联权重。' },
|
|
635
|
+
},
|
|
636
|
+
},
|
|
637
|
+
output: TEXT_OUT,
|
|
638
|
+
// [macro-fusion 0.2.58] 模式名先过白名单(不合法就一句都不查),再把「参数给错模式」的
|
|
639
|
+
// 尾注统一贴在出口上——原来十个 return 各说各的,没有一个会说「你这个参数根本没用上」。
|
|
640
|
+
async execute(args, exec) {
|
|
641
|
+
const mode = modeOf(args)
|
|
642
|
+
if (mode.bad) return badModeText(mode)
|
|
643
|
+
// [macro-fusion 0.2.65] flags 让 runSearch 把「这次到底用没用上 limit / hops」告诉尾注,
|
|
644
|
+
// 而不是让尾注自己猜(猜的那一版对 local 自动扩散说了反话)。
|
|
645
|
+
const flags = {}
|
|
646
|
+
// [macro-fusion 0.2.109] 预算在出口解析一次、传到底:四处 return 各自解析会写出四种口径。
|
|
647
|
+
const budget = budgetOf(args.budget)
|
|
648
|
+
const text = await runSearch(flow, args, exec, flags, budget)
|
|
649
|
+
const notes = modeNotes(mode.name, args, flags)
|
|
650
|
+
const body = notes.length > 0 ? `${text}\n\n${notes.join('\n')}` : text
|
|
651
|
+
return costTail(body, { budget, flags })
|
|
652
|
+
},
|
|
653
|
+
presentCall(args) {
|
|
654
|
+
// [macro-fusion 0.2.60] 卡片标题不贴参数键:`检索记忆:graph` 是给机器看的。
|
|
655
|
+
const mode = modeOf(args)
|
|
656
|
+
const name = mode.bad ? '模式名没对上' : MODE_LABELS[mode.name]
|
|
657
|
+
const q = typeof args.query === 'string' ? args.query.trim() : ''
|
|
658
|
+
return { card: 'generic', title: cardTitle('检索记忆', q === '' ? name : `${name} · ${q}`), kind: 'read' }
|
|
659
|
+
},
|
|
660
|
+
}
|
|
661
|
+
}
|