@furongjun1999/dsh-memory 0.4.3 → 0.4.5

package/md_cg/test_p15_scrub.py

@@ -0,0 +1,280 @@
+# -*- coding: utf-8 -*-
+"""P15：记忆自净（`scrub.py`）——抽查 / 联想 / 去污染 / 校准偏差。
+
+覆盖：分层抽样（可复现、风险层 + 对照组）→ 三路联想（关系链 / 子图 / 词法）
+→ 污染体检（矛盾 / 过期 / 重复 / 孤立噪音 / 长期未验证）→ 去污染
+（dry-run / weaken+demote / 幂等 / 保护跳过 / 永不删节点）→ 校准偏差
+（gap → 偏置建议 → 可选写回）→ 挂载自维持循环 + MCP `op=scrub`。
+"""
+import json
+import os
+import shutil
+import tempfile
+import time
+
+from . import scrub, sustain
+from .fsutil import append_jsonl
+from .mdcg import MdCG
+from .mdcos import MdCGSecure
+from .security import Principal
+
+PASS = FAIL = 0
+
+
+def check(name, cond, detail=""):
+    global PASS, FAIL
+    if cond:
+        PASS += 1
+        print(f"  [PASS] {name}" + (f"  · {detail}" if detail else ""))
+    else:
+        FAIL += 1
+        print(f"  [FAIL] {name}" + (f"  · {detail}" if detail else ""))
+
+
+def _touch(cg, nid, days_ago=0.0, count=1):
+    for _ in range(count):
+        append_jsonl(cg.access_log,
+                     {"t": time.time() - days_ago * 86400, "ids": [nid],
+                      "tier": None})
+
+
+def _set(cg, nid, **fm):
+    """改写节点 frontmatter，并同步索引里受影响的快照字段。"""
+    e = cg.index["nodes"][nid]
+    node = cg.get(nid)
+    f = dict(node["frontmatter"])
+    f.update(fm)
+    cg._write_node(nid, os.path.join(cg.root, e["path"]), f, node["content"])
+    for k in ("created_at", "importance", "evidence_count"):
+        if k in fm:
+            e[k] = fm[k]
+
+
+def main():
+    net = tempfile.mkdtemp(prefix="mdcg_p15_net_")
+    os.environ["MDCG_SUSTAIN_DIR"] = net
+    root = sroot = None
+    try:
+        # ---------- A. 记忆抽查 ----------
+        print("\n[A] 记忆抽查（分层 + 可复现）")
+        root = tempfile.mkdtemp(prefix="mdcg_p15_")
+        cg = MdCG(root)
+        cg.add("a", "# 功能名：甲\n# 执行：add\n\n超时：30s\n禁止并发写入")
+        cg.add("b", "# 功能名：乙\n# 执行：add\n\n超时：60s\n应当并发写入")
+        cg.add("c", "# 功能名：丙\n\n完全无关的另一个主题内容")
+        cg.add("d", "# 功能名：丁\n\n第三种主题，用于孤立与陈旧")
+        cg.add("e", "# 功能名：戊\n\n第五个节点")
+        cg.add("f", "# 功能名：己\n\n第六个节点，用于补足抽样池")
+        _touch(cg, "d", days_ago=40)          # 陈旧
+        _touch(cg, "e", count=4)              # 高频
+
+        s1 = scrub.sample(cg, 6, seed=7)
+        check("A1 抽样返回条数", s1["n"] == 6 and len(s1["sample"]) == 6)
+        check("A2 分层标签合法",
+              all(x["stratum"] in scrub.STRATA for x in s1["sample"]))
+        s2 = scrub.sample(cg, 6, seed=7)
+        check("A3 同 seed 同样本（可复现）",
+              [x["node_id"] for x in s1["sample"]]
+              == [x["node_id"] for x in s2["sample"]])
+        check("A4 不同 seed 仍返回满额", scrub.sample(cg, 6, seed=99)["n"] == 6)
+        check("A5 陈旧节点入 stale 层",
+              any(x["node_id"] == "d" and x["stratum"] == "stale"
+                  for x in s1["sample"]))
+        check("A6 高频节点入 hot 层（对照组）",
+              any(x["node_id"] == "e" and x["stratum"] == "hot"
+                  for x in s1["sample"]))
+        sr = scrub.sample(cg, 4, strategy="random", seed=1)
+        check("A7 random 策略只取随机层",
+              sr["n"] == 4
+              and all(x["stratum"] == "random" for x in sr["sample"]))
+        rk = scrub.sample(cg, 4, strategy="risk", seed=1)
+        check("A8 risk 策略不含对照层",
+              all(x["stratum"] != "hot" for x in rk["sample"]))
+        try:
+            scrub.sample(cg, 1, strategy="nope")
+            raised = False
+        except ValueError:
+            raised = True
+        check("A9 未知策略报错", raised)
+        check("A10 抽查只读（节点数不变）", len(cg.index["nodes"]) == 6)
+
+        # ---------- B. 联想 ----------
+        print("\n[B] 联想（关系链 / 子图 / 词法）")
+        cg.add("chain_t", "# 功能名：链目标\n\n与甲有因果关系",
+               edges=[{"target": "a", "relation_type": "causal",
+                       "condition": "当 X 成立", "confidence": 0.9}])
+        cg.add("p", "# 功能名：父\n\n子图父节点",
+               subgraph={"nodes": ["a"], "edges": []})
+        assoc_a = scrub.associate(cg, "a", hops=2, limit=20)
+        rel = {r["node_id"]: r for r in assoc_a["related"]}
+        check("B1 关系链命中（带条件）",
+              "chain_t" in rel and rel["chain_t"]["via"] == "chain"
+              and rel["chain_t"].get("condition") == "当 X 成立")
+        check("B2 词法近邻命中（无边也联得上）",
+              "b" in rel and rel["b"]["via"] == "lexical")
+        check("B3 子图层级命中", "p" in rel and rel["p"]["via"] == "subgraph")
+        ws = [r["weight"] for r in assoc_a["related"]]
+        check("B4 权重降序", ws == sorted(ws, reverse=True))
+        check("B5 by_via 统计", assoc_a["by_via"].get("chain", 0) >= 1
+              and assoc_a["by_via"].get("lexical", 0) >= 1)
+        check("B6 不含自身", all(r["node_id"] != "a"
+                                for r in assoc_a["related"]))
+        # ---------- C. 去污染 ----------
+        print("\n[C] 去污染（体检 / dry-run / 可逆处置）")
+        cg.add("exp1", "# 功能名：过期\n\n这条已过期", valid_until="2020-01-01")
+        cg.add("noise", "# 功能名：噪音\n\n孤立低重要")
+        cg._move_layer("noise", "contextual", reason="test")
+        _set(cg, "noise", importance=0.1)
+        cg.add("old1", "# 功能名：老知识\n\n从未验证的旧知识")
+        _set(cg, "old1", created_at=time.time() - 20 * 86400)
+        cg.add("dup1", "# 功能名：重复甲\n\n重复内容主体：超时参数是 30 秒")
+        cg.add("dup2", "# 功能名：重复乙\n\n重复内容主体：超时参数是 30 秒")
+
+        ids_c = ["a", "b", "exp1", "noise", "old1", "dup1"]
+        rep = scrub.audit(cg, ids_c)
+        kinds = {i["kind"] for i in rep["issues"]}
+        check("C1 同键不同值 → contradiction（high）",
+              "contradiction" in kinds
+              and any(i["kind"] == "contradiction" and i["severity"] == "high"
+                      for i in rep["issues"]))
+        check("C2 时效过期 → expired",
+              "expired" in kinds
+              and any(i["node_id"] == "exp1" for i in rep["issues"]))
+        check("C3 孤立噪音 → orphan_noise", "orphan_noise" in kinds)
+        check("C4 长期未验证 → unverified", "unverified" in kinds)
+        check("C5 高冗余 → duplicate", "duplicate" in kinds)
+        check("C6 体检只读（节点数不变）", len(cg.index["nodes"]) == 13)
+        check("C7 每条判据都可解释",
+              bool(rep["issues"]) and all(i.get("detail")
+                                          for i in rep["issues"]))
+
+        conf0 = float(cg.get("a")["frontmatter"].get("confidence") or 0.6)
+        lay0 = cg.get("a")["frontmatter"].get("layer")
+        dry = scrub.decontaminate(cg, ["a"], dry_run=True)
+        check("C8 dry-run 不改动",
+              float(cg.get("a")["frontmatter"].get("confidence") or 0.6) == conf0
+              and cg.get("a")["frontmatter"].get("layer") == lay0
+              and all(not x["applied"] for x in dry["actions"]))
+        check("C9 dry-run 给出计划动作",
+              any(x.get("planned") for x in dry["actions"]))
+
+        n_before = len(cg.index["nodes"])
+        scrub.decontaminate(cg, ["a"], dry_run=False)
+        fm_a = cg.get("a")["frontmatter"]
+        check("C10 实修 weaken：置信下调 + 记反例",
+              float(fm_a.get("confidence") or 1) < conf0
+              and int(fm_a.get("negative_evidence") or 0) >= 1)
+        check("C11 实修 demote：降级到情境层",
+              fm_a.get("layer") == "contextual" and lay0 == "knowledge")
+        check("C12 永不删除节点", len(cg.index["nodes"]) == n_before)
+        again = scrub.decontaminate(cg, ["a"], dry_run=False)
+        check("C13 幂等：重复处置被跳过",
+              again["applied"] == 0 and again["skipped_done"] >= 1)
+        hint = scrub.decontaminate(cg, ["dup1"], dry_run=False)
+        check("C14 冗余只给建议不代劳",
+              hint["hints"] >= 1
+              and all(x["action"] == "hint" for x in hint["actions"]))
+        check("C15 审计留痕",
+              os.path.exists(os.path.join(root, "_scrub.jsonl"))
+              and scrub.summary(cg)["decontaminated"] >= 1)
+
+        cg.add("imp1", "# 功能名：重要\n# 执行：add\n\n超时：99s\n禁止并发写入",
+               importance=0.9)
+        prot_rep = scrub.decontaminate(cg, ["imp1"], dry_run=False)
+        check("C16 受保护节点跳过（importance≥0.7）",
+              prot_rep["skipped_protected"] >= 1
+              and cg.get("imp1")["frontmatter"].get("layer") == "knowledge")
+        # ---------- D. 校准偏差 ----------
+        print("\n[D] 校准偏差（gap → 偏置 → 可选写回）")
+        cro = tempfile.mkdtemp(prefix="mdcg_p15_cal_")
+        cg2 = MdCG(cro)
+        cg2.add("plain", "# 功能名：无证据\n\n没有任何验证记录")
+        check("D1 无证据 → 数据不足", scrub.calibrate(cg2)["ok"] is False)
+
+        for i in range(4):
+            cg2.add(f"c{i}", f"# 功能名：校准{i}\n\n内容 {i}")
+            cg2.verify(f"c{i}", "e1", "confirmed")
+        for i in range(4, 8):
+            cg2.add(f"c{i}", f"# 功能名：校准{i}\n\n内容 {i}")
+            cg2.verify(f"c{i}", "e1", "weakened")
+            cg2.verify(f"c{i}", "e2", "weakened")
+        cal = scrub.calibrate(cg2)
+        check("D2 有证据 → 可校准",
+              cal["ok"] is True and cal["n_nodes"] >= 8)
+        check("D3 过度自信 → gap>0", cal["gap"] > 0.05, f"gap={cal['gap']}")
+        check("D4 建议负偏置（下调置信）", cal["suggested_offset"] < 0)
+        c_before = float(cg2.get("c0")["frontmatter"].get("confidence"))
+        scrub.calibrate(cg2, apply=False)
+        check("D5 apply=False 不写回",
+              float(cg2.get("c0")["frontmatter"].get("confidence")) == c_before)
+        cg2.add("imp2", "# 功能名：保护\n\n重要节点", importance=0.9)
+        cg2.verify("imp2", "e1", "confirmed")
+        adj = scrub.calibrate(cg2, apply=True)
+        check("D6 apply=True 写回偏置",
+              adj["applied"] is True and adj["n_adjusted"] >= 8
+              and float(cg2.get("c0")["frontmatter"]["confidence"]) < c_before)
+        check("D7 保护节点跳过", adj["skipped_protected"] >= 1)
+        check("D8 分桶偏差按幅值降序",
+              cal["bins_bias"] == sorted(cal["bins_bias"],
+                                         key=lambda x: -abs(x["bias"])))
+        shutil.rmtree(cro, ignore_errors=True)
+
+        # ---------- E. 挂载自维持 + MCP ----------
+        print("\n[E] 挂载自维持循环与 MCP 接入")
+        lp = sustain.SustainLoop(cg, "p15loop", beat_interval=0.05,
+                                 heal_interval=0.05, scrub_interval=0.05,
+                                 auto_scrub=False, d=net)
+        lp.start()
+        time.sleep(0.8)
+        check("E1 常驻循环周期自净",
+              lp.last_scrub is not None and lp.last_scrub["dry_run"] is True)
+        check("E2 默认只巡检（不改节点）",
+              lp.last_scrub["applied"] == 0 and lp.last_scrub["n_issues"] >= 1)
+        check("E3 status 暴露自净字段",
+              lp.status()["scrub_interval"] == 0.05
+              and lp.status()["auto_scrub"] is False)
+        lp.stop()
+        check("E4 sustain.summary 含自净摘要",
+              sustain.summary(cg)["scrub"]["sweeps"] >= 1)
+
+        from .mcp_server import call_tool
+        smp = call_tool(cg, "cg", {"op": "scrub", "action": "sample",
+                                   "k": 3, "seed": 5})
+        check("E5 MCP sample", smp["n"] == 3 and smp["seed"] == 5)
+        au = call_tool(cg, "cg", {"op": "scrub", "action": "audit",
+                                  "ids": ["b"]})
+        check("E6 MCP audit", au["n_checked"] == 1 and "n_issues" in au)
+        dc = call_tool(cg, "cg", {"op": "scrub", "action": "decontaminate",
+                                  "ids": ["b"], "dry_run": True})
+        check("E7 MCP decontaminate 默认 dry-run", dc["dry_run"] is True)
+        cc = call_tool(cg, "cg", {"op": "scrub", "action": "calibrate"})
+        check("E8 MCP calibrate", "suggested_offset" in cc)
+        sw = call_tool(cg, "cg", {"op": "scrub", "action": "sweep",
+                                  "k": 4, "seed": 2})
+        check("E9 MCP sweep 默认只读",
+              sw["dry_run"] is True and "sample" in sw
+              and "calibration" in sw)
+        cat = call_tool(cg, "cg", {"op": "scrub", "action": "catalog"})
+        check("E10 MCP catalog", "decontaminate" in cat["actions"]
+              and "contradiction" in cat["contamination"])
+        hs = call_tool(cg, "cg", {"op": "scrub", "action": "history"})
+        check("E11 MCP history", hs["n"] >= 1)
+        sm = call_tool(cg, "cg", {"op": "scrub", "action": "summary"})
+        check("E12 MCP summary", "sweeps" in sm)
+        ast = call_tool(cg, "cg", {"op": "scrub", "action": "associate",
+                                   "node_id": "a", "hops": 1})
+        check("E13 MCP associate", ast["n"] >= 1)
+    finally:
+        os.environ.pop("MDCG_SUSTAIN_DIR", None)
+        sustain.stop_all()
+        for d in (net, root, sroot):
+            if d:
+                shutil.rmtree(d, ignore_errors=True)
+
+    print(f"\n==== P15 结果：{PASS} 通过 / {FAIL} 失败 ====")
+    return 1 if FAIL else 0
+
+
+if __name__ == "__main__":
+    import sys
+    sys.exit(main())

