@furongjun1999/dsh-memory 0.5.0 → 0.6.0

package/md_cg/test_chain_read_isolate.py

@@ -0,0 +1,168 @@
+# -*- coding: utf-8 -*-
+"""读隔离守卫：因果链面（causal_chain / explain_chain / causal_path / 检索
+chain 路 provenance）不得泄漏不可见节点。
+
+缺陷形态（2026-09-25 检索域新发现，报告编号 N130 与他域冲突，以 where 定位，
+high）：MdCGOS.causal_chain / explain_chain（mdcos.py:3491-3506）裸转调
+chain.walk / chain.explain，causal_path（mdcos.py:3544→predict.py:1020）BFS
+直用 chain.adjacency——而 chain.adjacency（chain.py:127-159）以 cg.index 全量
+节点 frontmatter 建出边表，全程不经 cg.get / MdCGSecure._readable。任何持
+read op 的低权令牌（ROLE_SPECS 全表 ops_allow 均含 read；mdcg_causal 的
+_MDCG_OP_REQUIRE 即为 "read"）可：①对不可见节点起链；②看到链上不可见节点
+id、边条件文本与下游拓扑；③检索 chain 路 provenance（_path_chain→
+expand_from_seeds，同走 adjacency）把全链与秘密条件文本附带在可见节点条目上。
+
+修复：在 chain.adjacency 单点接可见性闸——cg 提供 `_chain_visible(nid)` 谓词
+（MdCGSecure 注入 = 索引有条目 ∧ _readable(e)；基类不注入行为零变化）时，
+不可见节点的出边整体不入表、可见节点指向不可见目标的边截断、层级合成边同
+闸；缓存键带上闸存在位。单点覆盖 walk / explain / causal_path /
+expand_from_seeds（检索 chain 路 provenance）全部消费者——比三方法各自覆盖
+多堵住 provenance 面，且预测器其余 adjacency 消费者（causal roadmap /
+共同父节点等）一并隔离。_readable 的绑定档判定恒用 principal.session
+（mdcos.py:3901-3906），实例身份稳定，adjacency 缓存无跨身份串台面。
+
+红项 = R1-R5（链/路径/解释/检索 provenance 四面泄漏复现）；
+G 项锁语义不变（designer/admin 可见性不变、可见-可见边链照常展开、get 隔离
+基线）。
+运行：python -m md_cg.test_chain_read_isolate
+"""
+from __future__ import annotations
+
+import os
+import shutil
+import sys
+import tempfile
+
+try:
+    from .mdcos import MdCGSecure
+    from .security import Principal
+except ImportError:                                  # 直接脚本运行
+    sys.path.insert(0, os.path.dirname(os.path.dirname(os.path.abspath(__file__))))
+    from md_cg.mdcos import MdCGSecure
+    from md_cg.security import Principal
+
+PASS = FAIL = 0
+FAILS = []
+
+_SECRET_COND = "Y侧秘密条件文本YY"
+_SECRET_ID = "Y秘密"
+
+
+def ok(cond, label):
+    global PASS, FAIL
+    if cond:
+        PASS += 1
+        print(f"  OK   {label}")
+    else:
+        FAIL += 1
+        FAILS.append(label)
+        print(f"  FAIL {label}")
+
+
+def _body(name):
+    return (f"# 功能名：{name}\n# 生效条件：无条件\n# 子功能：无\n"
+            f"# 执行：无\n# 验证方式：test\n# 不适用条件：无\n\n正文。")
+
+
+def main():
+    tmp = tempfile.mkdtemp(prefix="mdcg_chain_iso_")
+    try:
+        root = os.path.join(tmp, "kg")
+        # 写者：designer（can_admin → private 档可见），建链 X→Y→Z
+        dw = Principal(actor="designer-1", role="designer", can_write=True,
+                       can_admin=True, clearance="secret")
+        cg = MdCGSecure(root, principal=dw, master_key=bytes(range(32)))
+        cg.add("X苹果", _body("X苹果"), layer="knowledge", sensitivity="internal",
+               edges=[{"target": _SECRET_ID, "relation_type": "causal",
+                       "condition": _SECRET_COND, "confidence": 0.9}])
+        cg.add(_SECRET_ID, _body("Y秘密"), layer="knowledge", sensitivity="private",
+               edges=[{"target": "Z结论", "relation_type": "causal",
+                       "condition": "到Z的显性条件", "confidence": 0.9}])
+        cg.add("Z结论", _body("Z结论"), layer="knowledge", sensitivity="internal")
+        # 可见-可见对照链：A内→B内（reader 应照常展开）
+        cg.add("A内", _body("A内"), layer="knowledge", sensitivity="internal",
+               edges=[{"target": "B内", "relation_type": "causal",
+                       "condition": "显性条件AB", "confidence": 0.8}])
+        cg.add("B内", _body("B内"), layer="knowledge", sensitivity="internal")
+        cg.close()
+
+        # 读者：record 角色，clearance=internal（低于 private），异会话
+        rd = Principal(actor="reader-1", role="record", can_write=True,
+                       can_admin=False, clearance="internal",
+                       layers_allow=["knowledge"], ops_allow=["read"])
+        r = MdCGSecure(root, principal=rd, master_key=bytes(range(32)))
+
+        # R0 基线：get 读隔离本就生效（旧码即过，锁语义）
+        ok(r.get(_SECRET_ID) is None, "R0 基线：reader.get(Y秘密) 隔离生效")
+
+        # R1 链展开：不可见中转节点 id + 边条件文本不得出现在链输出
+        chains = r.causal_chain("X苹果")
+        blob = repr(chains)
+        ok(_SECRET_ID not in blob,
+           "R1a causal_chain(X苹果) 输出不含不可见节点 id")
+        ok(_SECRET_COND not in blob,
+           "R1b causal_chain(X苹果) 输出不含秘密边条件文本")
+
+        # R2 不可见节点起链：应与节点不存在同形（空链）
+        ok(r.causal_chain(_SECRET_ID) == [],
+           "R2 causal_chain(Y秘密) 不可见起点返回空链")
+
+        # R3 解释面：同源 walk，渲染输出不得带秘密
+        ex = r.explain_chain("X苹果")
+        ok(_SECRET_ID not in repr(ex) and _SECRET_COND not in repr(ex),
+           "R3 explain_chain(X苹果) 渲染输出零泄漏")
+
+        # R4 因果路径：经不可见中转的路径不可达
+        cp = r.causal_path("X苹果", "Z结论")
+        ok(not cp.get("reachable") and _SECRET_ID not in repr(cp)
+           and _SECRET_COND not in repr(cp),
+           "R4 causal_path(X苹果→Z结论) 不可达且零泄漏")
+
+        # R5 检索 chain 路：provenance/chain 字段（evidence ⑤ 所指）不得携带
+        # 不可见全链。注意范围：可读节点**自身 frontmatter 的 edges 元数据**
+        # 随节点视图返回是另一回事（读者本就可读该节点的 md 原文），不在
+        # 本缺陷（链展开面）范围。prov 形态：nid → [{"path","rank",
+        # "chain"?,"conditions"?}, …]；结果 4 元组第 4 位同源。
+        res, meta = r.search_rrf("苹果", paths=("lexical", "chain"), record=False)
+        chain_fields = []
+        for entries in ((meta or {}).get("provenance") or {}).values():
+            chain_fields.extend(en for en in entries
+                                if isinstance(en, dict) and en.get("chain"))
+        for t in res:
+            if isinstance(t, tuple) and len(t) >= 4 and isinstance(t[3], list):
+                chain_fields.extend(en for en in t[3]
+                                    if isinstance(en, dict) and en.get("chain"))
+        ok(all(_SECRET_ID not in repr(en.get("chain")) for en in chain_fields),
+           "R5a search_rrf provenance 链不含不可见节点 id")
+        ok(all(_SECRET_COND not in repr(en.get("conditions"))
+               for en in chain_fields),
+           "R5b search_rrf provenance 条件不含秘密文本")
+
+        # G1 可见-可见链照常展开（闸不误伤本职语义）
+        ok(r.causal_chain("A内") != [],
+           "G1a reader 对可见链 A内→B内 照常展开")
+        ok("显性条件AB" in repr(r.causal_chain("A内")),
+           "G1b 可见边条件文本照常返回")
+
+        # G2 designer/admin 可见性不变（private 档链对设计者完整可见）
+        cg2 = MdCGSecure(root, principal=dw, master_key=bytes(range(32)))
+        dch = cg2.causal_chain("X苹果")
+        ok(any(_SECRET_ID in c.get("nodes", []) for c in dch),
+           "G2a designer causal_chain 照常含 private 节点（admin 可见性不变）")
+        ok(any(_SECRET_COND in c.get("conditions", []) for c in dch),
+           "G2b designer 照常见到边条件文本")
+        cg2.close()
+        r.close()
+    finally:
+        shutil.rmtree(tmp, ignore_errors=True)
+
+    print("\n" + "=" * 60)
+    print(f"结果：PASS {PASS} / FAIL {FAIL}")
+    if FAILS:
+        for f in FAILS:
+            print(f"  - {f}")
+    return 0 if FAIL == 0 else 1
+
+
+if __name__ == "__main__":
+    sys.exit(main())

