@furongjun1999/dsh-memory 0.4.4 → 0.4.6

package/md_cg/test_p7_goals_recent.py

@@ -0,0 +1,202 @@
+# -*- coding: utf-8 -*-
+"""md_cg · 第 5 篇七件套补齐验收：目标槽 + 近期事件 + 证据计数/降级
+
+覆盖（白箱智能系列·第五篇）：
+  A 目标槽（第 3 章）：写入 / 排序 / 状态机 / 不进正排
+  B 目标定向路（第 3 章）：goal 路召回、显式启用、可审计 goal_used
+  C 近期事件滚动窗口（第 3 章）：最新在前 / 角色过滤 / 滚动截断 / recall 附带
+  D 证据计数 + 可信度降级（第 4 章）：evidence_count、正反例分离、跌破阈值降级
+  E MCP 接口面：cg(op=goal) / cg(op=recent) / mdcg_recall(goal, include_recent)
+  F 健康度覆盖：health_os 报告 goals / recent_events
+
+运行：python -m md_cg.test_p7_goals_recent
+"""
+from __future__ import annotations
+
+import os
+import shutil
+import sys
+import tempfile
+
+from .mdcos import MdCGOS
+from .mcp_server import call_tool
+
+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 ccg(title, cond="任意情境", sub="验收", exe="直接调用", verify="test", body=""):
+    return (f"# 功能名：{title}\n"
+            f"# 生效条件：{cond}\n"
+            f"# 子功能：{sub}\n"
+            f"# 执行：{exe}\n"
+            f"# 验证方式：{verify}\n"
+            f"# 不适用条件：无\n"
+            f"{body or title}\n")
+
+
+def main():
+    root = tempfile.mkdtemp(prefix="mdcg_p7_")
+    cg = MdCGOS(root)
+    try:
+        # ---------- A. 目标槽 ----------
+        print("\n[A] 目标槽（第 5 篇第 3 章「目标」）")
+        g1 = cg.add_goal("修复登录超时", priority=0.9, deadline="2026-10-01")
+        g2 = cg.add_goal("降低内存占用", priority=0.2)
+        check("add_goal 落 goals 层",
+              (cg.get(g1) or {}).get("frontmatter", {}).get("layer") == "goals", g1)
+        check("目标文本可读回",
+              (cg.get(g1) or {}).get("frontmatter", {}).get("goal_text") == "修复登录超时")
+        check("add_goal 幂等（同文本同 id）", cg.add_goal("修复登录超时", priority=0.9) == g1)
+        act = cg.active_goals()
+        check("active_goals 按优先级排序",
+              [g["id"] for g in act] == [g1, g2], str([g["goal"] for g in act]))
+        check("goal_text 拼接活跃目标",
+              cg.goal_text() == "修复登录超时 降低内存占用", cg.goal_text())
+        cg.set_goal_status(g2, "done")
+        check("done 目标退出 active", [g["id"] for g in cg.active_goals()] == [g1])
+        check("list_goals 仍可见 done 目标",
+              {g["id"] for g in cg.list_goals()} == {g1, g2})
+        res, _m = cg.search("修复登录超时", k=20)
+        check("目标节点不参与正排（只是方向）",
+              g1 not in [n["id"] for n, _s, _q in res])
+
+        # ---------- B. 目标定向路 ----------
+        print("\n[B] 目标定向路（goal 路，显式启用）")
+        for g in cg.list_goals(status="active"):      # 先清空活跃目标
+            cg.set_goal_status(g["id"], "done")
+        a = cg.add("n_login", ccg("登录会话超时处理", cond="登录态",
+                                 body="登录 超时 session token 过期"),
+                   tags=["login"], verification_basis="test")
+        b = cg.add("n_memory", ccg("内存泄漏排查", cond="长时间运行",
+                                  body="内存 泄漏 gc 回收"),
+                   tags=["memory"], verification_basis="test")
+        # 单独启用 goal 路，隔离 lexical 等路的影响
+        _r0, m0 = cg.search_rrf("问题", k=10, paths=("goal",), record=False)
+        check("无活跃目标时 goal 路为空", not m0.get("goal_used") and not _r0,
+              f"goal_used={m0.get('goal_used')!r} n={len(_r0)}")
+        r1, m1 = cg.search_rrf("问题", k=10, paths=("goal",),
+                               record=False, goal_text="登录 超时")
+        ids = [n["id"] for n, _s, _q, _p in r1]
+        check("有目标时 goal 路召回目标相关记忆", a in ids, str(ids))
+        check("goal 路不混入与目标无关的记忆", b not in ids, str(ids))
+        check("meta 暴露 goal_used（可审计）", m1.get("goal_used") == "登录 超时")
+        base, _mb = cg.search_rrf("问题", k=10, paths=("lexical",), record=False)
+        same, _ms = cg.search_rrf("问题", k=10, paths=("lexical",), record=False,
+                                  goal_text="登录 超时")
+        check("未启用 goal 路时目标不生效（既有基线不变）",
+              [n["id"] for n, *_ in base] == [n["id"] for n, *_ in same])
+
+        # ---------- C. 近期事件滚动窗口 ----------
+        print("\n[C] 近期事件滚动窗口（第 5 篇第 3 章「近期事件」）")
+        cg.clear_recent()
+        cg.remember_event("user", "开始重构登录模块")
+        cg.remember_event("assistant", "已定位到 token 过期逻辑")
+        cg.remember_event("command", "pytest -k login")
+        ev = cg.recent_events(limit=10)
+        check("近期事件最新在前", ev[0]["text"] == "pytest -k login", ev[0]["text"])
+        check("近期事件按角色过滤",
+              [e["text"] for e in cg.recent_events(roles=("user",))] == ["开始重构登录模块"])
+        for i in range(6):
+            cg.remember_event("user", f"事件{i}", window=3)
+        ev2 = cg.recent_events(limit=10)
+        check("滚动窗口截断到最近 N 条", len(ev2) == 3, f"n={len(ev2)}")
+        check("窗口保留最新事件", ev2[0]["text"] == "事件5", ev2[0]["text"])
+        p_no = cg.recall("登录超时", budget_tokens=400, include_recent=False)
+        p_yes = cg.recall("登录超时", budget_tokens=400,
+                          include_recent=True, recent_limit=3)
+        check("recall 默认不带近期事件", p_no.get("recent") == [])
+        check("recall(include_recent=True) 附带近期事件",
+              len(p_yes.get("recent") or []) == 3, str(len(p_yes.get("recent") or [])))
+        check("近期事件计入 token 预算（诚实口径）",
+              p_yes["tokens_used"] > p_no["tokens_used"],
+              f"{p_no['tokens_used']} → {p_yes['tokens_used']}")
+
+        # ---------- D. 证据计数 + 可信度降级 ----------
+        print("\n[D] 证据计数 + 可信度降级（第 5 篇第 4 章）")
+        n = cg.add("n_ev", ccg("临时缓存策略", cond="高并发",
+                               body="缓存 过期 时间 30s"),
+                   verification_basis="test", confidence=0.6)
+        r = cg.verify(n, "压测命中率 92%", "confirmed")
+        check("confirmed 累加 evidence_count", r["evidence_count"] == 1, str(r))
+        fm = cg.get(n)["frontmatter"]
+        check("正例计数", fm["positive_evidence"] == 1 and fm["negative_evidence"] == 0,
+              f"pos={fm['positive_evidence']} neg={fm['negative_evidence']}")
+        r = cg.verify(n, "压测命中率降至 71%", "weakened")
+        fm = cg.get(n)["frontmatter"]
+        check("weakened 累加 evidence_count", r["evidence_count"] == 2)
+        check("反例计数", fm["negative_evidence"] == 1)
+        check("反例权重 > 正例（0.6 +0.05 -0.15 = 0.5）",
+              abs(fm["confidence"] - 0.5) < 1e-9, str(fm["confidence"]))
+        demoted = None
+        for i in range(3):
+            r = cg.verify(n, f"继续走弱 {i}", "weakened")
+            demoted = r.get("demoted") or demoted
+        fm = cg.get(n)["frontmatter"]
+        check("跌破阈值后降级为 contextual", fm["layer"] == "contextual",
+              str(fm.get("layer")))
+        check("降级留 demotion 审计",
+              bool(fm.get("demotion")) and fm["demotion"]["from"] == "knowledge",
+              str(fm.get("demotion")))
+        check("降级后文件搬离 knowledge/",
+              not os.path.exists(os.path.join(root, "knowledge", f"{n}.md")))
+        check("索引层同步更新", cg.index["nodes"][n]["layer"] == "contextual")
+
+        # ---------- E. MCP 接口面 ----------
+        print("\n[E] MCP 接口面（cg op=goal / op=recent + mdcg_recall）")
+        out = call_tool(cg, "cg", {"op": "goal", "action": "add",
+                                   "goal": "优化检索延迟", "priority": 0.8})
+        check("cg(op=goal,action=add) 可用", out.get("ok") and out.get("id"), str(out))
+        out = call_tool(cg, "cg", {"op": "goal", "action": "list"})
+        check("cg(op=goal,action=list) 返回目标",
+              any(g["goal"] == "优化检索延迟" for g in out.get("goals", [])),
+              str(out)[:120])
+        out = call_tool(cg, "cg", {"op": "recent", "action": "add",
+                                   "role": "user", "text": "MCP 追加的事件"})
+        check("cg(op=recent,action=add) 可用",
+              out.get("event", {}).get("text") == "MCP 追加的事件", str(out)[:120])
+        out = call_tool(cg, "cg", {"op": "recent", "action": "list", "limit": 1})
+        check("cg(op=recent,action=list) 返回事件",
+              (out.get("events") or [{}])[0].get("text") == "MCP 追加的事件",
+              str(out)[:120])
+        out = call_tool(cg, "mdcg_recall",
+                        {"query": "登录超时", "budget_tokens": 400,
+                         "goal": "登录 超时", "include_recent": True})
+        check("mdcg_recall 支持 goal + include_recent",
+              out.get("meta", {}).get("goal_used") == "登录 超时" and out.get("recent"),
+              f"goal_used={out.get('meta', {}).get('goal_used')!r} "
+              f"recent={len(out.get('recent') or [])}")
+
+        # ---------- F. 健康度覆盖 ----------
+        print("\n[F] 健康度覆盖")
+        h = cg.health_os()
+        check("health_os 报告 goals", h["os"]["goals"]["total"] >= 3,
+              str(h["os"]["goals"]))
+        check("health_os 报告 recent_events", h["os"]["recent_events"] >= 1,
+              str(h["os"]["recent_events"]))
+    finally:
+        try:
+            cg.close()
+        except Exception:  # noqa: BLE001
+            pass
+        shutil.rmtree(root, ignore_errors=True)
+
+    print(f"\n=== PASS {PASS} / FAIL {FAIL} ===")
+    if FAILS:
+        print("失败项：" + ", ".join(FAILS))
+    return 1 if FAIL else 0
+
+
+if __name__ == "__main__":
+    sys.exit(main())

