@furongjun1999/dsh-memory 0.5.1 → 0.6.1

package/md_cg/test_ccg_form_parity.py

@@ -0,0 +1,188 @@
+# -*- coding: utf-8 -*-
+"""CCG 六要素「形态口径一致性」验收（2026-09-28）。
+
+运行：python -m md_cg.test_ccg_form_parity
+
+为什么需要这一套（本套的由来，是一个真实的口径分叉）：
+六要素标题存在两种书写形态——带冒号 `# 生效条件：<值>` 与不带冒号
+`# 生效条件` 后换行接值。写入闸门 `data/policy.json` 的必需正则
+`(?m)^#\\s*生效条件` **不要求冒号**，而检索面判据 `nodefile.ccg_completeness`
+原先**要求冒号**才计入「已声明」。二者对同一条正文给出相反结论：归档过闸
+（ACCEPT）后到检索路由被判 BLINDSPOT「CCG 要素不全」——归档看着写成了，
+检索面却当它没声明。存量实测 6905 件含六要素节点中 88 件处于该状态。
+
+判据收敛在**单点** `nodefile.ccg_mark_present` / `nodefile.ccg_field_value`
+（冒号可有可无），`mdcos._ccg_field`、`ccgc._has_ccg_line`、
+`consolidate._has_ccg_line`、`tasks._field_line` 一律委托该单点。
+
+本套的六组断言：
+ ① 两形态都判齐（形态不改变「齐不齐」）
+ ② 缺要素仍判不全（放宽的是标点，不是要求——判别力自证，两种形态各测）
+ ③ 写入闸门与检索面**结论一致**（读真源 data/policy.json 复算，直接钉住分叉）
+ ④ 取值面同源：无冒号的「值」= 标题后首个非空非标题行
+ ⑤ 四个副本函数与单点结论一致（防未来再长出第五、第六套口径）
+ ⑥ 写读闭环：无冒号节点经 upsert 后取得到新值（不出现「写进去读不出」）
+"""
+from __future__ import annotations
+
+import io
+import json
+import os
+import re
+import sys
+
+from . import ccgc, consolidate, nodefile, tasks
+from .mdcos import _ccg_field
+
+PASS = FAIL = 0
+FAILS = []
+
+
+def ok(cond, label):
+    global PASS, FAIL
+    if cond:
+        PASS += 1
+        print("  [PASS] %s" % label)
+    else:
+        FAIL += 1
+        FAILS.append(label)
+        print("  [FAIL] %s" % label)
+
+
+MARKS = ("功能名", "生效条件", "子功能", "执行", "验证方式", "不适用条件")
+
+# ① 带冒号形态（既有惯例形态）
+COLON = "".join("# %s：值_%s\n" % (m, m) for m in MARKS)
+# ① 不带冒号形态（policy 正则接受，标题行 + 换行接值）
+NONCOLON = "".join("# %s\n值_%s\n" % (m, m) for m in MARKS)
+# ① 混形态（一半带冒号一半不带）
+MIXED = "".join(("# %s：值_%s\n" if i % 2 == 0 else "# %s\n值_%s\n") % (m, m)
+                for i, m in enumerate(MARKS))
+
+
+def _drop(body: str, mark: str) -> str:
+    """删掉某要素的标题行（连带其值行）——用于②的判别力自证。"""
+    out = []
+    skip_next = False
+    for ln in body.splitlines(True):
+        if skip_next:
+            skip_next = False
+            continue
+        if re.match(r"^#\s*%s\s*[:：]?\s*$" % re.escape(mark), ln.rstrip("\n")):
+            skip_next = True
+            continue
+        if ln.startswith("# %s：" % mark) or ln.startswith("# %s:" % mark):
+            continue
+        out.append(ln)
+    return "".join(out)
+
+
+def _policy_required() -> list:
+    """读**真源**策略文件的必需正则（相对本模块定位，不依赖 cwd）。"""
+    root = os.path.dirname(os.path.dirname(os.path.abspath(__file__)))
+    path = os.path.join(root, "data", "policy.json")
+    with io.open(path, encoding="utf-8") as fh:
+        return [re.compile(p) for p in json.load(fh)["required"]]
+
+
+def main() -> int:
+    print("== ① 两形态都判齐 ==")
+    for name, body in (("带冒号", COLON), ("无冒号", NONCOLON), ("混形态", MIXED)):
+        comp = nodefile.ccg_completeness(body)
+        ok(comp["complete"] and sorted(comp["required_present"]) == sorted(MARKS),
+           "①%s：六要素判齐（present=%d/%d）" % (name, len(comp["required_present"]), len(MARKS)))
+        ok(abs(comp["ratio"] - 1.0) < 1e-9, "①%s：ratio=1.0（%s）" % (name, comp["ratio"]))
+
+    print("== ② 缺要素仍判不全（放宽的是标点，不是要求）==")
+    for name, body in (("带冒号", COLON), ("无冒号", NONCOLON)):
+        for mark in MARKS:
+            broken = _drop(body, mark)
+            comp = nodefile.ccg_completeness(broken)
+            ok(not comp["complete"] and mark not in comp["required_present"],
+               "②%s 缺「%s」→ 判不全" % (name, mark))
+    ok(not nodefile.ccg_completeness("")["complete"], "②空正文 → 判不全")
+    ok(not nodefile.ccg_completeness("# 生效条件\n只要这一条\n")["complete"],
+       "②只声明一条 → 判不全（不冒充齐全）")
+
+    print("== ③ 写入闸门与检索面结论一致（读真源 policy 复算）==")
+    pats = _policy_required()
+    for name, body in (("带冒号", COLON), ("无冒号", NONCOLON), ("混形态", MIXED),
+                       ("空正文", ""), ("只一条", "# 生效条件：x\n")):
+        gate = all(p.search(body) for p in pats)
+        retr = nodefile.ccg_completeness(body)["complete"]
+        ok(gate == retr, "③%s：闸门=%s 检索面=%s（必须相等）" % (name, gate, retr))
+    for mark in MARKS:
+        for name, body in (("带冒号", COLON), ("无冒号", NONCOLON)):
+            broken = _drop(body, mark)
+            gate = all(p.search(broken) for p in pats)
+            retr = nodefile.ccg_completeness(broken)["complete"]
+            ok(gate == retr and not retr,
+               "③%s 缺「%s」：两侧同判不全" % (name, mark))
+    # 边界形态：二级标题 / 缩进标题 / 无空格 —— 两侧必须同判（宽松方向也要一致）。
+    # 注意按**该要素自身**的那条必需正则比对（拿「全六条」的结论比「单条」判据
+    # 是错的口径——空正文与二级标题会因两侧同假而蒙对，暴露不出真差异）。
+    for name, line in (("二级标题", "## 生效条件：x\n"),
+                       ("缩进标题", "  # 生效条件：x\n"),
+                       ("无空格", "#生效条件：x\n"),
+                       ("制表符", "#\t生效条件：x\n")):
+        pat = next(p for p in pats if "生效条件" in p.pattern)
+        gate = bool(pat.search(line))
+        present = nodefile.ccg_mark_present(line, "生效条件")
+        ok(gate == present,
+           "③%s（%r）：闸门=%s 判据=%s（必须相等）" % (name, line.strip(), gate, present))
+    # 全形态 × 全要素的逐条一致性（比「整体 complete」更细，能定位到具体要素）
+    for name, body in (("带冒号", COLON), ("无冒号", NONCOLON), ("混形态", MIXED)):
+        for mark in MARKS:
+            pat = next(p for p in pats if mark in p.pattern)
+            ok(bool(pat.search(body)) == nodefile.ccg_mark_present(body, mark),
+               "③%s 逐要素一致：「%s」" % (name, mark))
+
+    print("== ④ 取值面：无冒号的值 = 标题后首个非空非标题行 ==")
+    ok(nodefile.ccg_field_value(COLON, "功能名") == "值_功能名",
+       "④带冒号：取行内值")
+    ok(nodefile.ccg_field_value(NONCOLON, "功能名") == "值_功能名",
+       "④无冒号：取下一行值")
+    ok(nodefile.ccg_field_value("# 执行\n\n真实值行\n后文\n", "执行") == "真实值行",
+       "④无冒号：跳过空行取首个非空行")
+    ok(nodefile.ccg_field_value("# 功能名\n# 生效条件：x\n", "功能名") == "",
+       "④无冒号且下一行又是标题：取空串而非吞掉下一个要素")
+    ok(nodefile.ccg_field_value(COLON, "不存在的字段") is None,
+       "④无该字段行 → None")
+
+    print("== ⑤ 四个副本与单点结论一致（防再长出口径分叉）==")
+    for name, body in (("带冒号", COLON), ("无冒号", NONCOLON)):
+        for mark in ("功能名", "生效条件", "执行"):
+            single = nodefile.ccg_mark_present(body, mark)
+            ok(ccgc._has_ccg_line(body, mark) == single,
+               "⑤ccgc._has_ccg_line(%s,%s) 与单点一致" % (name, mark))
+            ok(consolidate._has_ccg_line(body, mark) == single,
+               "⑤consolidate._has_ccg_line(%s,%s) 与单点一致" % (name, mark))
+            ok(bool(_ccg_field(body, mark)) == single or not single,
+               "⑤mdcos._ccg_field(%s,%s) 与单点一致" % (name, mark))
+            ok(tasks._field_line(body, mark) == (nodefile.ccg_field_value(body, mark) or ""),
+               "⑤tasks._field_line(%s,%s) 与单点同值" % (name, mark))
+
+    print("== ⑥ 写读闭环：无冒号节点 upsert 后取得到新值 ==")
+    for enc, upsert in (("ccgc", ccgc._upsert_ccg_line), ("consolidate", consolidate._upsert_ccg_line)):
+        after = upsert(NONCOLON, "生效条件", "新条件")
+        ok(_ccg_field(after, "生效条件") == "新条件",
+           "⑥%s：无冒号节点 upsert 后 mdcos 读出「新条件」" % enc)
+        ok(nodefile.ccg_field_value(after, "生效条件") == "新条件",
+           "⑥%s：同一次写单点读出「新条件」" % enc)
+        ok(nodefile.ccg_completeness(after)["complete"],
+           "⑥%s：upsert 后仍判齐" % enc)
+        try:
+            upsert(NONCOLON, "生效条件", "多行\n注入")
+            ok(False, "⑥%s：值含换行应被拒（N208）" % enc)
+        except ValueError:
+            ok(True, "⑥%s：值含换行被拒（N208 fail-closed）" % enc)
+
+    print()
+    print("ccg_form_parity: PASS=%d FAIL=%d" % (PASS, FAIL))
+    if FAILS:
+        print("FAILS: " + "; ".join(FAILS))
+    return 1 if FAIL else 0
+
+
+if __name__ == "__main__":
+    sys.exit(main())