package/md_cg/test_datapath_device_name.py

@@ -0,0 +1,203 @@
+# -*- coding: utf-8 -*-
+"""test_datapath_device_name.py · Windows 保留设备名末段吞路径的守卫（issue #39 相邻缺陷）
+
+现场（Windows 实测）：``ntpath.abspath`` 经 ``GetFullPathNameW`` 归一路径时，若
+路径**末段是 Windows 保留设备名**（aux/con/nul/prn/com1-9/lpt1-9 等），整个路径
+被吞成设备命名空间形态——env 设 ``MDCG_AUX_ROOT=<临时目录>\\aux`` 时
+``datapath.aux_root()`` 返回 ``\\\\.\\aux``，原目录语义**静默丢失**：密钥/令牌/
+信任面被指到不存在的设备路径，覆盖键静默失联（不报错、最难察觉的失败形态）。
+``abspath`` 是纯字符串归一**不触盘**，故守卫只需把 env 指向含保留名末段的
+**不存在路径**即可实弹复现——绝不能真的创建 aux 末段目录（Win32
+CreateDirectory 同样被设备名劫持）。
+
+修复（本守卫的红绿两态锚点）：``md_cg/datapath.py`` 新增模块级
+``_abs_host_path(p, env_key)``——Windows（os.name=="nt"）上归一结果以
+``\\\\.\\`` 前缀开头即抛 ValueError（消息含键名与「保留设备名」字样及改法）；
+``state_root``/``data_root``/``mdcg_root``/``aux_root`` 四处 env 覆盖面（含
+paths.json 直值面）改走该辅助。非 Windows 平台 ``\\\\.\\aux`` 是合法目录名
+字面量，**不判定**（§4 在 POSIX 上反断言「不抛」，守住平台闸本身）。
+承接面：``mcp_server.main()`` 启动早期对 root/aux 各探一次，ValueError →
+stderr 告警 + return 2（对照 `_md_cg_` 前缀守卫先例「启动即拒绝，不带病运行」）。
+
+隔离纪律：四个覆盖键（MDCG_STATE_ROOT/MDCG_DATA_ROOT/MDCG_ROOT/MDCG_AUX_ROOT）
+与 DSH_HOME 以 os.environ 副本注入、finally 逐键还原；探针路径全部是
+tempfile.mkdtemp 下**不存在**的纯字符串（或正常临时子目录），不创建任何含
+保留名的真实目录，不触真实令牌库与真实状态根。env 直设即命中各函数第一分支，
+paths.json 回落面零参与。
+
+自检 floor：断言总数低于 FLOOR 视为失败——防「探针面失效 → 假绿」。
+"""
+from __future__ import annotations
+
+import os
+import shutil
+import sys
+import tempfile
+
+try:
+    sys.stdout.reconfigure(encoding="utf-8", errors="replace")
+except AttributeError:
+    pass
+
+from .datapath import (ENV_AUX_ROOT, ENV_DATA_ROOT, ENV_MDCG_ROOT,
+                       ENV_STATE_ROOT, aux_root, data_root, mdcg_root,
+                       state_root)
+
+FLOOR = 8            # 断言总数下限（防假绿）
+PASS, FAIL = 0, 0
+
+#: 守卫注入/还原面（含 DSH_HOME——state_root 的第二档，一并与真实环境隔离）
+_GUARD_KEYS = (ENV_STATE_ROOT, ENV_DATA_ROOT, ENV_MDCG_ROOT, ENV_AUX_ROOT,
+               "DSH_HOME")
+
+
+def check(name, cond, detail=""):
+    global PASS, FAIL
+    if cond:
+        PASS += 1
+        print(f"  [ok] {name}")
+    else:
+        FAIL += 1
+        print(f"  [FAIL] {name}  {detail}")
+
+
+def _probe_reject(fn, key, tail, tmp):
+    """设 env=<tmp>/<tail>（不存在的纯字符串路径）→ 返回 (抛出异常, 异常消息)。
+
+    红态（修复前）fn() 不抛而返回 \\\\.\\<tail> 形态——由调用方断言兜住。
+    """
+    os.environ[key] = os.path.join(tmp, tail)
+    try:
+        fn()
+    except ValueError as ve:
+        return True, str(ve)
+    return False, ""
+
+
+def _func_window(src: str, func_name: str) -> str:
+    """取 src 中 ``def <func_name>`` 起到下一个顶层 ``def ``/``class`` 的源窗口。"""
+    start = src.find(f"def {func_name}(")
+    if start < 0:
+        return ""
+    nxt = src.find("\ndef ", start + 1)
+    nxt_cls = src.find("\nclass ", start + 1)
+    ends = [e for e in (nxt, nxt_cls) if e > 0]
+    return src[start:min(ends)] if ends else src[start:]
+
+
+def main():
+    saved = {k: os.environ.get(k) for k in _GUARD_KEYS}
+    tmp = tempfile.mkdtemp(prefix="mdcg_devname_")
+    try:
+        for k in _GUARD_KEYS:
+            os.environ.pop(k, None)
+
+        # ---- 1. 实弹红转绿核心：MDCG_AUX_ROOT 末段 aux → aux_root() 必须拒绝 ----
+        print("[1] 实弹核心：MDCG_AUX_ROOT=<临时目录>\\aux（不存在，纯字符串）")
+        raised, msg = _probe_reject(aux_root, ENV_AUX_ROOT, "aux", tmp)
+        if os.name == "nt":
+            check("1a aux_root() 抛 ValueError（红态：静默返回 \\\\.\\aux 不抛）",
+                  raised, f"msg={msg[:160]!r}")
+            check("1b 消息含覆盖键名 MDCG_AUX_ROOT（定位误配来源）",
+                  ENV_AUX_ROOT in msg, f"msg={msg[:160]!r}")
+            check("1c 消息含「保留设备名」字样（说清劫持机理）",
+                  "保留设备名" in msg, f"msg={msg[:160]!r}")
+        else:
+            # 与 [4] 同口径：平台门在 `_abs_host_path`（`os.name == "nt"`），POSIX 上
+            # `\\.\aux` 是合法目录名字面量，不判定 → 必须不抛且原样返回。
+            check("1a 非 Windows 不判定（\\\\.\\aux 是合法目录名字面量，原样返回不抛）",
+                  not raised, f"msg={msg[:160]!r}")
+            check("1b 非 Windows 不判定：不产生保留设备名拒因（消息为空）",
+                  msg == "", f"msg={msg[:160]!r}")
+            check("1c 非 Windows 不判定：aux_root() 原样返回该路径（未被吞成设备路径）",
+                  aux_root() == os.path.abspath(os.path.join(tmp, "aux")),
+                  f"aux_root()={aux_root()!r}")
+
+        # ---- 2. 同族四面：state/data/mdcg 各 env 面同样拒绝 ----
+        print("[2] 同族 env 面（MDCG_STATE_ROOT/MDCG_DATA_ROOT/MDCG_ROOT）")
+        for key, fn, tail in ((ENV_STATE_ROOT, state_root, "con"),
+                              (ENV_DATA_ROOT, data_root, "nul"),
+                              (ENV_MDCG_ROOT, mdcg_root, "aux")):
+            raised, msg = _probe_reject(fn, key, tail, tmp)
+            if os.name == "nt":
+                check(f"2·{key}: {fn.__name__}() 抛 ValueError 且消息含键名"
+                      "（env 直设命中第一分支，paths.json 零参与）",
+                      raised and key in msg,
+                      f"raised={raised} msg={msg[:160]!r}")
+            else:
+                # 与 [4] 同口径：平台门在 `_abs_host_path`，POSIX 不判定保留设备名。
+                check(f"2·{key}: 非 Windows 不判定（末段 {tail} 是合法目录名，"
+                      f"{fn.__name__}() 原样返回不抛）",
+                      not raised
+                      and fn() == os.path.abspath(os.path.join(tmp, tail)),
+                      f"raised={raised} msg={msg[:160]!r} got={fn()!r}")
+
+        # ---- 3. 正常路径不误伤：无保留名末段 → abspath 原样返回 ----
+        print("[3] 正常路径不误伤（临时子目录，末段无保留名）")
+        normals = {}
+        for name in ("state", "data", "cgroot", "auxroot"):
+            p = os.path.join(tmp, name)
+            os.makedirs(p, exist_ok=True)
+            normals[name] = p
+        os.environ[ENV_STATE_ROOT] = normals["state"]
+        os.environ[ENV_DATA_ROOT] = normals["data"]
+        os.environ[ENV_MDCG_ROOT] = normals["cgroot"]
+        os.environ[ENV_AUX_ROOT] = normals["auxroot"]
+        check("3a 四面正常值全部原样返回（不抛、不变形）",
+              state_root() == os.path.abspath(normals["state"])
+              and data_root() == os.path.abspath(normals["data"])
+              and mdcg_root() == os.path.abspath(normals["cgroot"])
+              and aux_root() == os.path.abspath(normals["auxroot"]),
+              f"state={state_root()!r} data={data_root()!r} "
+              f"mdcg={mdcg_root()!r} aux={aux_root()!r}")
+
+        # ---- 4. 保留名清单抽查（aux_root 面）：Windows 全抛；POSIX 反断言不抛 ----
+        print("[4] 保留名清单抽查（aux/con/nul/com1/lpt1）")
+        for tail in ("aux", "con", "nul", "com1", "lpt1"):
+            raised, msg = _probe_reject(aux_root, ENV_AUX_ROOT, tail, tmp)
+            if os.name == "nt":
+                check(f"4·{tail}: aux_root() 抛 ValueError（GetFullPathNameW "
+                      "劫持被拦）", raised, f"msg={msg[:160]!r}")
+            else:
+                check(f"4·{tail}: 非 Windows 不判定（\\\\.\\{tail} 是合法目录名"
+                      "字面量，原样返回不抛）",
+                      not raised, f"msg={msg[:160]!r}")
+
+        # ---- 5. 源断言：辅助函数在、四处 env 面改走它、未改面逐字保留 ----
+        print("[5] 源断言（datapath.py 四处 env 面 + mcp_server 承接）")
+        here = os.path.dirname(os.path.abspath(__file__))
+        with open(os.path.join(here, "datapath.py"), encoding="utf-8") as fh:
+            src = fh.read()
+        check("5a datapath.py 定义 _abs_host_path",
+              "def _abs_host_path(" in src)
+        for fname in ("state_root", "data_root", "mdcg_root", "aux_root"):
+            check(f"5·{fname}: 函数体改走 _abs_host_path（env 覆盖面全覆盖）",
+                  "_abs_host_path(" in _func_window(src, fname))
+        check("5e plugin_root 基于 __file__ 的 abspath 未改（非攻击/误配面，逐字保留）",
+              "os.path.abspath(__file__)" in _func_window(src, "plugin_root"))
+        with open(os.path.join(here, "mcp_server.py"), encoding="utf-8") as fh:
+            msrc = fh.read()
+        mwin = msrc[msrc.find("def main"):msrc.find("def main") + 2000]
+        check("5f mcp_server.main() 启动早期探 root/aux 且 ValueError → return 2",
+              "_probe_root" in mwin and "_probe_aux" in mwin
+              and "except ValueError" in mwin and "return 2" in mwin,
+              "main() 首段缺承接受理")
+
+        # ---- 6. 守卫自检 floor ----
+        print("[6] 守卫自检")
+        check(f"6a 断言总数 ≥ {FLOOR}（防探针面失效假绿）",
+              PASS + FAIL >= FLOOR, f"total={PASS + FAIL}")
+    finally:
+        for k, v in saved.items():
+            if v is None:
+                os.environ.pop(k, None)
+            else:
+                os.environ[k] = v
+        shutil.rmtree(tmp, ignore_errors=True)
+
+    print(f"\n=== datapath device-name tests: {PASS} passed, {FAIL} failed ===")
+    sys.exit(1 if FAIL else 0)
+
+
+if __name__ == "__main__":
+    sys.exit(main())

