@furongjun1999/dsh-memory 0.4.4 → 0.4.6

package/md_cg/test_p3.py

@@ -0,0 +1,252 @@
+# -*- coding: utf-8 -*-
+"""md_cg · P3 验收（#2 进程/权限 + #3 设备驱动）
+
+运行：python -m md_cg.test_p3
+"""
+from __future__ import annotations
+
+import json
+import os
+import shutil
+import sys
+import tempfile
+
+from .mdcos import MdCGSecure
+from .security import Principal, TenantRegistry, AccessDenied
+from .sources import JsonlSource, DSHSessionSource, Ingestor
+
+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}")
+
+
+CCG = ("# 功能名：{n}\n# 生效条件：问{n}\n# 子功能：{n}\n# 执行：{n}\n"
+       "# 验证方式：test\n# 不适用条件：其它\n\n{n} 的内容\n")
+
+
+def main():
+    root = tempfile.mkdtemp(prefix="mdcg_p3_")
+    try:
+        # ================= #2 权限模型 =================
+        print("\n【#2-1】Principal / 密级")
+        pub = Principal(tenant="public", actor="web", clearance="public")
+        priv = Principal(tenant="private", actor="owner", clearance="private",
+                         can_admin=True)
+        check("public 只能看 public", pub.allows("public") and not pub.allows("internal"),
+              f"clearance={pub.clearance}")
+        check("private 能看 internal 与 private",
+              priv.allows("internal") and priv.allows("private") and not priv.allows("secret"))
+
+        print("\n【#2-2】写隔离")
+        cg_pub = MdCGSecure(root, principal=pub)
+        cg_pub.add("pub1", CCG.format(n="公开知识"), sensitivity="public")
+        check("public 可写 public", cg_pub.get("pub1") is not None)
+        denied = None
+        try:
+            cg_pub.add("pub2", CCG.format(n="内部知识"), sensitivity="internal")
+        except AccessDenied as e:
+            denied = str(e)
+        check("public 写 internal 被拒", denied is not None, denied)
+        denied2 = None
+        try:
+            MdCGSecure(root, principal=priv).add(
+                "s1", CCG.format(n="机密"), sensitivity="secret")
+        except AccessDenied as e:
+            denied2 = str(e)
+        check("clearance<secret 写 secret 被拒", denied2 is not None, denied2)
+
+        print("\n【#2-3】读隔离（search / get 一致）")
+        cg_priv = MdCGSecure(root, principal=priv)
+        cg_priv.add("int1", CCG.format(n="内部条目"), sensitivity="internal")
+        cg_priv.add("prv1", CCG.format(n="私有条目"), sensitivity="private")
+        pub_again = MdCGSecure(root, principal=Principal(
+            tenant="public", actor="web", clearance="public"))
+        check("public 读不到 internal 节点", pub_again.get("int1") is None)
+        check("public 读不到 private 节点", pub_again.get("prv1") is None)
+        res_pub, _ = pub_again.search("条目", k=10)
+        check("public 检索结果全部 public",
+              all(r[0]["id"] == "pub1" for r in res_pub) and res_pub,
+              f"{[r[0]['id'] for r in res_pub]}")
+        res_priv, _ = cg_priv.search("条目", k=10)
+        check("private 检索能看到 private 节点",
+              any(r[0]["id"] == "prv1" for r in res_priv),
+              f"{[r[0]['id'] for r in res_priv]}")
+        rec = pub_again.recall("条目", budget_tokens=500)
+        check("recall 同样受密级过滤",
+              all(p["id"] == "pub1" for p in rec["pack"]),
+              f"{[p['id'] for p in rec['pack']]}")
+
+        print("\n【#2-4】管理隔离")
+        adm_denied = None
+        try:
+            pub_again.forget("pub1", "试试")
+        except AccessDenied as e:
+            adm_denied = str(e)
+        check("无 can_admin 的 forget 被拒", adm_denied is not None, adm_denied)
+
+        print("\n【#2-5】租户注册表（公开/私有物理隔离）")
+        reg_path = os.path.join(root, "_tenants.json")
+        reg = TenantRegistry(reg_path)
+        pub_root = os.path.join(root, "public-root")
+        priv_root = os.path.join(os.path.expanduser("~"), ".mdcg", "private-root")
+        reg.register("public", pub_root, clearance_cap="public",
+                     description="开源仓库内：仅公开知识")
+        reg.register("private", priv_root, clearance_cap="private",
+                     description="仓库外：私有记忆")
+        check("租户 root 注册", reg.root_of("public") == os.path.abspath(pub_root)
+              and reg.root_of("private") == os.path.abspath(priv_root))
+        p2 = reg.principal_for("public", clearance="secret")
+        check("调用方 clearance 被租户上限夹紧", p2.clearance == "public", p2.clearance)
+        check("公开根在仓库内 / 私有根在仓库外",
+              os.path.abspath(pub_root).startswith(os.path.abspath(root))
+              and not os.path.abspath(priv_root).startswith(os.path.abspath(root)))
+
+        print("\n【#2-6】审计带 tenant/session")
+        audits = cg_priv.audit_records()
+        check("审计含 tenant", all("tenant" in a for a in audits), str(audits[-1])[:90])
+        check("审计含 session", all("session" in a for a in audits), str(audits[-1])[:90])
+        who = cg_priv.whoami()
+        check("whoami 报告可见/总节点数", "nodes_visible" in who and "nodes_total" in who,
+              json.dumps({k: who[k] for k in ("nodes_visible", "nodes_total")}))
+        h = cg_priv.health_os()
+        check("health_os 报告 security", "security" in h and "sensitivity_counts" in h["security"],
+              json.dumps(h["security"], ensure_ascii=False)[:110])
+
+        # ================= #3 设备驱动 =================
+        print("\n【#3-1】JsonlSource")
+        jl = os.path.join(root, "events.jsonl")
+        with open(jl, "w", encoding="utf-8") as f:
+            for i, (role, text) in enumerate([
+                ("user", "跑测试"),
+                ("tool-output", "Traceback (most recent call last):\nModuleNotFoundError: No module named 'zzz'"),
+                ("assistant", "pip install zzz"),
+                ("assistant", "再跑一次"),
+            ]):
+                f.write(json.dumps({"time": 1780000000000 + i * 1000, "seq": i,
+                                    "role": role, "text": text,
+                                    "session": "s1"}, ensure_ascii=False) + "\n")
+        src = JsonlSource(jl)
+        evs = list(src.events())
+        check("JsonlSource 解析事件", len(evs) == 4, f"{len(evs)} 条")
+        check("JsonlSource 保留 role/seq", evs[1]["role"] == "tool-output"
+              and evs[1]["seq"] == 1, json.dumps(evs[1], ensure_ascii=False)[:80])
+
+        print("\n【#3-2】DSHSessionSource（DSH 真实格式）")
+        dsh_dir = os.path.join(root, "dsh-sess")
+        os.makedirs(dsh_dir, exist_ok=True)
+        dsh = os.path.join(dsh_dir, "session.jsonl")
+        rows = [
+            {"type": "session", "version": 0, "id": "session-abc", "createdAt": 1780000000000,
+             "cwd": "D:/proj", "delegationDepth": 0, "agentPreset": "standard"},
+            {"type": "user/message", "seq": 1, "time": 1780000001000,
+             "data": {"content": [{"type": "text", "text": "帮我跑测试"}]}},
+            {"type": "tool/call", "seq": 2, "time": 1780000002000,
+             "data": {"turn": 1, "step": 1, "callId": "c1", "name": "bash",
+                      "arguments": "{\"cmd\":\"npm test\"}"}},
+            {"type": "tool/result", "seq": 3, "time": 1780000003000,
+             "data": {"message": {"source": {"kind": "tool", "callId": "c1"},
+                                  "content": [{"type": "tool-result", "toolCallId": "c1",
+                                               "content": [{"type": "text",
+                                                            "text": "Error: boom"}]}]}}},
+            {"type": "assistant/message", "seq": 4, "time": 1780000004000,
+             "data": {"turn": 1, "step": 1,
+                      "message": {"role": "assistant", "content": [
+                          {"type": "reasoning", "text": "想想"},
+                          {"type": "text", "text": "npm install --save-dev foo"}]}}},
+        ]
+        with open(dsh, "w", encoding="utf-8") as f:
+            for r in rows:
+                f.write(json.dumps(r, ensure_ascii=False) + "\n")
+        dsrc = DSHSessionSource(dsh)
+        devs = list(dsrc.events())
+        roles = [e["role"] for e in devs]
+        check("DSH 源解析出 4 条消息事件", len(devs) == 4, f"{len(devs)} 条 roles={roles}")
+        check("DSH 事件角色映射正确",
+              roles == ["user", "command", "tool-output", "assistant"], str(roles))
+        check("DSH reasoning 默认丢弃",
+              "想想" not in (devs[-1]["text"] or ""), devs[-1]["text"][:60])
+        check("DSH session/cwd 透传", devs[0]["session"] == "session-abc"
+              and devs[0]["cwd"] == "D:/proj", f"{devs[0].get('session')} {devs[0].get('cwd')}")
+
+        print("\n【#3-3】Ingestor 增量摄取 + 幂等 + 自动 fix-pair")
+        ing_root = tempfile.mkdtemp(prefix="mdcg_ing_")
+        try:
+            ing_cg = MdCGSecure(ing_root, principal=Principal(
+                tenant="private", actor="ing", clearance="private", can_admin=True))
+            ing = Ingestor(ing_cg)
+            r1 = ing.ingest(dsrc)
+            check("摄取写入节点", r1["written"] == 4, json.dumps(
+                {k: r1[k] for k in ("new_events", "written")}, ensure_ascii=False))
+            check("watermark 已记录", ing.watermark(dsrc.key()).get("seq") == 4,
+                  json.dumps(ing.watermark(dsrc.key()), ensure_ascii=False))
+            check("自动 fix-pair 挖掘触发", "fix_pairs" in r1 and r1["fix_pairs"]["pairs"],
+                  json.dumps(r1.get("fix_pairs", {}).get("pairs"), ensure_ascii=False)[:100])
+            r2 = ing.ingest(dsrc)
+            check("重复摄取幂等（无新增）", r2["new_events"] == 0 and r2["written"] == 0,
+                  json.dumps({k: r2[k] for k in ("new_events", "written")}))
+            # 追加一条新事件 → 只增量摄取它
+            with open(dsh, "a", encoding="utf-8") as f:
+                f.write(json.dumps({"type": "user/message", "seq": 5, "time": 1780000005000,
+                                    "data": {"content": [{"type": "text", "text": "继续"}]}},
+                                   ensure_ascii=False) + "\n")
+            r3 = ing.ingest(dsrc)
+            check("增量只摄取新事件", r3["new_events"] == 1 and r3["written"] == 1,
+                  json.dumps({k: r3[k] for k in ("new_events", "written")}))
+            # 敏感度：会话默认 private
+            any_id = r1["ids"][0]
+            node = ing_cg.get(any_id)
+            check("会话节点默认敏感度 private",
+                  (node["frontmatter"].get("sensitivity") == "private"), str(
+                      node["frontmatter"].get("sensitivity")))
+            check("会话节点落 contextual 层",
+                  node["frontmatter"].get("layer") == "contextual",
+                  str(node["frontmatter"].get("layer")))
+            # 公开调用方看不到会话记忆
+            pub_view = MdCGSecure(ing_root, principal=Principal(
+                tenant="public", actor="web", clearance="public"))
+            check("public 调用方看不到私有会话记忆",
+                  pub_view.get(any_id) is None and not pub_view.search("测试", k=5)[0])
+        finally:
+            shutil.rmtree(ing_root, ignore_errors=True)
+
+        print("\n【#3-4】真实 DSH 会话（可选：zstd 可用时）")
+        try:
+            import zstandard  # noqa: F401
+            files = DSHSessionSource.discover(limit=3)
+            if files:
+                ok = 0
+                for p in files:
+                    try:
+                        n = len(list(DSHSessionSource(p).events()))
+                        ok += 1 if n > 0 else 0
+                    except Exception:      # noqa: BLE001
+                        pass
+                check("真实 DSH 会话可解析", ok > 0, f"{ok}/{len(files)} 个会话有事件")
+            else:
+                check("真实 DSH 会话可解析", True, "本机无会话文件（跳过）")
+        except ImportError:
+            check("真实 DSH 会话可解析", True, "zstandard 不可用（优雅跳过）")
+
+    finally:
+        shutil.rmtree(root, ignore_errors=True)
+
+    print("\n" + "=" * 68)
+    print(f"通过 {PASS} / 失败 {FAIL}")
+    if FAILS:
+        print("失败项：" + ", ".join(FAILS))
+    print("=" * 68)
+    return 0 if FAIL == 0 else 1
+
+
+if __name__ == "__main__":
+    sys.exit(main())