package/md_cg/test_p16_self_state.py

@@ -0,0 +1,275 @@
+# -*- coding: utf-8 -*-
+"""md_cg · 第 16 篇：自我状态层（薄自我 + 富索引）
+
+理论出处（本仓原文）：
+  · `docs/灵枢_自我层定义.md:6`：SELF 层 = 身份 + 价值观 + 图接口，
+    不可遗忘、跨会话自动加载，且**是薄的**（不该变成事件仓库）。
+  · 智能论 §十一：情绪 = 信息差二阶 d^2D/dt^2；§十：P_gap / P_trust；
+    情感 = 信任二阶 d^2T/dt^2。
+
+覆盖：
+  A 薄卡建立：八项自我信息 → 当前值 + 指针；无数据不编造
+  B 幂等刷新：状态未变不写盘
+  C 版本链：version +1 / prev_state_hash / 留痕对齐
+  D 派生自洽：情绪由 d2 推出，与 metacognition 一致
+  E 信任面：verify 留痕 → P_trust / 情感
+  F 五维索引：task/person/session/time/trust 反查详情（认知图连接，非搬运）
+  G 关系：有向 / 双向 / 自环拒绝
+  H 保护一致：状态卡可覆盖但不可遗忘；身份锚点两者皆禁
+  I 篡改检测：绕过 refresh 改卡 → audit 报 log_tail_mismatch
+  J 启动加载：bootstrap
+  K MCP 入口 / L 自描述
+
+运行：python -m md_cg.test_p16_self_state
+"""
+from __future__ import annotations
+
+import tempfile
+
+from .mdcos import MdCGOS
+from .mdcg import STATE_ACCEPT, STATE_REJECT
+from . import self_state as ss
+from . import protect
+
+PASS = FAIL = 0
+FAILS = []
+
+
+def check(name, cond, detail=""):
+    global PASS, FAIL
+    if cond:
+        PASS += 1
+        print(f"  [PASS] {name}" + (f"  · {detail}" if detail else ""))
+    else:
+        FAIL += 1
+        FAILS.append(name)
+        print(f"  [FAIL] {name}  · {detail}")
+
+
+def _r(state):
+    return [({"id": "x", "frontmatter": {}, "content": "", "path": "x"},
+             1.0, {"state": state})]
+
+
+S = "self:lingshu"
+ALICE = "user:alice"
+
+
+def main():
+    root = tempfile.mkdtemp(prefix="mdcg_p16_")
+    cg = MdCGOS(root)
+
+    # ---------- A. 薄卡建立 ----------
+    print("\n[A] 薄自我：八项自我信息 → 当前值 + 指针（无数据不编造）")
+    r0 = cg.self_state_refresh(S)
+    st = cg.self_state_snapshot(S)
+    check("A1 状态卡单例建立", st is not None and st["node_id"] == ss.state_node_id(S),
+          str((st or {}).get("node_id")))
+    check("A2 无反思留痕 → 情绪 unknown（不编造）",
+          st["emotion"] == "unknown", f"emotion={st['emotion']}")
+    check("A3 无验证留痕 → 情感 unknown（不编造）",
+          st["affect"] == "unknown", f"affect={st['affect']}")
+    check("A4 短期记忆只存摘要 + 指针",
+          isinstance(st["short_term"], dict) and "ptr" in st["short_term"],
+          str(st["short_term"]))
+    check("A5 八项自我信息字段齐备",
+          all(k in st for k in ("information_gap", "trust", "emotion",
+                                "affect", "short_term", "importance_self",
+                                "identity_ref", "relations")),
+          str(sorted(k for k in st if k in (
+              "information_gap", "trust", "emotion", "affect", "short_term",
+              "importance_self", "identity_ref", "relations"))))
+    check("A6 首次刷新 version=1", r0["state_version"] == 1,
+          str(r0["state_version"]))
+
+    # ---------- B. 幂等 ----------
+    print("\n[B] 幂等刷新（状态未变不写盘）")
+    r1 = cg.self_state_refresh(S)
+    r2 = cg.self_state_refresh(S)
+    check("B1 无新信息 → changed=False（幂等）",
+          r1["changed"] is False, str(r1.get("note")))
+    check("B2 再次刷新仍幂等", r2["changed"] is False, str(r2.get("note")))
+    check("B3 幂等时不推进版本",
+          cg.self_state_snapshot(S)["state_version"] == 1,
+          str(cg.self_state_snapshot(S)["state_version"]))
+
+    # ---------- C. 版本链 ----------
+    print("\n[C] 版本链：version +1 / prev_state_hash / 留痕对齐")
+    cg.reflect("自我层一致性", _r(STATE_ACCEPT))
+    cg.reflect("自我层一致性", _r(STATE_ACCEPT))
+    r3 = cg.self_state_refresh(S)
+    check("C1 状态变化 → version+1", r3["state_version"] == 2,
+          str(r3["state_version"]))
+    check("C2 prev_state_hash == 上一版 hash",
+          r3["prev_state_hash"] == r0["state_hash"],
+          f"{r3['prev_state_hash']} vs {r0['state_hash']}")
+    hist = cg.self_state_history(limit=5, subject=S)
+    check("C3 留痕末条 hash == 卡 hash",
+          hist[0]["state_hash"] == r3["state_hash"],
+          f"{hist[0]['state_hash']} vs {r3['state_hash']}")
+    check("C4 留痕版本递增",
+          [h["version"] for h in hist[:3]] == [2, 1],
+          str([h["version"] for h in hist[:3]]))
+
+    # ---------- D. 派生自洽 ----------
+    print("\n[D] 派生自洽：情绪 = d^2D/dt^2（与 metacognition 同口径）")
+    st = cg.self_state_snapshot(S)
+    tr = cg.metacognition_trace()
+    check("D1 d2 有值 → emotion 非 unknown",
+          st["information_gap"]["d2"] is not None
+          and st["emotion"] != "unknown",
+          f"d2={st['information_gap']['d2']} emotion={st['emotion']}")
+    check("D2 卡上 emotion == metacognition.trace().emotion",
+          st["emotion"] == tr["emotion"],
+          f"{st['emotion']} vs {tr['emotion']}")
+
+    # ---------- E. 信任面 ----------
+    print("\n[E] 信任面：verify 留痕 → P_trust / 情感 d^2T/dt^2")
+    for i in range(6):
+        cg.add(f"ev{i}", f"# 功能：证据样本 {i}\n", layer="knowledge",
+               importance=0.5)
+        cg.verify(f"ev{i}", "实测通过", "confirmed")
+    cg.self_state_refresh(S, force=True)
+    st = cg.self_state_snapshot(S)
+    check("E1 P_trust 由验证留痕算出",
+          st["trust"]["p_trust"] is not None,
+          f"p_trust={st['trust']['p_trust']}")
+    check("E2 信任档入索引（low|mid|high）",
+          st["trust"]["band"] in ("low", "mid", "high"),
+          str(st["trust"]["band"]))
+    check("E3 情感由 d^2T/dt^2 推出",
+          st["affect"] != "unknown" or st["trust"]["d2t"] is None,
+          f"d2t={st['trust']['d2t']} affect={st['affect']}")
+
+    # ---------- F. 五维索引 ----------
+    print("\n[F] 五维索引：具体任务/人物/会话/时间/信任 → 反查详情")
+    cg.self_state_refresh(S, dimensions={
+        "task": "自我层一致性", "person": ALICE, "session": "s-20260909"})
+    check("F1 任务维度命中状态卡",
+          any(x["node_id"] == ss.state_node_id(S)
+              for x in cg.self_state_index("task", "自我层一致性")["items"]),
+          str(cg.self_state_index("task", "自我层一致性")["count"]))
+    check("F2 会话维度命中",
+          cg.self_state_index("session", "s-20260909")["count"] >= 1,
+          str(cg.self_state_index("session", "s-20260909")["count"]))
+    # 具体详情节点留在原层，只带同名维度标签即可被索引到（薄自我不搬运内容）
+    cg.add("detail_task_1", "# 功能名：任务详情\n# 生效条件：一致性审计时\n",
+           layer="contextual", tags=["task:自我层一致性"], importance=0.6)
+    idx = cg.self_state_index("task", "自我层一致性", with_content=True)
+    check("F3 认知图连接：详情节点被同一索引反查到",
+          idx["count"] >= 2
+          and any(x["node_id"] == "detail_task_1" for x in idx["items"]),
+          str([x["node_id"] for x in idx["items"]]))
+    check("F4 时间维度自动登记",
+          bool(cg.self_state_dimensions(S)["dimensions"].get("time")),
+          str(cg.self_state_dimensions(S)["dimensions"].get("time")))
+    check("F5 未知维度被拒",
+          cg.self_state_index("mood", "x")["ok"] is False,
+          str(cg.self_state_index("mood", "x")))
+
+    # ---------- G. 关系 ----------
+    print("\n[G] 关系：有向 / 双向 / 自环拒绝")
+    g1 = cg.self_state_relate(S, ALICE, relation_type="collaborator",
+                              strength=0.8)
+    check("G1 写有向关系", g1["ok"] and len(g1["written"]) == 1, str(g1))
+    check("G2 自环被拒",
+          cg.self_state_relate(S, S)["ok"] is False,
+          str(cg.self_state_relate(S, S)))
+    g3 = cg.self_state_relate(ALICE, "agent:reviewer", reciprocal=True)
+    check("G3 reciprocal 写双向", g3["ok"] and len(g3["written"]) == 2, str(g3))
+    rels = cg.self_state_relations(S)
+    check("G4 出度统计正确", len(rels) == 1 and rels[0]["to"] == ss._slug(ALICE),
+          str([(r["from"], r["to"]) for r in rels]))
+    cg.self_state_refresh(S, force=True)
+    check("G5 关系度入薄卡",
+          cg.self_state_snapshot(S)["relations"]["out"] == 1,
+          str(cg.self_state_snapshot(S)["relations"]))
+
+    # ---------- H. 保护一致 ----------
+    print("\n[H] 保护一致：状态卡可覆盖但不可遗忘；身份锚点两者皆禁")
+    nid = ss.state_node_id(S)
+    imm, why = protect.is_immutable(cg, nid)
+    check("H1 状态卡可覆盖（自我状态能演化）", imm is False, str(why))
+    pro, _ = protect.is_protected(cg, nid)
+    check("H2 状态卡不可遗忘", pro is True, "")
+    cg.identity_anchor(S, "我是灵枢：认知图的操作者，自我层不可遗忘。")
+    anchor_id = (cg.identity_profile(S) or {}).get("anchor", {}) or {}
+    anchor_id = anchor_id.get("node_id")
+    check("H3 身份锚点两者皆禁",
+          bool(anchor_id) and protect.is_immutable(cg, anchor_id)[0] is True
+          and protect.is_protected(cg, anchor_id)[0] is True,
+          str(anchor_id))
+    cg.self_state_refresh(S, force=True)
+    check("H4 identity_ref 指向锚点",
+          cg.self_state_snapshot(S)["identity_ref"] == anchor_id,
+          f"{cg.self_state_snapshot(S)['identity_ref']} vs {anchor_id}")
+
+    # ---------- I. 审计 ----------
+    print("\n[I] 一致性审计：可重算，能抓到绕过 refresh 的改动")
+    au = cg.self_state_audit(S)
+    check("I1 健康态 verdict=consistent",
+          au["verdict"] == "consistent",
+          f"verdict={au['verdict']} issues={[i['code'] for i in au['issues']]}")
+    # 绕过 refresh 直接覆写状态卡 → 卡上 state_hash 丢失 → 留痕不对齐
+    cg.add(nid, "# 被外部改写的状态卡\n", layer="self",
+           importance=1.0, override=True, self_state=True)
+    au2 = cg.self_state_audit(S)
+    check("I2 篡改被检出 log_tail_mismatch",
+          any(i["code"] == "log_tail_mismatch" for i in au2["issues"]),
+          str([i["code"] for i in au2["issues"]]))
+    check("I3 篡改 → verdict=broken", au2["verdict"] == "broken",
+          au2["verdict"])
+    cg.self_state_refresh(S, force=True)          # 修复
+    check("I4 refresh 后恢复一致",
+          cg.self_state_audit(S)["verdict"] == "consistent",
+          str([i["code"] for i in cg.self_state_audit(S)["issues"]]))
+
+    # ---------- J. 启动加载 ----------
+    print("\n[J] 跨会话加载（bootstrap）")
+    boot = cg.self_state_bootstrap(S)
+    check("J1 加载状态卡 + 关系 + 索引",
+          boot["ok"] and boot["state"] is not None
+          and boot["relations_count"] >= 1 and "task" in boot["dimensions"],
+          f"rels={boot['relations_count']} dims={list(boot['dimensions'])}")
+    check("J2 最近留痕可读", len(boot["recent_states"]) >= 1,
+          str(len(boot["recent_states"])))
+
+    # ---------- K. MCP 入口 ----------
+    print("\n[K] MCP 入口（mdcg_self_state + cg op + health 面）")
+    from . import mcp_server as ms
+    m1 = ms._self_state_call(cg, {"action": "summary", "subject": S})
+    check("K1 summary 一句话", m1["ok"] and S in m1["text"], str(m1["text"]))
+    m2 = ms._self_state_call(cg, {"action": "index", "dim": "person",
+                                  "value": ALICE})
+    check("K2 index 按人物反查", m2["ok"] and m2["count"] >= 1,
+          str(m2["count"]))
+    m3 = ms._self_state_call(cg, {"action": "audit", "subject": S})
+    check("K3 audit 可调用", "verdict" in m3, str(m3["verdict"]))
+    check("K4 MCP 注册 mdcg_self_state",
+          any(t["name"] == "mdcg_self_state" for t in ms.TOOLS))
+    check("K5 cg op=self_state 路由",
+          ms._cg_call(cg, {"op": "self_state",
+                           "action": "catalog"}).get("module") == "self_state")
+    check("K6 health 报告 self_state 面",
+          "self_state" in cg.health_os().get("os", {}),
+          str(cg.health_os().get("os", {}).get("self_state")))
+
+    # ---------- L. 自描述 ----------
+    print("\n[L] 自描述")
+    cat = cg.self_state_catalog()
+    check("L1 八项自我信息齐全", len(cat["self_info"]) == 8,
+          str(sorted(cat["self_info"])))
+    check("L2 五维索引齐全",
+          set(cat["dimensions"]) == {"task", "person", "session", "time",
+                                     "trust"},
+          str(cat["dimensions"]))
+
+    print(f"\n{'=' * 60}\n通过 {PASS} / {PASS + FAIL}")
+    if FAILS:
+        print("失败：" + "、".join(FAILS))
+    return FAIL == 0
+
+
+if __name__ == "__main__":
+    import sys
+    sys.exit(0 if main() else 1)