package/md_cg/test_emit_negtail_cache.py

@@ -0,0 +1,156 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+"""_emit 尾部 covered_neg 裸读守卫（v9 留档复测·修复，缺陷迭代第 14 轮）。
+
+缺陷形态（缺陷报告实测，60 knowledge + 8 rejected 临时库，逐位复现）：
+  _emit 尾部「把被负记忆覆盖的查询也作为结果条目返回」对 neg_coverage[:3]
+  逐条裸 open+nodefile.loads（mdcg.py _emit 尾，不经 self._read 不在读缓存
+  包装面）——每条命中负层的查询恒 ≤3 次盘读（Q1 loads=71=全池 60+负层
+  扫描 8+尾部 3；Q2 同查询增量恰 3）；负层主面 IO 已被读缓存覆盖（残余项）。
+
+修复口径：尾部改走 self._read(nc)（读缓存覆盖，增量归零）；_read 同款
+  _node_disk_path 边界闸（P2-20——索引被污染时不得绕过统一校验读 root 外
+  文件）、OSError→(None,None) 与旧 continue 同义；负层写路径（add/
+  add_rejected → _stage 标脏带 path）在读缓存脏集精确失效面内——覆写后
+  尾部条目即时见新内容，不陈旧。
+
+本守卫（调用计数断言形态，非时间阈值）：
+  E1 热缓存后同查询 loads 增量 == 0（旧实现恒 3 → 红）；
+  E2 功能在位：rejected 前 3 条仍在结果、covered_neg 计数/tier/scanned
+     不变（尾部不是被静默关掉）；
+  E3 两轮查询结果 ids 逐位一致（确定性）；
+  E4 读缓存开/关（MDCG_READ_CACHE=1/0）同库同查询 ids 逐位一致；
+  E5 覆写负层节点后尾部条目见新内容（脏集精确失效联动，不陈旧）。
+
+运行：python -m md_cg.test_emit_negtail_cache
+"""
+import os
+import shutil
+import sys
+import tempfile
+
+sys.path.insert(0, os.path.dirname(os.path.dirname(os.path.abspath(__file__))))
+
+from md_cg import nodefile                     # noqa: E402
+from md_cg.mdcos import MdCGOS                 # noqa: E402
+
+PASS = 0
+FAIL = 0
+FAILS = []
+
+N = 60
+NNEG = 8
+QUERY = "已被否决的做法"
+
+
+def check(name, cond, detail=""):
+    global PASS, FAIL
+    if cond:
+        PASS += 1
+        print(f"  OK   {name}")
+    else:
+        FAIL += 1
+        FAILS.append(name)
+        print(f"  FAIL {name}  {detail}")
+
+
+def build_lib(root):
+    cg = MdCGOS(root)
+    for i in range(N):
+        cg.add("mem_%03d" % i,
+               "# 功能名：正层样本 %d\n# 正文：蜂群调度 节点 %d" % (i, i),
+               layer="knowledge")
+    for j in range(NNEG):
+        cg.add("r%d" % j,
+               "# 假设：%s 第 %d 号\n# 原因：与既有验证结论冲突" % (QUERY, j),
+               layer="rejected", verification_basis="test")
+    cg.flush()
+    return cg
+
+
+def count_loads(fn):
+    st = {"n": 0}
+    real = nodefile.loads
+
+    def _spy(*a, **kw):
+        st["n"] += 1
+        return real(*a, **kw)
+
+    nodefile.loads = _spy
+    try:
+        return fn(), st["n"]
+    finally:
+        nodefile.loads = real
+
+
+def neg_ids(res):
+    return [x[0].get("id") for x in res if str(x[0].get("id")).startswith("rejected/")]
+
+
+def main():
+    root = tempfile.mkdtemp(prefix="mdcg_negtail_")
+    cg = None
+    try:
+        os.environ.pop("MDCG_READ_CACHE", None)
+        cg = build_lib(root)
+        (r1, m1), n1 = count_loads(lambda: cg.search(QUERY))
+        ids1 = [x[0].get("id") for x in r1]
+        check("E0a 首查口径复现：covered_neg=8、tier=T3、scanned=60",
+              len(m1.get("covered_neg") or []) == NNEG
+              and m1.get("tier") == "T3_global_scan"
+              and m1.get("scanned") == N,
+              f"covered={len(m1.get('covered_neg') or [])} "
+              f"tier={m1.get('tier')} scanned={m1.get('scanned')}")
+        check("E0b rejected 前 3 条在结果（尾部功能在位）",
+              neg_ids(r1)[:3] == ["rejected/r0.md", "rejected/r1.md",
+                                  "rejected/r2.md"],
+              f"neg={neg_ids(r1)[:3]}")
+
+        (r2, m2), n2 = count_loads(lambda: cg.search(QUERY))
+        ids2 = [x[0].get("id") for x in r2]
+        check("E1a 热缓存后同查询 loads 增量 == 0（旧实现恒 3）",
+              n2 == 0, f"loads={n2}")
+        check("E2a rejected 前 3 条仍逐位在位、meta 口径不变",
+              neg_ids(r2)[:3] == ["rejected/r0.md", "rejected/r1.md",
+                                  "rejected/r2.md"]
+              and len(m2.get("covered_neg") or []) == NNEG
+              and m2.get("tier") == "T3_global_scan"
+              and m2.get("scanned") == N)
+        check("E3a 两轮查询结果 ids 逐位一致", ids1 == ids2,
+              f"n={len(ids1)}/{len(ids2)}")
+
+        # E4 读缓存开/关结果一致
+        os.environ["MDCG_READ_CACHE"] = "0"
+        try:
+            cg0 = MdCGOS(root)
+            r_off, m_off = cg0.search(QUERY)
+            cg0.close()
+            check("E4a 读缓存开/关同库同查询 ids 逐位一致",
+                  [x[0].get("id") for x in r_off] == ids2)
+        finally:
+            os.environ.pop("MDCG_READ_CACHE", None)
+
+        # E5 覆写负层节点 → 尾部条目即时见新内容（脏集精确失效联动）
+        cg.add("r0", "# 假设：%s 第 0 号\n# 原因：覆写后的新结论ZZZ" % QUERY,
+               layer="rejected", verification_basis="test")
+        r3, _ = cg.search(QUERY)
+        neg3 = next((x[0] for x in r3
+                     if x[0].get("id") == "rejected/r0.md"), None)
+        check("E5a 覆写 r0 后尾部条目见新内容（不陈旧）",
+              neg3 is not None and "新结论ZZZ" in (neg3.get("content") or ""),
+              f"content={str((neg3 or {}).get('content'))[:40]}")
+        cg.close()
+    finally:
+        os.environ.pop("MDCG_READ_CACHE", None)
+        shutil.rmtree(root, ignore_errors=True)
+
+    print("\n" + "=" * 60)
+    print(f"结果：PASS {PASS} / FAIL {FAIL}")
+    if FAILS:
+        for f in FAILS:
+            print(f"  - {f}")
+    return 0 if FAIL == 0 else 1
+
+
+if __name__ == "__main__":
+    sys.exit(main())