@furongjun1999/dsh-memory 0.5.0 → 0.6.0

package/md_cg/test_govern_directread.py

@@ -0,0 +1,421 @@
+# -*- coding: utf-8 -*-
+"""治理写面读-改-写直读守卫（缺陷：读缓存默认开 × 治理 RMW 读点未走 direct_read）。
+
+缺陷形态（缺陷报告 2026-09-25 复现证实，high）：读缓存默认开
+（readcache.py:36-38 install 默认装配，mdcos.py:366-368 构造即装）后，
+`cg._read` 是进程内脏代际快照——**只对本实例写路径失效**。治理面的
+读-改-写（ccgc.link/recalibrate、crosscheck 主流程/回滚、
+vision_evidence 执行/回滚）若在写前用 `cg._read` 重查节点，
+则「A 常驻实例检索装载缓存 → B 另一实例以统一写口 `_write_node`
+落盘修正 → A 同实例执行治理写」时，A 读到的是**装载时的旧快照**，
+写回后 B 的修正被静默覆盖丢失（默认开组幸存=False；
+MDCG_READ_CACHE=0 对照组幸存=True）。
+
+修复口径（与第 7 轮 backfill 15 处 / mreview.govern 3 处一致）：
+治理文件写前重查/回滚比对读点改走 `readcache.direct_read`
+（穿透缓存读盘上真值）。本守卫先证旧代码红（G1-G6），再由修复转绿。
+
+断言分两类：
+  G1-G6  红守卫（cg/x 参数传入常驻实例 → 陈旧形态真实可达）：
+         G1/G2 ccgc.recalibrate / link；G3/G4 crosscheck 主流程 / 回滚；
+         G5/G6 vision_evidence.apply / rollback。
+  G7-G12 口径守卫（consolidate 六读点为 root 入口内部自建**新实例**，
+         单次调用内首触即盘上真值，先写 B 修正并不丢失——断言改为
+         「direct_read 改动不破坏这些流程」，非红证明）。
+
+运行：python -m md_cg.test_govern_directread
+"""
+from __future__ import annotations
+
+import json
+import os
+import shutil
+import sys
+import tempfile
+
+from . import ccgc, consolidate, crosscheck, vision_evidence
+from .mdcos import MdCGOS
+
+PASS = FAIL = 0
+FAILS = []
+
+MARK = "B实例的重要修正v1"
+MARK2 = "B实例的重要修正v2"
+
+CS_FULL = {
+    "observation_position": "此功能在本地文件系统中生效",
+    "observation_tool": "该方法使用扩展名映射表进行路由",
+    "time_window": [0.0, 9999999999.0],
+    "existence_constraint": "仅对本地可读文件生效",
+}
+
+
+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 _disk(root, nid):
+    """盘上真值直读：新实例首触（构造后未读该路径）即磁盘当前内容。"""
+    cg = MdCGOS(root)
+    e = (cg.index.get("nodes") or {}).get(nid)
+    if not e:
+        return None, None
+    fn = getattr(cg, "_read_uncached", None) or cg._read
+    return fn(e)
+
+
+def _b_write(root, nid, marker):
+    """B = 另一实例（全合作写者）：读盘上真值 → 加 fm 标记 → 统一写口落盘。"""
+    b = MdCGOS(root)
+    e = b.index["nodes"][nid]
+    fm, content = b._read(e)              # B 新实例首触 = 盘上真值
+    fm["owner_note"] = marker
+    b._write_node(nid, os.path.join(root, e["path"]), fm, content,
+                  durable=True)
+    return marker
+
+
+def _warm(a, nid):
+    """A 常驻实例检索装载缓存（生产形态：search/_read 装配后常驻）。"""
+    return a._read(a.index["nodes"][nid])
+
+
+def _doc(fn, cond, sub, exe, va="", neg="问完全无关主题"):
+    lines = [f"# 功能名：{fn}", f"# 生效条件：{cond}",
+             f"# 子功能：{sub}", f"# 执行：{exe}"]
+    if va:
+        lines.append(f"# 验证方式：{va}")
+    lines.append(f"# 不适用条件：{neg}")
+    return "\n".join(lines) + "\n"
+
+
+# ---- G1 ccgc.recalibrate（缺陷报告原样复现：ccgc.py:841 读 → :860 写）----
+
+def g1_recalibrate(tmp):
+    print("== G1 ccgc.recalibrate（缺陷原样复现） ==")
+    root = os.path.join(tmp, "g1")
+    os.makedirs(root)
+    a = MdCGOS(root)
+    a.add("gd_recal", "# 功能名：直读守卫节点\n\n正文。\n", layer="knowledge",
+          condition_space=dict(CS_FULL))
+    a.flush()
+    _warm(a, "gd_recal")                    # A 装载缓存
+    _b_write(root, "gd_recal", MARK)        # B 统一写口落盘重要修正
+    fm_a, _ = _warm(a, "gd_recal")
+    ok(fm_a.get("owner_note") is None,
+       "G1a A 进程内缓存陈旧（治理写前重查命中旧代际）")
+    rc = ccgc.recalibrate("gd_recal",
+                          {"existence_constraint": "修正后的存在约束GD"},
+                          "designer", "agent:a1", evidence="守卫复核",
+                          cg=a, apply=True)
+    ok(rc.ok and rc.written == 1, "G1b recalibrate 执行成功（含写入）")
+    fm, _content = _disk(root, "gd_recal")
+    ok(fm.get("owner_note") == MARK,
+       "G1c B 修正幸存（写前重查走盘上真值，不被陈旧缓存覆盖）")
+    ok((fm.get("condition_space") or {}).get("existence_constraint")
+       == "修正后的存在约束GD", "G1d A 的治理写入仍生效")
+
+    # 对照组：MDCG_READ_CACHE=0（退出阀）同流程 → 无陈旧，恒幸存
+    os.environ["MDCG_READ_CACHE"] = "0"
+    try:
+        root0 = os.path.join(tmp, "g1_ctl")
+        os.makedirs(root0)
+        a0 = MdCGOS(root0)
+        a0.add("gd_recal", "# 功能名：直读守卫节点\n\n正文。\n",
+               layer="knowledge", condition_space=dict(CS_FULL))
+        a0.flush()
+        _warm(a0, "gd_recal")
+        _b_write(root0, "gd_recal", MARK)
+        rc0 = ccgc.recalibrate("gd_recal",
+                               {"existence_constraint": "修正后的存在约束GD"},
+                               "designer", "agent:a1", cg=a0, apply=True)
+        fm0, _ = _disk(root0, "gd_recal")
+        ok(rc0.ok and fm0.get("owner_note") == MARK,
+           "G1e 对照组（缓存关）B 修正幸存——丢失由默认开缓存引入")
+    finally:
+        os.environ.pop("MDCG_READ_CACHE", None)
+
+
+# ---- G2 ccgc.link（ccgc.py:757 读 → :784 写）----
+
+DIALOG = ("文件摄取分派：按扩展名把文件路由到对应摄取器"
+          "。该方法使用扩展名映射表进行路由"
+          "。此功能在本地文件系统中生效"
+          "。仅对本地可读文件生效"
+          "。2026-09-16"
+          "。通过回放测试验证"
+          "。二进制文件不适用")
+
+SLOTS = {
+    "observation_position": {"value": "此功能在本地文件系统中生效"},
+    "observation_tool": {"value": "该方法使用扩展名映射表进行路由"},
+    "time_window": {"value": [0.0, 9999999999.0]},
+    "existence_constraint": {"value": "仅对本地可读文件生效"},
+}
+
+MARKS = {
+    "功能名": {"value": "文件摄取分派：按扩展名把文件路由到对应摄取器"},
+    "子功能": {"value": "按扩展名把文件路由到对应摄取器"},
+    "执行": {"value": "使用扩展名映射表进行路由"},
+    "验证方式": {"value": "回放测试", "basis": "test"},
+    "不适用条件": {"value": "二进制文件不适用"},
+}
+
+
+def g2_link(tmp):
+    print("== G2 ccgc.link ==")
+    root = os.path.join(tmp, "g2")
+    os.makedirs(root)
+    a = MdCGOS(root)
+    a.add("gd_link", "# 功能名：待编译节点\n\n占位正文。\n", layer="knowledge")
+    a.flush()
+    _warm(a, "gd_link")
+    _b_write(root, "gd_link", MARK)
+    r = ccgc.compile_dialog(DIALOG, "gd_link", "agent:a1",
+                            slots=SLOTS, marks=MARKS, cg=a)
+    ok(r.success, "G2a 编译成功")
+    a_ok = ccgc.attest("gd_link", ccgc.ACCEPT, "designer", "agent:a1",
+                       evidence="守卫：候选与对话原文一致", cg=a)
+    ok(a_ok.ok, "G2b 编外验证方签章")
+    l = ccgc.link(r, a_ok, cg=a, apply=True)
+    ok(l.ok and l.written == 6, "G2c link 写入六行")
+    fm, _c = _disk(root, "gd_link")
+    ok(fm.get("owner_note") == MARK, "G2d B 修正幸存（link 写前重查走直读）")
+    ok(fm.get("condition_space") == {k: v["value"] for k, v in SLOTS.items()},
+       "G2e link 自身写入仍生效（condition_space 落盘）")
+
+
+# ---- G3/G4 crosscheck 主流程（:344/:786 读 → :674 写）与回滚（:941 读 → :970 写）----
+
+SRC_MEASURE = ["《函数单调性基准集》v1 第 3 节"]
+SCI_NAME = "数学·函数单调性判定"
+
+
+def _verdict_rows(nid, value):
+    return [
+        {"id": nid, "unit": "reflect", "field": "验证方式", "value": value,
+         "basis": "measurement", "source": SRC_MEASURE, "verdict": "accept"},
+        {"id": nid, "unit": "verify", "field": "验证方式", "value": value,
+         "verdict": "accept"},
+    ]
+
+
+def g3_crosscheck(tmp):
+    print("== G3 crosscheck 主流程（写前重查） ==")
+    root = os.path.join(tmp, "g3")
+    os.makedirs(root)
+    a = MdCGOS(root)
+    a.add("gd_cc", _doc("函数单调性判定", "问单调性", "判定单调区间", "取导数定号"),
+          layer="knowledge", state_attributes={"name": SCI_NAME})
+    a.flush()
+    _warm(a, "gd_cc")
+    _b_write(root, "gd_cc", MARK)
+    rep = crosscheck.crosscheck(a, ids=["gd_cc"],
+                                verdicts=_verdict_rows("gd_cc",
+                                                       "以基准函数集实测判定单调区间"),
+                                apply=True, batch="gdxb", actor="guard")
+    ok(rep["written"] == 1, f"G3a crosscheck 写入 1（实测 {rep['written']}）")
+    fm, c = _disk(root, "gd_cc")
+    ok(fm.get("owner_note") == MARK, "G3b B 修正幸存（:786 写前重查走直读）")
+    ok(fm.get("verification_basis") == "measurement"
+       and "# 验证方式：以基准函数集实测判定单调区间" in c,
+       "G3c crosscheck 自身写入仍生效")
+    return root
+
+
+def g4_crosscheck_rollback(root):
+    print("== G4 crosscheck.rollback（回滚比对） ==")
+    a2 = MdCGOS(root)
+    _warm(a2, "gd_cc")                       # A2 装载（含上一步 evidence 现场）
+    _b_write(root, "gd_cc", MARK2)           # B 再落一笔修正
+    rep2 = crosscheck.rollback(a2, batch="gdxb")
+    ok(rep2["reverted"] == 1, f"G4a 回滚 1（实测 {rep2['reverted']}）")
+    fm, c = _disk(root, "gd_cc")
+    ok(fm.get("owner_note") == MARK2,
+       "G4b B 修正幸存（:941 回滚比对走直读，write_id 防护所验 fm 为盘上真值）")
+    ok(fm.get("verification_basis") is None
+       and "# 验证方式：" not in c,
+       "G4c 回滚自身仍生效（验证方式行/基底还原）")
+
+
+# ---- G5/G6 vision_evidence.apply（:296/:495 读 → :522 写）与 rollback（:579 读 → :591 写）----
+
+def g5_vision_apply(tmp):
+    print("== G5 vision_evidence.apply ==")
+    root = os.path.join(tmp, "g5")
+    os.makedirs(root)
+    aeis = os.path.join(tmp, "g5_aeis")      # 空归档目录（不触真实数据目录）
+    os.makedirs(aeis)
+    a = MdCGOS(root)
+    a.add("imgpart_gd",
+          "img9 部件 torso: bbox=[1, 1, 2, 2] cond_hash=eeee555566667777 "
+          "verdict=ACCEPT reason=x fg=0.5\n",
+          layer="contextual", tags=["vision", "img9", "part", "torso"])
+    a.flush()
+    _warm(a, "imgpart_gd")
+    _b_write(root, "imgpart_gd", MARK)
+    rep = vision_evidence.apply(a, aeis_root_=aeis)
+    ok(rep["written"] >= 1, f"G5a 盲区落盘 ≥1（实测 {rep['written']}）")
+    fm, _c = _disk(root, "imgpart_gd")
+    ok(fm.get("owner_note") == MARK,
+       "G5b B 修正幸存（:495 写前重查走直读）")
+    ok(fm.get("evidence_status") is not None,
+       "G5c 证据面写入仍生效")
+    return root, rep["batch"]
+
+
+def g6_vision_rollback(root, batch):
+    print("== G6 vision_evidence.rollback ==")
+    a2 = MdCGOS(root)
+    _warm(a2, "imgpart_gd")
+    _b_write(root, "imgpart_gd", MARK2)
+    rep2 = vision_evidence.rollback(a2, batch=batch)
+    ok(rep2["reverted"] >= 1, f"G6a 回滚 ≥1（实测 {rep2['reverted']}）")
+    fm, _c = _disk(root, "imgpart_gd")
+    ok(fm.get("owner_note") == MARK2, "G6b B 修正幸存（:579 回滚读走直读）")
+    ok(fm.get("evidence_status") is None, "G6c 回滚自身仍生效（证据键清除）")
+
+
+# ---- G7-G12 consolidate（口径守卫：root 入口内部自建新实例，非红证明）----
+
+def g7_fill_verification_basis(tmp):
+    print("== G7 consolidate.fill_verification_basis（口径） ==")
+    root = os.path.join(tmp, "g7")
+    os.makedirs(root)
+    a = MdCGOS(root)
+    a.add("gd_fvb", _doc("函数单调性判定", "问单调性", "判定单调区间", "取导数定号"),
+          layer="knowledge")
+    a.flush()
+    _b_write(root, "gd_fvb", MARK)           # 先于调用的 B 写：新实例首触可见
+    rep = consolidate.fill_verification_basis(root, "编译器/静态检查通过",
+                                               apply=True)
+    ok(rep["written"] == 1, f"G7a 补写 1（实测 {rep['written']}）")
+    fm, c = _disk(root, "gd_fvb")
+    ok(fm.get("owner_note") == MARK, "G7b B 修正幸存")
+    ok("# 验证方式：编译器/静态检查通过" in c, "G7c 补写自身生效")
+
+
+def _g89_root(tmp):
+    root = os.path.join(tmp, "g8")
+    os.makedirs(root)
+    a = MdCGOS(root)
+    a.add("gd_pro",
+          "# 功能名：待提升节点\n# 生效条件：问提升\n# 子功能：说明提升\n"
+          "# 执行：按热度\n# 不适用条件：问无关\n",
+          layer="contextual", merge_count=2)
+    a.flush()
+    return root
+
+
+def g8_promote(tmp):
+    print("== G8/G9 consolidate.promote / rollback_promotion（口径） ==")
+    root = _g89_root(tmp)
+    _b_write(root, "gd_pro", MARK)
+    rep = consolidate.promote_memories(root, min_merge=1, apply=True)
+    ok(rep["written"] == 1, f"G8a 提升 1（实测 {rep['written']}）")
+    fm, _c = _disk(root, "gd_pro")
+    ok(fm.get("layer") == "knowledge", "G8b 已迁 knowledge")
+    ok(fm.get("owner_note") == MARK, "G8c B 修正幸存")
+    rep2 = consolidate.rollback_promotion(root)
+    ok(rep2.get("ok") and rep2["reverted"] == 1,
+       f"G9a 回滚 1（实测 {rep2})")
+    fm2, _c2 = _disk(root, "gd_pro")
+    ok(fm2.get("layer") == "contextual", "G9b 迁回 contextual")
+    ok(fm2.get("owner_note") == MARK, "G9c B 修正幸存（回滚读走直读口径）")
+
+
+def g10_contextualize(tmp):
+    print("== G10/G11 consolidate.contextualize / rollback（口径） ==")
+    root = os.path.join(tmp, "g10")
+    os.makedirs(root)
+    a = MdCGOS(root)
+    a.add("note_gd", "# 功能名：批次流水账\n\n正文。\n", layer="knowledge")
+    a.flush()
+    _b_write(root, "note_gd", MARK)
+    rep = consolidate.contextualize_prefixes(root, prefixes=["note_"],
+                                             apply=True)
+    ok(rep["written"] == 1, f"G10a 归位 1（实测 {rep['written']}）")
+    fm, _c = _disk(root, "note_gd")
+    ok(fm.get("layer") == "contextual", "G10b 已归位 contextual")
+    ok(fm.get("owner_note") == MARK, "G10c B 修正幸存")
+    rep2 = consolidate.rollback_contextualize(root)
+    ok(rep2.get("ok") and rep2["reverted"] == 1, "G11a 回滚 1")
+    fm2, _c2 = _disk(root, "note_gd")
+    ok(fm2.get("layer") == "knowledge", "G11b 迁回 knowledge")
+    ok(fm2.get("owner_note") == MARK, "G11c B 修正幸存（回滚读走直读口径）")
+
+
+BODY = ("# 功能名：微分方程应用\n"
+        "微分方程应用：建模与求解，使用数值方法迭代求解，需给定边界条件\n")
+CAND = {
+    "生效条件": ["微分方程", "数值方法"],
+    "子功能": ["建模", "求解"],
+    "执行": "使用数值方法迭代求解",
+    "不适用条件": ["边界条件缺失"],
+}
+
+
+def _fake_reflect(prompt):
+    return "```json\n" + json.dumps(CAND, ensure_ascii=False) + "\n```"
+
+
+def _fake_verify(prompt):
+    out = {f: {"keep": (v if isinstance(v, list) else [v]), "drop": [],
+               "reason": "逐条核验"}
+           for f, v in CAND.items()}
+    return json.dumps(out, ensure_ascii=False)
+
+
+def g12_consolidate(tmp):
+    print("== G12 consolidate.consolidate（LLM 固化流，口径） ==")
+    root = os.path.join(tmp, "g12")
+    os.makedirs(root)
+    a = MdCGOS(root)
+    a.add("gd_llm", BODY, layer="knowledge")
+    a.flush()
+    _b_write(root, "gd_llm", MARK)
+    rep = consolidate.consolidate(root, apply=True, reflect_fn=_fake_reflect,
+                                  verify_fn=_fake_verify,
+                                  verification_basis="回放测试核验（守卫）")
+    ok(rep["written"] == 1, f"G12a 固化 1（实测 {rep['written']}）")
+    fm, c = _disk(root, "gd_llm")
+    ok(fm.get("owner_note") == MARK, "G12b B 修正幸存（:678 读走直读口径）")
+    ok("# 生效条件：" in c and "# 验证方式：回放测试核验（守卫）" in c,
+       "G12c 固化自身生效")
+
+
+def main():
+    os.environ.pop("MDCG_READ_CACHE", None)
+    tmp = tempfile.mkdtemp(prefix="mdcg_gov_directread_")
+    try:
+        g1_recalibrate(tmp)
+        g2_link(tmp)
+        g3root = g3_crosscheck(tmp)
+        g4_crosscheck_rollback(g3root)
+        g5root, g5batch = g5_vision_apply(tmp)
+        g6_vision_rollback(g5root, g5batch)
+        g7_fill_verification_basis(tmp)
+        g8_promote(tmp)
+        g10_contextualize(tmp)
+        g12_consolidate(tmp)
+    finally:
+        os.environ.pop("MDCG_READ_CACHE", None)
+        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_i32_hotcache_env_key.py