package/md_cg/test_p30_maintain.py

@@ -0,0 +1,330 @@
+# -*- coding: utf-8 -*-
+"""记忆维护 + 离线固化（P30 · P1 工程缺口验收）。
+
+对照 docs §五：P1 新增 maintain / consolidate 两 op。验收覆盖：
+  ① op 契约链：ALL_OPS == 工具 schema，且按 op / action 分级授权
+  ② maintain.stat/history：只读盘点，不需管理权限
+  ③ maintain.importance：dry-run 报表 → apply → 留痕 → rollback 复原
+  ④ maintain.longterm：dry-run → 断面落盘 → 幂等 → list/show
+  ⑤ maintain.prefeed：预演不写 → write 时 ACCEPT 新增 / MERGE 并入不新增
+  ⑥ maintain.separate：相似而条件不同 → 候选 → apply 写对称边 → 幂等
+  ⑦ consolidate.promote：dry-run 分流 → 迁移 → 追溯 → 回滚
+  ⑧ 权限分档：写层可 stat/prefeed、不可 importance/separate/rollback
+  ⑨ 未知 action 不静默成功
+
+批量改写均可预演 / 可留痕 / 可回滚；独立临时根，重跑 ≡ 首跑。
+
+运行：python -m md_cg.test_p30_maintain
+"""
+from __future__ import annotations
+
+import os
+import shutil
+import sys
+import tempfile
+
+from . import consistency, corpus, forgetting, subgraph, tokens, weights
+from .mdcos import MdCGOS
+from .mcp_server import KERNEL_TOOLS, call_tool
+from .security import AccessDenied, Principal
+
+PASS = FAIL = 0
+FAILS = []
+
+SEP_A = ("# 功能名：连接池选择\n# 生效条件：单机离线环境\n"
+         "# 子功能：在无外部依赖时选本地池\n# 执行：读配置选 local 建池\n"
+         "# 不适用条件：无缓存场景\n")
+SEP_B = ("# 功能名：连接池选择\n# 生效条件：多租户在线服务\n"
+         "# 子功能：在无外部依赖时选本地池\n# 执行：读配置选 local 建池\n"
+         "# 不适用条件：嵌入式设备\n")
+PROMO_HOT = ("# 功能名：重试退避策略\n# 生效条件：网络抖动且请求幂等\n"
+             "# 子功能：在瞬时故障下限制重试次数\n# 执行：指数退避重试至多三次\n"
+             "# 不适用条件：非幂等写操作\n")
+PROMO_COLD = ("# 功能名：日志轮转策略\n# 生效条件：磁盘占用超过阈值\n"
+              "# 子功能：按大小切分历史日志\n# 执行：达到上限即滚动归档\n"
+              "# 不适用条件：只读挂载卷\n")
+# 反复命中但四要素不全（缺「不适用条件」）
+PROMO_BAD = ("# 功能名：缓存穿透保护\n# 生效条件：高频查询未命中\n"
+             "# 子功能：用空值占位挡住穿透\n# 执行：写空对象并设短 TTL\n")
+NOVEL = ("# 观察：本机固定使用 Windows 与 cmd\n# 生效条件：本机开发环境\n"
+         "# 执行：命令示例一律给 cmd 语法\n# 不适用条件：容器内构建\n"
+         "用户多次强调命令行需适配 cmd.exe 而非 bash 语法。\n")
+
+
+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 _principal(role):
+    s = tokens.role_spec(role)
+    return Principal(tenant="default", actor=role, clearance="internal",
+                     can_write=bool(s["can_write"]), can_admin=bool(s["can_admin"]),
+                     role=role, layers_allow=s["layers_allow"],
+                     ops_allow=s["ops_allow"])
+
+
+def _denied(fn):
+    try:
+        fn()
+        return False
+    except AccessDenied:
+        return True
+
+
+def main():
+    print("=" * 68)
+    print("md 认知图 P30 验收 · 记忆维护 / 离线固化（P1）")
+    print("=" * 68)
+    tmp = tempfile.mkdtemp(prefix="mdcg_p30_")
+    ROOT = os.path.join(tmp, "root")
+    corpus.reset_root(ROOT)
+    cg = MdCGOS(ROOT, actor="p30")
+    cg.principal = Principal(tenant="default", actor="p30", clearance="internal",
+                             can_write=True, can_admin=True, role="designer")
+    try:
+        # ---------------------------------------------- ① 契约链
+        print("\n【1】op 契约链与分级授权")
+        tool = next(t for t in KERNEL_TOOLS if t["name"] == "cg")
+        declared = set(tool["inputSchema"]["properties"]["op"]["description"].split("|"))
+        check("工具 op 枚举 == ALL_OPS（防漏改）", declared == set(tokens.ALL_OPS),
+              f"diff={sorted(declared ^ set(tokens.ALL_OPS))}")
+        check("maintain/consolidate 已进 ALL_OPS",
+              {"maintain", "consolidate"} <= set(tokens.ALL_OPS))
+        check("写层三单元获 maintain 授权",
+              all("maintain" in tokens.role_spec(r)["ops_allow"]
+                  for r in ("record", "reflect", "sustain")))
+        check("verify/output 未获 maintain",
+              all("maintain" not in tokens.role_spec(r)["ops_allow"]
+                  for r in ("verify", "output")))
+        check("consolidate 为 designer 专属",
+              all("consolidate" not in tokens.role_spec(r)["ops_allow"]
+                  for r in ("record", "reflect", "verify", "output", "sustain")))
+        check("MAINTAIN_ACTIONS 覆盖 P1 五项",
+              {"importance", "longterm", "prefeed", "separate", "stat"}
+              <= set(cg.MAINTAIN_ACTIONS), str(cg.MAINTAIN_ACTIONS))
+
+        # ---------------------------------------------- ② stat / history
+        print("\n【2】maintain.stat / history（只读）")
+        st = call_tool(cg, "cg", {"op": "maintain", "action": "stat"})
+        check("stat 返回盘点字段", st.get("ok") and "by_layer" in st
+              and "importance" in st, str(st)[:100])
+        keep = cg.principal
+        cg.principal = _principal("record")
+        check("stat 对写层角色放行（只读）",
+              not _denied(lambda: call_tool(cg, "cg",
+                                            {"op": "maintain", "action": "stat"})))
+        cg.principal = keep
+        hi = call_tool(cg, "cg", {"op": "maintain", "action": "history"})
+        check("history 返回记录列表",
+              hi.get("ok") and isinstance(hi.get("records"), list))
+
+        # ---------------------------------------------- ③ importance + 回滚
+        print("\n【3】maintain.importance：预演 → 改写 → 留痕 → 回滚")
+        cg.add("w_fp", "# 功能名：形式化证明\n# 生效条件：任意\n# 子功能：可证\n"
+                       "# 执行：证\n# 不适用条件：无\n", layer="knowledge",
+               verification_basis="formal_proof", importance=0.5)
+        cg.add("w_no", "# 功能名：无基底经验\n# 生效条件：任意\n# 子功能：经验\n"
+                       "# 执行：试\n# 不适用条件：无\n", layer="knowledge",
+               importance=0.5)
+        cg.flush()
+        i1 = call_tool(cg, "cg", {"op": "maintain", "action": "importance"})
+        check("默认 dry-run 不改写", i1.get("dry_run") and i1.get("written") == 0,
+              f"changed={i1.get('changed')}")
+        check("报表识别变动节点", i1.get("changed", 0) >= 1)
+        check("报表含分量（可审计）",
+              bool(i1.get("samples")) and "basis_trust" in
+              (i1["samples"][0].get("components") or {}))
+        i2 = call_tool(cg, "cg", {"op": "maintain", "action": "importance",
+                                  "apply": True})
+        check("apply 改写节点", i2.get("written", 0) >= 1, f"written={i2.get('written')}")
+        check("写入留痕 _maintain.jsonl", len(weights.history(cg, action="importance")) >= 1)
+        check("改写已落盘面",
+              abs(float(cg.get("w_fp")["frontmatter"]["importance"]) - 0.5) > 0.01)
+        rb = call_tool(cg, "cg", {"op": "maintain", "action": "rollback"})
+        check("rollback 反向应用", rb.get("ok") and rb.get("reverted", 0) >= 1,
+              str(rb)[:100])
+        cg.rebuild_index()
+        check("rollback 复原为 0.5",
+              abs(float(cg.get("w_fp")["frontmatter"]["importance"]) - 0.5) < 1e-9)
+
+        # ---------------------------------------------- ④ longterm
+        print("\n【4】maintain.longterm：预演 → 断面 → 幂等 → list/show")
+        l1 = call_tool(cg, "cg", {"op": "maintain", "action": "longterm"})
+        check("dry-run 未写盘", l1.get("dry_run") and l1.get("written") == 0)
+        check("报表含分层与孤岛", "tiers" in l1 and "islands" in l1)
+        l2 = call_tool(cg, "cg", {"op": "maintain", "action": "longterm",
+                                  "apply": True})
+        check("apply 写出断面",
+              l2.get("written", 0) >= 1 and l2.get("same_as_current") is False,
+              f"written={l2.get('written')}")
+        check("断面文件落盘", os.path.exists(os.path.join(ROOT, l2.get("path") or "")))
+        l3 = call_tool(cg, "cg", {"op": "maintain", "action": "longterm",
+                                  "apply": True})
+        check("幂等：内容相同跳过重写",
+              l3.get("same_as_current") and l3.get("written") == 0)
+        l4 = call_tool(cg, "cg", {"op": "maintain", "action": "longterm",
+                                  "mode": "list"})
+        check("list 返回 current 与历史",
+              l4.get("current") and bool(l4.get("snapshots")))
+        l5 = call_tool(cg, "cg", {"op": "maintain", "action": "longterm",
+                                  "mode": "show"})
+        check("show 聚合断面总数", l5.get("ok") and l5.get("total") == l2.get("total"),
+              f"total={l5.get('total')}")
+
+        # ---------------------------------------------- ⑤ prefeed
+        print("\n【5】maintain.prefeed：预演 → ACCEPT 新增 → MERGE 不新增")
+        p0 = call_tool(cg, "cg", {"op": "maintain", "action": "prefeed",
+                                  "content": NOVEL, "layer": "contextual"})
+        check("默认只预演未写盘",
+              p0.get("written") is None and p0.get("decision") is not None,
+              f"verdict={p0.get('verdict')}")
+        n0 = len(cg.index["nodes"])
+        p1 = call_tool(cg, "cg", {"op": "maintain", "action": "prefeed",
+                                  "content": NOVEL, "layer": "contextual",
+                                  "write": True})
+        check("ACCEPT 落库新增",
+              p1.get("decision") == "write" and bool(p1.get("written")),
+              f"decision={p1.get('decision')}")
+        n1 = len(cg.index["nodes"])
+        check("写入后节点 +1", n1 == n0 + 1, f"{n0} → {n1}")
+        p2 = call_tool(cg, "cg", {"op": "maintain", "action": "prefeed",
+                                  "content": NOVEL, "layer": "contextual",
+                                  "write": True})
+        check("重复内容判 MERGE 并入",
+              p2.get("decision") == "reinforce" and bool(p2.get("reinforced")),
+              f"decision={p2.get('decision')}")
+        check("MERGE 后节点数不变", len(cg.index["nodes"]) == n1)
+
+        # ---------------------------------------------- ⑥ separate
+        print("\n【6】maintain.separate：候选 → 对称边 → 幂等")
+        cg.add("sep_a", SEP_A, layer="contextual", importance=0.4)
+        cg.add("sep_b", SEP_B, layer="contextual", importance=0.4)
+        cg.flush()
+        s1 = call_tool(cg, "cg", {"op": "maintain", "action": "separate",
+                                  "layer": "contextual", "min_jaccard": 0.4})
+        pairs = {(c["a"], c["b"]) for c in (s1.get("candidates") or [])}
+        check("dry-run 给出候选且未写盘",
+              s1.get("dry_run") and ("sep_a", "sep_b") in pairs, f"{sorted(pairs)}")
+        check("候选条件重合度低",
+              bool(s1.get("candidates")) and all(
+                  c["cond_overlap"] <= subgraph.SEP_MAX_COND_OVERLAP
+                  for c in s1["candidates"]))
+        s2 = call_tool(cg, "cg", {"op": "maintain", "action": "separate",
+                                  "layer": "contextual", "min_jaccard": 0.4,
+                                  "apply": True})
+        check("apply 写出分离边", s2.get("written_count", 0) >= 1,
+              f"written_count={s2.get('written_count')}")
+        fa = cg.get("sep_a")["frontmatter"]
+        fb = cg.get("sep_b")["frontmatter"]
+        check("sep_a → sep_b 对称边", "sep_b" in consistency.separation_targets(fa))
+        check("sep_b → sep_a 对称边", "sep_a" in consistency.separation_targets(fb))
+        s3 = call_tool(cg, "cg", {"op": "maintain", "action": "separate",
+                                  "layer": "contextual", "min_jaccard": 0.4,
+                                  "apply": True})
+        newly = sum(len(r.get("written") or []) for r in (s3.get("written") or []))
+        check("幂等：二次 apply 不重写", newly == 0, str(newly))
+
+        # ---------------------------------------------- ⑦ promote
+        print("\n【7】consolidate.promote：分流 → 迁移 → 追溯 → 回滚")
+        cg.add("promo_hot", PROMO_HOT, layer="contextual", importance=0.5,
+               merge_count=3)
+        cg.add("promo_cold", PROMO_COLD, layer="contextual", importance=0.2)
+        cg.add("promo_bad", PROMO_BAD, layer="contextual", importance=0.5,
+               merge_count=3)
+        cg.flush()
+        r1 = call_tool(cg, "cg", {"op": "consolidate", "action": "promote"})
+        check("dry-run 未写盘", r1.get("dry_run") and r1.get("written") == 0)
+        check("命中热节点", r1.get("targeted", 0) >= 1, f"targeted={r1.get('targeted')}")
+        check("剔除四要素不全", r1.get("skipped_incomplete", 0) >= 1)
+        check("剔除不热节点", r1.get("skipped_not_hot", 0) >= 1)
+        r2 = call_tool(cg, "cg", {"op": "consolidate", "action": "promote",
+                                  "apply": True})
+        check("apply 提升节点",
+              r2.get("written", 0) >= 1 and "promo_hot" in (r2.get("promoted") or []),
+              f"promoted={r2.get('promoted')}")
+        fresh = MdCGOS(ROOT)
+        check("已迁到 knowledge 层",
+              (fresh.index["nodes"].get("promo_hot") or {}).get("layer") == "knowledge")
+        check("留下 promoted_from=contextual 追溯",
+              fresh.get("promo_hot")["frontmatter"].get("promoted_from") == "contextual")
+        check("promo_bad 仍留 contextual",
+              (fresh.index["nodes"].get("promo_bad") or {}).get("layer") == "contextual")
+        r3 = call_tool(cg, "cg", {"op": "consolidate", "action": "promote_history"})
+        check("promote_history 记录本次提升",
+              any(x.get("id") == "promo_hot" for x in (r3.get("records") or [])))
+        r4 = call_tool(cg, "cg", {"op": "consolidate", "action": "promote_rollback",
+                                  "node_ids": ["promo_hot"]})
+        check("promote_rollback 迁回", r4.get("ok") and r4.get("reverted", 0) >= 1,
+              str(r4)[:100])
+        fresh2 = MdCGOS(ROOT)
+        check("迁回 contextual",
+              (fresh2.index["nodes"].get("promo_hot") or {}).get("layer") == "contextual")
+
+        # ---------------------------------------------- ⑧ 权限分档
+        print("\n【8】权限分档")
+        cg.principal = _principal("record")
+        check("record 可 importance dry-run（只读预演）",
+              not _denied(lambda: call_tool(cg, "cg",
+                                            {"op": "maintain", "action": "importance"})))
+        check("record 不可 importance apply（需 admin）",
+              _denied(lambda: call_tool(cg, "cg", {"op": "maintain",
+                                                   "action": "importance",
+                                                   "apply": True})))
+        check("record 不可 separate apply", _denied(
+            lambda: call_tool(cg, "cg", {"op": "maintain", "action": "separate",
+                                         "apply": True})))
+        check("record 不可 rollback", _denied(
+            lambda: call_tool(cg, "cg", {"op": "maintain", "action": "rollback"})))
+        check("record 不可 longterm apply", _denied(
+            lambda: call_tool(cg, "cg", {"op": "maintain", "action": "longterm",
+                                         "apply": True})))
+        cg.principal = _principal("output")
+        check("output 整 op 被拒（未授权 maintain）", _denied(
+            lambda: call_tool(cg, "cg", {"op": "maintain", "action": "stat"})))
+        cg.principal = _principal("verify")
+        check("verify 不可 consolidate（未授权）", _denied(
+            lambda: call_tool(cg, "cg", {"op": "consolidate", "action": "promote"})))
+        cg.principal = Principal(tenant="default", actor="p30", clearance="internal",
+                                 can_write=True, can_admin=True, role="designer")
+
+        # ---------------------------------------------- ⑨ 未知 action
+        print("\n【9】未知 action 不静默成功")
+        bad = None
+        try:
+            call_tool(cg, "cg", {"op": "maintain", "action": "no_such_action"})
+        except Exception as exc:                       # noqa: BLE001
+            bad = exc
+        check("maintain 未知 action 抛错", bad is not None, type(bad).__name__)
+        bad2 = None
+        try:
+            call_tool(cg, "cg", {"op": "consolidate", "action": "no_such_action"})
+        except Exception as exc:                       # noqa: BLE001
+            bad2 = exc
+        check("consolidate 未知 action 抛错", bad2 is not None, type(bad2).__name__)
+
+    finally:
+        try:
+            cg.close()
+        except Exception:                              # noqa: BLE001
+            pass
+        shutil.rmtree(tmp, ignore_errors=True)
+
+    print("\n" + "=" * 68)
+    print(f"结果：{PASS} 通过 / {FAIL} 失败")
+    if FAILS:
+        print("失败项：")
+        for n in FAILS:
+            print(f"  - {n}")
+    print("=" * 68)
+    return 0 if FAIL == 0 else 1
+
+
+if __name__ == "__main__":
+    sys.exit(main())