@furongjun1999/dsh-memory 0.4.4 → 0.4.6

package/md_cg/test_p46_unit_scope.py

@@ -0,0 +1,272 @@
+# -*- coding: utf-8 -*-
+"""md_cg · 第 46 篇：请求级单元收窄（单进程多身份 · as_unit）
+
+设计口径（2026-09-11）
+--------------------
+两个身份维度**职责分离**：
+  · env 身份（MDCG_TOKEN）—— 「谁装了这个大脑」，进程级恒定，是权限**上限**；
+  · 请求参数 `as_unit`  —— 「这一次调用以哪个单元执行」，请求级、可缺省。
+
+与第 45 篇不冲突：第 45 篇确立「不靠多令牌 / 多实例提权」；本篇是**单令牌内收窄**
+——`as_unit` 参与授权时**只做减法**（与 owner 求交 + 管理权恒 False），故伪造
+`as_unit` 的最坏结果等于不传，**不可能提权**。`unit` 字段本身仍是归因维度。
+
+`as_unit`（受限枚举，参与授权，未知值 fail-closed 报错）与 `unit`（自由文本，
+仅归因）职责分离：拼错单元名必须报错，**绝不静默退回 owner 全权**。
+
+覆盖
+----
+A narrowed_principal：单元 → ROLE_SPECS 收窄（层 / op / 密级 / 写权 / 管理权）
+B 不放大不变量：五单元逐一 can_admin=False；只读 owner 收不成可写；求交语义
+C fail-closed：未知单元报错；大小写 / 角色别名归一
+D call_tool 包装：as_unit 生效 / 调用后 principal 复原 / 非法值拒绝 / 缺省不变
+E 真实闸门联动：收窄后的 require_layer_write / require_op / require_admin 拦得住
+
+运行：python -m md_cg.test_p46_unit_scope
+"""
+import os
+import sys
+
+sys.path.insert(0, os.path.dirname(os.path.dirname(os.path.abspath(__file__))))
+
+from md_cg import mcp_server as ms
+from md_cg import tokens
+from md_cg.security import AccessDenied, Principal, _rank
+
+_N = {"pass": 0, "fail": 0}
+
+
+def check(name, cond, detail=""):
+    if cond:
+        _N["pass"] += 1
+        print(f"  PASS  {name}")
+    else:
+        _N["fail"] += 1
+        print(f"  FAIL  {name}" + (f"  <- {detail}" if detail else ""))
+
+
+def _designer(**kw):
+    """owner：设计者载体全权（模拟 env 身份 = MDCG_TOKEN 的权限域）。"""
+    base = dict(actor="dsh", role="designer", clearance="secret",
+                can_write=True, can_admin=True,
+                layers_allow=["*"], ops_allow=["*"])
+    base.update(kw)
+    return Principal(**base)
+
+
+def test_a_unit_scope():
+    print("[A] narrowed_principal 单元收窄")
+    p = _designer()
+    rec = tokens.narrowed_principal(p, "record")
+    check("A1 unit 与 role 均记为执行单元",
+          rec.unit == "record" and rec.role == "record",
+          f"unit={rec.unit} role={rec.role}")
+    check("A2 管理权被剥夺（单元永无管理权）", rec.can_admin is False)
+    check("A3 写权保留（record 可写）", rec.can_write is True)
+    check("A4 层白名单 = record spec（含 contextual，不含 self）",
+          rec.allows_layer("contextual") and not rec.allows_layer("self"),
+          f"layers={list(rec.layers_allow or ())}")
+    check("A5 op 白名单 = record spec（含 write，不含 verify）",
+          rec.allows_op("write") and not rec.allows_op("verify"),
+          f"ops={list(rec.ops_allow or ())}")
+    check("A6 密级被 spec 上限夹紧（secret -> internal）",
+          rec.clearance == "internal", f"clearance={rec.clearance}")
+
+    out = tokens.narrowed_principal(p, "output")
+    check("A7 output 只读（can_write False）", out.can_write is False)
+    check("A8 output 层白名单为空", not out.allows_layer("knowledge"))
+
+    sus = tokens.narrowed_principal(p, "sustain")
+    check("A9 sustain 仅可写 self 层",
+          sus.allows_layer("self") and not sus.allows_layer("knowledge"),
+          f"layers={list(sus.layers_allow or ())}")
+
+    ver = tokens.narrowed_principal(p, "verify")
+    check("A10 verify 可执行 verify op", ver.allows_op("verify"))
+    # 取证修正（2026-09-11）：verify.ops_allow **含** write（验证器要写裁决证据
+    # rejected/contextual），故「无 write op」是错误假设；真正的护栏在**层白名单**。
+    check("A11 verify 可写但仅限 rejected/contextual（不得写 knowledge）",
+          ver.allows_layer("rejected") and ver.allows_layer("contextual")
+          and not ver.allows_layer("knowledge"),
+          f"layers={list(ver.layers_allow or ())}")
+
+    ref = tokens.narrowed_principal(p, "reflect")
+    check("A14 reflect 仅可写 contextual（不得写 knowledge）",
+          ref.allows_layer("contextual") and not ref.allows_layer("knowledge"),
+          f"layers={list(ref.layers_allow or ())}")
+    check("A15 record 可写 knowledge 但不得写 self 层",
+          rec.allows_layer("knowledge") and not rec.allows_layer("self"))
+
+    check("A12 归因维度继承（actor/session/tenant 不变）",
+          rec.actor == p.actor and rec.session == p.session and rec.tenant == p.tenant)
+    check("A13 令牌溯源保留（token_id/parent 与 owner 一致）",
+          rec.token_id == p.token_id and rec.parent == p.parent)
+
+
+def test_b_no_escalation():
+    print("[B] 不放大不变量（核心安全论证）")
+    p = _designer()
+    for u in tokens.POSITION_ROLES:
+        n = tokens.narrowed_principal(p, u)
+        check(f"B1.{u} 管理权恒 False", n.can_admin is False)
+        check(f"B2.{u} 密级 <= owner",
+              _rank(n.clearance) <= _rank(p.clearance),
+              f"{n.clearance} vs {p.clearance}")
+
+    g = Principal(actor="g", role="guest", clearance="internal",
+                  can_write=False, can_admin=False, layers_allow=[], ops_allow=["read"])
+    for u in tokens.POSITION_ROLES:
+        check(f"B3.{u} 只读 owner 收不成可写",
+              tokens.narrowed_principal(g, u).can_write is False)
+
+    lim = _designer(ops_allow=["read"])
+    n = tokens.narrowed_principal(lim, "record")
+    check("B4 op 求交（owner 限 read -> 收窄后仍只有 read）",
+          n.allows_op("read") and not n.allows_op("write"),
+          f"ops={list(n.ops_allow or ())}")
+
+    lim2 = _designer(layers_allow=["knowledge"])
+    n2 = tokens.narrowed_principal(lim2, "record")
+    check("B5 层求交（owner 限 knowledge -> 不含 contextual）",
+          n2.allows_layer("knowledge") and not n2.allows_layer("contextual"),
+          f"layers={list(n2.layers_allow or ())}")
+
+    low = _designer(clearance="internal")
+    check("B6 密级不会因单元而上浮",
+          tokens.narrowed_principal(low, "record").clearance == "internal")
+
+    # 强 owner（*）经收窄后，对每个单元都不得比 owner 更宽
+    check("B7 收窄结果恒为 spec 与 owner 的并集下界（抽查 output/record 不相交扩张）",
+          not tokens.narrowed_principal(p, "output").allows_op("forget")
+          and not tokens.narrowed_principal(p, "record").allows_op("forget"))
+
+
+def test_c_failclosed():
+    print("[C] fail-closed 与归一")
+    p = _designer()
+    # 'root' / 'admin' 是 designer 的别名 -> 归一后不在五单元内 -> 必须拒绝
+    for bad in ("root", "admin", "designer", "", "   ", "recorder2", "executor"):
+        try:
+            tokens.narrowed_principal(p, bad)
+            check(f"C1 未知单元 {bad!r} 必须报错", False, "未抛 TokenError")
+        except tokens.TokenError:
+            check(f"C1 未知单元 {bad!r} 报错", True)
+    check("C2 大小写归一（RECORD -> record）",
+          tokens.narrowed_principal(p, "RECORD").unit == "record")
+    check("C3 角色别名归一（recorder -> record）",
+          tokens.narrowed_principal(p, "recorder").unit == "record")
+    check("C4 空白归一（' verify ' -> verify）",
+          tokens.narrowed_principal(p, " verify ").unit == "verify")
+    check("C5 verifier 别名归一（verifier -> verify）",
+          tokens.narrowed_principal(p, "verifier").unit == "verify")
+
+
+class _ProbeCG:
+    """最小 cg 替身：只供 call_tool 收窄 / 复原验证，不触碰磁盘。
+
+    字段恰好满足 `mdcg_service_info` 的读取需求
+    （root / actor / index["nodes"] / principal.as_dict()）。
+    """
+    root = "."
+    actor = "probe"
+    index = {"nodes": {}}
+
+    def __init__(self, principal):
+        self.principal = principal
+
+
+def test_d_call_tool_wrapper():
+    print("[D] call_tool 包装：生效 / 复原 / 拒绝")
+    owner = _designer()
+    cg = _ProbeCG(owner)
+
+    ok = ms.call_tool(cg, "mdcg_service_info", {"as_unit": "record"})
+    pr = (ok or {}).get("principal") or {}
+    check("D1 as_unit 生效（返回身份为执行单元）", pr.get("unit") == "record",
+          f"principal={pr}")
+    check("D2 收窄后管理权 False", pr.get("can_admin") is False)
+    check("D3 调用结束后 principal 复原（不泄漏到后续调用）",
+          cg.principal is owner)
+
+    nxt = ms.call_tool(cg, "mdcg_service_info", {})
+    pr2 = (nxt or {}).get("principal") or {}
+    check("D4 缺省 as_unit 不改身份（等价改动前行为）",
+          pr2.get("unit") is None and pr2.get("can_admin") is True,
+          f"principal={pr2}")
+
+    bad = ms.call_tool(cg, "mdcg_service_info", {"as_unit": "root"})
+    check("D5 非法 as_unit fail-closed",
+          isinstance(bad, dict) and bad.get("ok") is False
+          and "as_unit" in str(bad.get("error", "")), f"resp={bad}")
+    check("D6 非法 as_unit 不改变 principal", cg.principal is owner)
+
+    # 空串 / 纯空白视为「未声明」，走 owner 全权（不报错）
+    for blank in ("", "   "):
+        r = ms.call_tool(cg, "mdcg_service_info", {"as_unit": blank})
+        pr3 = (r or {}).get("principal") or {}
+        check(f"D7 空白 as_unit={blank!r} 视为缺省",
+              pr3.get("unit") is None and cg.principal is owner)
+
+
+def test_e_gates():
+    print("[E] 真实权限闸门联动（收窄后确实拦得住）")
+    p = _designer()
+    rec = tokens.narrowed_principal(p, "record")
+
+    rec.require_layer_write("contextual", "internal")
+    check("E1 record 可写 contextual", True)
+
+    try:
+        rec.require_layer_write("self", "internal")
+        check("E2 record 不可写 self 层", False, "未抛 AccessDenied")
+    except AccessDenied:
+        check("E2 record 不可写 self 层", True)
+
+    try:
+        rec.require_admin("forget")
+        check("E3 record 无管理权", False, "未抛 AccessDenied")
+    except AccessDenied:
+        check("E3 record 无管理权", True)
+
+    try:
+        rec.require_op("verify")
+        check("E4 record 不可执行 verify op", False, "未抛 AccessDenied")
+    except AccessDenied:
+        check("E4 record 不可执行 verify op", True)
+
+    out = tokens.narrowed_principal(p, "output")
+    try:
+        out.require_write("internal")
+        check("E5 output 不可写", False, "未抛 AccessDenied")
+    except AccessDenied:
+        check("E5 output 不可写", True)
+
+    rec.require_op("read")
+    check("E6 record 仍可读（未误伤读路径）", True)
+
+    sus = tokens.narrowed_principal(p, "sustain")
+    sus.require_layer_write("self", "internal")
+    check("E7 sustain 可写 self（互维维护路径未被误伤）", True)
+    try:
+        sus.require_layer_write("knowledge", "internal")
+        check("E8 sustain 不可写 knowledge", False, "未抛 AccessDenied")
+    except AccessDenied:
+        check("E8 sustain 不可写 knowledge", True)
+
+
+def main():
+    print("=" * 68)
+    print("md_cg 第 46 篇 · 请求级单元收窄（as_unit）—— 单进程多身份")
+    print("=" * 68)
+    test_a_unit_scope()
+    test_b_no_escalation()
+    test_c_failclosed()
+    test_d_call_tool_wrapper()
+    test_e_gates()
+    print("-" * 68)
+    print(f"PASS {_N['pass']} / FAIL {_N['fail']}")
+    return 1 if _N["fail"] else 0
+
+
+if __name__ == "__main__":
+    sys.exit(main())

