@furongjun1999/dsh-memory 0.4.11 → 0.5.1

package/md_cg/test_i27_e041_identity.py

@@ -0,0 +1,128 @@
+# -*- coding: utf-8 -*-
+"""issue #27 守卫：E041 身份识别（归一化 + 令牌凭据），非裸字符串相等。
+
+病灶（2026-09-23 外部报告，两方独立复现）：E041「LLM 不得自己验证自己」
+的三处判据是裸 `==`（attest / link 准入门 / recalibrate）——`agent-A` 编译、
+`agent-a` 验证即可绕过并落盘（报告实测 WRITTEN=6）。而代码声明宣称
+「结构级阻断，不依赖 prompt 自觉」。
+
+修复（分层，处置强度如实声明）：
+  ①身份归一比较（_same_subject：casefold + 去空白 + 去尾部括号注记）
+    ——拦截报告表格全部同源变体（对旧实现能红）；
+  ②verifier_token 凭据通路（mdcg 令牌 HMAC 验签，与 narrowed_principal
+    同一信任源）——根本保障；令牌身份自证同样 E041；伪造令牌 fail-closed；
+  ③诚实降级标注——无令牌时 AttestResult.verifier_identity =
+    "self-reported"，下游策略/审计可识别。
+"""
+import json
+import os
+import sys
+import tempfile
+
+sys.path.insert(0, os.path.dirname(os.path.dirname(os.path.abspath(__file__))))
+
+from md_cg import ccgc, tokens
+
+PASS = 0
+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 main():
+    # 令牌文件隔离（issue/verify 经 TOKEN_FILE_ENV 同源）
+    tf = tempfile.mkdtemp(prefix="mdcg_i27_tok_")
+    tokens.TOKEN_FILE_ENV and os.environ.setdefault(tokens.TOKEN_FILE_ENV
+                                                    if isinstance(tokens.TOKEN_FILE_ENV, str)
+                                                    else "MDCG_TOKEN_FILE",
+                                                    os.path.join(tf, "tokens.json"))
+    tok_env = tokens.token_file()
+    os.environ[tokens.TOKEN_FILE_ENV] = tok_env
+
+    print("== X1 归一化：报告表格全形态拦截（attest 面，能红旧实现）==")
+    compiled = "agent-A"
+    variants = {
+        "完全相同（旧实现也拦）": "agent-A",
+        "小写（报告 BYPASS 形态）": "agent-a",
+        "全大写": "AGENT-A",
+        "括号注记后缀": "agent-A（复核）",
+        "夹空白": " agent - a ",
+    }
+    for label, ver in variants.items():
+        r = ccgc.attest("node_x", ccgc.ACCEPT, ver, compiled, ledger=False)
+        want = label != "完全相同（旧实现也拦）"
+        check(f"X1 {label} → E041{'（旧实现也拦，回归对照）' if not want else '（能红旧实现）'}",
+              (not r.ok) and r.error.startswith("E041"),
+              f"error={r.error[:80]}")
+    check("X1z 自报身份诚实标注（verifier_identity=self-reported）",
+          r.verifier_identity == "self-reported")
+
+    print("== X2 verifier_token 凭据通路（根本保障）==")
+    tk = tokens.issue("verifier", actor="external-reviewer",
+                      path=tok_env)["token"]
+    r2 = ccgc.attest("node_x", ccgc.ACCEPT, "随便自报的字符串",
+                     "agent-A", ledger=False, verifier_token=tk)
+    check("X2a 令牌身份覆盖自报（verifier=令牌 actor）",
+          r2.ok and r2.verifier == "external-reviewer"
+          and r2.verifier_identity == "token",
+          f"ok={r2.ok} verifier={r2.verifier} id={r2.verifier_identity}")
+    check("X2b 不同主体凭据放行（非自证）",
+          r2.ok is True)
+
+    print("== X3 令牌身份自证仍 E041（归一化形态）==")
+    tk_self = tokens.issue("verifier", actor="Agent-a",
+                           path=tok_env)["token"]
+    r3 = ccgc.attest("node_x", ccgc.ACCEPT, "whoever",
+                     "agent-A", ledger=False, verifier_token=tk_self)
+    check("X3 令牌 actor 与编译方归一同源 → E041",
+          (not r3.ok) and r3.error.startswith("E041"),
+          f"error={r3.error[:80]}")
+
+    print("== X4 伪造令牌 fail-closed ==")
+    r4 = ccgc.attest("node_x", ccgc.ACCEPT, "whoever",
+                     "agent-A", ledger=False,
+                     verifier_token="mdcg1.verifier.tk_fake.badsecretvalue")
+    check("X4 令牌验签失败 → 拒绝（不回落自报）",
+          (not r4.ok) and "E041" in r4.error and "令牌" in r4.error,
+          f"error={r4.error[:90]}")
+
+    print("== X5 link 准入门归一化（能红旧实现）==")
+    compiled_obj = ccgc.CompileResult(node_id="node_x", actor="agent-A")
+    compiled_obj.success = True
+    att_ok = ccgc.attest("node_x", ccgc.ACCEPT, "agent-a",
+                         "agent-A", ledger=False)
+    # attest 已拦（attest.ok=False），模拟旧数据面：手构 ok 签章验证 link 门自身
+    att = ccgc.AttestResult(node_id="node_x", state=ccgc.ACCEPT,
+                            verifier="agent-a", compiled_by="agent-A",
+                            ok=True, token="t")
+    lr = ccgc.link(compiled_obj, att, apply=False, actor="agent-A")
+    check("X5 link 门大小写变体 → E041",
+          any(e.startswith("E041") for e in lr.errors),
+          f"errors={lr.errors[:2]}")
+
+    print("== X6 不同主体正常放行（不误杀）==")
+    att_ok2 = ccgc.attest("node_x", ccgc.ACCEPT, "external-reviewer",
+                          "agent-A", ledger=False)
+    check("X6 真不同主体签章 ok（召回面不回归）",
+          att_ok2.ok and att_ok2.verifier_identity == "self-reported")
+
+    print()
+    if FAILS:
+        print(f"FAILED: {len(FAILS)} 项 → {', '.join(FAILS)}")
+        return 1
+    print(f"ALL OK: {PASS} 项（issue #27 E041 身份识别守卫全绿）")
+    return 0
+
+
+if __name__ == "__main__":
+    sys.exit(main())