package/md_cg/test_p8_subgraph_chain.py

@@ -0,0 +1,200 @@
+# -*- coding: utf-8 -*-
+"""md_cg · 第 8 篇：嵌套子图 + 关系链检索（结构 S / 检索 R 的补强）
+
+覆盖：
+  A 嵌套子图（结构）：引用式写入 / 递归展开 / 数据驱动深度 / 硬截断 /
+     flatten 对称父子边 / 层级路径 / 树一致性（多父·环·悬空·自环）/ 根
+  B 关系链（因果链＝条件链）：多跳 / 方向 / visited 剪枝 / 权重累积 /
+     条件序列 / 排序 / 种子扩散打分 / 层级边参与
+  C 检索接入：chain 路召回链下游 / provenance 带条件序列 / 默认路不受影响 /
+     公开 API 面
+
+运行：python -m md_cg.test_p8_subgraph_chain
+"""
+from __future__ import annotations
+
+import tempfile
+
+from .mdcos import MdCGOS
+
+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 ccg(title, cond="任意情境", sub="验收", exe="直接调用", verify="test", body=""):
+    return (f"# 功能名：{title}\n"
+            f"# 生效条件：{cond}\n"
+            f"# 子功能：{sub}\n"
+            f"# 执行：{exe}\n"
+            f"# 验证方式：{verify}\n"
+            f"# 不适用条件：无\n"
+            f"{body or title}\n")
+
+
+def main():
+    root = tempfile.mkdtemp(prefix="mdcg_p8_")
+    cg = MdCGOS(root)
+    try:
+        # ================= A. 嵌套子图 =================
+        print("\n[A] 嵌套子图（结构要素可递归化）")
+        cg.add("r", ccg("根", body="根节点"), subgraph=["a", "b"])
+        cg.add("a", ccg("中间", body="中间节点"), subgraph=["a1"])
+        cg.add("a1", ccg("叶一层", body="叶一层"), subgraph=["a1x"])
+        cg.add("a1x", ccg("叶二层", body="叶二层"))
+        cg.add("b", ccg("旁支", body="旁支节点"))
+
+        check("subgraph 引用式写入并读回",
+              (cg.get("r") or {}).get("frontmatter", {}).get("subgraph") == ["a", "b"])
+        from . import subgraph as sg
+        check("children 解析（声明式）", sg.children(cg, "r") == ["a", "b"], str(sg.children(cg, "r")))
+        check("索引快照含 subgraph（免读文件）",
+              "subgraph" in cg.index["nodes"].get("r", {}))
+
+        ex = cg.subgraph_expand("r")                       # 数据驱动：展开到自然耗尽
+        check("递归展开 5 节点", ex["n_nodes"] == 5, str(sorted(ex["nodes"])))
+        check("层级路径正确",
+              ex["paths"].get("a1x") == "r/a/a1/a1x", str(ex["paths"]))
+        check("父子边 part_of 方向 child→parent",
+              all(e["relation_type"] == "part_of" for e in ex["edges"]) and ex["n_edges"] == 4)
+        check("自然耗尽不置 truncated", ex["truncated"] is False)
+
+        ex1 = cg.subgraph_expand("r", max_depth=1)
+        check("max_depth=1 硬截断且置 truncated",
+              ex1["n_nodes"] == 3 and ex1["truncated"] is True, str(sorted(ex1["nodes"])))
+
+        fl = cg.subgraph_flatten("r")
+        check("flatten 生成对称父子边（4 对 → 8 条）", fl["n_edges"] == 8, str(fl["n_edges"]))
+        rels = {e["relation_type"] for e in fl["edges"]}
+        check("flatten 同时含 part_of / parent_of",
+              rels == {"part_of", "parent_of"}, str(rels))
+        check("roots 识别根节点", "r" in cg.subgraph_roots(), str(cg.subgraph_roots()))
+
+        # 树一致性
+        cg.add("m", ccg("第二父", body="第二父"), subgraph=["a"])          # 多父
+        cg.add("x", ccg("环x", body="环x"), subgraph=["y"])                # 环
+        cg.add("y", ccg("环y", body="环y"), subgraph=["x"])
+        cg.add("d", ccg("悬空", body="悬空"), subgraph=["ghost"])          # 悬空
+        cg.add("s", ccg("自环", body="自环"), subgraph=["s"])              # 自环
+        val = cg.subgraph_validate(limit=50)
+        issues = {i["issue"] for i in val["items"]}
+        check("检出 multi_parent", "multi_parent" in issues, str(sorted(issues)))
+        check("检出 cycle", "cycle" in issues, str(sorted(issues)))
+        check("检出 dangling_child", "dangling_child" in issues, str(sorted(issues)))
+        check("检出 self_loop", "self_loop" in issues, str(sorted(issues)))
+
+        # ================= B. 因果链＝条件链 =================
+        print("\n[B] 关系链（causal = 条件依赖因果；链 = 条件序列）")
+        cg.add("db", ccg("数据库", cond="数据库已启动", body="数据库服务"),
+               edges=[{"target": "svc", "relation_type": "causal",
+                       "confidence": 0.9, "condition": "数据库在运行"}])
+        # causal 方向 = 依赖方向（基础→应用）：db 是 svc 成立的条件
+        cg.add("svc", ccg("服务层", cond="数据库在运行", body="服务层"),
+               edges=[{"target": "api", "relation_type": "causal",
+                       "confidence": 1.0, "condition": "服务在运行"}])
+        cg.add("api", ccg("接口层", cond="服务在运行", body="接口层"))
+        cg.add("job", ccg("定时任务", cond="服务在运行", body="定时任务"),
+               edges=[{"target": "job2", "relation_type": "sequential",
+                       "confidence": 1.0, "condition": "顺序执行"}])
+        cg.add("job2", ccg("定时任务下一步", body="定时任务下一步"))
+
+        chains = cg.causal_chain("db", max_depth=5)
+        depths = sorted(c["depth"] for c in chains)
+        check("多跳展开（db→svc→api 共 2 条链）", depths == [1, 2], str(depths))
+        two = [c for c in chains if c["depth"] == 2][0]
+        check("链节点序列正确", two["nodes"] == ["db", "svc", "api"], str(two["nodes"]))
+        check("累积权重 = Π(类型base × 置信度)",
+              abs(two["weight"] - (0.85 * 0.9) * (0.85 * 1.0)) < 1e-6, str(two["weight"]))
+        check("条件序列逐跳标注",
+              two["conditions"] == ["数据库在运行", "服务在运行"], str(two["conditions"]))
+        check("只走 causal（不含 sequential）",
+              all("job" not in c["nodes"] for c in chains))
+
+        seq = cg.causal_chain("job", relation_types=("sequential",))
+        check("relation_types 过滤生效",
+              len(seq) == 1 and seq[0]["nodes"] == ["job", "job2"], str(seq))
+        check("causal 过滤下不含 sequential 边",
+              cg.causal_chain("job", relation_types=("causal",)) == [])
+
+        back = cg.causal_chain("api", direction="in", relation_types=("causal",))
+        check("direction=in 反向可达", any("db" in c["nodes"] for c in back))
+
+        # 环不无限（visited 剪枝）
+        cg.add("p", ccg("环p", body="环p"), edges=[{"target": "q", "relation_type": "causal"}])
+        cg.add("q", ccg("环q", body="环q"), edges=[{"target": "p", "relation_type": "causal"}])
+        cyc = cg.causal_chain("p", max_depth=10)
+        check("visited 剪枝：环链不无限增长", all(c["depth"] <= 1 for c in cyc), str([c["depth"] for c in cyc]))
+
+        ex_chain = cg.explain_chain("db")
+        check("explain 输出「条件→结果」步骤",
+              ex_chain["count"] >= 1 and ex_chain["chains"][0]["步骤"][0]["条件"] == "数据库在运行",
+              str(ex_chain["chains"][0]["步骤"][0] if ex_chain["chains"] else None))
+
+        # 节点生效条件回退（边无条件时用起点节点声明的条件）
+        cg.add("z1", ccg("起点", cond="午夜窗口", body="起点"),
+               edges=[{"target": "z2", "relation_type": "causal", "confidence": 1.0}])
+        cg.add("z2", ccg("终点", body="终点"))
+        zc = cg.causal_chain("z1")[0]
+        check("边无条件 → 回退节点生效条件", zc["conditions"][0] == "午夜窗口", str(zc["conditions"]))
+
+        from . import chain as ch
+        best = ch.expand_from_seeds(cg, {"db": 1.0}, relation_types=("causal",),
+                                    max_depth=5, decay=0.9)
+        want = 1.0 * (0.85 * 0.9) * 0.9
+        check("种子扩散打分 = 种子 × 链权 × decay^跳",
+              abs(best["svc"]["score"] - want) < 1e-6, str(best.get("svc", {}).get("score")))
+
+        # 层级边参与链
+        hier = cg.causal_chain("r", relation_types=("part_of",), max_depth=2)
+        check("层级 part_of 边参与链遍历",
+              any("a" in c["nodes"] for c in hier), str([c["nodes"] for c in hier]))
+
+        # ================= C. 检索接入 =================
+        print("\n[C] 检索接入（chain 路 + 可审计 provenance）")
+        results, meta = cg.search_rrf("数据库在运行",
+                                      paths=("lexical", "entity", "chain"), k=8)
+        got = [r[0].get("id") for r in results]
+        check("chain 路召回链下游节点", ("svc" in got) or ("api" in got), str(got))
+        prov = meta.get("provenance") or {}
+        chained = [nid for nid, items in prov.items()
+                   if any(p.get("path") == "chain" for p in items)]
+        check("provenance 标注 chain 路", bool(chained), str(chained))
+        with_cond = [p for items in prov.values() for p in items
+                     if p.get("path") == "chain" and p.get("conditions")]
+        check("provenance 带条件序列（可审计）",
+              bool(with_cond) and any(p["conditions"] for p in with_cond), str(with_cond[:1]))
+
+        _dr, dmeta = cg.search_rrf("数据库在运行", k=8)
+        dpaths = set()
+        for items in (dmeta.get("provenance") or {}).values():
+            for p in items:
+                dpaths.add(p.get("path"))
+        check("默认检索路不含 chain（不改变既有基线）", "chain" not in dpaths, str(sorted(dpaths)))
+
+        check("公开 API：subgraph_expand/flatten/validate/roots",
+              all(hasattr(cg, n) for n in ("subgraph_expand", "subgraph_flatten",
+                                           "subgraph_validate", "subgraph_roots")))
+        check("公开 API：causal_chain/explain_chain",
+              all(hasattr(cg, n) for n in ("causal_chain", "explain_chain")))
+    finally:
+        import shutil
+        shutil.rmtree(root, ignore_errors=True)
+
+    print(f"\n==== P8 结果：{PASS} 通过 / {FAIL} 失败 ====")
+    if FAILS:
+        print("失败项：" + "，".join(FAILS))
+    return 1 if FAIL else 0
+
+
+if __name__ == "__main__":
+    raise SystemExit(main())