package/md_cg/test_p4_fuzzy.py

@@ -0,0 +1,223 @@
+# -*- coding: utf-8 -*-
+"""md_cg · P4 验收：分级隶属度 + LLM 查询侧扩展 + fuzzy RRF 路径
+
+运行：python -m md_cg.test_p4_fuzzy
+
+验证口径（对齐「只新增、不改既有语义」）：
+  1. 分级隶属度：membership / IDF 加权大域打分 / 域相似度，且老二值实现不变
+  2. LLM 查询侧扩展：llm / whitebox / whitebox_fallback 三态 + 缓存
+  3. fuzzy 路径：作为**第 5 路**接入 RRF，默认路径不含它（基线不受影响）
+"""
+from __future__ import annotations
+
+import shutil
+import sys
+import tempfile
+
+from . import routing
+from .mdcg import (expand_query_terms, expand_query_terms_weighted,
+                   expand_query_terms_llm, SYNONYM_GROUPS,
+                   SYNONYM_GROUPS_WEIGHTED)
+from .mdcos import MdCGOS, _term_degree, _weighted_coverage
+
+PASS = FAIL = 0
+FAILS = []
+
+
+def check(name, cond, detail=""):
+    global PASS, FAIL
+    if cond:
+        PASS += 1
+        print(f"  [PASS] {name}" + (f"  · {detail}" if detail else ""))
+    else:
+        FAIL += 1
+        FAILS.append(name)
+        print(f"  [FAIL] {name}  · {detail}")
+
+
+CCG = ("# 功能名：{n}\n# 生效条件：{c}\n# 子功能：{s}\n# 执行：{e}\n"
+       "# 验证方式：test\n# 不适用条件：{neg}\n\n{body}\n")
+
+
+def mk(n, cond, body, neg="其它"):
+    return CCG.format(n=n, c=cond, s=body[:20], e=body, neg=neg, body=body)
+
+
+def main():
+    # ---------------- 1. 分级隶属度 ----------------
+    print("\n【1】分级隶属度（手写隶属函数）")
+    check("完全相同 → 隶属度 1.0", routing.membership("物理", "物理") == 1.0)
+    check("term 包含 word → 长度比",
+          abs(routing.membership("牛顿第二定律", "牛顿") - 2 / 6) < 1e-9,
+          f"{routing.membership('牛顿第二定律', '牛顿')}")
+    check("word 包含 term → 长度比",
+          abs(routing.membership("物理", "高中物理") - 2 / 4) < 1e-9,
+          f"{routing.membership('物理', '高中物理')}")
+    check("无包含关系 → 0.0", routing.membership("物理", "化学") == 0.0)
+
+    idf_rare = routing.domain_idf("贝塞尔")     # 只覆盖数学
+    idf_common = routing.domain_idf("文明")     # 覆盖历史 + 通用（跨域）
+    check("IDF：稀有词区分度 > 跨域通用词", idf_rare > idf_common,
+          f"贝塞尔={idf_rare:.3f} 文明={idf_common:.3f}")
+
+    w_bd = routing.big_domain_score_weighted({"贝塞尔": 1.0})
+    check("IDF 加权大域打分：贝塞尔 → 数学最高",
+          max(w_bd, key=lambda d: w_bd[d]) == "数学",
+          f"数学={w_bd['数学']:.3f} 物理={w_bd['物理']:.3f}")
+    w_bd2 = routing.big_domain_score_weighted({"牛顿第二定律": 1.0})
+    check("加权打分为连续值（部分命中→非整数）",
+          0 < w_bd2["物理"] < 2 and w_bd2["物理"] != int(w_bd2["物理"]),
+          f"物理={w_bd2['物理']:.3f}")
+    check("加权收敛 top-1",
+          routing.big_domain_classify_weighted({"贝塞尔": 1.0}) == "数学")
+
+    # 老二值实现不变（基线可比性的前提）
+    old_scores = routing.big_domain_score_breakdown(["贝塞尔"])
+    check("老二值打分仍为整数计数", all(isinstance(v, int) for v in old_scores.values()),
+          f"数学={old_scores['数学']}")
+    check("老 big_domain_classify 结果不变",
+          routing.big_domain_classify(["贝塞尔"]) == "数学")
+
+    check("域相似度：包含 → 长度比",
+          abs(routing.domain_similarity("计算机", "计算机科学") - 3 / 5) < 1e-9,
+          f"{routing.domain_similarity('计算机', '计算机科学')}")
+    check("域相似度：无关 → 0", routing.domain_similarity("物理", "音乐") == 0.0)
+
+    # ---------------- 2. 加权扩展 + LLM 查询侧扩展 ----------------
+    print("\n【2】加权扩展 + LLM 查询侧扩展")
+    check("加权同义词组与老表组数一致",
+          len(SYNONYM_GROUPS_WEIGHTED) == len(SYNONYM_GROUPS),
+          f"{len(SYNONYM_GROUPS_WEIGHTED)} vs {len(SYNONYM_GROUPS)}")
+    check("组内权重落在 0.3~1.0",
+          all(0.3 <= w <= 1.0 for g in SYNONYM_GROUPS_WEIGHTED for w in g.values()))
+    check("每组恰有一个 1.0 组心",
+          all(sum(1 for v in g.values() if v == 1.0) == 1
+              for g in SYNONYM_GROUPS_WEIGHTED))
+
+    tw = expand_query_terms_weighted("图片识别")
+    check("加权扩展：整句权重 1.0", tw.get("图片识别") == 1.0)
+    check("加权扩展：同义词带权重（图片→图像 0.9）", tw.get("图像") == 0.9, str(tw))
+    check("加权扩展：弱相关低权（发现 0.5）", tw.get("发现") == 0.5, str(tw))
+    check("老扩展仍返回 list（未改语义）",
+          isinstance(expand_query_terms("图片识别"), list))
+
+    # 分级命中（模糊匹配）
+    check("整词命中 → 1.0", _term_degree("红按钮", "红按钮控制角色") == 1.0)
+    check("部分命中 → 长度比 × 0.5（贝塞尔不等式 vs 贝塞尔公式）",
+          abs(_term_degree("贝塞尔不等式", "贝塞尔公式") - 0.5 * 3 / 6) < 1e-9,
+          f"{_term_degree('贝塞尔不等式', '贝塞尔公式')}")
+    check("部分命中 < 整词命中（模糊路不压倒词法路）",
+          _term_degree("红按钮", "蓝按钮") < 1.0,
+          f"共享后缀「按钮」={_term_degree('红按钮', '蓝按钮')}")
+    check("完全未命中 → 0", _term_degree("红按钮", "天气晴朗") == 0.0)
+    check("加权覆盖率 ∈ [0,1]",
+          0 <= _weighted_coverage({"红按钮": 1.0, "发现": 0.5}, "红按钮") <= 1.0)
+
+    # LLM 三态
+    fake_ok = lambda p: '[{"term": "视觉识别", "weight": 0.8}, {"term": "图片", "weight": 0.5}]'
+    out = expand_query_terms_llm("图片", llm_fn=fake_ok)
+    check("LLM 扩展：source=llm", out.get("__source__") == "llm", str(out))
+    check("LLM 扩展：合并 LLM 词", out.get("视觉识别") == 0.8)
+    check("LLM 扩展：不压低白箱精确命中", out.get("图片") == 1.0, f"图片={out.get('图片')}")
+    n_calls = []
+
+    def counting(p):
+        n_calls.append(1)
+        return '[{"term": "视觉识别", "weight": 0.8}]'
+
+    cache = {}
+    expand_query_terms_llm("图片", llm_fn=counting, cache=cache)
+    expand_query_terms_llm("图片", llm_fn=counting, cache=cache)
+    check("LLM 扩展：显式缓存下同 query 只调一次", len(n_calls) == 1, f"调用={len(n_calls)}")
+
+    def boom(_p):
+        raise RuntimeError("llm down")
+
+    out_fb = expand_query_terms_llm("图片", llm_fn=boom)
+    check("LLM 失败 → 回退白箱", out_fb.get("__source__") == "whitebox_fallback"
+          and out_fb.get("图像") == 0.9, str(out_fb)[:80])
+    out_wb = expand_query_terms_llm("图片")
+    check("无 llm_fn → 纯白箱", out_wb.get("__source__") == "whitebox")
+    out_bad = expand_query_terms_llm("图片", llm_fn=lambda p: "抱歉我不能")
+    check("LLM 输出非 JSON → 回退白箱",
+          out_bad.get("__source__") == "whitebox_fallback")
+
+    # ---------------- 3. fuzzy RRF 路径 ----------------
+    print("\n【3】fuzzy 路径接入 RRF（默认不启用）")
+    root = tempfile.mkdtemp(prefix="mdcg_fuzzy_")
+    try:
+        cg = MdCGOS(root, actor="test")
+        cg.add("img_strong", mk("图像节点", "问图片", "画面渲染管线"),
+               tags=["图像"], condition_space={"observation_position": "视觉知识点（渲染）"})
+        cg.add("img_weak", mk("视像节点", "问图片", "画面渲染管线"),
+               tags=["视像"], condition_space={"observation_position": "视觉知识点（渲染）"})
+        cg.add("math1", mk("贝塞尔不等式", "问贝塞尔", "贝塞尔不等式的证明与推导"),
+               tags=["domain:数学"], condition_space={"observation_position": "数学知识点（贝塞尔）"})
+        cg.add("noise", mk("无关节点", "问无关", "完全无关的内容"), tags=["其它"])
+
+        # 默认路径不含 fuzzy → 既有行为不变
+        res0, meta0 = cg.search_rrf("图片", k=5)
+        check("默认 RRF 路径不含 fuzzy",
+              "fuzzy" not in meta0.get("paths", {}), str(list(meta0.get("paths", {}))))
+        check("默认 RRF meta 仍有 expand_source 字段（值为 None）",
+              "expand_source" in meta0 and meta0["expand_source"] is None)
+
+        # 显式启用 fuzzy
+        paths5 = ("lexical", "bucket", "entity", "graph", "fuzzy")
+        res, meta = cg.search_rrf("图片", k=5, paths=paths5)
+        check("fuzzy 路径被记录进 meta", "fuzzy" in meta.get("paths", {}),
+              str(meta.get("paths")))
+        check("fuzzy 扩展来源标注（白箱）", meta.get("expand_source") == "whitebox",
+              str(meta.get("expand_source")))
+        prov = meta.get("provenance", {})
+        check("结果 provenance 含 fuzzy 路",
+              any(any(p["path"] == "fuzzy" for p in prov.get(nid, [])) for nid in prov),
+              str({k: [p['path'] for p in v] for k, v in prov.items()})[:160])
+
+        # 分级：强同义词节点分数 > 弱同义词节点（fuzzy 路内）
+        fuzzy_scored, _src = cg._path_fuzzy("图片", cg._candidates())
+        smap = {n["id"]: s for n, s in fuzzy_scored}
+        check("fuzzy 分级：图像(0.9) > 视像(0.6)",
+              smap.get("img_strong", 0) > smap.get("img_weak", 0),
+              f"图像={smap.get('img_strong')} 视像={smap.get('img_weak')}")
+        check("fuzzy 打分 ∈ (0,1]", all(0 < s <= 1.0 for s in smap.values()),
+              str({k: round(v, 3) for k, v in smap.items()}))
+
+        # 大域亲和：数学节点在「贝塞尔」查询下获得 fuzzy 分
+        fuzzy_math, _ = cg._path_fuzzy("贝塞尔不等式", cg._candidates())
+        mids = {n["id"] for n, _ in fuzzy_math}
+        check("fuzzy 大域亲和命中数学节点", "math1" in mids, str(mids))
+
+        # 注入 LLM 查询侧扩展 → meta 标注 llm
+        llm_expand = lambda q: expand_query_terms_llm(
+            q, llm_fn=lambda p: '[{"term": "画面", "weight": 0.9}]')
+        res_l, meta_l = cg.search_rrf("图片", k=5, paths=paths5, query_expand=llm_expand)
+        check("注入 LLM 扩展 → meta expand_source=llm",
+              meta_l.get("expand_source") == "llm", str(meta_l.get("expand_source")))
+        check("LLM 扩展后仍有结果", len(res_l) > 0, f"{len(res_l)} 条")
+
+        # recall 透传 paths
+        rec = cg.recall("图片", budget_tokens=400, k=5, paths=paths5)
+        check("recall 可透传 paths 启用 fuzzy",
+              "fuzzy" in rec["meta"].get("paths", {}), str(rec["meta"].get("paths")))
+        check("recall 仍遵守预算", rec["tokens_used"] <= rec["budget"],
+              f"used={rec['tokens_used']}/{rec['budget']}")
+
+        # 无 context 时 fuzzy 不应因缺 context 报错
+        res_nc, meta_nc = cg.search_rrf("贝塞尔", k=5, paths=("fuzzy",))
+        check("fuzzy 单路在无 context 下可运行", isinstance(res_nc, list),
+              f"{len(res_nc)} 条")
+        cg.close()
+    finally:
+        shutil.rmtree(root, ignore_errors=True)
+
+    print("\n" + "=" * 68)
+    print(f"通过 {PASS} / 失败 {FAIL}")
+    if FAILS:
+        print("失败项：" + ", ".join(FAILS))
+    print("=" * 68)
+    return 0 if FAIL == 0 else 1
+
+
+if __name__ == "__main__":
+    sys.exit(main())