package/md_cg/test_i28_hotcache_prodpath.py

@@ -0,0 +1,122 @@
+# -*- coding: utf-8 -*-
+"""issue #28 守卫：hotcache 生产路径挂载（读侧写侧已接、中间从未装上）。
+
+病灶（2026-09-23 外部报告）：search_rrf 读 hotcache（mdcos:1195）、writepipe
+写后失效（writepipe:436），但全仓无任何 attach() 调用——生产 get(cg) 恒
+None，重复 query 永远全量重扫。与 #25 同模式：读写两侧在、挂载点悬空。
+
+修复：MdCGOS.__init__ 按 MDCG_HOTCACHE=1 显式挂载（默认关零变更）；
+容量 env 可配（MDCG_HOTCACHE_MAX_NODES/MAX_QUERIES）。
+
+断言：
+  H1 默认零变更（无 env → get 为 None，能红「无条件挂载」的过度修复）；
+  H2 开关开启 → 生产类（MdCGSecure）get 非 None（能红旧实现）；
+  H3 query 缓存命中（重复 query meta.cached=True + stats）；
+  H4 写后失效联动（写入 → query 缓存全清，不返回陈旧结果）；
+  H5 容量 env 生效（max_nodes 缩容 → LRU 淘汰按新上限）。
+"""
+import json
+import os
+import sys
+import tempfile
+
+sys.path.insert(0, os.path.dirname(os.path.dirname(os.path.abspath(__file__))))
+
+from md_cg import hotcache
+from md_cg.mdcos import MdCGSecure
+
+PASS = 0
+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.security import Principal
+    return MdCGSecure(root, principal=Principal(
+        actor="t_i28", clearance="secret", can_write=True,
+        role="designer", auth_mode="test"))
+
+
+def main():
+    print("== H1 默认零变更 ==")
+    os.environ.pop("MDCG_HOTCACHE", None)
+    cg1 = _mk(tempfile.mkdtemp(prefix="mdcg_i28a_"))
+    check("H1 无 env → 不挂载（get=None；能红『无条件挂载』误修）",
+          hotcache.get(cg1) is None)
+
+    print("== H2 开关挂载（能红旧实现）==")
+    os.environ["MDCG_HOTCACHE"] = "1"
+    try:
+        cg2 = _mk(tempfile.mkdtemp(prefix="mdcg_i28b_"))
+        check("H2 生产类构造后 hotcache 已挂（旧实现恒 None）",
+              hotcache.get(cg2) is not None)
+        cg2.add("mem_h1", "# 功能名：热缓存探针\n# 正文：hotcache probe 内容",
+                layer="knowledge")
+
+        print("== H3 query 缓存命中 ==")
+        _r1, m1 = cg2.search_rrf("hotcache probe") if hasattr(
+            cg2, "search_rrf") else (None, {})
+        _r2, m2 = cg2.search_rrf("hotcache probe")
+        check("H3a 重复 query 命中缓存（meta.cached=True）",
+              m2.get("cached") is True,
+              json.dumps(m2, ensure_ascii=False, default=str)[:160])
+        st = hotcache.get(cg2).stats()
+        check("H3b 统计计数可见（query_hits>=1）",
+              st.get("query_hits", 0) >= 1, json.dumps(st))
+
+        print("== H4 写后失效联动（生产写入路径）==")
+        # 失效挂在 writepipe 的 after_trust（MCP op=write 路径）——库层直调
+        # cg.add 不经过该链（内部/测试场景），其失效缺口如实登记不在本断言。
+        from md_cg.mcp_server import _cg_dispatch
+        _w = _cg_dispatch(cg2, {"op": "write", "content_kind": "code",
+                                "layer": "knowledge", "node_id": "mem_h2",
+                                "content": "def h2():\n    return 'hotcache new'\n"})
+        check("H4a 生产写入成功（失效触发前提）",
+              _w.get("committed") is True,
+              json.dumps(_w, ensure_ascii=False, default=str)[:160])
+        _r3, m3 = cg2.search_rrf("hotcache probe")
+        check("H4b 写入后 query 缓存全清（不返回陈旧结果）",
+              m3.get("cached") is not True,
+              json.dumps({k: m3.get(k) for k in ("cached", "tier")},
+                         ensure_ascii=False))
+
+        print("== H5 容量 env 生效 ==")
+        os.environ["MDCG_HOTCACHE_MAX_NODES"] = "3"
+        cg3 = _mk(tempfile.mkdtemp(prefix="mdcg_i28c_"))
+        hc3 = hotcache.get(cg3)
+        check("H5a 容量 env 进入实例（max_nodes=3）",
+              hc3 is not None and hc3._max_nodes == 3,
+              f"max_nodes={getattr(hc3, '_max_nodes', None)}")
+        for i in range(6):
+            hc3.put_node(f"n{i}", {"layer": "knowledge"}, "")
+            _ = hc3.get_node(f"n{i}")     # 反复摸 n0..n5 → n0/n1 应被挤出
+        check("H5b LRU 按新上限淘汰（size==3，最旧两节点不在）",
+              len(hc3._nodes) == 3
+              and hotcache.get(cg3).get_node("n0") is None
+              and hotcache.get(cg3).get_node("n5") is not None,
+              f"size={len(hc3._nodes)}")
+    finally:
+        os.environ.pop("MDCG_HOTCACHE", None)
+        os.environ.pop("MDCG_HOTCACHE_MAX_NODES", None)
+
+    print()
+    if FAILS:
+        print(f"FAILED: {len(FAILS)} 项 → {', '.join(FAILS)}")
+        return 1
+    print(f"ALL OK: {PASS} 项（issue #28 热缓存生产路径守卫全绿）")
+    return 0
+
+
+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())

