dsh-macro-memory 0.4.1 → 0.5.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/README.md CHANGED
@@ -2,9 +2,9 @@
2
2
 
3
3
  > 一个记忆插件,接管全部记忆能力:**8 个工具、一段 1,235 字符的常驻注入**,主库仍是 meow 的七层 SQLite,星图退成可重建的索引。
4
4
  >
5
- > 适用:DeepSeek Harness(DSH)。版本 **0.4.1** · 许可 MIT · 内置 meow-memory 与 dsh-memory-nebula 的完整副本(均为 MIT,见[第三方声明](#第三方声明与来源))。
5
+ > 适用:DeepSeek Harness(DSH)。版本 **0.5.0** · 许可 MIT · 内置 meow-memory 与 dsh-memory-nebula 的完整副本(均为 MIT,见[第三方声明](#第三方声明与来源))。
6
6
 
7
- | 指标 | 融合前(三插件并存) | 现在(0.4.1) | 变化 |
7
+ | 指标 | 融合前(三插件并存) | 现在(0.5.0) | 变化 |
8
8
  | --- | --- | --- | --- |
9
9
  | 工具 schema 合计 | 17 个工具 / 56,759 B | **8 个工具 / 13,567 B** | **−76.1%** |
10
10
  | 常驻注入 | 4,085 字符(meow 3,396 + nebula 689) | **1,235 字符(1 段)** | **−69.8%** |
@@ -14,6 +14,8 @@
14
14
 
15
15
  > **0.4.0 里程碑**:这一版不换引擎、只把「账」和「刀」都做实——六件事全部带开关、带回滚、带能红证明:**口径单**(新建 `docs/EVAL-CLAIMS.md`,把可引用的与过期的分成两张表)、**查询分解** `multiQuery`(默认 `off`)、**写入端巩固** `consolidate`(默认 `suggest`,一个字不写库)、**写入端通胀体检**(`selfecho` / `unused` / `inflate` 三类)、**自动取代** `autoSupersede`(默认 `suggest`)、**实体星图**(四类硬事实成层,顺带修掉「两跳从来没跑过第二跳」的沉默 bug)、**共现自学习扩词**(词源取每条的 `keywords`,不靠人手枚举)。读数:**30 支自检 / 3,511 条可执行断言 / 约 220 秒**;gold 宽池 146 条 **照抄 1.000 / 换说法 1.000(14/14)**、关掉共现即退回 0.929(增量可归因);窄池 40 条换说法 0.929、时间锚 1.000;真库 635 条 40 问 hit@1 0.925、MRR 0.963。以上全部无 LLM,端到端 judge 仍未重测(口径见 `docs/EVAL-CLAIMS.md`)。
16
16
 
17
+ > **0.5.0 里程碑**:这一版只回答一个问题——**「换个完全陌生的场景,它还能不能找到」**。0.4 的 gold 池只有一个领域(这个插件自己的开发史),在那儿调出来的分数换到医学/法律/园艺/天文/财务就不作数了。诊断出来的病根不是词库小,而是**两套词形不在一个坐标系**:共现表学的是 `keywords` 的原词(降糖药 / 二甲双胍 / 氮肥过量),索引与问句却被切成二元组(降糖/糖药、二甲/甲双/双胍)——表再准也接不上。修法分两层:① 索引里多一张「碎片 → 整词」的桥;② 这条桥**不进常规打分**,而是单独听第二遍,两遍按 RRF 合并(第一遍权重 1、第二遍 0.5),所以**第一名永远是第一遍的答案**,桥只负责补位。读数(5 个陌生领域 × 12 条 / 10 条换说法问句,`node tools/probe-adapt.mjs`):**换说法 hit@3 0.40 → 0.80**、第一名改判 **0 题**、关掉共现自学习掉回 0.30(增量可归因)、五域混库与单域持平;老读数一个字不动(gold 三档、`probe-cost` 快照 C5 逐位相同)。**31 支自检 / 3,522 条断言**。
18
+
17
19
  > **0.4.1**:只修文档口径——npm 上的 0.4.0 是在补完英文段之前打的包,包内 README 还停在 `13,372 B` 与「21 支 / 2,198 条」。0.4.1 不动任何代码逻辑,只让 GitHub 与 npm 上的 README 同 `tools/probe-host.mjs` 的 D3 实测对齐(13,567 B / 30 支 / 3,511 条)。
18
20
 
19
21
  > **0.3.0 里程碑**:从 0.1 的「把三套记忆插件合成一套」走到这里,它已经是一条能自证的流水线——180 个补丁版本、**24 支自检 / 3,323 条可执行断言**(约 200 秒跑完;这是 0.3.0 发布那一刻的读数,现状见 §六 与 [`docs/EVAL-CLAIMS.md`](docs/EVAL-CLAIMS.md) 表 A),每次调参都留下读数、否决记录和阴性对照;检索三档在 146 条宽池上的读数是**照抄 1.000 / 换说法 0.929 / 时间锚 0.889**(每档配一条「关掉这把刀就变差」的对照)。到这里接口面已经冻结:**8 个 `memory_*` 工具、一段 1,235 字符注入、7 层 SQLite 主库、format-1 市场索引**——0.3 之后只加字段不删字段、只加工具不改名,旧调用原样能用。同时首发到 npm(`npm i dsh-macro-memory`)、GitHub 与 awesome-dsh-plugin 目录。
@@ -22,7 +24,8 @@
22
24
 
23
25
  ## 目录
24
26
 
25
- - [一眼看懂(0.4.0,全部可复核)](#一眼看懂040全部可复核)
27
+ - [一眼看懂(0.5.0,全部可复核)](#一眼看懂050全部可复核)
28
+ - [换个陌生场景,它还认不认得(0.5.0 的全部工作)](#换个陌生场景它还认不认得050-的全部工作)
26
29
  - [它解决什么问题](#它解决什么问题)
27
30
  - [它是怎么搭起来的](#它是怎么搭起来的)
28
31
  - [记忆怎么工作](#记忆怎么工作)
@@ -39,14 +42,15 @@
39
42
 
40
43
  ---
41
44
 
42
- ## 一眼看懂(0.4.0,全部可复核)
45
+ ## 一眼看懂(0.5.0,全部可复核)
43
46
 
44
47
  | 维度 | 数字 | 怎么来的 |
45
48
  | --- | --- | --- |
46
49
  | 工具面 | **8 个 `memory_*` 工具 / 13,567 B schema**(三插件并存时 17 个 / 56,759 B,**−76.1%**) | 17 个原工具的能力压进 8 个,参数级覆盖审计逐条钉住(`tools/coverage-audit.mjs`) |
47
50
  | 常驻注入 | **1,235 字符 / 1 段**(原来 4,085 字 / 3 段,**−69.8%**) | 每轮固定开销约 14–16K token → **约 2.2K token** |
48
51
  | 检索延迟 | 1,200 条库 **p50 2.9ms**(三插件并存时 107.2ms) | 纯本地词法 + 索引缓存,不调网络、不调模型 |
49
- | 自证规模 | **30 支自检 / 3,511 条可执行断言**,全跑约 220 秒,少一条就判红 | `node tools/check-all.mjs`;断言数与基线逐支对账 |
52
+ | 自证规模 | **31 支自检 / 3,522 条可执行断言**,全跑约 220 秒,少一条就判红 | `node tools/check-all.mjs`;断言数与基线逐支对账 |
53
+ | 换场景适应力(5 个陌生领域) | 换说法 **hit@3 0.80**(只跑一遍 0.40)、第一名改判 **0 题**、关掉共现自学习掉回 **0.30** | `node tools/probe-adapt.mjs`:医学/法律/园艺/天文/财务各 12 条 + 10 条换说法问句 |
50
54
  | gold 召回(146 条宽池) | **照抄 1.000 / 换说法 1.000 / 时间锚 0.889** | `node tools/probe-gold.mjs`,关掉共现扩词换说法立刻退回 0.929 |
51
55
  | 真库召回(635 条 / 40 问) | **hit@1 0.925 / hit@5 1.000 / MRR 0.963** | 本地全量库实测,无 LLM |
52
56
  | LoCoMo 1,536 题(无 LLM) | hit@20 **0.7546**(旧口径 0.651)、MRR **0.4953**(旧 0.3768)、平均取回 17.77 条(旧 19.99) | 给得更少、命中更高;口径与命令见 [`docs/EVAL-CLAIMS.md`](docs/EVAL-CLAIMS.md) A2 |
@@ -61,16 +65,47 @@
61
65
  自己复核(三条命令,全部离线):
62
66
 
63
67
  ```bash
64
- node tools/check-all.mjs # 30 支自检 / 3,511 条断言,约 220 秒
68
+ node tools/check-all.mjs # 31 支自检 / 3,522 条断言,约 220 秒
65
69
  node tools/doctor.mjs # 两棵树字节一致、账本指纹、加载面、备份
66
70
  node tools/probe-gold.mjs # gold 三档 + 开关对照
71
+ node tools/probe-adapt.mjs # 换场景:5 个陌生领域 × 换说法,两遍只补位不翻盘
67
72
  ```
68
73
 
69
74
  **不说满的地方**(详见[§七](#七不说满的地方)):gold 是自建语料、不是公开榜单;真库数字随库增长不可跨时间比;端到端 LLM-judge 在 0.4.0 之后没重跑过,任何「端到端涨了多少」的说法本仓库不认。
70
75
 
71
76
  ---
72
77
 
73
- ## 它解决什么问题
78
+ ## 换个陌生场景,它还认不认得(0.5.0 的全部工作)
79
+
80
+ 记忆插件最容易骗自己的地方,是拿**自己开发史**当评测集:在那个池子上调出来的 0.9,是「它认识这个项目里的词」,不是「它听得懂你」。0.5.0 造了第二把尺子(`tools/probe-adapt.mjs` + `tools/fixtures/domains.json`):**医学、法律、园艺、天文、财务五个互不相关的领域,每域 12 条记忆**,每域 5 条问句——3 条用正文原词问(同词),2 条用**口语**问、答案在**正式文档**里(换说法,例:「降糖药第一次吃多少量」→ 答案条目写的是「起始剂量」)。
81
+
82
+ 每一条换说法问句都过三道夹具检查才允许进尺子:口语词与手工同义表零交集(不许借老表的光)、口语词不在答案里、正式词只在答案里、口语词确实出现在别处(否则它只是一条没被检索到的普通干扰词)。这样量出来的高分离不开「从库里学出来的桥」。
83
+
84
+ **病根不是词库小,是两套词形不在一个坐标系。** 共现表学的是 `keywords` 的**原词**(`降糖药`、`二甲双胍`、`氮肥过量`),而索引和问句都被 `tokenize()` 切成**二元组**(`降糖/糖药`、`二甲/甲双/双胍`、`氮肥/肥过/过量`)。于是问「降糖药第一次吃多少量」时,表里明明躺着 `降糖药` 的邻居,查 `降糖` 得到的却是 `(无)`——表再准也接不上。
85
+
86
+ 修法分两层,而且第二层才是关键:
87
+
88
+ 1. **建桥**(`buildCoocForms`):把每个 ≥3 字的整词切开,记住「碎片 → 整词」,再让整词的邻居在查表那一刻落回自己的碎片。这样 `降糖` 就能找到 `降糖药`,进而找到 `二甲双胍`。
89
+ 2. **桥不进常规打分,只单独听第二遍**(`searchAdaptive`):实测把桥常开会把宽池两题换说法从第 1 挤到第 2(1.000 → 0.857),因为它给「两跳来的候选」和真词一样的票。所以第一遍照 0.4.1 的老坐标系听(**一个字节都不改**),第二遍才开桥,两遍按 RRF 合并:第一遍权重 1、第二遍 0.5,`k = 60`。
90
+
91
+ 这样「适应力」和「别动老答案」就不是二选一了,五条判据把边界钉死(`probe-adapt` 的 A0–A5):
92
+
93
+ | 判据 | 要求 | 实测 |
94
+ | --- | --- | --- |
95
+ | A1 陌生领域同词 | 问句里的词就在正文里,第一条必须对(≥90%) | **100%**(五域各 100%) |
96
+ | A2 消融可归因 | 关共现自学习,换说法必须变差 | hit@3 **0.80 → 0.30** |
97
+ | A2' 手工表不背锅 | 冷域里手工表本就无词可用,关扩词应与关共现同读数 | 0.30 vs 0.30 |
98
+ | A3 混库不污染 | 五域 60 条混成一个库,读数不许比单域差 | 持平 |
99
+ | A4 只补位不翻盘 | 每条问句第一名与只跑一遍**逐位相同**;hit@3 至少涨 2 题 | 改判 **0 题**;0.40 → **0.80** |
100
+ | A5 真库噪声不塌 | 混进 146 条真记忆(gold 40 + 宽池 106)当干扰,hit@3 ≥ 50%,且关共现仍掉 2 题 | **60%**(纯池 70%)· 关共现 **30%** |
101
+
102
+ A5 是给「过拟合小池」留的反证:A1–A4 都在 12 条干净小池里量,小池的干扰项也来自同一张词表,idf 稳得像实验室。真库不是这样。混进 146 条讲这个插件自己开发史的真记忆之后,换说法 hit@3 从 70% 掉到 60%(五域混库 60 条时是 70%),关共现直接掉到 30%——**桥在噪声里仍然可归因,但确实会被稀释**。这条下降写在判据里,不当成丢人的事藏起来。
103
+
104
+ 两件没做到的事,写在这里不遮:**hit@1 仍是 0**——「多少量」→「起始剂量」这种要的是语义,不是词形,词形桥到不了;冷域的提升全部发生在第 2、第 3 位,这也是为什么主判据是 hit@3 / MRR 而不是 hit@1。第二件:桥只在真接得上时才跑第二遍(问句里至少一个碎片能落回某个整词),接不上就原样返回,不花这份钱;但接得上时确实多跑一遍词法扫描:1,200 条库实测 **4.4 → 11.3 ms/问**(2.6 倍),仍是毫秒级,但别当成免费。
105
+
106
+ 另外三条路走过、量过、没走通,记在这里省得下次再走(`docs/INTERNAL.md` 9.198 有完整读数):**单字重叠通道**(字符级 idf 重叠,单用 hit@3 70%、hit@1 30%,但并进 RRF 后第一名 10/10 全被改判、hit@3 反掉到 60%);**伪相关反馈**(拿第一遍榜首的关键词再查一遍,冷域 hit@3 +1 题、hit@1 不动、gold 逐位不变,但要付 3 倍检索成本,不划算);**库放大 25 倍(240 条关键词汤干扰)**的读数记在 INTERNAL,说明桥的边界在「库里还有正经词」而不是「库里全是词表碎渣」。
107
+
108
+ ---
74
109
 
75
110
  记忆插件通常各干各的:一个存长期记忆、一个建关系图谱、一个做性格画像。装三套的代价不是磁盘,是**每一轮都要重付的上下文税**:
76
111
 
package/lib/index.js CHANGED
@@ -24,7 +24,7 @@ import { withCost } from './macro/cost.js'
24
24
  import { NEIGHBOR_DEFAULT_CHARS, NEIGHBOR_DEFAULT_MAX, createNeighborInjector } from './macro/neighbor.js'
25
25
 
26
26
  export const name = 'macro-memory'
27
- export const version = '0.4.1'
27
+ export const version = '0.5.0'
28
28
  export const inject = ['tools']
29
29
 
30
30
  /** 融合层自己的默认值;配置里可写在顶层,也可写在 macro: 段下。 */
package/package.json CHANGED
@@ -1,6 +1,6 @@
1
1
  {
2
2
  "name": "dsh-macro-memory",
3
- "version": "0.4.1",
3
+ "version": "0.5.0",
4
4
  "private": false,
5
5
  "description": "宏观记忆调控插件:以 meow-memory 的记忆库为主库、dsh-memory-nebula 的星图为索引,融合成一套 8 个 memory_* 统一工具 + 一段最小注入;两个原插件退化为引擎,工具面与注入面由本插件统一接管并互相联动。",
6
6
  "type": "module",
@@ -8,8 +8,8 @@
8
8
  "name": "meow-memory",
9
9
  "version": "0.32.8",
10
10
  "files": 44,
11
- "bytes": 1997459,
12
- "sha256": "e4770b3c73ca9e81cc82e774edfeee503fac782fdfe66ea74e9d60eca7a35d37"
11
+ "bytes": 2008203,
12
+ "sha256": "b8dad4e47725b3d9455d12918b38d0d62f01da4aab2c7f6f53209e43ca9008f3"
13
13
  },
14
14
  {
15
15
  "dir": "vendor/dsh-memory-nebula",
@@ -2326,21 +2326,53 @@ function synMapOf() {
2326
2326
  // [macro-fusion 0.4.0 · P5] 两个来源合流:手工表是种子(管「人已经确定的等价说法」),
2327
2327
  // 共现表是自学习(管「新领域、新术语、新缩写——从来没人告诉过我它们是一回事」)。
2328
2328
  // 第四参 cooc 缺省 null 时,行为与 0.3.0 一字不差:老探针和外部脚本调三个参数照样跑。
2329
- function synExpandOf(qTerms, df, n, cooc) {
2329
+ function synExpandOf(qTerms, df, n, cooc, forms) {
2330
2330
  const map = synMapOf();
2331
2331
  const cap = Number.isFinite(n) && n > 0 ? Math.max(1, Math.floor(n * SYN_MAX_DF_RATIO)) : Infinity;
2332
2332
  const out = /* @__PURE__ */ new Map();
2333
2333
  const usable = (a, list) => !qTerms.includes(a) && !list.includes(a) && (df.get(a) ?? 0) > 0 && (df.get(a) ?? 0) <= cap;
2334
+ // 名额按**碎片**算(就是打分用的那个坐标系)。试过放宽到两倍、试过按整词算名额,两版在冷域
2335
+ // 十题上都更差(hit@3 0.90 → 0.60):多出来的名额被同项目层的邻居占走(番茄/整枝/蚜虫),
2336
+ // 它们能命中别的条目,把答文档从第三挤到第四。扩词是桥,桥要窄。
2337
+ // [macro-fusion 0.5.0 · P1] 碎片只在**第二遍(桥那一遍)**投:第一遍必须与 0.4.1 逐位一致,
2338
+ // 连分数都不许漂(probe-cost 的 C5 快照守的就是这条),而把整词切碎会多命中一批碎片、
2339
+ // 把分数抬高(实测 40.096866 → 42.811168,名次不变但数字变了)。碎片是桥自己的词形,
2340
+ // 就该留在桥那一遍;第一遍只按 0.4.1 的老坐标系说话。
2341
+ const fragOk = forms instanceof Map;
2342
+ const push = (use, a) => {
2343
+ if (typeof a !== "string" || a.length === 0) return;
2344
+ if (usable(a, use)) use.push(a);
2345
+ if (!fragOk) return;
2346
+ // 邻居是整词,正文里是碎片:把整词切开的碎片算候选,否则「二甲双胍」永远匹配不上「二甲/甲双/双胍」。
2347
+ for (const f of tokenize(a)) {
2348
+ if (f.length < 2 || f === a || !usable(f, use)) continue;
2349
+ use.push(f);
2350
+ }
2351
+ };
2334
2352
  for (const t of qTerms) {
2335
- const manual = map.get(t) ?? [];
2336
- const learned = cooc instanceof Map ? cooc.get(t) ?? [] : [];
2337
2353
  const use = [];
2338
- for (const a of manual) if (usable(a, use)) use.push(a);
2339
- for (const a of learned) if (usable(a, use)) use.push(a);
2354
+ for (const a of map.get(t) ?? []) push(use, a);
2355
+ if (cooc instanceof Map) {
2356
+ for (const a of cooc.get(t) ?? []) push(use, a);
2357
+ // 问句里的碎片先落回整词,再查那个整词的邻居:降糖 → 降糖药 → 二甲双胍。
2358
+ if (forms instanceof Map) {
2359
+ for (const w of forms.get(t) ?? []) {
2360
+ if (w === t) continue;
2361
+ for (const a of cooc.get(w) ?? []) push(use, a);
2362
+ }
2363
+ }
2364
+ }
2340
2365
  if (use.length > 0) out.set(t, use.slice(0, SYN_MAX_PER_TERM));
2341
2366
  }
2342
2367
  return out.size > 0 ? out : null;
2343
2368
  }
2369
+ // [macro-fusion 0.5.0 · P1] 词形桥的第二遍怎么并回第一遍:
2370
+ // FORM_MERGE_W 是第二遍的权重(第一遍恒为 1),FORM_RRF_K 是 RRF 的平滑常数(取 60 是 RRF 惯例)。
2371
+ // 实测:整份替换会把第一遍排第一的挤下去(财务「发票丢了还能报销吗」0 → 1);权重 0.5 的 RRF
2372
+ // 只补位不翻盘——第一遍第 1 名仍是第 1 名,第二遍捞回来的条目填进第 2、第 3 位
2373
+ // (冷域十题 hit@3 0.40 → 0.80;宽池换说法两档 1.000 / 0.956 与第一遍逐位相同)。
2374
+ var FORM_MERGE_W = 0.5;
2375
+ var FORM_RRF_K = 60;
2344
2376
  var KW_TF_W = 0.35;
2345
2377
  var FIELD_KW_W_DEF = 0.6;
2346
2378
  function hintWordsOf(hit, query) {
@@ -2631,13 +2663,59 @@ function coocWordsOf(d) {
2631
2663
  return out;
2632
2664
  }
2633
2665
 
2666
+ // [macro-fusion 0.5.0 · P1] 词形桥:keywords 里是多字词(二甲双胍 / 降糖药 / 叶子发黄),
2667
+ // 而问句与正文都被 tokenize 切成二元组——两套词形不在同一个坐标系里。共现表记得再准,
2668
+ // 问句那头用「降糖」也永远查不到「降糖药」这条键:跨领域换说法 hit@1 实测 0/10。
2669
+ // 第一版的做法是把 keywords 先切碎再学(表里全是 降糖/糖药 这种碎片),桥是长出来了,
2670
+ // 但整词的语义一起丢了:一条记忆的 8–13 个关键词切完变 20 多个 token,同条层每对都同分,
2671
+ // 「每词最多带 6 个」一砍就把真正要的映射对砍掉了(实测园艺「不开」只连到「叶子/发黄」,
2672
+ // 「氮肥/过量」被排在第七位直接丢掉)。所以改成:**表里存整词**(降糖药 ↔ 二甲双胍),
2673
+ // 只在查表那一刻补一层「碎片 → 整词」的桥(见 buildCoocForms)。
2674
+ // 纪律不变:只投 keywords,绝不 tokenize 正文——碎片是正文切出来的,keywords 是字与词。
2675
+ function coocFormsOf(words) {
2676
+ const out = [];
2677
+ for (const w of words) {
2678
+ for (const u of tokenize(w)) {
2679
+ if (u.length < 2) continue;
2680
+ if (!out.includes(u)) out.push(u);
2681
+ }
2682
+ }
2683
+ return out;
2684
+ }
2685
+
2686
+ // [macro-fusion 0.5.0 · P1] 碎片 → 整词的桥:共现表里存的是 keywords 的**原词**(降糖药 / 二甲双胍 / 缺氮),
2687
+ // 而索引里的文档词、问句词都被 tokenize 切成二元组(降糖/糖药、二甲/甲双/双胍)。两套词形不在一个
2688
+ // 坐标系,表再准也接不上:查「降糖/糖药」得到 (无),共现表里有降糖药带的一串邻居也白搭。
2689
+ // 这张表就是坐标系之间的翻译:碎片 → 它属于哪几个整词(整词必须真的是共现表的键,否则查它也没邻居)。
2690
+ // 一个碎片最多挂 4 个整词:挂太多说明这碎片本身没信息量(如「我们」「一直」),宁可不桥。
2691
+ // 只在 searchAdaptive 那一层启用(第二遍),常规打分路径一律不开——宽池实测(106 条真库快照)
2692
+ // 这一层常开会把两题换说法从第 1 挤到第 2,只有「补位」时才值。
2693
+ var COOC_FORM_WORDS = 4;
2694
+ function buildCoocForms(docs, cooc) {
2695
+ if (!(cooc instanceof Map)) return null;
2696
+ const out = new Map();
2697
+ for (const d of docs) {
2698
+ for (const w of coocWordsOf(d)) {
2699
+ const word = String(w ?? "").trim();
2700
+ if (word.length < 3 || !cooc.has(word)) continue;
2701
+ for (const f of coocFormsOf([word])) {
2702
+ if (f === word) continue;
2703
+ const list = out.get(f);
2704
+ if (!list) out.set(f, [word]);
2705
+ else if (!list.includes(word) && list.length < COOC_FORM_WORDS) list.push(word);
2706
+ }
2707
+ }
2708
+ }
2709
+ return out.size > 0 ? out : null;
2710
+ }
2711
+
2634
2712
  function coocShareHan(a, b) {
2635
2713
  if (!/[\u4e00-\u9fff]/.test(a) || !/[\u4e00-\u9fff]/.test(b)) return false;
2636
2714
  for (const ch of a) if (b.includes(ch)) return true;
2637
2715
  return false;
2638
2716
  }
2639
2717
 
2640
- function buildCoocSyn(docs, n) {
2718
+ function buildCoocSyn(docs, n, opts) {
2641
2719
  const pairs = new Map();
2642
2720
  // 两级证据分别记账:同条层(强)与项目层(弱)各一张表,最后按「强在前、弱补位」合流。
2643
2721
  // 混在一张表里按比例排序的话,项目层的词会把同条层的桥词挤出前六——实测宽池换说法因此从
@@ -2661,15 +2739,17 @@ function buildCoocSyn(docs, n) {
2661
2739
  }
2662
2740
  };
2663
2741
  const kwDf = new Map();
2742
+ // 表里一律存原词(不切碎):语义与「每词几个邻居」的名额都靠原词撑住,碎片桥在查表时补(buildCoocForms)。
2743
+ const wordsOf = (d) => coocWordsOf(d);
2664
2744
  for (const d of docs) {
2665
- const words = coocWordsOf(d);
2745
+ const words = wordsOf(d);
2666
2746
  if (words.length === 0) continue;
2667
2747
  for (const w of words) kwDf.set(w, (kwDf.get(w) ?? 0) + 1);
2668
2748
  pairUp(words, COOC_W_SAME);
2669
2749
  }
2670
2750
  const byProject = new Map();
2671
2751
  for (const d of docs) {
2672
- const words = coocWordsOf(d);
2752
+ const words = wordsOf(d);
2673
2753
  if (words.length === 0) continue;
2674
2754
  const p = String(d.project ?? "全局");
2675
2755
  if (!byProject.has(p)) byProject.set(p, []);
@@ -2784,12 +2864,14 @@ function buildSearchIndex(docs, opts = {}, sig = null) {
2784
2864
  const kwSets = useField ? docs.map((d) => new Set((Array.isArray(d.keywords) ? d.keywords : []).flatMap((w) => tokenize(String(w ?? ''))))) : null;
2785
2865
  // [macro-fusion 0.4.0 · P5] 共现表跟索引一起建(库一变就重算,不需要额外失效逻辑)。
2786
2866
  // coocLearn:false 一键回到「只有手工表」的旧口径,用来做开/关对照。
2787
- const coocSyn = opts.coocLearn === false ? null : buildCoocSyn(docs, n);
2867
+ const coocSyn = opts.coocLearn === false ? null : buildCoocSyn(docs, n, opts);
2868
+ // [macro-fusion 0.5.0 · P1] 碎片 → 整词的桥(opts.coocForms === false 可单独关掉,用来量这一层值多少分)。
2869
+ const coocForms = opts.coocForms === false ? null : buildCoocForms(docs, coocSyn);
2788
2870
  return {
2789
2871
  __n: n,
2790
2872
  __sig: sig ?? indexSignature(docs),
2791
- __opts: `${useField ? 1 : 0}${opts.kwSeparate === false ? 0 : 1}${opts.sessionTopic === false ? 0 : 1}${kwTfW}${opts.coocLearn === false ? 0 : 1}`,
2792
- plainToks, docToks, avgdl, bodyLen, avgBody, df, tf, kwToks, kwTfW, titleSets, kwSets, postings, useField, coocSyn
2873
+ __opts: `${useField ? 1 : 0}${opts.kwSeparate === false ? 0 : 1}${opts.sessionTopic === false ? 0 : 1}${kwTfW}${opts.coocLearn === false ? 0 : 1}${opts.coocForms === false ? 0 : 1}`,
2874
+ plainToks, docToks, avgdl, bodyLen, avgBody, df, tf, kwToks, kwTfW, titleSets, kwSets, postings, useField, coocSyn, coocForms
2793
2875
  };
2794
2876
  }
2795
2877
 
@@ -2801,7 +2883,7 @@ const SEARCH_INDEX_CACHE_MAX = 4;
2801
2883
  const searchIndexCache = new Map();
2802
2884
 
2803
2885
  function indexPathKey(docs, opts) {
2804
- return `${indexSignature(docs)}|${opts.fieldBoost === false ? 0 : 1}${opts.kwSeparate === false ? 0 : 1}${opts.sessionTopic === false ? 0 : 1}${Number.isFinite(opts.kwTfW) && opts.kwTfW >= 0 ? opts.kwTfW : KW_TF_W}${opts.inverted === false ? 0 : 1}${opts.coocLearn === false ? 0 : 1}`;
2886
+ return `${indexSignature(docs)}|${opts.fieldBoost === false ? 0 : 1}${opts.kwSeparate === false ? 0 : 1}${opts.sessionTopic === false ? 0 : 1}${Number.isFinite(opts.kwTfW) && opts.kwTfW >= 0 ? opts.kwTfW : KW_TF_W}${opts.inverted === false ? 0 : 1}${opts.coocLearn === false ? 0 : 1}${opts.coocForms === false ? 0 : 1}`;
2805
2887
  }
2806
2888
 
2807
2889
  // 调用方也可以直接传 opts.index(自己缓存那张表);签名或口径对不上就自己重建——
@@ -2810,7 +2892,7 @@ function searchIndexOf(docs, opts) {
2810
2892
  const key = indexPathKey(docs, opts);
2811
2893
  const given = opts.index;
2812
2894
  if (given && given.__n === docs.length && given.__sig === indexSignature(docs) &&
2813
- given.__opts === `${opts.fieldBoost === false ? 0 : 1}${opts.kwSeparate === false ? 0 : 1}${opts.sessionTopic === false ? 0 : 1}${Number.isFinite(opts.kwTfW) && opts.kwTfW >= 0 ? opts.kwTfW : KW_TF_W}${opts.coocLearn === false ? 0 : 1}`) {
2895
+ given.__opts === `${opts.fieldBoost === false ? 0 : 1}${opts.kwSeparate === false ? 0 : 1}${opts.sessionTopic === false ? 0 : 1}${Number.isFinite(opts.kwTfW) && opts.kwTfW >= 0 ? opts.kwTfW : KW_TF_W}${opts.coocLearn === false ? 0 : 1}${opts.coocForms === false ? 0 : 1}`) {
2814
2896
  return given;
2815
2897
  }
2816
2898
  if (opts.cache === false) return buildSearchIndex(docs, opts, key);
@@ -2859,7 +2941,7 @@ function search(query, docs, opts = {}) {
2859
2941
  if (q.length === 0 && idents.length === 0) return [];
2860
2942
  // [macro-fusion 0.2.153] 切词与建表挪进索引:这部分跟「问什么」无关,只跟「库里有什么」有关。
2861
2943
  const index = searchIndexOf(docs, opts);
2862
- const { docToks, avgdl, bodyLen, avgBody, df, tf, kwToks, kwTfW, titleSets, kwSets, postings, coocSyn } = index;
2944
+ const { docToks, avgdl, bodyLen, avgBody, df, tf, kwToks, kwTfW, titleSets, kwSets, postings, coocSyn, coocForms } = index;
2863
2945
  const FIELD_TITLE_W = 0.6;
2864
2946
  const FIELD_KW_W = Number.isFinite(opts.fieldKwW) ? opts.fieldKwW : FIELD_KW_W_DEF;
2865
2947
  const COORD_W = Number.isFinite(opts.coordW) ? opts.coordW : COORD_W_DEF;
@@ -2890,7 +2972,9 @@ function search(query, docs, opts = {}) {
2890
2972
  // [macro-fusion 0.4.0 · P5] 第四参是索引随库自建出来的共现表——手工表管「人确定过的说法」,
2891
2973
  // 共现表管「库里自己长出来的说法」。opts.coocLearn === false 时 index.coocSyn 为 null,
2892
2974
  // 这里就干净地退回只有手工表的老行为。
2893
- const synOf = opts.synBridge === false ? null : synExpandOf(qKept, df, n, coocSyn);
2975
+ // [macro-fusion 0.5.0 · P1] 第五参是「碎片 → 整词」的桥:问句里的碎片先落回整词,再去查共现表。
2976
+ // 少了这一层,表里存的降糖药/二甲双胍与索引里的 降糖/糖药 根本碰不到一起。
2977
+ const synOf = opts.synBridge === false ? null : synExpandOf(qKept, df, n, coocSyn, opts.synFormBridge === true ? coocForms : null);
2894
2978
  const synW = Number.isFinite(opts.synW) && opts.synW >= 0 ? opts.synW : SYN_W;
2895
2979
  // [macro-fusion 0.2.153] 打分只碰「问句里那几个词真的出现过」的条目。
2896
2980
  const coverLenRelief = Number.isFinite(opts.coverLenRelief) ? Math.min(1, Math.max(0, opts.coverLenRelief)) : COVER_LEN_RELIEF;
@@ -3147,6 +3231,83 @@ function search(query, docs, opts = {}) {
3147
3231
  if (opts.keepBand === true) return hits.slice(0, Number.isFinite(k) && k > 0 ? Math.round(k) : hits.length);
3148
3232
  return trimByBand(hits, k, opts);
3149
3233
  }
3234
+ // ═══════════════ [macro-fusion 0.5.0 · P1] 换场景检索:词形桥的第二遍 ═══════════════
3235
+ // 问题不是「词库太死」,而是**两套词形不在一个坐标系**:共现表学的是 keywords 的原词
3236
+ // (降糖药 / 二甲双胍 / 氮肥过量),索引与问句都被 tokenize 切成二元组(降糖/糖药、二甲/甲双/双胍、
3237
+ // 氮肥/肥过/过量)。于是问「降糖药第一次吃多少量」时,表里明明有降糖药的邻居,查「降糖」却得到 (无),
3238
+ // 表再准也接不上——这就是「换个场景、换种叫法就查不到」的真正原因,不是词库小。
3239
+ // 修法分两层:
3240
+ // ① 索引里多一张 碎片 → 整词 的桥(buildCoocForms),把两套词形接起来;
3241
+ // ② 但这条桥**不进常规打分**:宽池实测(106 条真库快照)常开会把两题换说法从第 1 挤到第 2
3242
+ // (1.000 → 0.857),因为它给两跳来的候选和真词一样的票。
3243
+ // 所以桥只在这一层开,而且只「补位」不「翻盘」:第一遍照常听(老行为一字不改),听完再按桥听
3244
+ // 第二遍,两遍用 RRF 并(第一遍权重 1、第二遍 FORM_MERGE_W)。第一遍排第一的仍是第一遍的答案,
3245
+ // 桥捞回来的条目填进第 2、第 3 位——冷域实测 hit@3 0.40 → 0.80,hit@1 不动(0.10)。
3246
+ // 桥接不上(问句里没有一个碎片能落回整词)就原样返回,不花第二遍的钱。
3247
+ function searchAdaptive(query, docs, opts = {}) {
3248
+ const first = search(query, docs, opts);
3249
+ if (opts.formRescue === false || opts.synBridge === false || opts.coocForms === false) return first;
3250
+ if (first.length === 0) return first;
3251
+ let idx = null;
3252
+ try {
3253
+ idx = searchIndexOf(docs, opts);
3254
+ } catch {
3255
+ idx = null;
3256
+ }
3257
+ const forms = idx === null ? null : idx.coocForms;
3258
+ if (!(forms instanceof Map)) return first;
3259
+ // 桥得真接得上才值得再听一遍:问句里至少有一个碎片能落回某个整词(而且那个整词在表里)。
3260
+ // 接不上就原样返回——这一步是常数,不会因为多听一遍把内存检索拖慢。
3261
+ let bridged = false;
3262
+ for (const t of q0ToksOf(query)) {
3263
+ if (forms.has(t)) {
3264
+ bridged = true;
3265
+ break;
3266
+ }
3267
+ }
3268
+ if (!bridged) return first;
3269
+ const alt = search(query, docs, { ...opts, synFormBridge: true });
3270
+ if (alt.length === 0) return first;
3271
+ // 融合而不是替换:第一遍的排序是主(权重 1),第二遍按名次补位(权重 FORM_MERGE_W)。
3272
+ // 为什么不用「第二遍更确定就整份替换」:实测替换会把第一遍排第一的挤下去(财务「发票丢了
3273
+ // 还能报销吗」0 → 1),而两份名单里各占第一的条目会打平。RRF 只做「补位」,不做「翻盘」:
3274
+ // 第一遍的第 1 名仍然是第 1 名,除非第二遍把它排到很后面(此时它本来也没听懂)。
3275
+ const k = Number.isFinite(opts.k) && opts.k > 0 ? Math.round(opts.k) : first.length;
3276
+ const score = /* @__PURE__ */ new Map();
3277
+ const keep = /* @__PURE__ */ new Map();
3278
+ const w = Number.isFinite(opts.formMergeW) ? opts.formMergeW : FORM_MERGE_W;
3279
+ const add = (list, weight) => {
3280
+ for (let i = 0; i < list.length; i++) {
3281
+ const h = list[i];
3282
+ const id = String(h.id);
3283
+ const rr = weight / (FORM_RRF_K + i);
3284
+ score.set(id, (score.get(id) ?? 0) + rr);
3285
+ const prev = keep.get(id);
3286
+ if (prev === void 0 || weight >= 1) keep.set(id, h);
3287
+ }
3288
+ };
3289
+ add(first, 1);
3290
+ add(alt, w);
3291
+ const ordered = [...keep.keys()].sort((a, b) => {
3292
+ const d = score.get(b) - score.get(a);
3293
+ if (Math.abs(d) > 1e-12) return d;
3294
+ const ra = Number(keep.get(a)._raw ?? keep.get(a).score) || 0;
3295
+ const rb = Number(keep.get(b)._raw ?? keep.get(b).score) || 0;
3296
+ return rb - ra;
3297
+ });
3298
+ // [macro-fusion 0.5.0 · P1] 「只补位」的硬边界:合并完如果**名次一个字都没变**,就把第一遍原样
3299
+ // 返回,连分数都不动。理由有两层:① 用户看得见的是分数,桥没改变结论时不该让数字漂
3300
+ // (probe-cost 的快照 C5 就是这么守的:只许变快,不许变答案);② 顺序没变时合并纯属白算。
3301
+ const merged = ordered.slice(0, Number.isFinite(k) && k > 0 ? k : ordered.length).map((id) => keep.get(id));
3302
+ const sameOrder = merged.length === first.length && merged.every((h, i) => String(h.id) === String(first[i].id));
3303
+ if (sameOrder) return first;
3304
+ return merged;
3305
+ }
3306
+ function q0ToksOf(query) {
3307
+ const out = [];
3308
+ for (const t of tokenize(String(query ?? ""))) if (t.length >= 2) out.push(t);
3309
+ return out;
3310
+ }
3150
3311
  function keywordHitScore(query, docs, opts = {}) {
3151
3312
  const k = opts.k ?? 2;
3152
3313
  const now = opts.now === void 0 ? Date.now() : opts.now;
@@ -9042,14 +9203,16 @@ function persistWindowIndex() {
9042
9203
  // 第一次调用顺手把预热排进后台(不 await),等向量攒齐了下一问自然变准;
9043
9204
  // 预热失败也不影响本次结果——这条路上任何一环坏掉,退回去的答案都必须是词法原样。
9044
9205
  let denseWarmPromise = null;
9206
+ // [macro-fusion 0.5.0 · P1] 词法这一路换成 searchAdaptive:听不懂时再按「碎片 → 整词」的桥听一遍。
9207
+ // 稠密这一路只要接上了就用它的融合结果(FUSION 已经做了词法+稠密的取舍),接不上则整条路走词法。
9045
9208
  async function rankForSearch(query, docs, opts = {}) {
9046
- if (denseDisabled()) return search(query, docs, opts);
9209
+ if (denseDisabled()) return searchAdaptive(query, docs, opts);
9047
9210
  let fused = null;
9048
9211
  try { fused = await searchHybrid(query, docs, opts); } catch { fused = null; }
9049
9212
  if (denseWarmPromise === null && denseRt.state !== 'off') {
9050
9213
  denseWarmPromise = denseWarm(docs, opts).catch(() => null);
9051
9214
  }
9052
- return fused ?? search(query, docs, opts);
9215
+ return fused ?? searchAdaptive(query, docs, opts);
9053
9216
  }
9054
9217
 
9055
9218
  // ═══════════════════════ [macro-fusion 0.2.154] 稠密向量:可选的一路 ═══════════════════════
@@ -9740,6 +9903,7 @@ export {
9740
9903
  scanTurn,
9741
9904
  search,
9742
9905
  searchHybrid,
9906
+ searchAdaptive,
9743
9907
  indexSignature,
9744
9908
  searchIndexOf,
9745
9909
  searchIndexCacheInfo,