@@ -0,0 +1,218 @@
+# -*- coding: utf-8 -*-
+"""issue #32 守卫：query 缓存的**口径键**必须覆盖进程级开关（env）。
+
+病灶（2026-09-24 审查复现）：v14 缺陷 C 修的是**参数面**（include_work /
+roles / paths / fusion / judge_ranking / …），但还有一类口径来自**环境变量**
+——MDCG_SEMANTIC / MDCG_EN_ATOMS / MDCG_UNIFY_QUERY。它们不入键时，同一 query
+在切换开关后会命中**另一口径**的缓存（cached=True + 陈旧结果），表现为静默
+错答：先按 MDCG_SEMANTIC=1 查一次写缓存，再关掉语义路重查，拿到的仍是
+「语义路开启时」的排序。
+
+修法（本件守门）：`hotcache._KEYED_EXTRA` 增列 `env_switch`，
+调用方 `mdcos.search_rrf` 以 `hotcache.env_switch_key()` 填该键——开关一变
+键就变，缓存自然不命中；同一口径内缓存收益不变。
+
+断言（含能红旧实现的两条）：
+  K1 _KEYED_EXTRA 登记 env_switch（清单真源，防漏登）
+  K2 env_switch_key() 随开关取值变化（未设 = None 也进键）
+  K3 semantic=1 首查：gold 经语义资格路命中（非缓存）
+  K4 切到 semantic=0 后同 query **不命中**旧口径缓存（旧实现这里 cached=True）
+  K5 切开关后的结果 == 关缓存重算的结果（无跨口径串味）
+  K6 同口径重复查仍命中缓存（修完不许把缓存打废）
+
+运行：python -m md_cg.test_i32_hotcache_env_key
+"""
+import json
+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 eval_common as ec                              # noqa: E402
+from md_cg import hotcache, mdcos                                # noqa: E402
+
+PASS = FAIL = 0
+FAILS = []
+
+
+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 _mk(root):
+    from md_cg.mdcos import MdCGOS
+    return MdCGOS(root, autoflush=500)
+
+
+def _query(cg, q="horse meat"):
+    res, meta = cg.search_rrf(q, k=5, paths=("lexical",), judge=False,
+                              record=False)
+    return [r[0]["id"] for r in res], res, meta
+
+
+def main():
+    ec.unlock_global_cap()
+    ec.use_jaccard()
+
+    print("== K1/K2 清单真源与键值 ==")
+    check("K1 _KEYED_EXTRA 登记 env_switch",
+          "env_switch" in hotcache._KEYED_EXTRA, str(hotcache._KEYED_EXTRA))
+    os.environ.pop("MDCG_SEMANTIC", None)
+    before = hotcache.env_switch_key()
+    os.environ["MDCG_SEMANTIC"] = "1"
+    after = hotcache.env_switch_key()
+    os.environ.pop("MDCG_SEMANTIC", None)
+    check("K2 env_switch_key() 随开关变化（未设=None 也进键）",
+          before != after and any(v is None for _k, v in before),
+          f"{before} vs {after}")
+
+    tmp = tempfile.mkdtemp(prefix="mdcg_i32_")
+    try:
+        rooth = os.path.join(tmp, "hot")
+        rootn = os.path.join(tmp, "nocache")
+        for root in (rooth, rootn):
+            cg = _mk(root)
+            # gold 只有 fm.semantic（「马 肉」）能对上英文 query；正文是中文，
+            # 归一路关闭时词法零交集 → 语义路开关是唯二变量（另一个是归一层）。
+            cg.add("gold", "今天午饭吃了马肉，味道不错，下次还做。",
+                   layer="knowledge", semantic="马 肉", verification_basis="data")
+            cg.add("d1", "下午去市场买了马，价格比昨天便宜一些。",
+                   layer="knowledge", verification_basis="data")
+            cg.flush()
+            cg.close()
+
+        print("== K3~K6 跨口径缓存（MDCG_HOTCACHE=1，归一层关闭以隔离变量）==")
+        os.environ["MDCG_HOTCACHE"] = "1"
+        os.environ["MDCG_UNIFY_QUERY"] = "0"
+        cg = _mk(rooth)
+        try:
+            os.environ["MDCG_SEMANTIC"] = "1"
+            ids_sem, _r, m_sem = _query(cg)
+            check("K3 semantic=1 首查：gold 命中且非缓存",
+                  bool(ids_sem) and ids_sem[0] == "gold"
+                  and m_sem.get("cached") is not True,
+                  f"{ids_sem} cached={m_sem.get('cached')}")
+
+            os.environ.pop("MDCG_SEMANTIC", None)
+            ids_off, _r2, m_off = _query(cg)
+            check("K4 切开关后不命中旧口径缓存（旧实现 cached=True）",
+                  m_off.get("cached") is not True,
+                  f"cached={m_off.get('cached')} ids={ids_off}")
+            check("K5 切开关后结果与 semantic=1 不同（无跨口径串味）",
+                  ids_off != ids_sem,
+                  f"sem={ids_sem} / off={ids_off}")
+
+            _ids3, _r3, m3 = _query(cg)
+            check("K6 同口径重复查仍命中缓存（缓存未被打废）",
+                  m3.get("cached") is True, json.dumps(m3, default=str)[:160])
+        finally:
+            cg.close()
+            os.environ.pop("MDCG_SEMANTIC", None)
+
+        # 旁路对照：不挂热缓存重算 semantic=0 的结果必须与 K5 一致
+        os.environ.pop("MDCG_HOTCACHE", None)
+        cg2 = _mk(rootn)
+        try:
+            ids_plain, _r4, _m4 = _query(cg2)
+        finally:
+            cg2.close()
+            os.environ.pop("MDCG_UNIFY_QUERY", None)
+        check("K5b 与旁路（无缓存）重算结果一致",
+              ids_plain == ids_off, f"cached={ids_off} plain={ids_plain}")
+
+        # ---- v9 N78：MDCG_CN_GRAMS 漏登（中文 2-gram 召回开关）----
+        # 病灶同构：mdcg.py cn_recall_grams 每调用读 env（="0" 即回退旧行为），
+        # 改变 expand_query_terms 召回词集，但 _ENV_SWITCHES 没登记它 →
+        # 翻转后同 query 命中另一口径缓存（cached=True + 旧口径召回结果）。
+        print("== K7~K10 MDCG_CN_GRAMS 入键（v9 N78）==")
+        check("K7 MDCG_CN_GRAMS 登记在 _ENV_SWITCHES（清单真源，新增一个登记一个）",
+              "MDCG_CN_GRAMS" in hotcache._ENV_SWITCHES,
+              str(hotcache._ENV_SWITCHES))
+        os.environ.pop("MDCG_CN_GRAMS", None)
+        bg = hotcache.env_switch_key()
+        os.environ["MDCG_CN_GRAMS"] = "0"
+        ag = hotcache.env_switch_key()
+        os.environ.pop("MDCG_CN_GRAMS", None)
+        check("K8 env_switch_key() 随 MDCG_CN_GRAMS 变化（未设=None 也进键）",
+              bg != ag, f"{bg} vs {ag}")
+
+        rootg = os.path.join(tmp, "cgrams")
+        rootg2 = os.path.join(tmp, "cgrams_plain")
+        for root in (rootg, rootg2):
+            cgx = _mk(root)
+            # gold 正文含「抑制/制剂」2-gram 但不含整句——grams 开=经 bigram
+            # 召回命中；grams 关=只剩整句召回词 → 词法零命中（口径差可观测）。
+            cgx.add("gold", "酪氨酸激酶抑制剂用于白血病靶向治疗，需遵医嘱。",
+                    layer="knowledge", verification_basis="data")
+            cgx.add("d1", "下午去市场买了马，价格比昨天便宜一些。",
+                    layer="knowledge", verification_basis="data")
+            cgx.flush()
+            cgx.close()
+
+        def _q_cn(cg):
+            res, meta = cg.search_rrf("抑制剂怎么选", k=5, paths=("lexical",),
+                                      judge=False, record=False)
+            return [r[0]["id"] for r in res], meta
+
+        os.environ["MDCG_HOTCACHE"] = "1"
+        os.environ["MDCG_UNIFY_QUERY"] = "0"
+        os.environ.pop("MDCG_CN_GRAMS", None)      # 缺省=grams 开
+        cg3 = _mk(rootg)
+        try:
+            ids_on, m_on = _q_cn(cg3)
+            check("K9a grams 开首查：gold 经 2-gram 召回命中且非缓存",
+                  "gold" in ids_on and m_on.get("cached") is not True,
+                  f"{ids_on} cached={m_on.get('cached')}")
+            os.environ["MDCG_CN_GRAMS"] = "0"       # 运行期翻转（关 grams）
+            ids_offg, m_offg = _q_cn(cg3)
+            check("K9b 翻转后不命中旧口径缓存（旧实现 cached=True 静默错答）",
+                  m_offg.get("cached") is not True,
+                  f"cached={m_offg.get('cached')} ids={ids_offg}")
+            check("K9c 翻转后结果与 grams 开不同（无跨口径串味）",
+                  ids_offg != ids_on, f"on={ids_on} / off={ids_offg}")
+            _ids3g, m3g = _q_cn(cg3)
+            check("K10 同口径重复查仍命中缓存（缓存未被打废）",
+                  m3g.get("cached") is True
+                  and _ids3g == ids_offg, json.dumps(m3g, default=str)[:160])
+        finally:
+            cg3.close()
+            os.environ.pop("MDCG_CN_GRAMS", None)
+
+        # 旁路对照：无缓存重算 grams=0 的结果必须与 K9c 一致
+        os.environ.pop("MDCG_HOTCACHE", None)
+        os.environ["MDCG_CN_GRAMS"] = "0"
+        cg4 = _mk(rootg2)
+        try:
+            ids_plain_g, _mg = _q_cn(cg4)
+        finally:
+            cg4.close()
+            os.environ.pop("MDCG_CN_GRAMS", None)
+            os.environ.pop("MDCG_UNIFY_QUERY", None)
+        check("K10b 与旁路（无缓存）重算结果一致",
+              ids_plain_g == ids_offg, f"cached={ids_offg} plain={ids_plain_g}")
+    finally:
+        for k in ("MDCG_HOTCACHE", "MDCG_SEMANTIC", "MDCG_UNIFY_QUERY",
+                  "MDCG_CN_GRAMS"):
+            os.environ.pop(k, None)
+        shutil.rmtree(tmp, ignore_errors=True)
+
+    print("\n" + "=" * 64)
+    print(f"PASS={PASS}  FAIL={FAIL}")
+    if FAILS:
+        print("失败项：" + "；".join(FAILS))
+    return 0 if FAIL == 0 else 1
+
+
+if __name__ == "__main__":
+    if hasattr(sys.stdout, "reconfigure"):
+        sys.stdout.reconfigure(encoding="utf-8")
+    sys.exit(main())