package/md_cg/test_ccgc.py

@@ -23,7 +23,7 @@ import tempfile
 import threading
 import time
 
-from . import audit, backfill, ccgc, nodefile, units
+from . import audit, backfill, ccgc, nodefile, tokens, units
 from .mdcos import MdCGOS
 
 PASS = FAIL = 0
@@ -126,6 +126,13 @@ def _import_mcp():
 def main():
     global PASS, FAIL
     tmp = tempfile.mkdtemp(prefix="mdcg_ccgc_")
+    # N176 契约：落库准入须令牌验证方——本测试自备哑令牌环境（临时 MDCG_TOKEN_FILE）
+    _old_tf = os.environ.get(tokens.TOKEN_FILE_ENV)
+    os.environ[tokens.TOKEN_FILE_ENV] = os.path.join(tmp, "tokens.json")
+    tk_reviewer = tokens.issue("designer", actor="designer",
+                               path=os.environ[tokens.TOKEN_FILE_ENV])["token"]
+    tk_reviewer_ext = tokens.issue("verify", actor="external-reviewer",
+                                   path=os.environ[tokens.TOKEN_FILE_ENV])["token"]
     try:
         root = os.path.join(tmp, "root")
         os.makedirs(root, exist_ok=True)
@@ -192,8 +199,11 @@ def main():
         a_defer = ccgc.attest("tgt", ccgc.DEFER, "designer", "agent:a1", cg=cg)
         ok((not a_defer.ok) and "E042" in a_defer.error, "V7b DEFER 不构成签章")
         a_ok = ccgc.attest("tgt", ccgc.ACCEPT, "designer", "agent:a1",
-                           evidence="设计者核对原文一致", cg=cg)
+                           evidence="设计者核对原文一致", cg=cg,
+                           verifier_token=tk_reviewer)
         ok(a_ok.ok and bool(a_ok.token), "V7c 编外验证方 ACCEPT → 有效签章")
