@furongjun1999/dsh-memory 0.6.0 → 0.7.0

package/md_cg/test_n230_dirty_replay.py

@@ -0,0 +1,375 @@
+# -*- coding: utf-8 -*-
+"""N230 `_dirty` 重放遮蔽守卫（P0-3：新记录必须能盖住旧记录，旧不得盖新）。
+
+缺陷（材料自编 N226，`docs/eval/缺陷挖掘_自主迭代_v25.md:132/:178` 记为**留档未修**）：
+
+    站点 `md_cg/mdcg.py` 的 `_maybe_reload_index`（改动前 :1353-1357）——
+    `for nid, e in self._dirty.items(): … idx["nodes"][nid] = e` **无条件**把本实例
+    未 flush 的 `_dirty` 条目盖回重载后的索引上，没有任何时序/代际比较。
+
+**探针实跑复现（2026-10-01，独立 tempfile 沙箱）**：
+
+    ① A = MdCG(R, autoflush=1000)；A.add("x_node", 正文=OLD) ⇒ A._dirty 含 x_node（未 flush）
+    ② B = MdCG(R, autoflush=1)；B.add("x_node", 正文=NEW)；B.close() ⇒ 盘面与快照都是 NEW
+    ③ A._maybe_reload_index() 返回 **True**（确实重载了），但重载后
+       A.index["nodes"]["x_node"]["content_hash"] **仍是 OLD**；新建读者实例 C 读到 NEW
+       ⇒ 索引与盘面撕裂（检索面按旧值给候选/桶/指纹）
+
+**修法（本轮）**：给 `_dirty` 引入「**落盘逐字见证**」——标脏时记下节点文件的
+`(st_mtime_ns, st_size)`；重放前再 stat 一次，失配 ⇒ 本实例这条已被盘面更新盖过
+⇒ **跳过重放**（放行盘面）。证不出陈旧（无 path / stat 失败 / 未挂 root）时照旧
+重放——「本实例未落盘写入不因重载从检索面消失」这条既有不变量一并保留。
+tombstone（`None`）语义**一字不改**（`_unstage` 立即 flush，不跨重载存活）。
+
+断言分组：
+
+  G0 前置——站点在位：`_dirty_entry_superseded` / `_note_witness` 各一处；`_dirty.root` 已挂。
+  G1 **红基线可出示**（探针三步复现）——旧记录**不得**盖住盘面新记录：A 重载后
+     必须收敛到 NEW（= 新建读者实例 C 的读数），且 `_dirty_replay_superseded ≥ 1`。
+  G2 不变量保持——他进程只动**别的**节点时，本实例未 flush 的写入必须仍在检索面
+     上（`_dirty_replay_superseded == 0`，该条目仍在 index 且哈希不变）。
+  G3 tombstone 语义一字不改——`_dirty[nid]=None` 在重载时仍 pop 掉该条目。
+  G4 见证判据的判别力（正/负对照）——`_dirty_entry_superseded` 的四条边界逐一断言。
+  G5 单点结构（静态）——`for nid, e in self._dirty.items():` 的重放体内**必须**
+     经过 `_dirty_entry_superseded`（副本回归/裸赋值回归即红）。
+
+运行：python -X utf8 -m md_cg.test_n230_dirty_replay
+      python -X utf8 -m md_cg.test_n230_dirty_replay --head-baseline  # 红基线自证
+      python -X utf8 -m md_cg.test_n230_dirty_replay --mutate         # 定点变异自证
+      python -X utf8 -m md_cg.test_n230_dirty_replay --mutate --list
+
+退出码（fail-closed）：0 = 全绿；1 = 有断言失败 / 变异未按预期转红；
+2 = ANCHOR-MISS（变异锚点在当前源码里找不到——实现改了却没同步本表）。
+
+**基线纪律**：`--head-baseline` 把 `_dirty_entry_superseded` 换回「恒 False」
+（= 改动前的无条件重放），G1 必须转红；若不红，说明 G1 没有判别力。
+"""
+from __future__ import annotations
+
+import contextlib
+import io
+import os
+import shutil
+import sys
+import tempfile
+import types
+
+from .mdcg import MdCG
+
+_PASS = []
+_FAIL = []
+_SKIP = []
+_SRC = {}
+_TMP = tempfile.mkdtemp(prefix="mdcg_n230_")
+_GEN = [0]
+_REPO = os.path.dirname(os.path.dirname(os.path.abspath(__file__)))
+
+BODY = "# 功能名：%s\n# 生效条件：全时窗\n# 子功能：s\n# 执行：%s\n" \
+       "# 验证方式：test\n# 不适用条件：无\n"
+
+
+def ok(cond, msg, extra=""):
+    (_PASS if cond else _FAIL).append(msg)
+    print(("  PASS " if cond else "  FAIL ") + msg
+          + (("  ← " + str(extra)) if (extra and not cond) else ""))
+
+
+def _rel_text(rel: str) -> str:
+    if rel in _SRC:
+        return _SRC[rel]
+    with open(os.path.join(_REPO, rel), encoding="utf-8") as f:
+        return f.read()
+
+
+def _sandbox(name: str) -> str:
+    _GEN[0] += 1
+    d = os.path.join(_TMP, "gen%d_%s" % (_GEN[0], name))
+    os.makedirs(d, exist_ok=True)
+    return d
+
+
+def _disk_body(root: str, nid: str) -> str:
+    p = os.path.join(root, "knowledge", "orphan", nid + ".md")
+    return open(p, encoding="utf-8").read()
+
+
+# ---------------------------------------------------------------- G0
+def g0():
+    print("== G0 站点在位（前置）==")
+    src = _rel_text("md_cg/mdcg.py")
+    ok(src.count("def _dirty_entry_superseded") == 1,
+       "G0a mdcg.py 内 `_dirty_entry_superseded` 恰一处定义")
+    ok(src.count("def _note_witness") == 1,
+       "G0b mdcg.py 内 `_note_witness` 恰一处定义")
+    ok("self._dirty.root = self.root" in src,
+       "G0c MdCG.__init__ 把数据根交给脏集（见证要靠它拼绝对路径）")
+    r = _sandbox("g0")
+    cg = MdCG(r, autoflush=1000)
+    ok(cg._dirty.root == cg.root and os.path.isabs(cg._dirty.root),
+       "G0d 实例构造后 _dirty.root = 数据根", cg._dirty.root)
+    ok(cg._dirty_replay_superseded == 0,
+       "G0e 读数 _dirty_replay_superseded 初始为 0")
+    cg.close()
+
+
+# ---------------------------------------------------------------- G1
+def _probe_repro():
+    """探针三步复现（返回值供 G1 逐条断言）。"""
+    r = _sandbox("g1")
+    a = MdCG(r, autoflush=1000)
+    a.add("x_node", BODY % ("x", "OLD"), layer="knowledge",
+          verification_basis="test")
+    witness = dict(a._dirty.staged_stat)
+    b = MdCG(r, autoflush=1)
+    b.add("x_node", BODY % ("x", "NEW"), layer="knowledge",
+          verification_basis="test")
+    b.close()                                   # 他进程写出新盘面 + 新快照
+    reloaded = a._maybe_reload_index()
+    c = MdCG(r, autoflush=1000)                 # 新建读者实例（只读盘面）
+    out = {"root": r, "a": a, "c": c, "reloaded": reloaded,
+           "a_hash": (a.index["nodes"].get("x_node") or {}).get("content_hash"),
+           "c_hash": (c.index["nodes"].get("x_node") or {}).get("content_hash"),
+           "superseded": a._dirty_replay_superseded,
+           "witness": witness, "dirty": list(a._dirty),
+           "disk": _disk_body(r, "x_node")}
+    return out
+
+
+def g1():
+    print("== G1 红基线可出示：旧记录不得盖住盘面新记录（探针复现）==")
+    R = _probe_repro()
+    ok(R["witness"].get("x_node") is not None,
+       "G1 前置：A 标脏时记下了逐字见证 (mtime_ns, size)", R["witness"])
+    ok(R["reloaded"] is True,
+       "G1a 前置：重载确已发生（_maybe_reload_index() == True）", R["reloaded"])
+    ok("执行：NEW" in R["disk"],
+       "G1b 前置：盘面真值是 NEW", R["disk"].splitlines()[3])
+    ok(R["c_hash"] is not None and R["a_hash"] == R["c_hash"],
+       "G1c **新盖旧**：A 重载后条目 == 新建读者实例 C 的条目（收敛到盘面）",
+       {"A": R["a_hash"], "C": R["c_hash"]})
+    ok(R["superseded"] >= 1,
+       "G1d 可判读数：至少 1 条被判「已被盘面更新盖过」而跳过重放",
+       R["superseded"])
+    ok(R["a"]._dirty.get("x_node") is not None,
+       "G1e 该条仍在 _dirty（本实例确实还没 flush——不是靠 flush 凑的绿）",
+       list(R["a"]._dirty))
+    R["a"].close(); R["c"].close()
+
+
+# ---------------------------------------------------------------- G2
+def g2():
+    print("== G2 不变量保持：他进程只动别的节点时，未落盘写入不消失 ==")
+    r = _sandbox("g2")
+    a = MdCG(r, autoflush=1000)
+    a.add("y_node", BODY % ("y", "MINE"), layer="knowledge",
+          verification_basis="test")
+    a_hash = a.index["nodes"]["y_node"]["content_hash"]
+    b = MdCG(r, autoflush=1)
+    b.add("z_node", BODY % ("z", "OTHER"), layer="knowledge",
+          verification_basis="test")
+    b.close()
+    reloaded = a._maybe_reload_index()
+    ok(reloaded is True, "G2 前置：重载确已发生（他进程改了签名）", reloaded)
+    ok(a._dirty_replay_superseded == 0,
+       "G2a y_node 未被判陈旧（盘面上没人动它）——见证失配才是陈旧",
+       a._dirty_replay_superseded)
+    e = a.index["nodes"].get("y_node")
+    ok(e is not None and e.get("content_hash") == a_hash,
+       "G2b **不变量保持**：本实例未 flush 的 y_node 仍在检索面上且哈希不变",
+       {"present": e is not None})
+    ok(a.index["nodes"].get("z_node") is not None,
+       "G2c 他进程的 z_node 也可见（重载不该只保一边）")
+    a.close(); b.close()
+
+
+# ---------------------------------------------------------------- G3
+def g3():
+    print("== G3 tombstone 语义一字不改 ==")
+    r = _sandbox("g3")
+    c = MdCG(r, autoflush=1000)
+    c.add("tomb_node", BODY % ("t", "X"), layer="knowledge",
+          verification_basis="test")
+    c.flush()                              # 入日志；_dirty 清空
+    ok("tomb_node" in c.index["nodes"], "G3 前置：节点已在索引里")
+    c.index["nodes"].pop("tomb_node", None)
+    c._dirty["tomb_node"] = None           # 不经 _unstage（那条路立即 flush）
+    ok(c._dirty.get("tomb_node") is None and "tomb_node" in c._dirty,
+       "G3a 前置：_dirty 里有该 nid 的 tombstone（值 None）")
+    c._index_sig = None                    # 强制签名失配 → 下次读面必然重载
+    ok(c._maybe_reload_index() is True, "G3b 前置：已重载")
+    ok("tomb_node" not in c.index["nodes"],
+       "G3c tombstone 仍被重放 pop 掉（本修复不碰 tombstone 语义）")
+    c.close()
+
+
+# ---------------------------------------------------------------- G4
+def g4():
+    print("== G4 见证判据的判别力（正/负对照）==")
+    r = _sandbox("g4")
+    c = MdCG(r, autoflush=1000)
+    c.add("w_node", BODY % ("w", "V1"), layer="knowledge",
+          verification_basis="test")
+    ok(c._dirty_entry_superseded("w_node") is False,
+       "G4a 负对照：标脏后盘面未动 → 不判陈旧（未落盘写入照旧重放）")
+    import time as _t
+    _t.sleep(0.01)
+    with open(os.path.join(r, c._dirty["w_node"]["path"]), "w",
+              encoding="utf-8", newline="\n") as f:
+        f.write(BODY % ("w", "V2"))
+    ok(c._dirty_entry_superseded("w_node") is True,
+       "G4b 正对照：盘面被改写 → 判陈旧（旧不得盖新）")
+    os.remove(os.path.join(r, c._dirty["w_node"]["path"]))
+    ok(c._dirty_entry_superseded("w_node") is True,
+       "G4c 正对照：文件被删掉（标脏时在）→ 判陈旧")
+    c._dirty.staged_stat.pop("w_node", None)
+    ok(c._dirty_entry_superseded("w_node") is False,
+       "G4d 无见证（证不出陈旧）→ 不判陈旧——不变量优先于覆盖面")
+    c._dirty.staged_stat["nopath"] = (1, 1)
+    c._dirty["nopath"] = {"layer": "knowledge"}       # 无 path 的条目
+    ok(c._dirty_entry_superseded("nopath") is False,
+       "G4e 条目无 path → 不判陈旧（无见证可查）")
+    ok(c._dirty.root == r and c._dirty.staged_stat.get("w_node") is None,
+       "G4f 移除文件的那次 stat 失败**不登记**见证（staged_stat 无该键）")
+    c.close()
+
+
+# ---------------------------------------------------------------- G5
+def g5():
+    print("== G5 单点结构（静态：重放体必须过判据）==")
+    src = _rel_text("md_cg/mdcg.py")
+    i = src.index("for nid, e in self._dirty.items():")
+    body = src[i:i + 900]
+    ok("self._dirty_entry_superseded(nid)" in body,
+       "G5 重放循环体内经过 `_dirty_entry_superseded`（副本回归即红）")
+    ok("superseded += 1" in body and "continue" in body,
+       "G5a 判为陈旧即 `continue`（跳过重放，不是只记账）")
+    # 可执行行里不得再有无条件覆盖的裸赋值形态
+    code = "\n".join(l for l in body.splitlines()
+                     if not l.strip().startswith("#"))
+    ok(code.count('idx["nodes"][nid] = e') == 1,
+       "G5b 重放体里 `idx[\"nodes\"][nid] = e` 恰一处（在判据之后）")
+    ok("self._dirty_replay_superseded = superseded" in src,
+       "G5c 跳过条数落在可判读数 `_dirty_replay_superseded` 上")
+
+
+_GROUPS = (g0, g1, g2, g3, g4, g5)
+
+
+def _run_groups() -> int:
+    _PASS.clear()
+    _FAIL.clear()
+    for g in _GROUPS:
+        try:
+            g()
+        except Exception as exc:                       # noqa: BLE001
+            ok(False, "断言组 %s 抛异常：%s" % (g.__name__, exc))
+            import traceback
+            print(traceback.format_exc()[-900:])
+    return len(_FAIL)
+
+
+# ---------------------------------------------------------------- 变异表
+# 锚点 = (名字, rel, old, new)。每次变异必须让套件**转红**：
+#   M1 重放体恢复无条件覆盖（= 改动前形态）→ G1c/G1d/G5 红
+#   M2 判据恒 False（见证照记但不采信）→ G1c/G1d 红
+#   M3 见证完全不登记 → 判据永远拿不到见证 ⇒ 同 M2
+_MUTATIONS = (
+    ("重放体恢复无条件覆盖（改动前形态）", "md_cg/mdcg.py",
+     "            if self._dirty_entry_superseded(nid):\n"
+     "                superseded += 1\n                continue",
+     "            if False:\n                superseded += 1\n                continue"),
+    ("判据恒 False（见证不采信）", "md_cg/mdcg.py",
+     "        return (cur.st_mtime_ns, cur.st_size) != st",
+     "        return False"),
+    ("见证完全不登记", "md_cg/mdcg.py",
+     "        self.staged_stat[k] = (st.st_mtime_ns, st.st_size)",
+     "        self.staged_stat.pop(k, None)"),
+)
+
+
+def _exec_module(name: str, rel: str, text: str):
+    ns = {"__name__": name, "__package__": "md_cg",
+          "__file__": os.path.join(_REPO, rel)}
+    exec(compile(text, rel, "exec"), ns)               # noqa: S102 —— 基线自证用
+    m = types.ModuleType(name)
+    m.__dict__.update(ns)
+    return m
+
+
+def _mutate_mode(list_only: bool = False) -> int:
+    print("!! 定点变异自证：逐条把判据改回「改动前/失效」形态，套件必须转红\n")
+    if list_only:
+        for name, rel, _o, _n in _MUTATIONS:
+            print("  %-34s [%s]" % (name, rel))
+        return 0
+    anchor_miss, bad = [], []
+    with contextlib.redirect_stdout(io.StringIO()):
+        clean = _run_groups()
+    print("  未变异基线：失败=%d（必须为 0）" % clean)
+    if clean:
+        bad.append("未变异基线即失败")
+
+    for name, rel, old, new in _MUTATIONS:
+        src = _rel_text(rel)
+        if old not in src:
+            print("  ANCHOR-MISS %s —— 锚点在 %s 源码里找不到（实现改了却没同步"
+                  "本表）" % (name, rel))
+            anchor_miss.append(name)
+            continue
+        mut_src = src.replace(old, new, 1)
+        _SRC[rel] = mut_src
+        try:
+            mut = _exec_module("md_cg._n230_mut", rel, mut_src)
+            globals()["MdCG"] = mut.MdCG
+            with contextlib.redirect_stdout(buf := io.StringIO()):
+                reds = _run_groups()
+            detail = buf.getvalue()
+        finally:
+            globals()["MdCG"] = _REAL_MdCG
+            _SRC.pop(rel, None)
+        red_lines = [l for l in detail.splitlines()
+                     if l.strip().startswith("FAIL ")]
+        verdict = "红" if reds else "**仍全绿 = 该判据空转**"
+        print("  %s %-34s 红项=%d  %s"
+              % ("OK    " if reds else "MISS  ", name, reds, verdict))
+        for l in red_lines[:5]:
+            print("        " + l.strip()[5:])
+        if not reds:
+            bad.append(name)
+
+    if anchor_miss:
+        print("\nANCHOR-MISS：%s" % "、".join(anchor_miss))
+        print("退出码 2（fail-closed）：变异表锚点漂移即判失败，不得静默跳过")
+        return 2
+    print("\n定点变异自证：%s"
+          % ("PASS（每处判据都被打红）" if not bad else "FAIL —— " + "、".join(bad)))
+    return 0 if not bad else 1
+
+
+_REAL_MdCG = MdCG
+
+
+def main() -> int:
+    try:
+        if "--mutate" in sys.argv:
+            return _mutate_mode("--list" in sys.argv)
+        if "--head-baseline" in sys.argv:
+            print("!! 红基线模式：_dirty_entry_superseded 换回「恒 False」"
+                  "（= 改动前的无条件重放），G1 应当转红\n")
+            MdCG._dirty_entry_superseded = lambda self, nid: False
+            n = _run_groups()
+            print("\n== 红基线判定：应有失败 ==")
+            print("红基线失败数 = %d（>0 才算断言有判别力）" % n)
+            for f in _FAIL:
+                print("   红:", f)
+            return 0 if n else 1
+        n = _run_groups()
+        print("\nN230 `_dirty` 重放遮蔽守卫：%d 通过，%d 失败，%d 跳过"
+              % (len(_PASS), n, len(_SKIP)))
+        return 0 if not n else 1
+    finally:
+        shutil.rmtree(_TMP, ignore_errors=True)
+
+
+if __name__ == "__main__":
+    sys.exit(main())