package/md_cg/test_identity_attribution.py

@@ -1,10 +1,11 @@
 # -*- coding: utf-8 -*-
-"""test_identity_attribution · 写入归属（writer/session/harness）与检索会话过滤
+"""test_identity_attribution · 写入归属（writer/session/harness）与会话可见性
 
 背景：多会话共用一个 root 时，读取记忆无法区分「本会话写的」与「其他会话写的」。
-修复：写入自动归属（MdCGSecure 写路径注入 writer/session/harness）+ 检索
-session= 过滤（_candidates 一处生效：search/search_rrf/recall 全链路）+
-审计/提案入队补 session + MDCG_SESSION env（部署侧固定会话归属）。
+修复：写入自动归属（MdCGSecure 写路径注入 writer/session/harness）+ 会话可见性
+**分档判定**（issue #35 定稿：public/internal = 跨会话共享档；private/secret =
+绑定档，仅归属会话可见，设计者豁免；查询侧 session 参数只作归因过滤、不构成
+授权豁免）+ 审计/提案入队补 session + MDCG_SESSION env（部署侧固定会话归属）。
 边界：归属是归因维度不参与授权；MCP 面不透传写入归属入参（客户端不得伪造），
 库层调用方可显式覆盖（setdefault）；writer 语义=最后写入者。
 """
@@ -96,17 +97,72 @@ try:
           bool(hit) and (hit.get("frontmatter") or {}).get("session") == "sess_B",
           [_row(r).get("id") for r in res])
 
-    # ⑥ search 会话过滤
+    # ⑥⑦ 会话语义（issue #35 定稿：**分档**判定，查询参数不构成豁免）
+    #   · 共享档（public/internal）跨会话可见——n1/n2 都是 internal，故传任何
+    #     session（他人会话 / "*" / 缺省）都应看得见；旧断言「按 session 过滤掉」
+    #     编码的是 #35 之前的契约（同口径见 test_p47_session_view 的 D1a/D2/D3）。
+    #   · 绑定档（private/secret）仅归属会话——由 principal.session 判定，查询侧
+    #     自报的 session 不越权；can_admin（设计者）整体判断豁免。
     res_b, _ = cg2.search("知识", session="sess_B")
     ids_b = {_row(r).get("id") for r in res_b}
-    check("⑥search 会话过滤", "n1" in ids_b and "n2" not in ids_b, ids_b)
-
-    # ⑦ recall 会话过滤（RRF 主链）
-    pack = cg2.recall("知识", session="sess_custom")
-    hits = pack.get("pack") if isinstance(pack, dict) else None
-    hid = {_row(h).get("id") for h in (hits or [])}
-    check("⑦recall 会话过滤", "n2" in hid and "n1" not in hid,
-          list(hid) or (list(pack.keys()) if isinstance(pack, dict) else type(pack)))
+    check("⑥a 共享档跨会话可见：显式 session 不缩小可见性",
+          "n1" in ids_b and "n2" in ids_b, ids_b)
+
+    # ⑥b~⑦ 绑定档对照（private 节点归 sess_B）：
+    #   · 跨身份（另一 actor/会话）不可见；
+    #   · **同身份换会话**：非设计者不可见（绑定档生效）；
+    #   · **同身份换会话 + can_admin**：豁免可见（设计者整体判断）。
+    #   注：豁免的是「会话绑定判定」，不越过加密身份——private 内容按
+    #   (tenant, actor) 派生 DEK，跨 actor 即便判定可见也解不开（get 无正文），
+    #   故可见性对照必须在同一 actor 内做。
+    w_priv = MdCGSecure(root, principal=Principal(
+        actor="bob", clearance="private", can_write=True, can_admin=False,
+        role="recorder", session="sess_B"))
+    try:
+        w_priv.add("n_priv_b", "乙会话私有知识条目", layer="knowledge",
+                   sensitivity="private")
+        w_priv.flush()
+    finally:
+        w_priv.close()
+    carol = MdCGSecure(root, principal=Principal(
+        actor="carol", clearance="private", can_write=False, can_admin=False,
+        role="recorder", session="sess_C"))
+    try:
+        res_c, _ = carol.search("私有知识", session="sess_B")   # 自报他人会话
+        ids_c = {_row(r).get("id") for r in res_c}
+        check("⑥b 绑定档按身份判定：自报他人会话不越权",
+              "n_priv_b" not in ids_c, ids_c)
+    finally:
+        carol.close()
+    bob_other = MdCGSecure(root, principal=Principal(
+        actor="bob", clearance="private", can_write=False, can_admin=False,
+        role="recorder", session="sess_OTHER"))
+    try:
+        res_o, _ = bob_other.search("私有知识")
+        check("⑥c 同一身份换会话：非设计者仍受绑定档约束",
+              "n_priv_b" not in {_row(r).get("id") for r in res_o},
+              [_row(r).get("id") for r in res_o])
+    finally:
+        bob_other.close()
+    bob_admin = MdCGSecure(root, principal=Principal(
+        actor="bob", clearance="private", can_write=False, can_admin=True,
+        role="designer", session="sess_OTHER"))
+    try:
+        res_d, _ = bob_admin.search("私有知识", session="sess_C")
+        check("⑥d 同一身份 + 设计者（can_admin）：豁免绑定档",
+              "n_priv_b" in {_row(r).get("id") for r in res_d},
+              [_row(r).get("id") for r in res_d])
+
+        # ⑦ recall（RRF 主链）同口径：绑定档判定不因查询 session 变化
+        pack = bob_admin.recall("私有知识", session="sess_custom")
+        hits = pack.get("pack") if isinstance(pack, dict) else None
+        hid = {_row(h).get("id") for h in (hits or [])}
+        check("⑦recall 同口径：设计者可见绑定档（查询 session 不改判定）",
+              "n_priv_b" in hid,
+              list(hid) or (list(pack.keys()) if isinstance(pack, dict)
+                            else type(pack)))
+    finally:
+        bob_admin.close()
 
     # ⑧ 审计带 session
     last_audit = _last_jsonl(os.path.join(root, "**", "*audit*.jsonl"))
@@ -120,17 +176,42 @@ try:
           bool(rec_inbox) and rec_inbox.get("session") == "sess_B", rec_inbox)
 
     # ⑩ 旧节点兼容（基类写入、无归属字段）
+    #   · 共享档：跨会话可见（#35 定稿）；
+    #   · 绑定档但无归属：无法证明归属 → fail-closed，仅设计者（can_admin）可见。
     cg0 = MdCG(root)
     cg0.add("legacy", "旧库无归属节点的知识", layer="knowledge")
+    cg0.add("legacy_priv", "旧库无归属的私有知识条目", layer="knowledge",
+            sensitivity="private")
     cgs = MdCGSecure(root, principal=_p("carol", "sess_C"))
     res_all, _m = cgs.search("旧库无归属")
     check("⑩旧节点默认检索不受影响",
           any(_row(r).get("id") == "legacy" for r in res_all),
           [_row(r).get("id") for r in res_all])
     res_f, _ = cgs.search("旧库无归属", session="sess_C")
-    check("⑩b 旧节点被会话过滤排除（不炸）",
-          all(_row(r).get("id") != "legacy" for r in res_f),
+    check("⑩b 旧节点（无归属·共享档）跨会话可见（不炸）",
+          any(_row(r).get("id") == "legacy" for r in res_f),
           [_row(r).get("id") for r in res_f])
+    # ⑩c/⑩d 绑定档无归属的 fail-closed（同 clearance 的非设计者不可读 / 设计者豁免）
+    peak = MdCGSecure(root, principal=Principal(
+        actor="erin", clearance="private", can_write=False, can_admin=False,
+        role="recorder", session="sess_E"))
+    try:
+        res_p, _ = peak.search("旧库无归属")
+        ids_p = [_row(r).get("id") for r in res_p]
+        check("⑩c 绑定档无归属 fail-closed（同 clearance 非设计者不可读）",
+              "legacy_priv" not in ids_p and "legacy" in ids_p, ids_p)
+    finally:
+        peak.close()
+    lim = MdCGSecure(root, principal=Principal(
+        actor="dave2", clearance="private", can_write=True, can_admin=True,
+        role="designer", session="sess_D"))
+    try:
+        res_l, _ = lim.search("旧库无归属")
+        check("⑩d 设计者可见无归属绑定档（整体判断豁免）",
+              "legacy_priv" in [_row(r).get("id") for r in res_l],
+              [_row(r).get("id") for r in res_l])
+    finally:
+        lim.close()
 
     # ⑪⑫ 负记忆归属
     rn = cg2.add_rejected("假设X", "已被证伪")

package/md_cg/test_index_durability.py

@@ -138,8 +138,20 @@ def main():
             "from md_cg.mdcg import _LIVE_CGS\n"
             "_LIVE_CGS.clear()\n")
         check("反证子进程正常退出", r.returncode == 0, (r.stderr or "")[:200])
-        check("反证：索引不可见（缺陷可复现，证明兜底是有效变量）",
-              not _visible(root_b, "n_nohook"))
+        # issue #33（close 自动落快照 + 盘面指纹校验）后，「无 flush 退出 →
+        # 索引不可见」的原缺陷被修得更彻底：节点文件已落盘、目录 mtime 已
+        # 变 → 新进程 _load_index 指纹校验失败 → 回退全库扫描 → 节点**仍
+        # 可见**（可见性由盘面兜底接管，原「不可见」反证前提失效）。
+        # atexit 兜底的有效变量改为「增量日志是否落账」：摘掉 atexit →
+        # 子进程无 flush → 增量日志零记录（若【①】的兜底是空转，这里会
+        # 出现记录）——反证组据此继续防测试空转。
+        check("反证：可见性由盘面指纹兜底接管（原缺陷不可复现=修复增强）",
+              _visible(root_b, "n_nohook"))
+        log_dir = os.path.join(root_b, "_index_log")
+        n_log = (sum(1 for fn in os.listdir(log_dir) if fn.endswith(".log"))
+                 if os.path.isdir(log_dir) else 0)
+        check("反证：增量日志零记录（atexit flush 是有效变量，防【①】空转）",
+              n_log == 0, f"log_files={n_log}")
 
         # ---------------- ③ 显式 close 对照（原有正路不回归） ----------------
         print("\n【③】显式收尾对照：close() 仍是正路")
@@ -192,8 +204,10 @@ def main():
         pid_e = ose.propose("n_cli", mk("CLI 裁决节点", "问 CLI",
                                         "review_cli 落盘的目标节点"))
         ose.close()
+        # 入口为**包内**模块（`python -m md_cg.review_cli`）：出货包不含 scripts/，
+        # 旧写法 `scripts/review_cli.py` 在安装态必 FileNotFoundError（2026-09-24 修复）。
         r = subprocess.run(
-            [sys.executable, os.path.join(REPO, "scripts", "review_cli.py"),
+            [sys.executable, "-m", "md_cg.review_cli",
              "accept", pid_e, "--root", root_e, "--reason", "端到端守卫测试"],
             capture_output=True, text=True, encoding="utf-8", errors="replace",
             env=_child_env(), cwd=REPO)