@furongjun1999/dsh-memory 0.4.6 → 0.4.8

package/md_cg/test_review_conformance.py

@@ -0,0 +1,310 @@
+# -*- coding: utf-8 -*-
+"""md_cg · 审核队列 conformance（数据健康不变量，pi storage conformance 口径）
+
+把存储承诺写成断言，防止未来改动静默破坏：
+  ① strict 锁语义：不能丢的写超时必须显式报错，而非静默放行退化为无锁并发
+  ② 幂等对账：同内容重试（超时重试/崩溃恢复）→ 幂等返回既有 pid，不重复入队
+  ③ 已裁决内容的对账：accepted/rejected 内容重提 → 返回原 pid + 终态
+  ④ 存量兼容：无 payload_hash 的旧格式记录参与对账（现算）
+  ⑤ 级联出清：主提案终态裁决后，同内容存量兄弟提案自动关闭
+  ⑥ close/reopen 状态保持：重开实例后队列视图一致
+  ⑦ 并发幂等（真多进程）：N 进程同内容并发 propose → 恰好 1 条、pid 全同
+  ⑧ 并发不丢（真多进程）：N 进程×M 条不同内容 → inbox 读回恰好 N×M 条
+  ⑨ decisions 并发不丢（真多进程）：并发裁决 → 记录恰好 N 条且指纹完整
+
+运行：python -m md_cg.test_review_conformance
+"""
+from __future__ import annotations
+
+import hashlib
+import json
+import os
+import shutil
+import subprocess
+import sys
+import tempfile
+import time
+
+from .fsutil import FileLock, append_jsonl
+from .mdcos import MdCGOS
+from .security import Principal
+from .mdcos import MdCGSecure
+
+PASS = FAIL = 0
+FAILS = []
+
+REPO = os.path.dirname(os.path.dirname(os.path.abspath(__file__)))
+
+WORKER = '''# -*- coding: utf-8 -*-
+"""conformance worker：子进程内建 MdCGOS 执行单次 propose / review_decide。"""
+import json
+import sys
+
+sys.path.insert(0, sys.argv[1])
+from md_cg.mdcos import MdCGOS
+
+root, mode = sys.argv[2], sys.argv[3]
+arg = sys.argv[4] if len(sys.argv) > 4 else ""
+cg = MdCGOS(root, actor="conf-worker")
+if mode == "propose":                 # arg = content
+    print(json.dumps(cg.propose("w-node", arg, layer="knowledge", tags=["w"])))
+elif mode == "propose_n":             # arg = json list of contents
+    out = [cg.propose("w-node-%d" % i, c, layer="knowledge")
+           for i, c in enumerate(json.loads(arg))]
+    print(json.dumps(out))
+elif mode == "decide":                # arg = pid
+    print(json.dumps(cg.review_decide(arg, "reject", reason="conformance")))
+'''
+
+
+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}")
+
+
+def _ensure_worker(workdir):
+    wk = os.path.join(workdir, "worker.py")
+    if not os.path.exists(wk):
+        with open(wk, "w", encoding="utf-8") as f:
+            f.write(WORKER)
+    return wk
+
+
+def _run_worker(workdir, root, mode, arg="", timeout=120):
+    """子进程跑 worker（argv 列表 + UTF-8 + shell=False，纪律 15）。"""
+    wk = _ensure_worker(workdir)
+    env = dict(os.environ, PYTHONUTF8="1")
+    return subprocess.run(
+        [sys.executable, wk, REPO, root, mode, arg],
+        capture_output=True, text=True, encoding="utf-8", errors="replace",
+        timeout=timeout, env=env, shell=False)
+
+
+def main():
+    workdir = tempfile.mkdtemp(prefix="mdcg_conf_wk_")
+    root = tempfile.mkdtemp(prefix="mdcg_conf_")
+    root2 = root2b = root3 = root4 = ""
+    _ensure_worker(workdir)
+    try:
+        cg = MdCGOS(root, actor="test")
+
+        # ---------------- ① strict 锁语义 ----------------
+        print("\n【1】strict 锁：不能丢的写超时报错，不放行")
+        lock_path = os.path.join(root, "hippocampus", "inbox.jsonl")
+        blocker = FileLock(lock_path, timeout=30.0)
+        blocker.__enter__()
+        t0 = time.time()
+        raised = None
+        try:
+            FileLock(lock_path, timeout=0.3, strict=True).__enter__()
+        except TimeoutError as e:
+            raised = e
+        check("strict 占锁下获锁超时抛 TimeoutError", raised is not None,
+              str(raised)[:60])
+        check("strict 超时不做长等待", time.time() - t0 < 5.0,
+              f"耗时={time.time()-t0:.2f}s")
+        soft = FileLock(lock_path, timeout=0.3).__enter__()
+        check("非 strict 维持放行语义（best-effort 簿记不受影响）",
+              soft.acquired is False, f"acquired={soft.acquired}")
+        blocker.__exit__()
+
+        # ---------------- ② 幂等对账：pending ----------------
+        print("\n【2】幂等对账：同内容重试返回既有 pid")
+        c_body = "# 功能名：conformance 幂等探针\n\n同内容重试不应重复入队。\n"
+        p1 = cg.propose("dup1", c_body, layer="knowledge")
+        p2 = cg.propose("dup1", c_body, layer="knowledge")       # 模拟重试
+        p3 = cg.propose("dup2", c_body, layer="knowledge")       # 换 node_id 同内容
+        check("三次 propose 返回同一 pid", p1 == p2 == p3,
+              f"{p1} / {p2} / {p3}")
+        pend = [r for r in cg.review_list() if r.get("id") in ("dup1", "dup2")]
+        check("inbox 恰好 1 条该内容提案", len(pend) == 1, f"pending={len(pend)}")
+        info = cg.propose("dup1", c_body, layer="knowledge", info=True)
+        check("info=True 透出去重信息",
+              info.get("dedup") is True and info.get("dup_of") == p1
+              and info.get("dup_status") == "pending", str(info))
+
+        # ---------------- ③ 幂等对账：已裁决内容 ----------------
+        print("\n【3】幂等对账：已裁决内容重提返回原 pid + 终态")
+        d = cg.review_decide(p1, "accept")
+        check("accept 落库", d.get("ok") is True, str(d.get("error") or "")[:60])
+        again = cg.propose("dup3", c_body, layer="knowledge", info=True)
+        check("accepted 内容重提幂等返回原 pid",
+              again.get("dedup") is True and again.get("dup_of") == p1
+              and again.get("dup_status") == "accepted", str(again))
+        check("重提未产生新队列条目",
+              not any(r.get("id") == "dup3" for r in cg.review_list()), "")
+
+        # ---------------- ④ 存量兼容：无 payload_hash 旧记录 ----------------
+        print("\n【4】存量兼容：旧格式记录（无 payload_hash）参与对账")
+        # 独立内容探针（c_body 在【3】已被 accept，会抢先命中终态分支）
+        leg_body = "# 功能名：存量兼容探针\n\n旧账无 hash 也要能对账。\n"
+        old = {"t": time.time(), "pid": "prop_legacy0001", "id": "legacy1",
+               "content": leg_body, "layer": "knowledge", "tags": [],
+               "condition_space": {}, "verify": {}, "verify_hash": "",
+               "extra": {}, "actor": "legacy"}
+        append_jsonl(cg.inbox_log, old)
+        leg = cg.propose("dup4", leg_body, layer="knowledge", info=True)
+        check("对账命中存量记录（现算 hash）",
+              leg.get("dedup") is True and leg.get("dup_of") == "prop_legacy0001"
+              and leg.get("dup_status") == "pending", str(leg))
+
+        # ---------------- ⑤ 级联出清：同 hash 存量兄弟 ----------------
+        print("\n【5】级联出清：主提案终态后兄弟自动关闭")
+        sib_body = "# 功能名：级联探针\n\n存量重复入队产物。\n"
+        main_pid = cg.propose("casc_main", sib_body, layer="knowledge")
+        # 手工构造存量兄弟（绕过 propose 的入队查重，模拟修复上线前的旧账）
+        for i, nid in enumerate(("casc_sib_a", "casc_sib_b")):
+            ph = hashlib.sha1(sib_body.strip().encode("utf-8")).hexdigest()[:12]
+            append_jsonl(cg.inbox_log, {
+                "t": time.time(), "pid": f"prop_sib{i}000000", "id": nid,
+                "content": sib_body, "layer": "knowledge", "tags": [],
+                "condition_space": {}, "payload_hash": ph,
+                "verify": {}, "verify_hash": "", "extra": {}, "actor": "legacy"})
+        sibs_before = [r for r in cg.review_list()
+                       if r.get("id") in ("casc_main", "casc_sib_a", "casc_sib_b")]
+        check("裁决前 3 条同内容提案全部可见", len(sibs_before) == 3,
+              f"n={len(sibs_before)}")
+        dmain = cg.review_decide(main_pid, "accept")
+        check("accept 成功且级联出清 2 条兄弟",
+              dmain.get("ok") and len(dmain.get("cascade_closed") or []) == 2,
+              f"cascade={dmain.get('cascade_closed')}")
+        left = [r for r in cg.review_list()
+                if r.get("id") in ("casc_main", "casc_sib_a", "casc_sib_b")]
+        check("裁决后队列无同内容残留", len(left) == 0, f"left={len(left)}")
+        decs = [x for x in cg.decisions() if "cascade_dedup" in (x.get("reason") or "")]
+        check("级联裁决落 decisions 且带说明", len(decs) == 2
+              and all(x.get("status") == "rejected" for x in decs),
+              f"n={len(decs)}")
+
+        # ---------------- ⑥ close/reopen 状态保持 ----------------
+        print("\n【6】close/reopen：重开实例队列视图一致")
+        cg2 = MdCGOS(root, actor="test-reopen")
+        rl2 = cg2.review_list()
+        check("重开后 review_list 与原实例一致", rl2 == cg.review_list(),
+              f"n={len(rl2)}")
+
+        # ---------------- ⑦⑧⑨ 真多进程并发 ----------------
+        print("\n【7】并发幂等：4 进程同内容并发 propose")
+        root2 = tempfile.mkdtemp(prefix="mdcg_conf_p_")
+        content = "# 功能名：并发幂等探针\n\n四进程同时入队只应产生一条。\n"
+        procs = [subprocess.Popen(
+            [sys.executable, os.path.join(workdir, "worker.py"), REPO,
+             root2, "propose", content],
+            stdout=subprocess.PIPE, stderr=subprocess.PIPE, shell=False,
+            env=dict(os.environ, PYTHONUTF8="1")) for _ in range(4)]
+        pids = []
+        for p in procs:
+            out, _err = p.communicate(timeout=120)
+            pids.append(json.loads(out.strip()))
+        check("4 进程返回同一 pid", len(set(pids)) == 1, str(pids))
+        inbox2 = os.path.join(root2, "hippocampus", "inbox.jsonl")
+        with open(inbox2, encoding="utf-8") as f:
+            lines = [ln for ln in f if ln.strip()]
+        check("inbox 恰好 1 条（无重复入队）", len(lines) == 1,
+              f"lines={len(lines)}")
+        rec1 = json.loads(lines[0])
+        check("入队记录带 payload_hash", bool(rec1.get("payload_hash")), "")
+
+        print("\n【8】并发不丢：4 进程×5 条不同内容")
+        root2b = tempfile.mkdtemp(prefix="mdcg_conf_p2_")
+        contents = [json.dumps([
+            f"# 功能名：并发不丢 {i}-{j}\n\n第 {i} 进程第 {j} 条。\n"
+            for j in range(5)]) for i in range(4)]
+        procs = [subprocess.Popen(
+            [sys.executable, os.path.join(workdir, "worker.py"), REPO,
+             root2b, "propose_n", contents[i]],
+            stdout=subprocess.PIPE, stderr=subprocess.PIPE, shell=False,
+            env=dict(os.environ, PYTHONUTF8="1")) for i in range(4)]
+        for p in procs:
+            p.communicate(timeout=180)
+        with open(os.path.join(root2b, "hippocampus", "inbox.jsonl"),
+                  encoding="utf-8") as f:
+            all_lines = [ln for ln in f if ln.strip()]
+        recs = []
+        bad = 0
+        for ln in all_lines:
+            try:
+                recs.append(json.loads(ln))
+            except ValueError:
+                bad += 1
+        check("4×5 并发后读回恰好 20 条（一条不丢）",
+              len(recs) == 20 and bad == 0, f"read={len(recs)} bad={bad}")
+        check("pid 互不重复", len({r.get("pid") for r in recs}) == 20, "")
+
+        # 【8c】pid 唯一性守卫（2026-09-16 取证修复）：旧式
+        # "prop_" + _sig(node_id + time.time()) 无进程熵，同一时刻多 worker
+        # 用相同 node_id 入队会碰撞——本项在单进程内高频连续入队，把
+        # 「同一时刻多次 propose」这一碰撞条件压缩到必然暴露，防回归。
+        root2c = tempfile.mkdtemp(prefix="mdcg_conf_p3_")
+        cg2c = MdCGOS(root2c, actor="test")
+        pids2c = [cg2c.propose("same-node", f"# 功能名：唯一性 {i}\n\n内容 {i}。\n",
+                               layer="knowledge") for i in range(20)]
+        check("同 node_id 高频连续 propose：20 pid 互不重复",
+              len(set(pids2c)) == 20, f"uniq={len(set(pids2c))}/20")
+        check("pid 复现格式（prop_ + 12 hex，调用方依赖）",
+              all(isinstance(p, str) and len(p) == 17 and p.startswith("prop_")
+                  and all(ch in "0123456789abcdef" for ch in p[5:])
+                  for p in pids2c), pids2c[0])
+
+
+        print("\n【9】decisions 并发：4 进程各裁决 1 个 pid")
+        root3 = tempfile.mkdtemp(prefix="mdcg_conf_d_")
+        cg3 = MdCGOS(root3, actor="test")
+        pids3 = [cg3.propose(f"cc{i}", f"# 功能名：并发裁决 {i}\n\n内容 {i}。\n",
+                             layer="knowledge") for i in range(4)]
+        procs = [subprocess.Popen(
+            [sys.executable, os.path.join(workdir, "worker.py"), REPO,
+             root3, "decide", pids3[i]],
+            stdout=subprocess.PIPE, stderr=subprocess.PIPE, shell=False,
+            env=dict(os.environ, PYTHONUTF8="1")) for i in range(4)]
+        outs = []
+        for p in procs:
+            out, _err = p.communicate(timeout=180)
+            outs.append(out.strip())
+        check("4 项裁决全部成功", all(json.loads(o).get("ok") for o in outs),
+              str([o[:40] for o in outs]))
+        drecs = cg3.decisions()
+        check("decisions 读回恰好 4 条（无交错丢失）", len(drecs) == 4,
+              f"n={len(drecs)}")
+        check("每条裁决带 record_hash 指纹",
+              all(r.get("record_hash") for r in drecs), "")
+        check("重开后裁决状态保持",
+              len(MdCGOS(root3, actor="x")._closed_pids()) == 4, "")
+
+        # ---------------- ⑩ MdCGSecure.propose info 转发 ----------------
+        print("\n【10】安全层转发：MdCGSecure.propose 幂等透传")
+        root4 = tempfile.mkdtemp(prefix="mdcg_conf_s_")
+        sec = MdCGSecure(root4, principal=Principal(
+            actor="conf", clearance="private", can_write=True, can_admin=True))
+        sec_body = "# 功能名：安全层幂等\n\n转发链上的去重。\n"
+        sp1 = sec.propose("sec1", sec_body, layer="knowledge", info=True)
+        sp2 = sec.propose("sec1", sec_body, layer="knowledge", info=True)
+        check("安全层两次入队同一 pid 且 dedup 命中",
+              sp1.get("pid") == sp2.get("pid") and sp2.get("dedup") is True,
+              f"{sp1.get('pid')} / {sp2}")
+        with open(os.path.join(root4, "hippocampus", "inbox.jsonl"),
+                  encoding="utf-8") as f:
+            sec_rec = json.loads(f.readline())
+        check("info 不泄漏进 extra",
+              "info" not in (sec_rec.get("extra") or {}),
+              str(sec_rec.get("extra")))
+
+        print(f"\n===== conformance：PASS={PASS} FAIL={FAIL} =====")
+        if FAILS:
+            print("失败项：", "；".join(FAILS))
+        return 1 if FAIL else 0
+    finally:
+        shutil.rmtree(workdir, ignore_errors=True)
+        for r in (root, root2, root2b, root3, root4):
+            if r:
+                shutil.rmtree(r, ignore_errors=True)
+
+
+if __name__ == "__main__":
+    sys.exit(main())