package/md_cg/test_n62_tenant_bind_failclosed.py

@@ -0,0 +1,200 @@
+# -*- coding: utf-8 -*-
+"""N62 守卫（第 5 轮，2026-09-27）：令牌路径租户上限夹紧 + 租户绑定覆盖 fail-closed。
+
+留档复测（v8 N62 首报 → v9/v15/v16 历轮成立 → 本轮第 5 次，medium 维持）：
+
+病灶①（cap 夹紧从未接线）：verify_token 令牌路径返回 Principal 时
+clearance=rec["clearance"] 原样透出（tokens.py:450）——TenantRegistry.cap_of /
+principal_for 现成（security.py:323/332）但令牌路径零调用；tenantC 登记上限
+internal 时 designer(secret) 令牌仍以 secret 运行（可读含 private/secret）。
+
+病灶②（绑定覆盖 warn-only）：verify_token 形参 tenant（MCP 侧来自
+MDCG_TENANT）与令牌记录 rec["tenant"] 不同时仅 stderr 告警（tokens.py:441-446），
+形参值照常顶替（:448 tenant=tenant or ...）——tenantA 令牌在 MDCG_TENANT=
+tenantB 下以原权限对 tenantB 运行。
+
+红守卫（哑临时登记表 + 哑令牌库 + 临时根，确定性、零真实状态；登记表经
+MDCG_TENANT_REGISTRY 注入——与 _resolve_root 同源，无新形参，旧代码红为
+功能红而非 TypeError）：
+  R1 ② 覆盖被拒：tenantA designer 令牌 + tenant="tenantB" → TokenError
+      （fail-closed），消息含两侧租户与校正指引；
+  R2 ① cap 夹紧：tenantC（登记 cap=internal）designer 令牌（角色默认 secret）
+      无覆盖 → clearance 夹紧为 internal，allows("private"/"secret") 均 False；
+  R3 未登记租户零闸变：tenantD（不在登记表）令牌 clearance 原样；
+  R4 无冲突零误伤：tenant=None/""/同值 → 原令牌租户、零异常；
+  R5 MCP 进程面：_build_principal 同面复现（env 注入 MDCG_TOKEN + MDCG_TENANT
+      + MDCG_TENANT_REGISTRY）——② 拒绝、① 夹紧、同值零误伤。
+
+同面搭车（N174，low，见 deferred，本轮不修）：mcp_server.py:3522-3528 legacy
+env 路径 clearance 夹紧另行 deferred。
+
+运行：python -m md_cg.test_n62_tenant_bind_failclosed
+"""
+from __future__ import annotations
+
+import contextlib
+import io
+import os
+import shutil
+import sys
+import tempfile
+
+from . import tokens
+from .security import TenantRegistry
+
+PASS = FAIL = 0
+FAILS = []
+MARK = "租户绑定被入参覆盖"          # fail-closed 拒绝消息稳定锚点
+
+
+def check(name, cond, detail=""):
+    global PASS, FAIL
+    if cond:
+        PASS += 1
+        print("  OK   " + name)
+    else:
+        FAIL += 1
+        FAILS.append(name)
+        print("  FAIL " + name + "  " + str(detail)[:110])
+
+
+def _verify(token, tenant=None, path=None):
+    """verify_token 捕获异常，返回 (principal|None, exc|None)。"""
+    try:
+        return tokens.verify_token(token, tenant=tenant, path=path), None
+    except tokens.TokenError as e:
+        return None, e
+
+
+def main():
+    sys.stdout.reconfigure(encoding="utf-8", errors="replace")
+    tmp = tempfile.mkdtemp(prefix="mdcg_n62_")
+    tf = os.path.join(tmp, "_tokens.json")
+    reg_path = os.path.join(tmp, "_tenants.json")
+    old_reg = os.environ.get("MDCG_TENANT_REGISTRY")
+    try:
+        # 哑临时登记表：确定性上限（tenantA=secret 不夹、tenantB/tenantC=internal）
+        reg = TenantRegistry(reg_path)
+        reg.register("tenantA", os.path.join(tmp, "rootA"), clearance_cap="secret",
+                     description="N62 守卫哑登记 tenantA")
+        reg.register("tenantB", os.path.join(tmp, "rootB"),
+                     clearance_cap="internal", description="N62 哑登记 tenantB")
+        reg.register("tenantC", os.path.join(tmp, "rootC"),
+                     clearance_cap="internal", description="N62 哑登记 tenantC")
+        os.environ["MDCG_TENANT_REGISTRY"] = reg_path
+        d_a = tokens.issue("designer", actor="dummy-designer-a", tenant="tenantA",
+                           path=tf)          # 角色默认 clearance=secret
+        d_c = tokens.issue("designer", actor="dummy-designer-c", tenant="tenantC",
+                           path=tf)          # 登记 cap=internal < secret
+        d_d = tokens.issue("designer", actor="dummy-designer-d", tenant="tenantD",
+                           path=tf)          # tenantD 未登记
+
+        # ---------- R1 ② 覆盖 fail-closed ----------
+        print("== R1 租户绑定被入参覆盖 → 拒绝（fail-closed）==")
+        p1, e1 = _verify(d_a["token"], tenant="tenantB", path=tf)
+        check("R1a 覆盖被拒（TokenError 且含锚点）",
+              p1 is None and e1 is not None and MARK in str(e1),
+              f"p={p1} exc={type(e1).__name__}: {str(e1)[:80]}")
+        check("R1b 拒绝消息含两侧租户与校正指引",
+              e1 is not None and "tenantA" in str(e1) and "tenantB" in str(e1)
+              and "MDCG_TENANT" in str(e1), str(e1)[:100])
+
+        # ---------- R2 ① cap 夹紧（登记租户，纯收紧） ----------
+        print("== R2 登记租户上限夹紧（cap=internal < 令牌 secret）==")
+        p2, e2 = _verify(d_c["token"], path=tf)
+        check("R2a clearance 夹紧为 internal",
+              e2 is None and p2 is not None and p2.clearance == "internal",
+              f"clearance={getattr(p2, 'clearance', None)} err={e2}")
+        check("R2b 可读不含 private/secret",
+              p2 is not None and not p2.allows("private")
+              and not p2.allows("secret"),
+              f"private={p2.allows('private') if p2 else None} "
+              f"secret={p2.allows('secret') if p2 else None}")
+        check("R2c internal 本级仍可读（收紧不误伤）",
+              p2 is not None and p2.allows("internal"),
+              f"internal={p2.allows('internal') if p2 else None}")
+
+        # ---------- R3 未登记租户零闸变 ----------
+        print("== R3 未登记租户零闸变（fresh install 行为不变）==")
+        p3, e3 = _verify(d_d["token"], path=tf)
+        check("R3 未登记 tenantD clearance 原样（不夹紧）",
+              e3 is None and p3 is not None and p3.clearance == "secret"
+              and p3.tenant == "tenantD" and p3.allows("secret"),
+              f"clearance={getattr(p3, 'clearance', None)} "
+              f"tenant={getattr(p3, 'tenant', None)} err={e3}")
+
+        # ---------- R4 无冲突零误伤 ----------
+        print("== R4 无冲突路径零误伤 ==")
+        for label, arg in (("None", None), ("空串", ""), ("同值", "tenantA")):
+            p4, e4 = _verify(d_a["token"], tenant=arg, path=tf)
+            check(f"R4 tenant={label}：零异常且回落令牌租户 tenantA",
+                  e4 is None and p4 is not None and p4.tenant == "tenantA"
+                  and p4.clearance == "secret",
+                  f"tenant={getattr(p4, 'tenant', None)} "
+                  f"clearance={getattr(p4, 'clearance', None)} err={e4}")
+
+        # ---------- R5 MCP 进程面（_build_principal 同面） ----------
+        print("== R5 MCP 进程级：MDCG_TOKEN + MDCG_TENANT + MDCG_TENANT_REGISTRY ==")
+        from .mcp_server import _build_principal
+        saved = {k: os.environ.get(k) for k in
+                 ("MDCG_TOKEN", "MDCG_TENANT", "MDCG_TOKEN_FILE", "MDCG_ROOT",
+                  "MDCG_TENANT_REGISTRY", "MDCG_LEGACY_ENV_AUTH",
+                  "MDCG_LEGACY_ENV_ADMIN", "MDCG_CAN_ADMIN", "MDCG_CAN_WRITE",
+                  "MDCG_CLEARANCE", "MDCG_ACTOR")}
+        try:
+            os.environ["MDCG_TOKEN"] = d_a["token"]
+            os.environ["MDCG_TOKEN_FILE"] = tf
+            os.environ["MDCG_ROOT"] = os.path.join(tmp, "mcp")
+            os.environ["MDCG_TENANT_REGISTRY"] = reg_path
+            os.environ["MDCG_TENANT"] = "tenantB"
+            for k in ("MDCG_LEGACY_ENV_AUTH", "MDCG_LEGACY_ENV_ADMIN",
+                      "MDCG_CAN_ADMIN", "MDCG_CAN_WRITE", "MDCG_CLEARANCE",
+                      "MDCG_ACTOR"):
+                os.environ.pop(k, None)
+            buf = io.StringIO()
+            with contextlib.redirect_stderr(buf):
+                mp, merr = _build_principal()
+            check("R5a MCP 面覆盖被拒（err 含锚点，principal=None）",
+                  mp is None and merr is not None and MARK in merr,
+                  f"err={str(merr)[:90]}")
+            # ① 经 MCP 面：tenantC（登记 cap=internal）夹紧
+            os.environ["MDCG_TOKEN"] = d_c["token"]
+            os.environ["MDCG_TENANT"] = "tenantC"
+            mp2, merr2 = _build_principal()
+            check("R5b MCP 面 cap 夹紧（tenantC designer → internal）",
+                  merr2 is None and mp2 is not None
+                  and getattr(mp2, "clearance", None) == "internal",
+                  f"clearance={getattr(mp2, 'clearance', None)} err={merr2}")
+            # 同值零误伤
+            os.environ["MDCG_TOKEN"] = d_a["token"]
+            os.environ["MDCG_TENANT"] = "tenantA"
+            mp3, merr3 = _build_principal()
+            check("R5c MDCG_TENANT 同值：零误伤正常通过",
+                  merr3 is None and mp3 is not None
+                  and getattr(mp3, "tenant", None) == "tenantA"
+                  and getattr(mp3, "clearance", None) == "secret",
+                  f"err={merr3} tenant={getattr(mp3, 'tenant', None)} "
+                  f"clearance={getattr(mp3, 'clearance', None)}")
+        finally:
+            for k, v in saved.items():
+                if v is None:
+                    os.environ.pop(k, None)
+                else:
+                    os.environ[k] = v
+    finally:
+        if old_reg is None:
+            os.environ.pop("MDCG_TENANT_REGISTRY", None)
+        else:
+            os.environ["MDCG_TENANT_REGISTRY"] = old_reg
+        shutil.rmtree(tmp, ignore_errors=True)
+
+    print()
+    if FAILS:
+        print("FAILED: %d 项 → %s" % (len(FAILS), ", ".join(FAILS)))
+        return 1
+    print("ALL OK: %d 项（N62 令牌路径 cap 夹紧 + 租户覆盖 fail-closed 守卫全绿）" % PASS)
+    return 0
+
+
+if __name__ == "__main__":
+    sys.exit(main())