+        ok(a_ok.verifier_identity == "token", "V7d 令牌验证方 identity=token"
+           "（N176：self-reported 不再构成落库准入）")
 
         # ---------- V8 无章不写 ----------
         l0 = ccgc.link(r, None, cg=cg, apply=True)
@@ -283,7 +293,7 @@ def main():
         lz = ccgc.link_pending(cg, "tgt", apply=True, actor="agent:a1")
         ok(lz.ok and lz.written == 6, "V16f 读回原件+签章 → 落库成功")
         ok(not os.path.isfile(sv["path"]), "V16g 落库成功即清 pending（暂存非存档）")
-        ok(not any(ccgc.PENDING_DIR in str(k) for k in (cg.index.get("nodes") or {})),
+        ok(not any(ccgc.PENDING_DIR in str(k) for k in (list(cg.index.get("nodes") or {}))),
            "V16h pending 不进索引（冷区对检索隐身）")
 
         # ---------- V17 闸门：只认编外裁决，绝不假装通过 ----------
@@ -396,6 +406,17 @@ def main():
             ok(c5["state"] == units.HIVE and c5["verdict"] == "ACCEPT" and c5["passed"] is True,
                "V20g review 取回裁决：ok/verdict/passed 三者分离")
             ok(bool((c5.get("attest") or {}).get("ok")), "V20h 拿到裁决即自动签章")
+            c5b = mcp._ccg_call(cg, {"ccg": {"action": "link", "node_id": "tgt",
+                                             "apply": True}})
+            ok((not c5b["ok"]) and "E052" in str((c5b.get("link") or {}).get("errors")),
+               "V20n 无令牌自报签章 → link 拒绝（N176 E052，不落 knowledge 层）")
+            c5c = mcp._ccg_call(cg, {"ccg": {"action": "attest", "node_id": "tgt",
+                                             "verdict": "ACCEPT",
+                                             "verifier": "external-reviewer",
+                                             "verifier_token": tk_reviewer_ext,
+                                             "evidence": "令牌验证方复核"}})
+            ok(c5c["ok"] and (c5c.get("attest") or {}).get("verifier_identity") == "token",
+               "V20o 令牌验证方重签章 → identity=token（挂回 pending 待落库）")
             c7 = mcp._ccg_call(cg, {"ccg": {"action": "review", "node_id": "tgt",
                                             "jobs": jobs, "blocking": False}})
             ok(c7["state"] == units.HIVE and c7["verdict"] is None and c7["passed"] is False,
@@ -421,6 +442,10 @@ def main():
                 os.environ[units.ENV_EXE] = _old_exe
 
     finally:
+        if _old_tf is None:
+            os.environ.pop(tokens.TOKEN_FILE_ENV, None)
+        else:
+            os.environ[tokens.TOKEN_FILE_ENV] = _old_tf
         print()
         print("ccgc: PASS=%d FAIL=%d" % (PASS, FAIL))
         if FAILS:

package/md_cg/test_govern_directread.py

@@ -33,7 +33,7 @@ import shutil
 import sys
 import tempfile
 
-from . import ccgc, consolidate, crosscheck, vision_evidence
+from . import ccgc, consolidate, crosscheck, tokens, vision_evidence
 from .mdcos import MdCGOS
 
 PASS = FAIL = 0
@@ -181,9 +181,21 @@ def g2_link(tmp):
     r = ccgc.compile_dialog(DIALOG, "gd_link", "agent:a1",
                             slots=SLOTS, marks=MARKS, cg=a)
     ok(r.success, "G2a 编译成功")
+    # N176 契约：落库准入须令牌验证方——哑令牌临时文件 + 临时 MDCG_TOKEN_FILE
+    # （attest→verify_token 走环境变量定位令牌库，绝不触真实令牌库）
+    tok_env = os.path.join(tmp, "g2_tokens.json")
+    _old_tf = os.environ.get(tokens.TOKEN_FILE_ENV)
+    os.environ[tokens.TOKEN_FILE_ENV] = tok_env
+    tk = tokens.issue("designer", actor="designer", path=tok_env)["token"]
     a_ok = ccgc.attest("gd_link", ccgc.ACCEPT, "designer", "agent:a1",
-                       evidence="守卫：候选与对话原文一致", cg=a)
-    ok(a_ok.ok, "G2b 编外验证方签章")
+                       evidence="守卫：候选与对话原文一致", cg=a,
+                       verifier_token=tk)
+    if _old_tf is None:
+        os.environ.pop(tokens.TOKEN_FILE_ENV, None)
+    else:
+        os.environ[tokens.TOKEN_FILE_ENV] = _old_tf
+    ok(a_ok.ok and a_ok.verifier_identity == "token", "G2b 编外验证方签章"
+       "（N176：令牌凭据，self-reported 不构成落库准入）")
     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")
@@ -308,7 +320,8 @@ def _g89_root(tmp):
     a = MdCGOS(root)
     a.add("gd_pro",
           "# 功能名：待提升节点\n# 生效条件：问提升\n# 子功能：说明提升\n"
-          "# 执行：按热度\n# 不适用条件：问无关\n",
+          "# 执行：按热度\n# 验证方式：编译器/静态检查通过\n"
+          "# 不适用条件：问无关\n",
           layer="contextual", merge_count=2)
     a.flush()
     return root

package/md_cg/test_h2_session_view_norm.py

@@ -0,0 +1,233 @@
+# -*- coding: utf-8 -*-
+"""md_cg · H2：会话视图的读侧归一（「写进去能查出来」）
+
+病灶（端到端实测）：写侧落盘值 = `_normalize_session(请求声明值)`
+（`MdCGSecure._attribution` 取 `cg.session`，而 `cg.session` 由 `call_tool`
+→ `_declared_session` 归一）；读侧 `stg.timeline` 却拿**未归一的原值**做
+等值比较 ⇒ 同一条记忆「写进去查不出」——DSH 形态的会话 id 在会话根下不
+存在时写侧落 `anonymous`，读侧按 `session-…` 精确匹配得 `count=0`。
+
+修复（一处归一，改在视图层）：`stg._view_session` 只对「具体会话值」这一态
+消费 `mcp_server._normalize_session`（真源唯一，**不重写实现**），三态语义
+（None / "" / "*" = 跨会话）逐位不变。
+
+覆盖
+----
+A 端到端：MCP 写一条声明了 DSH 形态 session 的记忆 → 落盘值是归一值，
+  再用**原始声明值**读回来必须命中（H2 的核心断言）
+B 归一真源唯一：读侧消费的确实是 `mcp_server._normalize_session`
+  （哨兵替换法——防后续有人在 stg 里重写一把尺，那必然造出第三种不等值）
+C 三态视图不回归：None / "" / "*" 仍跨会话；具体非 DSH 值仍精确匹配
+D fail-soft：会话根不可读（OSError）时读写两侧都保原值，仍能读回
+E 不越界：cg 侧读路径（search）不吃请求 session（issue #35 定稿：身份不可自报）
+
+运行：python -m md_cg.test_h2_session_view_norm
+"""
+from __future__ import annotations
+
+import os
+import shutil
+import sys
+import tempfile
+
+sys.path.insert(0, os.path.dirname(os.path.dirname(os.path.abspath(__file__))))
+
+# Windows cmd 默认 GBK：中文打印即 UnicodeEncodeError，且崩在断言之后、报告之前。
+if hasattr(sys.stdout, "reconfigure"):
+    sys.stdout.reconfigure(encoding="utf-8", errors="replace")
+
+from md_cg.mdcos import MdCGSecure
+from md_cg.security import DEFAULT_SENSITIVITY, Principal
+from md_cg import mcp_server as ms
+
+PASS = 0
+FAILS = []
+
+# 合成会话 id（uuid4 形态的 DSH 会话；非真实凭据，仅形态样本）
+DSH_ID = "session-11111111-2222-3333-4444-555555555555"
+ENV_KEY = "MDCG_DSH_SESSIONS_ROOT"
+
+
+def check(name, cond, detail=""):
+    global PASS
+    if cond:
+        PASS += 1
+        print(f"  [PASS] {name}" + (f"  · {detail}" if detail else ""))
+    else:
+        FAILS.append(name)
+        print(f"  [FAIL] {name}  · {str(detail)[:240]}")
+
+
+def _p(actor, session):
+    return Principal(actor=actor, clearance=DEFAULT_SENSITIVITY,
+                     can_write=True, can_admin=True, role="designer",
+                     session=session, harness="test-harness")
+
+
+def _remember(cg, text, session):
+    """经 MCP 写入口落一条（gated 路径，与插件自动记忆同一条链）。"""
+    return ms.call_tool(cg, "mdcg_remember", {
+        "content": text, "layer": "contextual", "session": session,
+        "gated": True, "importance": 0.6})
+
+
+def _timeline(cg, session):
+    return ms.call_tool(cg, "stg", {"op": "timeline", "limit": 20, "session": session})
+
+
+def test_a(root, sessions_root):
+    """A 写进去能查出来（核心断言）。"""
+    print("\n[A] 端到端：DSH 形态声明 → 落盘归一值 → 原值读回命中")
+    old = os.environ.get(ENV_KEY)
+    os.environ[ENV_KEY] = sessions_root          # 根可读、但无该会话
+    try:
+        # 前置条件断言：本用例的环境确实触发归一，否则下面的断言是空的
+        check("A0 前置：该环境下 DSH 形态归一为 anonymous",
+              ms._normalize_session(DSH_ID) == "anonymous",
+              ms._normalize_session(DSH_ID))
+        cg = MdCGSecure(root, principal=_p("alice", "sess_A"))
+        res = _remember(cg, "阿尔法 会话视图归一 端到端写入样本", DSH_ID)
+        nid = res.get("written") or res.get("node_id")
+        check("A1 写入落盘（ACCEPT 且有节点 id）",
+              bool(nid) and res.get("verdict") == "ACCEPT",
+              (res.get("verdict"), nid))
+        fm = (cg.get(nid) or {}).get("frontmatter") or {}
+        check("A2 落盘 session = 归一声明值（写侧口径）",
+              fm.get("session") == "anonymous", fm.get("session"))
+        tl = _timeline(cg, DSH_ID)
+        check("A3 用**原始声明值**读回命中（H2 核心：写进去查得出）",
+              tl.get("count") == 1 and [i["id"] for i in tl.get("items", [])] == [nid],
+              (tl.get("count"), [i["id"] for i in tl.get("items", [])[:3]]))
+        check("A4 返回体 session = 归一后的生效值（诚实回带）",
+              tl.get("session") == "anonymous", tl.get("session"))
+    finally:
+        if old is None:
+            os.environ.pop(ENV_KEY, None)
+        else:
+            os.environ[ENV_KEY] = old
+
+
+def test_b(root, sessions_root):
+    """B 归一真源唯一（哨兵法）。"""
+    print("\n[B] 读侧消费 mcp_server 真源（不重写一把尺）")
+    old = os.environ.get(ENV_KEY)
+    os.environ[ENV_KEY] = sessions_root
+    orig = ms._normalize_session
+    try:
+        cg = MdCGSecure(root, principal=_p("alice", "sess_A"))
+        ms._normalize_session = lambda raw: "SENTINEL_" + str(raw)
+        out = _timeline(cg, "probe")
+        check("B1 具体值经 mcp_server._normalize_session（哨兵可见）",
+              out.get("session") == "SENTINEL_probe", out.get("session"))
+        star = _timeline(cg, "*")
+        check("B2 \"*\" 不经归一（跨会话开关是不变量）",
+              star.get("session") is None, star.get("session"))
+        blank = _timeline(cg, "")
+        check("B3 空串不经归一（缺省语义不变量）",
+              blank.get("session") is None, blank.get("session"))
+    finally:
+        ms._normalize_session = orig
+        if old is None:
+            os.environ.pop(ENV_KEY, None)
+        else:
+            os.environ[ENV_KEY] = old
+
+
+def test_c(root, sessions_root):
+    """C 三态视图不回归 + 具体值精确匹配。"""
+    print("\n[C] 视图三态与精确匹配不回归")
+    old = os.environ.get(ENV_KEY)
+    os.environ[ENV_KEY] = sessions_root
+    try:
+        cg = MdCGSecure(root, principal=_p("alice", "sess_A"))
+        _remember(cg, "贝塔 属于 会话 sess_A 的知识点", "sess_A")
+        a = _timeline(cg, "sess_A")
+        check("C1 具体非 DSH 值精确匹配（原样采用）",
+              a.get("count") == 1 and a.get("session") == "sess_A",
+              (a.get("count"), a.get("session")))
+        z = _timeline(cg, "sess_Z")
+        check("C2 未知会话为空（不因缺省而放行）",
+              z.get("count") == 0, z.get("count"))
+        for label, val in (("缺省", None), ("空串", ""), ("星号", "*")):
+            out = _timeline(cg, val)
+            check(f"C3 {label}仍为跨会话视图（返回体 session=None 且非空）",
+                  out.get("session") is None and out.get("count") >= 1,
+                  (out.get("session"), out.get("count")))
+    finally:
+        if old is None:
+            os.environ.pop(ENV_KEY, None)
+        else:
+            os.environ[ENV_KEY] = old
+
+
+def test_d(root, tmp):
+    """D fail-soft：根不可读 → 两侧都保原值。"""
+    print("\n[D] 会话根不可读（OSError）时 fail-soft 读写一致")
+    old = os.environ.get(ENV_KEY)
+    os.environ[ENV_KEY] = os.path.join(tmp, "no_such_root_dir")
+    try:
+        check("D1 根不可读 → 归一保原值",
+              ms._normalize_session(DSH_ID) == DSH_ID,
+              ms._normalize_session(DSH_ID))
+        cg = MdCGSecure(root, principal=_p("alice", "sess_A"))
+        res = _remember(cg, "伽马 根不可读 场景写入样本", DSH_ID)
+        nid = res.get("written") or res.get("node_id")
+        fm = (cg.get(nid) or {}).get("frontmatter") or {}
+        check("D2 落盘保原值（不因环境差异丢会话标记）",
+              fm.get("session") == DSH_ID, fm.get("session"))
+        tl = _timeline(cg, DSH_ID)
+        check("D3 同环境下读回命中（读写两侧同尺）",
+              tl.get("count") == 1, tl.get("count"))
+    finally:
+        if old is None:
+            os.environ.pop(ENV_KEY, None)
+        else:
+            os.environ[ENV_KEY] = old
+
+
+def test_e(root, sessions_root):
+    """E 不越界：cg 侧读路径不吃请求 session（issue #35 定稿）。"""
+    print("\n[E] 不越界：search 的 session 不构成授权/过滤豁免")
+    old = os.environ.get(ENV_KEY)
+    os.environ[ENV_KEY] = sessions_root
+    try:
+        cg = MdCGSecure(root, principal=_p("alice", "sess_A"))
+        _remember(cg, "德尔塔 共享档检索样本", "sess_A")
+        res_default, _ = cg.search("德尔塔", judge=False, record=False)
+        res_dsh, _ = cg.search("德尔塔", session=DSH_ID, judge=False, record=False)
+        ids_default = {r[0].get("id") if isinstance(r, tuple) else r.get("id")
+                       for r in res_default}
+        ids_dsh = {r[0].get("id") if isinstance(r, tuple) else r.get("id")
+                   for r in res_dsh}
+        check("E1 传 DSH 形态 session 与缺省结果一致（cg 侧不经 _view_session）",
+              ids_default == ids_dsh and bool(ids_default),
+              (sorted(ids_default)[:3], sorted(ids_dsh)[:3]))
+    finally:
+        if old is None:
+            os.environ.pop(ENV_KEY, None)
+        else:
+            os.environ[ENV_KEY] = old
+
+
+def main():
+    tmp = tempfile.mkdtemp(prefix="mdcg_h2_")
+    sessions_root = os.path.join(tmp, "sessions")
+    os.makedirs(sessions_root, exist_ok=True)
+    try:
+        test_a(os.path.join(tmp, "root_a"), sessions_root)
+        test_b(os.path.join(tmp, "root_b"), sessions_root)
+        test_c(os.path.join(tmp, "root_c"), sessions_root)
+        test_d(os.path.join(tmp, "root_d"), tmp)
+        test_e(os.path.join(tmp, "root_e"), sessions_root)
+    finally:
+        shutil.rmtree(tmp, ignore_errors=True)
+
+    print("\n通过 %d / 失败 %d" % (PASS, len(FAILS)))
+    if FAILS:
+        print("失败项：" + ", ".join(FAILS))
+        return 1
+    return 0
+
+
+if __name__ == "__main__":
+    sys.exit(main())