package/md_cg/test_sem_noise.py

@@ -0,0 +1,242 @@
+# -*- coding: utf-8 -*-
+"""弱语义噪声注入四臂实验（GPT 理论的形式化验证）。
+
+理论命题（本轮与 GPT 分析定稿）：
+  1. 三分离：语义完整度 ≠ 证据强度 ≠ 召回价值——「我在喝水」语义高度省略，
+     但作为 episodic fact 事实承诺明确（SELF+drinking+water+now）。
+  2. 语义联系是候选生成器，不是证据：semantic association ≠ evidence。
+     等权 RRF 会双重奖励「多路都靠前」的语义邻居，把真正的事实挤出前排
+     （排序污染）；mdcos.search_rrf docstring 已自注该现象。
+  3. 证据防火墙（judge_ranking）：语义负责「不要漏」，白箱负责「不要错」——
+     融合排序只产生候选，资格裁决（REJECT/BLINDSPOT 剔除、DEFER 降权、
+     ACCEPT 保位）决定最终优先级。
+  4. query-relative：同一记忆在不同问题下资格不同——否定事件
+     （「我没喝水」）在「刚才在干什么」问句下必须 REJECT。
+
+四臂（同一 42 节点确定性语料、同一查询）：
+  A lex        单词法路（词面+CCG 正文）
+  B semantic   单 fuzzy 路（同义词组/大域扩展 = 灵枢的「语义联系」等价物；
+               无神经嵌入是架构取向，如实测报）
+  C fusion     等权五路 RRF（现状默认形态，judge 只标注不改序）
+  D firewall   C + judge_ranking（白箱终排）
+
+指标：top1 命中率 / hit@10 / MRR（对 8 条 gold）。
+断言：D ≥ C（防火墙不劣于裸融合）、D 剔除数 > 0（防火墙生效）；
+C < A 的污染强度只测量不预设——实测反例时按第 4 条修正理论而非硬造。
+
+运行：python -m md_cg.test_sem_noise
+"""
+from __future__ import annotations
+
+import os
+import shutil
+import tempfile
+
+from .mdcg import STATE_REJECT
+from .mdcos import MdCGOS
+
+PASS = FAIL = 0
+FAILS = []
+
+
+def ok(cond, label):
+    global PASS, FAIL
+    if cond:
+        PASS += 1
+    else:
+        FAIL += 1
+        FAILS.append(label)
+        print(f"  FAIL {label}")
+
+
+#: 8 条 episodic gold——语义高度省略、事实承诺明确（正文首行即事实）
+GOLD = [
+    ("g1", "我在喝水。"),
+    ("g2", "我吃了饭。"),
+    ("g3", "我刚打开了电脑。"),
+    ("g4", "我在看书。"),
+    ("g5", "我在听音乐。"),
+    ("g6", "我刚出了门。"),
+    ("g7", "我在浇花。"),
+    ("g8", "我刚下了班。"),
+]
+
+#: 语义邻居（泛化句）：与 gold 同主题、语义上「可能相关」，但不是该事件。
+#: 每条 gold 配两条，生效条件各归各的主题问句——「问刚才在干什么」不命中。
+NEIGHBORS = {
+    "g1": [("n1a", "喝水对健康有好处。", "问健康建议"),
+           ("n1b", "运动后需要补充水分。", "问运动恢复")],
+    "g2": [("n2a", "规律饮食有助于消化。", "问健康建议"),
+           ("n2b", "营养均衡是饮食原则。", "问营养知识")],
+    "g3": [("n3a", "电脑需要定期清理缓存。", "问电脑维护"),
+           ("n3b", "工作离不开电脑。", "问工作方式")],
+    "g4": [("n4a", "阅读能增长知识。", "问阅读价值"),
+           ("n4b", "书籍是人类进步的阶梯。", "问读书意义")],
+    "g5": [("n5a", "音乐能舒缓情绪。", "问音乐作用"),
+           ("n5b", "听音乐是常见放松方式。", "问放松方法")],
+    "g6": [("n6a", "出门要记得带钥匙。", "问出门提醒"),
+           ("n6b", "散步有益身心健康。", "问健康建议")],
+    "g7": [("n7a", "浇花要在早晨或傍晚。", "问养花知识"),
+           ("n7b", "植物需要适量水分。", "问植物养护")],
+    "g8": [("n8a", "下班路上注意安全。", "问出行提醒"),
+           ("n8b", "工作与生活要平衡。", "问生活理念")],
+}
+
+#: 否定/反事实：语义上与 gold 最近（「我没喝水」vs「我在喝水」），
+#: 但 state/negation 完全不同——在「刚才在干什么」问句下必须被负条件 REJECT。
+NEG_TEXTS = [("x1", "我没喝水。"), ("x2", "我没吃饭。"), ("x3", "我还没打开电脑。"),
+             ("x4", "我没看书。"), ("x5", "我没听音乐。"), ("x6", "我没出门。"),
+             ("x7", "我没浇花。"), ("x8", "我还没下班。")]
+
+#: 无关背景噪声（占用候选池）
+UNREL = ["u%d" % i for i in range(1, 11)]
+UNREL_DOCS = [
+    ("u1", "今天天气很热。", "问天气"), ("u2", "周五下午三点开会。", "问会议安排"),
+    ("u3", "地铁三号线今天停运。", "问交通信息"), ("u4", "小区门口新开了超市。", "问周边设施"),
+    ("u5", "我的快递到了驿站。", "问快递状态"), ("u6", "明天可能下雨。", "问天气预报"),
+    ("u7", "这个月话费涨了。", "问账单"), ("u8", "楼下在修路。", "问施工信息"),
+    ("u9", "牙膏用完了要买。", "问采购清单"), ("u10", "窗台的多肉长新芽了。", "问植物状态"),
+]
+
+QUERY = "你刚才在干什么"
+#: episodic gold 的统一生效条件——必须是 QUERY 的词面子串（正条件确认即「情境
+#: 提问与记忆声明的问题类型一致」，这正是「条件是适用边界而非必填字段」）。
+GOLD_COND = "刚才在干什么"
+NEG_COND = "问没做的事"
+
+
+def _doc(fact, cond, extra_neg=False):
+    lines = ["# 功能名：事件记录",
+             f"# 生效条件：{cond}",
+             "# 子功能：episodic 片段（语义可省略，事实承诺明确）",
+             "# 执行：陈述事实",
+             "# 验证方式：据用户直接陈述核对",
+             f"# 不适用条件：{'刚才在干什么' if extra_neg else '无'}"]
+    return fact + "\n" + "\n".join(lines) + "\n"
+
+
+def _metrics(cg, arm_kw, gold_ids):
+    ranks, states = {}, {}
+    res, meta = cg.search_rrf(QUERY, k=10, judge=True, **arm_kw)
+    ids = [r[0]["id"] for r in res]
+    for gid in gold_ids:
+        if gid in ids:
+            r = ids.index(gid) + 1
+            ranks[gid] = r
+            states[gid] = res[ids.index(gid)][2].get("state")
+    top1 = sum(1 for r in ranks.values() if r == 1)
+    hit10 = len(ranks)
+    mrr = sum(1.0 / r for r in ranks.values()) / len(gold_ids)
+    return top1, hit10, mrr, ranks, states, meta
+
+
+def main():
+    global PASS, FAIL
+    tmp = tempfile.mkdtemp(prefix="mdcg_semanoise_")
+    try:
+        root = os.path.join(tmp, "root")
+        os.makedirs(root, exist_ok=True)
+        cg = MdCGOS(root)
+
+        for gid, fact in GOLD:
+            cg.add(gid, _doc(fact, GOLD_COND), layer="knowledge",
+                   verification_basis="test")
+        for gid, lst in NEIGHBORS.items():
+            for nid, fact, cond in lst:
+                cg.add(nid, _doc(fact, cond), layer="knowledge",
+                       verification_basis="test")
+        for nid, fact in NEG_TEXTS:
+            cg.add(nid, _doc(fact, NEG_COND, extra_neg=True), layer="knowledge",
+                   verification_basis="test",
+                   non_applicable_conditions=["刚才在干什么"])
+        for nid, fact, cond in UNREL_DOCS:
+            cg.add(nid, _doc(fact, cond), layer="knowledge",
+                   verification_basis="test")
+
+        gold_ids = [g for g, _ in GOLD]
+        ARMS = {
+            "A_lex": dict(paths=("lexical",)),
+            "B_sem": dict(paths=("fuzzy",)),
+            "C_fusion": dict(paths=("lexical", "bucket", "entity", "graph",
+                                    "fuzzy"), fusion="sum"),
+            "D_firewall": dict(paths=("lexical", "bucket", "entity", "graph",
+                                      "fuzzy"), fusion="sum", judge_ranking=True),
+        }
+        table = {}
+        for name, kw in ARMS.items():
+            top1, hit10, mrr, ranks, states, meta = _metrics(cg, kw, gold_ids)
+            table[name] = (top1, hit10, mrr)
+            print(f"{name:12s} top1={top1}/8  hit@10={hit10}/8  MRR={mrr:.3f}"
+                  + (f"  filtered={meta.get('judge_filtered')}"
+                     if name == "D_firewall" else ""))
+
+        c_top1, c_hit, c_mrr = table["C_fusion"]
+        d_top1, d_hit, d_mrr = table["D_firewall"]
+        a_top1, a_hit, a_mrr = table["A_lex"]
+        b_top1, b_hit, b_mrr = table["B_sem"]
+        print("\n排序污染测量（只报告，不预设）：C-A top1 差 = "
+              f"{a_top1 - c_top1}，C-A MRR 差 = {a_mrr - c_mrr:+.3f}")
+        print("防火墙增益（D-C）：top1 {:+d}，MRR {:+.3f}".format(
+            d_top1 - c_top1, d_mrr - c_mrr))
+
+        # ---------- 断言 ----------
+        ok(d_top1 >= c_top1 and d_mrr >= c_mrr - 1e-9,
+           "①防火墙不劣于裸融合（D≥C）")
+        # query-relative 否定剔除：否定节点声明的负条件是问句类型词面，
+        # 在同类问句下必须 REJECT（不依赖召回路径，直调裁决器验证）
+        bad = 0
+        for nid, _fact in NEG_TEXTS:
+            fm, c = cg._read(cg.index["nodes"][nid])
+            jn = MdCGOS.judge_qualification({"frontmatter": fm, "content": c},
+                                            QUERY, None)
+            if jn["state"] != STATE_REJECT:
+                bad += 1
+        ok(bad == 0,
+           f"②query-relative 否定剔除：{len(NEG_TEXTS)-bad}/{len(NEG_TEXTS)}"
+           " 个否定节点被 REJECT（「我没喝水」在「刚才在干什么」问句下"
+           "不得冒充事件）")
+        # 语义邻居「相关≠适用」：正条件不适用 → DEFER 降权而非 ACCEPT
+        fm, c = cg._read(cg.index["nodes"][NEIGHBORS["g1"][0][0]])
+        jn = MdCGOS.judge_qualification({"frontmatter": fm, "content": c},
+                                        QUERY, None)
+        ok(jn["state"] == "DEFER",
+           "②b 语义邻居「喝水对健康有好处」→ DEFER（正条件「问健康建议」"
+           "不适用该问句；相关但不适用）")
+        # query-relative：否定节点在该问句下不得冒充事件
+        res, _ = cg.search_rrf(QUERY, k=10, judge=True, judge_ranking=True)
+        st = {r[0]["id"]: r[2].get("state") for r in res}
+        ok(all("x" + g[1:] not in st for g in gold_ids),
+           "③top-10 无否定节点冒充（x* 全部被剔除）")
+        if c_top1 < a_top1:
+            ok(d_top1 >= a_top1,
+               "④融合确实产生排序污染（C<A 已实测）且防火墙恢复到词法水平（D≥A）")
+        else:
+            ok(True, "④本语料下融合未弱于词法（污染未实测到，如实记录）")
+        # gold 资格：正条件命中 → 全 ACCEPT（语义省略≠弱证据）
+        res2, _ = cg.search_rrf(QUERY, k=10, judge=True, judge_ranking=True)
+        gstates = {r[0]["id"]: r[2].get("state") for r in res2
+                   if r[0]["id"] in gold_ids}
+        ok(all(s == "ACCEPT" for s in gstates.values()),
+           f"⑤正条件命中的 episodic gold 全 ACCEPT（{len(gstates)} 条在 top-10）"
+           "——语义不完整不被降级")
+        # 同一记忆换问句 → 资格随情境变化（query-relative）
+        res3, _ = cg.search_rrf("你在哪里喝水", k=10, judge=True)
+        st3 = {r[0]["id"]: r[2] for r in res3 if r[0]["id"] == "g1"}
+        if st3:
+            ok(st3["g1"]["state"] != "ACCEPT",
+               "⑥query-relative：问「在哪里喝」时 g1 不再 ACCEPT（条件不适用→"
+               + st3["g1"]["state"] + "）——BLINDSPOT 是问出来的，不是存出来的")
+        else:
+            ok(True, "⑥query-relative：问「在哪里喝」时 g1 未被召回（等效不冒充）")
+    finally:
+        shutil.rmtree(tmp, ignore_errors=True)
+
+    print(f"\nsem_noise: {PASS} passed, {FAIL} failed")
+    if FAILS:
+        for f in FAILS:
+            print(f"  - {f}")
+    raise SystemExit(1 if FAIL else 0)
+
+
+if __name__ == "__main__":
+    main()