package/md_cg/test_p9_forget_protect.py

@@ -0,0 +1,231 @@
+# -*- coding: utf-8 -*-
+"""md_cg · 第 9 篇：主动遗忘闸门 + 自我认知写保护
+
+覆盖：
+  A 写保护（不可遗忘）
+      层保护 self/anchor · 新建放行 · 覆盖拒绝 · override 放行 + 旧版本快照 +
+      审计留痕 · 重要性≥0.7 自动打标 · 普通节点不受限 · 删除保护 ·
+      降级保护 · 保护层内搬迁放行 · 保护面盘点
+  B 主动遗忘闸门（写入侧三问）
+      重复→MERGE（不新增，强化既有） · 确定性内部冗余→DROP（先于 MERGE） ·
+      外部惊奇→ACCEPT · importance_hint≥0.7→ACCEPT（保护优先） ·
+      半重复且不重要→DEFER · DROP/DEFER 不落库 · 留痕可审计 ·
+      自信息代理单调性 · 来源分类 · 强化跨阈值自动保护 · gated=False 兼容
+
+运行：python -m md_cg.test_p9_forget_protect
+"""
+from __future__ import annotations
+
+import os
+import tempfile
+
+from .mdcos import MdCGOS
+from . import forgetting, 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 ccg(title, cond="任意情境", sub="验收", exe="直接调用", verify="test", body=""):
+    return (f"# 功能名：{title}\n"
+            f"# 生效条件：{cond}\n"
+            f"# 子功能：{sub}\n"
+            f"# 执行：{exe}\n"
+            f"# 验证方式：{verify}\n"
+            f"# 不适用条件：无\n"
+            f"{body or title}\n")
+
+
+def blocked_by(fn):
+    """执行 fn，返回是否被 ProtectionError 拦下。"""
+    try:
+        fn()
+        return False
+    except protect.ProtectionError:
+        return True
+
+
+def main():
+    root = tempfile.mkdtemp(prefix="mdcg_p9_")
+    cg = MdCGOS(root)
+    try:
+        # ================= A. 自我认知写保护 =================
+        print("\n[A] 自我认知写保护（不可遗忘）")
+
+        cg.add("self_identity", ccg("身份", body="我是灵枢"), layer="self")
+        check("self 层新建放行（保护的是已有认知，不是禁止产生）",
+              cg.get("self_identity") is not None)
+
+        check("self 层覆盖被拒",
+              blocked_by(lambda: cg.add("self_identity", ccg("身份", body="篡改"),
+                                        layer="self")))
+        cg.add("self_identity", ccg("身份", body="我是灵枢 v2"), layer="self",
+               override=True)
+        check("override 覆盖成功",
+              "我是灵枢 v2" in cg.get("self_identity")["content"])
+        hist = protect.history(cg, "self_identity")
+        check("override 前自动快照旧版本", len(hist) >= 1, str(hist))
+        check("写保护动作留痕 _protected_audit.jsonl",
+              os.path.exists(os.path.join(root, protect.AUDIT_FILE)))
+
+        cg.add("anc1", ccg("锚点", body="核心锚点"), layer="anchor")
+        prot, why = protect.is_protected(cg, "anc1")
+        check("anchor 层受保护", prot and "层保护" in why, why)
+
+        cg.add("imp9", ccg("高重要", body="关键知识"), layer="knowledge",
+               importance=0.9)
+        fm9 = cg.get("imp9")["frontmatter"]
+        check("importance≥0.7 自动打保护标记",
+              fm9.get("protected") is True, str(fm9.get("protection_reason")))
+        cg.add("imp9", ccg("高重要", body="关键知识 v2"), layer="knowledge",
+               importance=0.9)
+        check("高重要性节点仍可更新（不可遗忘 ≠ 不可覆盖）",
+              "v2" in cg.get("imp9")["content"])
+        check("高重要性节点删除被拒（不可遗忘）",
+              blocked_by(lambda: cg.forget("imp9", "想删掉")))
+
+        cg.add("imm1", ccg("不可覆盖", body="显式不可覆盖"), layer="knowledge",
+               immutable=True)
+        check("显式 immutable 节点覆盖被拒",
+              blocked_by(lambda: cg.add("imm1", ccg("不可覆盖", body="改写"),
+                                        layer="knowledge")))
+
+        cg.add("plain", ccg("普通", body="普通知识"), layer="knowledge",
+               importance=0.5)
+        cg.add("plain", ccg("普通", body="普通知识v2"), layer="knowledge",
+               importance=0.5)
+        check("普通节点可自由覆盖（保护不过度扩张）",
+              "v2" in cg.get("plain")["content"])
+
+        check("受保护节点删除被拒",
+              blocked_by(lambda: cg.forget("anc1", "测试删除")))
+        r = cg.forget("anc1", "确实要删", override=True)
+        check("override 删除放行",
+              r.get("ok") is True and cg.get("anc1") is None, str(r))
+
+        cg.add("anc2", ccg("锚点2", body="锚点2"), layer="anchor")
+        check("受保护节点降级被拒",
+              blocked_by(lambda: cg._move_layer("anc2", "knowledge", "降级测试")))
+        moved = cg._move_layer("anc2", "self", "保护层内搬迁")
+        check("保护层之间搬迁放行",
+              (moved or {}).get("to") == "self", str(moved))
+
+        st = cg.protect_stats()
+        check("保护面盘点（受保护数 + 自动保护计数）",
+              st["protected_count"] >= 2 and st["auto_by_importance"] >= 1,
+              str({k: st[k] for k in ("protected_count", "by_layer",
+                                      "auto_by_importance")}))
+
+        # ================= B. 主动遗忘闸门 =================
+        print("\n[B] 主动遗忘闸门（写入侧三问）")
+
+        body = ("# 功能名：编译缓存清理\n# 生效条件：缓存目录超过 2GB 时\n"
+                "# 子功能：删除最旧的分片\n# 执行：按 mtime 排序删除\n"
+                "# 验证方式：test\n# 不适用条件：缓存被其他进程占用\n"
+                "清理编译缓存目录释放磁盘空间\n")
+        cg.add("c1", body, layer="contextual", importance=0.5)
+        n_before = len(cg.index["nodes"])
+        r1 = cg.remember_gated("c2", body, layer="contextual", role="user")
+        check("重复内容 → MERGE（并入既有）",
+              r1["verdict"] == "MERGE" and r1["merged_into"] == "c1",
+              f"{r1['verdict']} · {r1['gate']['reason']}")
+        check("MERGE 不新增节点", len(cg.index["nodes"]) == n_before)
+        check("MERGE 强化既有节点 importance",
+              cg.get("c1")["frontmatter"]["importance"] > 0.5,
+              str(cg.get("c1")["frontmatter"]["importance"]))
+
+        r2 = cg.remember_gated("c3", ccg("重要结论", body="这是一条关键结论"),
+                               layer="contextual", importance_hint=0.8)
+        check("importance_hint≥0.7 → ACCEPT（保护优先）",
+              r2["verdict"] == "ACCEPT", r2["gate"]["reason"])
+        check("保护优先写入后自动打保护标记",
+              cg.get("c3")["frontmatter"].get("protected") is True)
+
+        r3 = cg.remember_gated("c4", body, layer="contextual", role="command")
+        check("确定性内部冗余 → DROP（先于 MERGE，不强化既有）",
+              r3["verdict"] == "DROP", r3["gate"]["reason"])
+        check("DROP 不落库", cg.get("c4") is None)
+        check("DROP 未污染既有节点 importance（未走 MERGE 强化）",
+              abs(cg.get("c1")["frontmatter"]["importance"] - 0.55) < 1e-6,
+              str(cg.get("c1")["frontmatter"]["importance"]))
+
+        fresh = ("# 功能名：奇点事故复盘\n# 生效条件：集群出现未知内存泄漏时\n"
+                 "# 子功能：定位泄漏点\n# 执行：堆转储对比\n"
+                 "# 验证方式：data\n# 不适用条件：非 JVM 进程\n"
+                 "首次观测到未知内存泄漏，与既有记忆无重叠\n")
+        r4 = cg.remember_gated("c5", fresh, layer="contextual", role="user")
+        check("外部惊奇（全新内容）→ ACCEPT", r4["verdict"] == "ACCEPT",
+              r4["gate"]["reason"])
+        ent = r4["gate"]["entropy"]
+        check("高熵判定：novelty 高 / 自信息代理高",
+              ent["novelty"] > 0.8 and ent["self_information_bits"] > 2.0, str(ent))
+        check("来源分类：外部惊奇",
+              ent["source_kind"] == "external_surprising")
+        g = r4["gate"]
+        check("裁决含三问完整判据",
+              all(k in g for k in ("redundancy", "importance", "entropy"))
+              and {"novelty", "self_information_bits", "duplicate_ratio",
+                   "source_kind"} <= set(g["entropy"]))
+
+        a2 = "订单退款审批流程校验优惠券叠加规则"
+        cg.add("d1", a2, layer="contextual", importance=0.5)
+        r5 = cg.remember_gated("d2", a2 + "新增风控节点", layer="contextual",
+                               role="assistant", importance_hint=0.1)
+        check("半重复且不重要 → DEFER（待定复核）",
+              r5["verdict"] == "DEFER",
+              f"{r5['verdict']} · dup={r5['gate']['entropy']['duplicate_ratio']:.2f}")
+        check("DEFER 不落库", cg.get("d2") is None)
+
+        check("自信息代理单调：dup↑ → bits↓",
+              forgetting.self_information(0.0) > forgetting.self_information(0.5)
+              > forgetting.self_information(0.99))
+        check("来源分类函数",
+              forgetting.source_kind(role="user") == "external_surprising"
+              and forgetting.source_kind(role="command") == "internal_deterministic"
+              and forgetting.source_kind(role="assistant") == "self_generated"
+              and forgetting.source_kind(verification_basis="data")
+              == "internal_deterministic")
+
+        for _ in range(6):
+            forgetting.reinforce(cg, "c1")
+        check("重复强化跨 0.7 自动打保护标记",
+              cg.get("c1")["frontmatter"].get("protected") is True,
+              str(cg.get("c1")["frontmatter"].get("importance")))
+
+        hist = cg.forgetting_history(limit=50)
+        check("遗忘裁决留痕（含 ACCEPT/MERGE/DROP/DEFER）",
+              {"ACCEPT", "MERGE", "DROP", "DEFER"} <= {h["verdict"] for h in hist},
+              str(sorted({h["verdict"] for h in hist})))
+        check("留痕文件 _forgetting.jsonl 存在",
+              os.path.exists(os.path.join(root, forgetting.LOG_FILE)))
+
+        r6 = cg.remember_gated("c6", body, layer="contextual", gated=False)
+        check("gated=False 绕过闸门（兼容既有写入路径）",
+              r6.get("bypass") is True and cg.get("c6") is not None)
+
+        check("公开 API：remember_gated / forgetting_history / protect_stats",
+              all(hasattr(cg, n) for n in ("remember_gated", "forgetting_history",
+                                           "protect_stats")))
+    finally:
+        import shutil
+        shutil.rmtree(root, ignore_errors=True)
+
+    print(f"\n==== P9 结果：{PASS} 通过 / {FAIL} 失败 ====")
+    if FAILS:
+        print("失败项：" + "、".join(FAILS))
+    return 1 if FAIL else 0
+
+
+if __name__ == "__main__":
+    raise SystemExit(main())