@furongjun1999/dsh-memory 0.9.7 → 0.9.9
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 +150 -662
- package/codebuddy/CODEBUDDY.md +337 -204
- package/docs/README.md +21 -0
- package/docs/discipline/harnesses.yaml +11 -3
- package/docs/discipline/templates/compact.txt.tmpl +20 -18
- package/docs/discipline/templates/full.md.tmpl +63 -61
- package/docs/discipline/templates/rules.mdc.tmpl +5 -3
- package/docs/discipline/templates/skill.md.tmpl +25 -23
- package/docs/discipline/templates/spec.txt.tmpl +1 -1
- package/docs/discipline/templates/zcode-user.md.tmpl +1 -1
- package/docs//350/247/204/350/214/203/AI/347/274/226/347/250/213/351/200/232/347/224/250/350/247/204/350/214/203.md +4 -0
- package/dsh/cordis.yml.example +2 -2
- package/lib/hooks.d.ts +11 -1
- package/lib/hooks.js +59 -4
- package/lib/index.d.ts +1 -1
- package/lib/index.js +11 -5
- package/lib/init.js +28 -4
- package/lib/lib/hook_audit.d.ts +3 -0
- package/lib/lib/hook_audit.js +63 -0
- package/md_cg/autonomy.py +1 -1
- package/md_cg/config_registry.py +329 -329
- package/md_cg/config_registry_bulk.py +483 -482
- package/md_cg/config_render.py +27 -0
- package/md_cg/config_validate.py +456 -455
- package/md_cg/conflict_surface.py +127 -0
- package/md_cg/mcp_server.py +5324 -5227
- package/md_cg/mdcg.py +12 -1
- package/md_cg/mdcos.py +7159 -7108
- package/md_cg/pooling.py +487 -485
- package/md_cg/qmd_llm.py +334 -334
- package/md_cg/reach.py +10 -4
- package/md_cg/sleep.py +2 -2
- package/md_cg/sustain.py +13 -4
- package/md_cg/test_auto_defaults.py +463 -463
- package/md_cg/test_autonomy_emotion.py +328 -328
- package/md_cg/test_bm25_default.py +56 -0
- package/md_cg/test_c3_transient_read_negative.py +7 -3
- package/md_cg/test_conflict_surface.py +75 -0
- package/md_cg/test_conflict_value_untrusted.py +63 -0
- package/md_cg/test_exact_text_cache.py +194 -191
- package/md_cg/test_heartbeat_ledger.py +563 -557
- package/md_cg/test_hotcache_tool.py +121 -0
- package/md_cg/test_issue274_read_node_id_none.py +364 -341
- package/md_cg/test_issue561_pending_review.py +89 -5
- package/md_cg/test_issue578_service_info_gate.py +264 -0
- package/md_cg/test_n184_keys_concurrent_provision.py +1 -1
- package/md_cg/test_p3_legacy_closure.py +441 -438
- package/md_cg/test_p43_pooling.py +419 -412
- package/md_cg/test_reach.py +5 -1
- package/md_cg/test_reach_exits.py +54 -0
- package/md_cg/test_reach_single_char.py +74 -0
- package/md_cg/test_read_scope_b27.py +2 -2
- package/md_cg/test_search_bm25_default.py +60 -0
- package/md_cg/test_security_audit_v21.py +249 -249
- package/md_cg/test_sleep_p1.py +1032 -1032
- package/md_cg/test_sustain_bad_stamp.py +178 -0
- package/md_cg/test_untrusted_audit.py +55 -0
- package/md_cg/test_untrusted_classifier.py +42 -0
- package/md_cg/test_untrusted_enforcement.py +66 -0
- package/md_cg/untrusted.py +45 -0
- package/md_cg/untrusted_audit.py +87 -0
- package/md_cg/value_conflict.py +71 -0
- package/package.json +7 -7
- package/src/hooks.ts +986 -932
- package/src/index.ts +20 -14
- package/src/init.ts +21 -4
- package/src/lib/hook_audit.ts +334 -282
- package/zcode/AGENTS.md +337 -204
|
@@ -1,412 +1,419 @@
|
|
|
1
|
-
# -*- coding: utf-8 -*-
|
|
2
|
-
"""§七 · 召回分池与降权(P43 设计态验收)。
|
|
3
|
-
|
|
4
|
-
对照 `docs/mdcg/认知图_G4-G8缺口裁定单_v0.1.md` §七:索引/产物类节点(`code_`/`doc_`)
|
|
5
|
-
词面更易命中,在 `GLOBAL_CAP` 单条截断点**先把知识节点挤掉**。本项把截断额度
|
|
6
|
-
**显式分池**(不是抬高额度),并立四条纪律。
|
|
7
|
-
|
|
8
|
-
覆盖:
|
|
9
|
-
(1) 契约与默认关闭:catalog/resolve/from_env,`pools=None` 即原行为;
|
|
10
|
-
(2) 硬约束一 · 不隐性提高上限:cap_ratio 之和必须 == 1.0(坏表一律 PoolError);
|
|
11
|
-
(3) 额度守恒:caps/allocate/take 的总账恒 == total(多组 total 实测);
|
|
12
|
-
(4) 默认关闭 ≡ 原行为:平截逐位一致、权重恒 1.0、meta 不伪造池账;
|
|
13
|
-
(5) 归池确定性:id 前缀 / 标签 / 负层三类归池,重复调用同结果;
|
|
14
|
-
(6) 分池生效:小额度下索引类不再吃满截断额度(前后张数 + 池账 `cands/lost` + 结果构成口径对比);
|
|
15
|
-
(7) 空池回流:未用额度回流前序池,`taken` 如实回报,总账不增;
|
|
16
|
-
(8) 硬约束二 · 降权显式可复算:命中分 == 原分 × 表内 weight;
|
|
17
|
-
(9) 硬约束四 · 口径先冻结 + **口径敏感性自检**:P95/中位/截断率/截断损失 + `index_share`/`pool_lost_rate`;
|
|
18
|
-
并断言「成本口径不敏感(delta 恒 0、被标 insensitive)但结果构成口径敏感」——量具先于测量;
|
|
19
|
-
(10) 复测只读:measure/compare 前后**全库文件逐字节不变**;
|
|
20
|
-
(11) 同口径可比:compare 前(关)/后(开) 同查询集 + delta + 副作用归因;
|
|
21
|
-
(12) 坏表不静默降级:非法权重表抛错,而不是当作「关闭」悄悄跑完;
|
|
22
|
-
(13) MCP 接入:mdcg_search 透传 pools + sustain pooling/pool_bench/pool_compare;
|
|
23
|
-
(14) 未知 action 不静默成功。
|
|
24
|
-
|
|
25
|
-
独立临时根,重跑 ≡ 首跑。运行:python -m md_cg.test_p43_pooling
|
|
26
|
-
"""
|
|
27
|
-
from __future__ import annotations
|
|
28
|
-
|
|
29
|
-
import hashlib
|
|
30
|
-
import os
|
|
31
|
-
import shutil
|
|
32
|
-
import tempfile
|
|
33
|
-
|
|
34
|
-
from . import pooling as PL
|
|
35
|
-
from .mdcos import MdCGOS
|
|
36
|
-
from .mcp_server import KERNEL_TOOLS, call_tool
|
|
37
|
-
import md_cg.mdcg as M
|
|
38
|
-
import md_cg.mdcos as MO
|
|
39
|
-
|
|
40
|
-
PASS = FAIL = 0
|
|
41
|
-
FAILS = []
|
|
42
|
-
|
|
43
|
-
BODY = "召回截断 索引 分池 内容"
|
|
44
|
-
# 多词查询:索引类含全部查询词、知识类缺「分池」→ 相关度有**区分度**。
|
|
45
|
-
# 原语料下 16 条分数全等(覆盖度口径),截断谁入榜只能由传入序决定——而传入序
|
|
46
|
-
# 本身不确定(目录枚举 + 并行 prefetch),断言 `off=6` 实为顺序抽签的产物。
|
|
47
|
-
QUERY = "召回截断 分池"
|
|
48
|
-
KBODY = "召回截断 索引 内容"
|
|
49
|
-
|
|
50
|
-
|
|
51
|
-
def ok(cond, label):
|
|
52
|
-
global PASS, FAIL
|
|
53
|
-
if cond:
|
|
54
|
-
PASS += 1
|
|
55
|
-
print(f" [PASS] {label}")
|
|
56
|
-
else:
|
|
57
|
-
FAIL += 1
|
|
58
|
-
FAILS.append(label)
|
|
59
|
-
print(f" [FAIL] {label}")
|
|
60
|
-
|
|
61
|
-
|
|
62
|
-
def _snapshot(root):
|
|
63
|
-
"""全库文件 → sha256(用于「巡检只读」断言)。"""
|
|
64
|
-
snap = {}
|
|
65
|
-
for dp, _dn, fns in os.walk(root):
|
|
66
|
-
for fn in fns:
|
|
67
|
-
p = os.path.join(dp, fn)
|
|
68
|
-
rel = os.path.relpath(p, root).replace("\\", "/")
|
|
69
|
-
try:
|
|
70
|
-
with open(p, "rb") as f:
|
|
71
|
-
snap[rel] = hashlib.sha256(f.read()).hexdigest()
|
|
72
|
-
except OSError:
|
|
73
|
-
snap[rel] = "<unreadable>"
|
|
74
|
-
return snap
|
|
75
|
-
|
|
76
|
-
|
|
77
|
-
def _mk(root):
|
|
78
|
-
"""6 个索引类(code_/doc_)+ 10 个知识类。
|
|
79
|
-
|
|
80
|
-
§七 的真实机制是「索引/产物类节点**词面命中率更高**」(正文短、查询词占比大),
|
|
81
|
-
故索引类正文短、知识类正文长(含背景说明),使索引类相似度**确实**高于知识类
|
|
82
|
-
——挤占由相关度驱动,不依赖写入顺序(截断依据已改为相关度,见 `cut_by_relevance`)。
|
|
83
|
-
"""
|
|
84
|
-
cg = MdCGOS(root, actor="test")
|
|
85
|
-
for i in range(4):
|
|
86
|
-
cg.add(f"code_{i}", f"# 功能名:索引条目 {i}\n# 生效条件:条件 I\n\n{BODY} {i}\n",
|
|
87
|
-
layer="knowledge", tags=["index"])
|
|
88
|
-
for i in range(2):
|
|
89
|
-
cg.add(f"doc_{i}", f"# 功能名:文档索引 {i}\n# 生效条件:条件 D\n\n{BODY} {i}\n",
|
|
90
|
-
layer="knowledge", tags=["index"])
|
|
91
|
-
for i in range(10):
|
|
92
|
-
cg.add(f"kp_{i}",
|
|
93
|
-
f"# 功能名:知识 {i}\n# 生效条件:条件 K\n\n{KBODY} {i}\n"
|
|
94
|
-
f"备注:本条为知识类条目,含背景说明、推理链与引用出处,正文较长,"
|
|
95
|
-
f"查询词在全文中的占比因此显著低于索引类条目。\n",
|
|
96
|
-
layer="knowledge")
|
|
97
|
-
cg.add("n_rej", f"# 功能名:被否决\n# 生效条件:条件 R\n\n{BODY} 否\n",
|
|
98
|
-
layer="rejected")
|
|
99
|
-
cg.flush()
|
|
100
|
-
return cg
|
|
101
|
-
|
|
102
|
-
|
|
103
|
-
def _patch_cap(value):
|
|
104
|
-
"""把全局额度换成小值以逼出截断点;返回还原函数。"""
|
|
105
|
-
old = (M.GLOBAL_CAP, MO.GLOBAL_CAP)
|
|
106
|
-
M.GLOBAL_CAP = MO.GLOBAL_CAP = value
|
|
107
|
-
return lambda: (setattr(M, "GLOBAL_CAP", old[0]),
|
|
108
|
-
setattr(MO, "GLOBAL_CAP", old[1]))
|
|
109
|
-
|
|
110
|
-
|
|
111
|
-
def _count(res, prefix):
|
|
112
|
-
return sum(1 for r in res if r[0]["id"].startswith(prefix))
|
|
113
|
-
|
|
114
|
-
|
|
115
|
-
def main():
|
|
116
|
-
print("md 认知图 P43 验收 · §七 召回分池与降权(不隐性提高上限)")
|
|
117
|
-
print("=" * 70)
|
|
118
|
-
|
|
119
|
-
|
|
120
|
-
|
|
121
|
-
|
|
122
|
-
|
|
123
|
-
|
|
124
|
-
|
|
125
|
-
|
|
126
|
-
|
|
127
|
-
|
|
128
|
-
|
|
129
|
-
|
|
130
|
-
ok(
|
|
131
|
-
|
|
132
|
-
ok(
|
|
133
|
-
|
|
134
|
-
|
|
135
|
-
ok(PL.
|
|
136
|
-
os.environ
|
|
137
|
-
ok(PL.from_env(None) is True, "(1)
|
|
138
|
-
|
|
139
|
-
|
|
140
|
-
|
|
141
|
-
|
|
142
|
-
|
|
143
|
-
|
|
144
|
-
|
|
145
|
-
|
|
146
|
-
|
|
147
|
-
|
|
148
|
-
|
|
149
|
-
|
|
150
|
-
|
|
151
|
-
"
|
|
152
|
-
|
|
153
|
-
"
|
|
154
|
-
|
|
155
|
-
|
|
156
|
-
|
|
157
|
-
|
|
158
|
-
|
|
159
|
-
|
|
160
|
-
|
|
161
|
-
|
|
162
|
-
|
|
163
|
-
|
|
164
|
-
|
|
165
|
-
|
|
166
|
-
|
|
167
|
-
|
|
168
|
-
|
|
169
|
-
|
|
170
|
-
|
|
171
|
-
|
|
172
|
-
|
|
173
|
-
|
|
174
|
-
ok(
|
|
175
|
-
ok(
|
|
176
|
-
|
|
177
|
-
|
|
178
|
-
|
|
179
|
-
|
|
180
|
-
|
|
181
|
-
|
|
182
|
-
ok(
|
|
183
|
-
ok(
|
|
184
|
-
|
|
185
|
-
ok(meta_off["
|
|
186
|
-
|
|
187
|
-
|
|
188
|
-
|
|
189
|
-
|
|
190
|
-
|
|
191
|
-
|
|
192
|
-
|
|
193
|
-
ok(PL.pool_of("
|
|
194
|
-
|
|
195
|
-
ok(PL.pool_of("
|
|
196
|
-
ok(PL.pool_of("
|
|
197
|
-
"(5)
|
|
198
|
-
ok(
|
|
199
|
-
|
|
200
|
-
|
|
201
|
-
|
|
202
|
-
|
|
203
|
-
|
|
204
|
-
|
|
205
|
-
|
|
206
|
-
|
|
207
|
-
|
|
208
|
-
|
|
209
|
-
|
|
210
|
-
|
|
211
|
-
|
|
212
|
-
|
|
213
|
-
|
|
214
|
-
|
|
215
|
-
|
|
216
|
-
|
|
217
|
-
|
|
218
|
-
|
|
219
|
-
|
|
220
|
-
ok(
|
|
221
|
-
|
|
222
|
-
f"(
|
|
223
|
-
ok(
|
|
224
|
-
|
|
225
|
-
|
|
226
|
-
|
|
227
|
-
|
|
228
|
-
|
|
229
|
-
|
|
230
|
-
|
|
231
|
-
|
|
232
|
-
|
|
233
|
-
|
|
234
|
-
|
|
235
|
-
|
|
236
|
-
|
|
237
|
-
|
|
238
|
-
|
|
239
|
-
|
|
240
|
-
|
|
241
|
-
ok(
|
|
242
|
-
|
|
243
|
-
|
|
244
|
-
|
|
245
|
-
|
|
246
|
-
|
|
247
|
-
|
|
248
|
-
|
|
249
|
-
#
|
|
250
|
-
|
|
251
|
-
|
|
252
|
-
|
|
253
|
-
|
|
254
|
-
|
|
255
|
-
|
|
256
|
-
|
|
257
|
-
|
|
258
|
-
|
|
259
|
-
|
|
260
|
-
|
|
261
|
-
|
|
262
|
-
|
|
263
|
-
#
|
|
264
|
-
|
|
265
|
-
|
|
266
|
-
|
|
267
|
-
|
|
268
|
-
|
|
269
|
-
|
|
270
|
-
|
|
271
|
-
|
|
272
|
-
|
|
273
|
-
|
|
274
|
-
|
|
275
|
-
|
|
276
|
-
|
|
277
|
-
|
|
278
|
-
|
|
279
|
-
|
|
280
|
-
|
|
281
|
-
|
|
282
|
-
|
|
283
|
-
|
|
284
|
-
|
|
285
|
-
|
|
286
|
-
|
|
287
|
-
|
|
288
|
-
|
|
289
|
-
|
|
290
|
-
|
|
291
|
-
|
|
292
|
-
|
|
293
|
-
|
|
294
|
-
|
|
295
|
-
|
|
296
|
-
|
|
297
|
-
|
|
298
|
-
|
|
299
|
-
ok(
|
|
300
|
-
f"(8)
|
|
301
|
-
|
|
302
|
-
|
|
303
|
-
|
|
304
|
-
|
|
305
|
-
|
|
306
|
-
|
|
307
|
-
|
|
308
|
-
|
|
309
|
-
|
|
310
|
-
|
|
311
|
-
|
|
312
|
-
|
|
313
|
-
|
|
314
|
-
|
|
315
|
-
|
|
316
|
-
|
|
317
|
-
|
|
318
|
-
|
|
319
|
-
ok(
|
|
320
|
-
|
|
321
|
-
"(11)
|
|
322
|
-
ok(
|
|
323
|
-
|
|
324
|
-
|
|
325
|
-
ok(
|
|
326
|
-
|
|
327
|
-
|
|
328
|
-
|
|
329
|
-
|
|
330
|
-
|
|
331
|
-
|
|
332
|
-
|
|
333
|
-
|
|
334
|
-
|
|
335
|
-
|
|
336
|
-
|
|
337
|
-
|
|
338
|
-
|
|
339
|
-
f"
|
|
340
|
-
ok(
|
|
341
|
-
f"(9)
|
|
342
|
-
|
|
343
|
-
|
|
344
|
-
"(9)
|
|
345
|
-
|
|
346
|
-
|
|
347
|
-
|
|
348
|
-
|
|
349
|
-
|
|
350
|
-
|
|
351
|
-
|
|
352
|
-
|
|
353
|
-
|
|
354
|
-
|
|
355
|
-
|
|
356
|
-
|
|
357
|
-
|
|
358
|
-
|
|
359
|
-
|
|
360
|
-
|
|
361
|
-
|
|
362
|
-
|
|
363
|
-
|
|
364
|
-
|
|
365
|
-
|
|
366
|
-
|
|
367
|
-
|
|
368
|
-
|
|
369
|
-
|
|
370
|
-
|
|
371
|
-
|
|
372
|
-
|
|
373
|
-
|
|
374
|
-
|
|
375
|
-
|
|
376
|
-
|
|
377
|
-
|
|
378
|
-
ok(
|
|
379
|
-
|
|
380
|
-
|
|
381
|
-
|
|
382
|
-
ok("pools"
|
|
383
|
-
|
|
384
|
-
|
|
385
|
-
ok("
|
|
386
|
-
|
|
387
|
-
|
|
388
|
-
|
|
389
|
-
|
|
390
|
-
|
|
391
|
-
|
|
392
|
-
|
|
393
|
-
|
|
394
|
-
|
|
395
|
-
|
|
396
|
-
|
|
397
|
-
|
|
398
|
-
|
|
399
|
-
|
|
400
|
-
|
|
401
|
-
|
|
402
|
-
|
|
403
|
-
|
|
404
|
-
|
|
405
|
-
|
|
406
|
-
|
|
407
|
-
|
|
408
|
-
|
|
409
|
-
|
|
410
|
-
|
|
411
|
-
|
|
412
|
-
|
|
1
|
+
# -*- coding: utf-8 -*-
|
|
2
|
+
"""§七 · 召回分池与降权(P43 设计态验收)。
|
|
3
|
+
|
|
4
|
+
对照 `docs/mdcg/认知图_G4-G8缺口裁定单_v0.1.md` §七:索引/产物类节点(`code_`/`doc_`)
|
|
5
|
+
词面更易命中,在 `GLOBAL_CAP` 单条截断点**先把知识节点挤掉**。本项把截断额度
|
|
6
|
+
**显式分池**(不是抬高额度),并立四条纪律。
|
|
7
|
+
|
|
8
|
+
覆盖:
|
|
9
|
+
(1) 契约与默认关闭:catalog/resolve/from_env,`pools=None` 即原行为;
|
|
10
|
+
(2) 硬约束一 · 不隐性提高上限:cap_ratio 之和必须 == 1.0(坏表一律 PoolError);
|
|
11
|
+
(3) 额度守恒:caps/allocate/take 的总账恒 == total(多组 total 实测);
|
|
12
|
+
(4) 默认关闭 ≡ 原行为:平截逐位一致、权重恒 1.0、meta 不伪造池账;
|
|
13
|
+
(5) 归池确定性:id 前缀 / 标签 / 负层三类归池,重复调用同结果;
|
|
14
|
+
(6) 分池生效:小额度下索引类不再吃满截断额度(前后张数 + 池账 `cands/lost` + 结果构成口径对比);
|
|
15
|
+
(7) 空池回流:未用额度回流前序池,`taken` 如实回报,总账不增;
|
|
16
|
+
(8) 硬约束二 · 降权显式可复算:命中分 == 原分 × 表内 weight;
|
|
17
|
+
(9) 硬约束四 · 口径先冻结 + **口径敏感性自检**:P95/中位/截断率/截断损失 + `index_share`/`pool_lost_rate`;
|
|
18
|
+
并断言「成本口径不敏感(delta 恒 0、被标 insensitive)但结果构成口径敏感」——量具先于测量;
|
|
19
|
+
(10) 复测只读:measure/compare 前后**全库文件逐字节不变**;
|
|
20
|
+
(11) 同口径可比:compare 前(关)/后(开) 同查询集 + delta + 副作用归因;
|
|
21
|
+
(12) 坏表不静默降级:非法权重表抛错,而不是当作「关闭」悄悄跑完;
|
|
22
|
+
(13) MCP 接入:mdcg_search 透传 pools + sustain pooling/pool_bench/pool_compare;
|
|
23
|
+
(14) 未知 action 不静默成功。
|
|
24
|
+
|
|
25
|
+
独立临时根,重跑 ≡ 首跑。运行:python -m md_cg.test_p43_pooling
|
|
26
|
+
"""
|
|
27
|
+
from __future__ import annotations
|
|
28
|
+
|
|
29
|
+
import hashlib
|
|
30
|
+
import os
|
|
31
|
+
import shutil
|
|
32
|
+
import tempfile
|
|
33
|
+
|
|
34
|
+
from . import pooling as PL
|
|
35
|
+
from .mdcos import MdCGOS
|
|
36
|
+
from .mcp_server import KERNEL_TOOLS, call_tool
|
|
37
|
+
import md_cg.mdcg as M
|
|
38
|
+
import md_cg.mdcos as MO
|
|
39
|
+
|
|
40
|
+
PASS = FAIL = 0
|
|
41
|
+
FAILS = []
|
|
42
|
+
|
|
43
|
+
BODY = "召回截断 索引 分池 内容"
|
|
44
|
+
# 多词查询:索引类含全部查询词、知识类缺「分池」→ 相关度有**区分度**。
|
|
45
|
+
# 原语料下 16 条分数全等(覆盖度口径),截断谁入榜只能由传入序决定——而传入序
|
|
46
|
+
# 本身不确定(目录枚举 + 并行 prefetch),断言 `off=6` 实为顺序抽签的产物。
|
|
47
|
+
QUERY = "召回截断 分池"
|
|
48
|
+
KBODY = "召回截断 索引 内容"
|
|
49
|
+
|
|
50
|
+
|
|
51
|
+
def ok(cond, label):
|
|
52
|
+
global PASS, FAIL
|
|
53
|
+
if cond:
|
|
54
|
+
PASS += 1
|
|
55
|
+
print(f" [PASS] {label}")
|
|
56
|
+
else:
|
|
57
|
+
FAIL += 1
|
|
58
|
+
FAILS.append(label)
|
|
59
|
+
print(f" [FAIL] {label}")
|
|
60
|
+
|
|
61
|
+
|
|
62
|
+
def _snapshot(root):
|
|
63
|
+
"""全库文件 → sha256(用于「巡检只读」断言)。"""
|
|
64
|
+
snap = {}
|
|
65
|
+
for dp, _dn, fns in os.walk(root):
|
|
66
|
+
for fn in fns:
|
|
67
|
+
p = os.path.join(dp, fn)
|
|
68
|
+
rel = os.path.relpath(p, root).replace("\\", "/")
|
|
69
|
+
try:
|
|
70
|
+
with open(p, "rb") as f:
|
|
71
|
+
snap[rel] = hashlib.sha256(f.read()).hexdigest()
|
|
72
|
+
except OSError:
|
|
73
|
+
snap[rel] = "<unreadable>"
|
|
74
|
+
return snap
|
|
75
|
+
|
|
76
|
+
|
|
77
|
+
def _mk(root):
|
|
78
|
+
"""6 个索引类(code_/doc_)+ 10 个知识类。
|
|
79
|
+
|
|
80
|
+
§七 的真实机制是「索引/产物类节点**词面命中率更高**」(正文短、查询词占比大),
|
|
81
|
+
故索引类正文短、知识类正文长(含背景说明),使索引类相似度**确实**高于知识类
|
|
82
|
+
——挤占由相关度驱动,不依赖写入顺序(截断依据已改为相关度,见 `cut_by_relevance`)。
|
|
83
|
+
"""
|
|
84
|
+
cg = MdCGOS(root, actor="test")
|
|
85
|
+
for i in range(4):
|
|
86
|
+
cg.add(f"code_{i}", f"# 功能名:索引条目 {i}\n# 生效条件:条件 I\n\n{BODY} {i}\n",
|
|
87
|
+
layer="knowledge", tags=["index"])
|
|
88
|
+
for i in range(2):
|
|
89
|
+
cg.add(f"doc_{i}", f"# 功能名:文档索引 {i}\n# 生效条件:条件 D\n\n{BODY} {i}\n",
|
|
90
|
+
layer="knowledge", tags=["index"])
|
|
91
|
+
for i in range(10):
|
|
92
|
+
cg.add(f"kp_{i}",
|
|
93
|
+
f"# 功能名:知识 {i}\n# 生效条件:条件 K\n\n{KBODY} {i}\n"
|
|
94
|
+
f"备注:本条为知识类条目,含背景说明、推理链与引用出处,正文较长,"
|
|
95
|
+
f"查询词在全文中的占比因此显著低于索引类条目。\n",
|
|
96
|
+
layer="knowledge")
|
|
97
|
+
cg.add("n_rej", f"# 功能名:被否决\n# 生效条件:条件 R\n\n{BODY} 否\n",
|
|
98
|
+
layer="rejected")
|
|
99
|
+
cg.flush()
|
|
100
|
+
return cg
|
|
101
|
+
|
|
102
|
+
|
|
103
|
+
def _patch_cap(value):
|
|
104
|
+
"""把全局额度换成小值以逼出截断点;返回还原函数。"""
|
|
105
|
+
old = (M.GLOBAL_CAP, MO.GLOBAL_CAP)
|
|
106
|
+
M.GLOBAL_CAP = MO.GLOBAL_CAP = value
|
|
107
|
+
return lambda: (setattr(M, "GLOBAL_CAP", old[0]),
|
|
108
|
+
setattr(MO, "GLOBAL_CAP", old[1]))
|
|
109
|
+
|
|
110
|
+
|
|
111
|
+
def _count(res, prefix):
|
|
112
|
+
return sum(1 for r in res if r[0]["id"].startswith(prefix))
|
|
113
|
+
|
|
114
|
+
|
|
115
|
+
def main():
|
|
116
|
+
print("md 认知图 P43 验收 · §七 召回分池与降权(不隐性提高上限)")
|
|
117
|
+
print("=" * 70)
|
|
118
|
+
# 2026-10-21 使用者裁定:分池默认开 ⇒ 本守卫的「关闭态」基线须显式关
|
|
119
|
+
_old_switch = os.environ.get(PL.ENV_SWITCH)
|
|
120
|
+
os.environ[PL.ENV_SWITCH] = "0"
|
|
121
|
+
root = None
|
|
122
|
+
try:
|
|
123
|
+
root = tempfile.mkdtemp(prefix="mdcg_p43_")
|
|
124
|
+
cg = _mk(root)
|
|
125
|
+
cfg = PL.resolve(True)
|
|
126
|
+
|
|
127
|
+
# ============================================= (1) 契约与默认开启(显式关=反向腿)
|
|
128
|
+
print("\n(1) 契约与默认关闭")
|
|
129
|
+
cat = PL.catalog()
|
|
130
|
+
ok(cat["pools"] == ["knowledge", "index", "negative"], "(1) catalog 三池齐备")
|
|
131
|
+
ok("on" in cat["default"], "(1) catalog 明示默认开启(2026-10-21 裁定)")
|
|
132
|
+
ok(cat["cap_ratio_sum"] == 1.0, "(1) 内置表额度之和为 1.0")
|
|
133
|
+
ok(PL.resolve(None) is None and PL.resolve(False) is None,
|
|
134
|
+
"(1) resolve(None/False) → 关闭")
|
|
135
|
+
ok(set(PL.resolve(True)) == set(PL.POOL_ORDER), "(1) resolve(True) → 三池")
|
|
136
|
+
old_env = os.environ.pop(PL.ENV_SWITCH, None)
|
|
137
|
+
ok(PL.from_env(None) is True, "(1) 环境变量未设 → 启用(默认开)")
|
|
138
|
+
ok(PL.from_env(cfg) is cfg, "(1) 显式传表优先于环境变量")
|
|
139
|
+
os.environ[PL.ENV_SWITCH] = "1"
|
|
140
|
+
ok(PL.from_env(None) is True, "(1) 环境变量=1 → 启用内置表")
|
|
141
|
+
if old_env is None:
|
|
142
|
+
os.environ.pop(PL.ENV_SWITCH, None)
|
|
143
|
+
else:
|
|
144
|
+
os.environ[PL.ENV_SWITCH] = old_env
|
|
145
|
+
|
|
146
|
+
# ===================================== (2) 硬约束一 · 不隐性提高上限
|
|
147
|
+
print("\n(2) 硬约束一 · 额度之和不为一 → 拒绝")
|
|
148
|
+
bad_cases = {
|
|
149
|
+
"和 0.8": {"knowledge": {"cap_ratio": 0.5}, "index": {"cap_ratio": 0.2},
|
|
150
|
+
"negative": {"cap_ratio": 0.1}},
|
|
151
|
+
"和 1.1": {"knowledge": {"cap_ratio": 0.8}, "index": {"cap_ratio": 0.2},
|
|
152
|
+
"negative": {"cap_ratio": 0.1}},
|
|
153
|
+
"缺池": {"knowledge": {"cap_ratio": 1.0}, "index": {"cap_ratio": 0.0}},
|
|
154
|
+
"比率为 0": {"knowledge": {"cap_ratio": 1.0}, "index": {"cap_ratio": 0.0},
|
|
155
|
+
"negative": {"cap_ratio": 0.0}},
|
|
156
|
+
"权重非正": {"knowledge": {"cap_ratio": 1.0, "weight": 0},
|
|
157
|
+
"index": {"cap_ratio": 0.0}, "negative": {"cap_ratio": 0.0}},
|
|
158
|
+
}
|
|
159
|
+
raised = 0
|
|
160
|
+
for label, tbl in bad_cases.items():
|
|
161
|
+
try:
|
|
162
|
+
PL.validate(tbl)
|
|
163
|
+
except PL.PoolError:
|
|
164
|
+
raised += 1
|
|
165
|
+
ok(raised == len(bad_cases), f"(2) {len(bad_cases)} 类坏表全部 PoolError")
|
|
166
|
+
ok(PL.validate(PL.WEIGHTS)["index"]["weight"] == 0.6, "(2) 合法表原样通过")
|
|
167
|
+
ok(abs(sum(PL.WEIGHTS[p]["cap_ratio"] for p in PL.POOL_ORDER) - 1.0) < 1e-9,
|
|
168
|
+
"(2) 内置表额度之和恰为 1.0")
|
|
169
|
+
|
|
170
|
+
# ============================================== (3) 额度守恒
|
|
171
|
+
print("\n(3) 额度守恒(总账恒 == total)")
|
|
172
|
+
totals_ok = all(sum(PL.caps(t, cfg).values()) == t
|
|
173
|
+
for t in (3, 4, 8, 20, 100, 500))
|
|
174
|
+
ok(totals_ok, "(3) caps 各池之和恒等于 total(3/4/8/20/100/500)")
|
|
175
|
+
ok(PL.plan(20, True)["cap_sum"] == 20, "(3) plan.cap_sum 与 total 一致")
|
|
176
|
+
docs = [(f"d{i}", {}) for i in range(30)]
|
|
177
|
+
ok(len(PL.allocate(docs, 7, pools=True)) <= 7, "(3) allocate 不超额度")
|
|
178
|
+
ok(len(PL.allocate(docs, 100, pools=True)) <= 30, "(3) 候选不足时不凭空造条目")
|
|
179
|
+
|
|
180
|
+
# ============================================ (4) 默认关闭 ≡ 原行为
|
|
181
|
+
print("\n(4) 默认关闭 ≡ 原行为")
|
|
182
|
+
ok(PL.allocate(docs, 5, pools=None) == docs[:5], "(4) 关闭态逐位等于平截")
|
|
183
|
+
ok(PL.weight_of("code_x", {}, None) == 1.0, "(4) 关闭态权重恒 1.0")
|
|
184
|
+
_res, meta_off = cg.search(QUERY, k=20, record=False)
|
|
185
|
+
ok(meta_off["pools"]["enabled"] is False, "(4) 关闭态 meta 如实报 enabled=False")
|
|
186
|
+
ok(not ({"taken", "cands", "lost"} & set(meta_off["pools"])),
|
|
187
|
+
"(4) 关闭态不伪造池账 taken/cands/lost")
|
|
188
|
+
ok(meta_off["pre_cap"] >= 0 and meta_off["cap"] == M.GLOBAL_CAP,
|
|
189
|
+
"(4) 关闭态仍暴露 pre_cap/cap(口径不变)")
|
|
190
|
+
|
|
191
|
+
# ============================================== (5) 归池确定性
|
|
192
|
+
print("\n(5) 归池确定性")
|
|
193
|
+
ok(PL.pool_of("code_a") == "index", "(5) code_ 前缀 → 索引池")
|
|
194
|
+
ok(PL.pool_of("doc_b") == "index", "(5) doc_ 前缀 → 索引池")
|
|
195
|
+
ok(PL.pool_of("kp_c") == "knowledge", "(5) 普通 id → 知识池")
|
|
196
|
+
ok(PL.pool_of("n1", {"layer": "rejected"}) == "negative",
|
|
197
|
+
"(5) rejected 层 → 负记忆池(层优先于 id 前缀)")
|
|
198
|
+
ok(PL.pool_of("misc", {"tags": ["index"]}) == "index", "(5) tags 标记 → 索引池")
|
|
199
|
+
ok(PL.pool_of("code_x", {"layer": "unresolved"}) == "negative",
|
|
200
|
+
"(5) 层优先:code_ 落在 unresolved 仍归负池")
|
|
201
|
+
ok(len({PL.pool_of(f"kp_{i}") for i in range(50)}) == 1,
|
|
202
|
+
"(5) 批量归池无抖动")
|
|
203
|
+
|
|
204
|
+
# ============================================== (6) 分池生效
|
|
205
|
+
print("\n(6) 分池生效(小额度下不再被索引类吃满)")
|
|
206
|
+
restore = _patch_cap(8)
|
|
207
|
+
try:
|
|
208
|
+
off, m_off = cg.search(QUERY, k=20, record=False)
|
|
209
|
+
on, m_on = cg.search(QUERY, k=20, record=False, pools=True)
|
|
210
|
+
finally:
|
|
211
|
+
restore()
|
|
212
|
+
n_off, n_on = _count(off, "code_") + _count(off, "doc_"), \
|
|
213
|
+
_count(on, "code_") + _count(on, "doc_")
|
|
214
|
+
ok(n_off == 6 and n_on == 2,
|
|
215
|
+
f"(6) 索引类入榜数 6 → 2(实得 off={n_off} on={n_on})")
|
|
216
|
+
ok(_count(on, "kp_") == 6, f"(6) 知识类入榜数 2 → 6(实得 {_count(on, 'kp_')})")
|
|
217
|
+
# 注:_emit 会在额度之外追加减负覆盖条目(covered_neg),故入榜总长 = 额度数 + 覆盖数;
|
|
218
|
+
# 分池只重分配,判定口径应为「开关前后总长一致」。
|
|
219
|
+
cov = len(m_off["covered_neg"])
|
|
220
|
+
ok(len(off) == len(on) and (len(on) - cov) == 8,
|
|
221
|
+
f"(6) 总入榜条数不变(分池只重分配;实得 off={len(off)} "
|
|
222
|
+
f"on={len(on)} 覆盖={cov})")
|
|
223
|
+
ok(m_off["pre_cap"] == m_on["pre_cap"] == 16, "(6) 截断前候选数前后一致")
|
|
224
|
+
ok(m_on["pools"]["caps"] == {"knowledge": 5, "index": 2, "negative": 1},
|
|
225
|
+
f"(6) 计划额度可复算(实得 {m_on['pools']['caps']})")
|
|
226
|
+
ok(m_on["pools"].get("lost") == {"knowledge": 4, "index": 4, "negative": 0},
|
|
227
|
+
f"(6) 池账含被挤掉数 lost(实得 {m_on['pools'].get('lost')})")
|
|
228
|
+
ok(m_on["pools"].get("cands") == {"knowledge": 10, "index": 6, "negative": 0},
|
|
229
|
+
f"(6) 池账含各池候选数 cands(实得 {m_on['pools'].get('cands')})")
|
|
230
|
+
|
|
231
|
+
def _ishare(res):
|
|
232
|
+
ids = [r[0]["id"] for r in res]
|
|
233
|
+
return sum(1 for i in ids if PL.pool_of(i) == "index") / max(1, len(ids))
|
|
234
|
+
ok(_ishare(on) < _ishare(off),
|
|
235
|
+
f"(6) 结果构成口径对分池敏感(索引占比 {_ishare(off):.2f} → {_ishare(on):.2f})")
|
|
236
|
+
|
|
237
|
+
# ============================================== (7) 空池回流
|
|
238
|
+
print("\n(7) 空池回流(未用额度给前序池,总账不增)")
|
|
239
|
+
taken = m_on["pools"]["taken"]
|
|
240
|
+
ok(sum(taken.values()) == 8, f"(7) 各池实取之和 == 8(实得 {sum(taken.values())})")
|
|
241
|
+
ok(taken["negative"] == 0, "(7) 空池实取 0(负池无候选)")
|
|
242
|
+
ok(taken["knowledge"] == 6 > m_on["pools"]["caps"]["knowledge"],
|
|
243
|
+
"(7) 负池未用额度回流给知识池")
|
|
244
|
+
ok(m_on["pools"]["cap_sum"] == 8, "(7) 回流不改计划总账")
|
|
245
|
+
docs_idx = [(f"code_{i}", {}) for i in range(5)]
|
|
246
|
+
ok(len(PL.allocate(docs_idx, 4, pools=True)) == 4,
|
|
247
|
+
"(7) 单池候选充足时额度被用满")
|
|
248
|
+
|
|
249
|
+
# ============================================== (7b) 部分占用回流守恒
|
|
250
|
+
# (批次 20,issue #30②:旧实现回流只加不扣——「部分占用」形态下
|
|
251
|
+
# Σquota 超 total(14/10、27/20、40/30 实测),空池形态 (7) 踩不到;
|
|
252
|
+
# taken 一直正确(转移语义数学等价),纯审计数字修复。能红旧实现)
|
|
253
|
+
print("\n(7b) 部分占用回流守恒(issue #30②:回流后 Σquota 恰等于 total)")
|
|
254
|
+
docs30 = [(f"d{i:02d}", {"id": f"d{i:02d}"}) for i in range(30)]
|
|
255
|
+
for _t in (10, 20, 30, 50):
|
|
256
|
+
_pk, _rep = PL.cut_report(docs30, _t, pools=PL.from_env(True),
|
|
257
|
+
backflow=True)
|
|
258
|
+
_sq = sum(_rep["quota"].values())
|
|
259
|
+
_want = min(_t, 30) # 守恒式:候选充足=total;不足=候选总量
|
|
260
|
+
ok(_sq == _want, f"(7b) total={_t} 回流后 Σquota={_sq}=={ _want }"
|
|
261
|
+
f"(taken={sum(_rep['taken'].values())})")
|
|
262
|
+
|
|
263
|
+
# ============================================== (8) 降权可复算
|
|
264
|
+
print("\n(8) 硬约束二 · 降权显式可复算")
|
|
265
|
+
# 降权断言与打分口径解耦:以关闭分池(权重恒 1.0)时同一条目的分数为 base,
|
|
266
|
+
# 断言 final == base × weight。口径由 legacy 切 jaccard 后 base ≠ 1.0,
|
|
267
|
+
# 但「乘数可复算」这一被测语义不变。
|
|
268
|
+
base = {r[0]["id"]: r[1] for r in off}
|
|
269
|
+
sc = {r[0]["id"]: r[1] for r in on}
|
|
270
|
+
|
|
271
|
+
def _pick_idx(d):
|
|
272
|
+
"""挑一条「关闭态也有基础分」的索引类入榜条目。
|
|
273
|
+
|
|
274
|
+
截断依据改为相关度后,具体哪条索引入榜由分数序决定(不再是固定的
|
|
275
|
+
`code_0`——那正是按传入序截断时代的产物),故动态取。
|
|
276
|
+
"""
|
|
277
|
+
return next((i for i in d if PL.pool_of(i) == "index" and i in base), None)
|
|
278
|
+
|
|
279
|
+
iid = _pick_idx(sc)
|
|
280
|
+
ok(iid is not None, "(8) 分池态含索引类条目(额度保底生效)")
|
|
281
|
+
ok(iid is not None and abs(sc[iid] - base[iid] * 0.6) < 1e-9,
|
|
282
|
+
f"(8) 索引类命中分 == 基础分 × 0.6({iid}: base={base.get(iid, 0.0):.6f} → "
|
|
283
|
+
f"{sc.get(iid, float('nan')):.6f})")
|
|
284
|
+
# 知识类权重 1.0 → 命中分应与关闭态同源分一致。不硬编码编号:关闭态额度
|
|
285
|
+
# 被索引类占满,只余 2 条知识类入榜,与分池态取的 6 条未必有同编号交集
|
|
286
|
+
# (全同分下由稳定序决定),故按「关闭态知识分基准」比对。
|
|
287
|
+
base_kp = [v for k, v in base.items() if k.startswith("kp_")]
|
|
288
|
+
sc_kp = [v for k, v in sc.items() if k.startswith("kp_")]
|
|
289
|
+
ok(base_kp and sc_kp and all(abs(v - base_kp[0]) < 1e-9 for v in sc_kp),
|
|
290
|
+
f"(8) 知识类命中分不被削(权重 1.0;base={base_kp[:1]} → on={sc_kp[:2]})")
|
|
291
|
+
ok(PL.weight_of("code_x", {}, True) == PL.WEIGHTS["index"]["weight"],
|
|
292
|
+
"(8) weight_of 与表内系数一致")
|
|
293
|
+
alt = {"knowledge": {"cap_ratio": 0.5, "weight": 1.0},
|
|
294
|
+
"index": {"cap_ratio": 0.4, "weight": 0.3},
|
|
295
|
+
"negative": {"cap_ratio": 0.1, "weight": 0.5}}
|
|
296
|
+
on2, _m2 = cg.search(QUERY, k=20, record=False, pools=alt)
|
|
297
|
+
sc2 = {r[0]["id"]: r[1] for r in on2}
|
|
298
|
+
iid2 = _pick_idx(sc2)
|
|
299
|
+
ok(iid2 is not None and abs(sc2[iid2] - base[iid2] * 0.3) < 1e-9,
|
|
300
|
+
f"(8) 换表即换行为({iid2}: base×0.3={base.get(iid2, 0.0) * 0.3:.6f} → "
|
|
301
|
+
f"{sc2.get(iid2, float('nan')):.6f})")
|
|
302
|
+
ok(PL.caps(10, PL.resolve(alt)) == {"knowledge": 4, "index": 4, "negative": 2},
|
|
303
|
+
f"(8) 换表额度同步可复算(实得 {PL.caps(10, PL.resolve(alt))})")
|
|
304
|
+
|
|
305
|
+
# ========================================= (9)(10) 口径 + 只读
|
|
306
|
+
print("\n(9) 硬约束四 · 先冻结口径,再复测")
|
|
307
|
+
before = _snapshot(root)
|
|
308
|
+
meas = PL.measure(cg, [QUERY], k=5, pools=True)
|
|
309
|
+
for key in ("p95_scanned", "p50_scanned", "mean_candidates",
|
|
310
|
+
"truncation_rate", "truncation_loss", "tiers"):
|
|
311
|
+
ok(key in meas, f"(9) 口径字段齐备:{key}")
|
|
312
|
+
ok(meas["readonly"] is True, "(9) 明确标注 read-only")
|
|
313
|
+
ok(meas["proxy"] is True, "(9) 查询集来自库内 → 标注 proxy")
|
|
314
|
+
ok(meas["n_queries"] == 1 and meas["pools"]["enabled"] is True,
|
|
315
|
+
"(9) 复测在启用态下执行")
|
|
316
|
+
cmp_rep = PL.compare(cg, [QUERY], k=5)
|
|
317
|
+
after = _snapshot(root)
|
|
318
|
+
ok(before == after, "(10) 复测前后全库文件逐字节不变(只读)")
|
|
319
|
+
ok(cmp_rep["before"]["pools"]["enabled"] is False
|
|
320
|
+
and cmp_rep["after"]["pools"]["enabled"] is True,
|
|
321
|
+
"(11) compare 前为关闭态、后为启用态")
|
|
322
|
+
ok(all(k in cmp_rep["delta"] for k in
|
|
323
|
+
("p95_scanned", "mean_candidates", "truncation_loss")),
|
|
324
|
+
"(11) delta 覆盖 P95/候选数/截断损失")
|
|
325
|
+
ok(bool(cmp_rep["attribution"]), "(11) 副作用有归因说明")
|
|
326
|
+
qs = PL.bench_queries(cg, n=5)
|
|
327
|
+
ok(len(qs) == 5 and all(q.strip() for q in qs), f"(11) 确定性取样 {len(qs)} 条")
|
|
328
|
+
ok(PL.bench_queries(cg, n=5) == qs, "(11) 取样可复现")
|
|
329
|
+
|
|
330
|
+
# ---- 口径敏感性自检:小额度下「敏感口径」必须动、成本口径可不动 ----
|
|
331
|
+
restore = _patch_cap(8)
|
|
332
|
+
try:
|
|
333
|
+
m_base = PL.measure(cg, [QUERY], k=20, pools=None)
|
|
334
|
+
m_en = PL.measure(cg, [QUERY], k=20, pools=True)
|
|
335
|
+
cmp2 = PL.compare(cg, [QUERY], k=20)
|
|
336
|
+
finally:
|
|
337
|
+
restore()
|
|
338
|
+
ok(m_en["index_share"] < m_base["index_share"],
|
|
339
|
+
f"(9) 结果构成对分池敏感({m_base['index_share']:.2f} → {m_en['index_share']:.2f})")
|
|
340
|
+
ok(m_base["pool_lost_rate"] is None and m_en["pool_lost_rate"] is not None,
|
|
341
|
+
f"(9) 池级截断损失仅启用态可算(关={m_base['pool_lost_rate']} "
|
|
342
|
+
f"开={m_en['pool_lost_rate']})")
|
|
343
|
+
ok(cmp2["delta"]["index_share"] < 0 and "index_share" in cmp2["sensitive_keys"],
|
|
344
|
+
f"(9) 自检把 index_share 归入敏感口径(实得 {cmp2['sensitive_keys']})")
|
|
345
|
+
ok(cmp2["delta"]["truncation_rate"] == 0
|
|
346
|
+
and "truncation_rate" in cmp2["insensitive_keys"],
|
|
347
|
+
"(9) 成本口径(全局截断率)不敏感被显式标出,不误读为无效")
|
|
348
|
+
|
|
349
|
+
# ======================================= (12) 坏表不静默降级
|
|
350
|
+
print("\n(12) 坏表不静默降级")
|
|
351
|
+
raised = 0
|
|
352
|
+
try:
|
|
353
|
+
cg.search(QUERY, k=5, record=False,
|
|
354
|
+
pools={"knowledge": {"cap_ratio": 0.5},
|
|
355
|
+
"index": {"cap_ratio": 0.5},
|
|
356
|
+
"negative": {"cap_ratio": 0.5}})
|
|
357
|
+
except PL.PoolError:
|
|
358
|
+
raised += 1
|
|
359
|
+
ok(raised == 1, "(12) 非法权重表直接抛错(不当成关闭)")
|
|
360
|
+
ok(isinstance(PL.PoolError("x"), ValueError), "(12) PoolError 兼容 ValueError")
|
|
361
|
+
|
|
362
|
+
# ============================================= (13) MCP 接入
|
|
363
|
+
print("\n(13) MCP 接入")
|
|
364
|
+
pc = call_tool(cg, "cg", {"op": "sustain", "action": "pooling"})
|
|
365
|
+
ok(pc["cap_ratio_sum"] == 1.0 and pc["default"].startswith("on"),
|
|
366
|
+
"(13) sustain pooling 自描述可用")
|
|
367
|
+
bench = call_tool(cg, "cg", {"op": "sustain", "action": "pool_bench",
|
|
368
|
+
"queries": [QUERY], "k": 5, "limit": 5})
|
|
369
|
+
ok(bench["readonly"] is True and bench["proxy"] is True,
|
|
370
|
+
"(13) sustain pool_bench 只读 + proxy")
|
|
371
|
+
ab = call_tool(cg, "cg", {"op": "sustain", "action": "pool_compare",
|
|
372
|
+
"queries": [QUERY], "k": 5, "limit": 5})
|
|
373
|
+
ok(ab["delta"]["mean_candidates"] >= 0, "(13) sustain pool_compare 给 delta")
|
|
374
|
+
cat = call_tool(cg, "cg", {"op": "sustain", "action": "catalog"})
|
|
375
|
+
for act in ("pooling", "pool_bench", "pool_compare"):
|
|
376
|
+
ok(act in cat["actions"], f"(13) sustain catalog 含 action={act}")
|
|
377
|
+
sres = call_tool(cg, "mdcg_search", {"query": QUERY, "k": 5, "pools": True})
|
|
378
|
+
ok(sres["meta"]["pools"]["enabled"] is True, "(13) mdcg_search 透传 pools=True")
|
|
379
|
+
ok("taken" in sres["meta"]["pools"], "(13) mdcg_search 回报各池实取数")
|
|
380
|
+
os.environ.pop(PL.ENV_SWITCH, None) # 未设 = 默认开(2026-10-21)
|
|
381
|
+
sres2 = call_tool(cg, "mdcg_search", {"query": QUERY, "k": 5})
|
|
382
|
+
ok(sres2["meta"]["pools"]["enabled"] is True,
|
|
383
|
+
"(14) 不传 pools ⇒ 默认启用分池(2026-10-21 裁定)")
|
|
384
|
+
sres3 = call_tool(cg, "mdcg_search", {"query": QUERY, "k": 5, "pools": False})
|
|
385
|
+
ok(sres3["meta"]["pools"]["enabled"] is False,
|
|
386
|
+
"(14b) 显式 pools=False ⇒ 退回平截(反向腿)")
|
|
387
|
+
tool = [t for t in KERNEL_TOOLS if t["name"] == "cg"][0]
|
|
388
|
+
props = tool["inputSchema"]["properties"]
|
|
389
|
+
ok("pools" in props and "queries" in props, "(13) schema 暴露 pools/queries")
|
|
390
|
+
blob = tool["description"] + props["op"]["description"] \
|
|
391
|
+
+ props["action"]["description"]
|
|
392
|
+
ok("pool_bench" in blob, "(13) 描述含 pool_bench(防漂移)")
|
|
393
|
+
raised = 0
|
|
394
|
+
try:
|
|
395
|
+
cg.search(QUERY, k=5, record=False, pools={"knowledge": {"cap_ratio": 2.0}})
|
|
396
|
+
except PL.PoolError:
|
|
397
|
+
raised += 1
|
|
398
|
+
ok(raised == 1, "(14) MCP 路径同样拒绝坏表(不静默)")
|
|
399
|
+
raised = 0
|
|
400
|
+
try:
|
|
401
|
+
call_tool(cg, "cg", {"op": "sustain", "action": "pool_nope"})
|
|
402
|
+
except ValueError:
|
|
403
|
+
raised += 1
|
|
404
|
+
ok(raised == 1, "(14) 未知 action 不静默成功")
|
|
405
|
+
|
|
406
|
+
print("\n" + "=" * 70)
|
|
407
|
+
print(f"结果:PASS {PASS} / FAIL {FAIL}")
|
|
408
|
+
if FAILS:
|
|
409
|
+
print("失败项:")
|
|
410
|
+
for f in FAILS:
|
|
411
|
+
print(f" - {f}")
|
|
412
|
+
return 0 if FAIL == 0 else 1
|
|
413
|
+
finally:
|
|
414
|
+
if root:
|
|
415
|
+
shutil.rmtree(root, ignore_errors=True)
|
|
416
|
+
|
|
417
|
+
|
|
418
|
+
if __name__ == "__main__":
|
|
419
|
+
raise SystemExit(main())
|