@furongjun1999/dsh-memory 0.4.11 → 0.5.1

package/md_cg/test_census_prune.py

@@ -1,81 +1,81 @@
-# -*- coding: utf-8 -*-
-"""PR #15 census 归档区剪枝探针（脚本式，exit code 定成败）。
-
-用法：python -X utf8 -m md_cg.test_census_prune
-覆盖：
-- ARCHIVE_DIRS 五个目录整体剪枝（含 _protected_history/<id>/<ts>.md 两层下钻）
-- _protected_history_* 前缀目录剪枝
-- 普通子目录不误伤
-- 无 frontmatter 的散落 md 仍被跳过（既有语义保持）
-- 真实库（data/mdcg）上活跃数不再被墓碑/快照稀释
-"""
-import os
-import sys
-import tempfile
-
-sys.path.insert(0, os.path.dirname(os.path.dirname(os.path.abspath(__file__))))
-
-from md_cg import census  # noqa: E402
-
-FM = "---\nid: {nid}\nlayer: knowledge\n---\n正文\n"
-passed = 0
-
-
-def check(name, cond, detail=""):
-    global passed
-    if cond:
-        passed += 1
-        print("  [PASS] " + name)
-    else:
-        print("  [FAIL] " + name + "  " + detail)
-
-
-def main():
-    root = tempfile.mkdtemp(prefix="census_prune_")
-    nodes = {
-        # (相对路径, 是否活跃)
-        ("act_root.md", True),
-        ("sub", "act_sub.md", True),          # 普通子目录不误伤
-        ("trash", "t1.md", False),
-        ("_protected_history", "n1", "20260101_000000.md", False),  # 两层下钻
-        ("_protected", "p1.md", False),
-        ("_index_log", "i1.md", False),
-        ("hippocampus", "h1.md", False),
-        ("_protected_history_extra", "x.md", False),  # 前缀分支
-        ("note.md", None),                    # 无 frontmatter 散落文档 → 跳过
-    }
-    for n in nodes:
-        parts = [p for p in n if p is not True and p is not False and p is not None]
-        active = n[-1] is True
-        rel = os.path.join(*parts) if parts else "note.md"
-        p = os.path.join(root, rel)
-        os.makedirs(os.path.dirname(p), exist_ok=True)
-        with open(p, "w", encoding="utf-8") as f:
-            f.write("" if n[-1] is None else FM.format(nid=os.path.splitext(parts[-1])[0]))
-    rows = census.load(root)
-    ids = sorted(r[0] for r in rows)
-    check("仅活跃节点入普查（2 个）", ids == ["act_root", "act_sub"], str(ids))
-    for bad in ("t1", "p1", "i1", "h1", "x", "20260101_000000"):
-        check(f"归档区 {bad} 被剪枝", bad not in ids, str(ids))
-
-    # 真实库对比：PR 版活跃数 vs 全遍历数（含归档区）
-    real = os.path.join(os.path.dirname(os.path.dirname(
-        os.path.abspath(__file__))), "data", "mdcg")
-    if os.path.isdir(real):
-        n_active = len(census.load(real))
-        n_all = sum(1 for dp, _ds, fs in os.walk(real) for f in fs
-                    if f.endswith(".md"))
-        print(f"\n  真实库 {real}")
-        print(f"  PR 版活跃节点 {n_active} / 全遍历 {n_all}"
-              f"（归档区剪掉 {n_all - n_active}）")
-        check("真实库剪枝后不再被墓碑稀释", n_active < n_all,
-              f"{n_active} vs {n_all}")
-
-    print(f"\ntest_census_prune: {passed} 断言通过")
-    return 0 if passed >= 7 else 1
-
-
-if __name__ == "__main__":
-    if hasattr(sys.stdout, "reconfigure"):
-        sys.stdout.reconfigure(encoding="utf-8")
-    sys.exit(main())
+# -*- coding: utf-8 -*-
+"""PR #15 census 归档区剪枝探针（脚本式，exit code 定成败）。
+
+用法：python -X utf8 -m md_cg.test_census_prune
+覆盖：
+- ARCHIVE_DIRS 五个目录整体剪枝（含 _protected_history/<id>/<ts>.md 两层下钻）
+- _protected_history_* 前缀目录剪枝
+- 普通子目录不误伤
+- 无 frontmatter 的散落 md 仍被跳过（既有语义保持）
+- 真实库（data/mdcg）上活跃数不再被墓碑/快照稀释
+"""
+import os
+import sys
+import tempfile
+
+sys.path.insert(0, os.path.dirname(os.path.dirname(os.path.abspath(__file__))))
+
+from md_cg import census  # noqa: E402
+
+FM = "---\nid: {nid}\nlayer: knowledge\n---\n正文\n"
+passed = 0
+
+
+def check(name, cond, detail=""):
+    global passed
+    if cond:
+        passed += 1
+        print("  [PASS] " + name)
+    else:
+        print("  [FAIL] " + name + "  " + detail)
+
+
+def main():
+    root = tempfile.mkdtemp(prefix="census_prune_")
+    nodes = {
+        # (相对路径, 是否活跃)
+        ("act_root.md", True),
+        ("sub", "act_sub.md", True),          # 普通子目录不误伤
+        ("trash", "t1.md", False),
+        ("_protected_history", "n1", "20260101_000000.md", False),  # 两层下钻
+        ("_protected", "p1.md", False),
+        ("_index_log", "i1.md", False),
+        ("hippocampus", "h1.md", False),
+        ("_protected_history_extra", "x.md", False),  # 前缀分支
+        ("note.md", None),                    # 无 frontmatter 散落文档 → 跳过
+    }
+    for n in nodes:
+        parts = [p for p in n if p is not True and p is not False and p is not None]
+        active = n[-1] is True
+        rel = os.path.join(*parts) if parts else "note.md"
+        p = os.path.join(root, rel)
+        os.makedirs(os.path.dirname(p), exist_ok=True)
+        with open(p, "w", encoding="utf-8") as f:
+            f.write("" if n[-1] is None else FM.format(nid=os.path.splitext(parts[-1])[0]))
+    rows = census.load(root)
+    ids = sorted(r[0] for r in rows)
+    check("仅活跃节点入普查（2 个）", ids == ["act_root", "act_sub"], str(ids))
+    for bad in ("t1", "p1", "i1", "h1", "x", "20260101_000000"):
+        check(f"归档区 {bad} 被剪枝", bad not in ids, str(ids))
+
+    # 真实库对比：PR 版活跃数 vs 全遍历数（含归档区）
+    real = os.path.join(os.path.dirname(os.path.dirname(
+        os.path.abspath(__file__))), "data", "mdcg")
+    if os.path.isdir(real):
+        n_active = len(census.load(real))
+        n_all = sum(1 for dp, _ds, fs in os.walk(real) for f in fs
+                    if f.endswith(".md"))
+        print(f"\n  真实库 {real}")
+        print(f"  PR 版活跃节点 {n_active} / 全遍历 {n_all}"
+              f"（归档区剪掉 {n_all - n_active}）")
+        check("真实库剪枝后不再被墓碑稀释", n_active < n_all,
+              f"{n_active} vs {n_all}")
+
+    print(f"\ntest_census_prune: {passed} 断言通过")
+    return 0 if passed >= 7 else 1
+
+
+if __name__ == "__main__":
+    if hasattr(sys.stdout, "reconfigure"):
+        sys.stdout.reconfigure(encoding="utf-8")
+    sys.exit(main())

package/md_cg/test_chain_read_isolate.py

@@ -0,0 +1,168 @@
+# -*- coding: utf-8 -*-
+"""读隔离守卫：因果链面（causal_chain / explain_chain / causal_path / 检索
+chain 路 provenance）不得泄漏不可见节点。
+
+缺陷形态（2026-09-25 检索域新发现，报告编号 N130 与他域冲突，以 where 定位，
+high）：MdCGOS.causal_chain / explain_chain（mdcos.py:3491-3506）裸转调
+chain.walk / chain.explain，causal_path（mdcos.py:3544→predict.py:1020）BFS
+直用 chain.adjacency——而 chain.adjacency（chain.py:127-159）以 cg.index 全量
+节点 frontmatter 建出边表，全程不经 cg.get / MdCGSecure._readable。任何持
+read op 的低权令牌（ROLE_SPECS 全表 ops_allow 均含 read；mdcg_causal 的
+_MDCG_OP_REQUIRE 即为 "read"）可：①对不可见节点起链；②看到链上不可见节点
+id、边条件文本与下游拓扑；③检索 chain 路 provenance（_path_chain→
+expand_from_seeds，同走 adjacency）把全链与秘密条件文本附带在可见节点条目上。
+
+修复：在 chain.adjacency 单点接可见性闸——cg 提供 `_chain_visible(nid)` 谓词
+（MdCGSecure 注入 = 索引有条目 ∧ _readable(e)；基类不注入行为零变化）时，
+不可见节点的出边整体不入表、可见节点指向不可见目标的边截断、层级合成边同
+闸；缓存键带上闸存在位。单点覆盖 walk / explain / causal_path /
+expand_from_seeds（检索 chain 路 provenance）全部消费者——比三方法各自覆盖
+多堵住 provenance 面，且预测器其余 adjacency 消费者（causal roadmap /
+共同父节点等）一并隔离。_readable 的绑定档判定恒用 principal.session
+（mdcos.py:3901-3906），实例身份稳定，adjacency 缓存无跨身份串台面。
+
+红项 = R1-R5（链/路径/解释/检索 provenance 四面泄漏复现）；
+G 项锁语义不变（designer/admin 可见性不变、可见-可见边链照常展开、get 隔离
+基线）。
+运行：python -m md_cg.test_chain_read_isolate
+"""
+from __future__ import annotations
+
+import os
+import shutil
+import sys
+import tempfile
+
+try:
+    from .mdcos import MdCGSecure
+    from .security import Principal
+except ImportError:                                  # 直接脚本运行
+    sys.path.insert(0, os.path.dirname(os.path.dirname(os.path.abspath(__file__))))
+    from md_cg.mdcos import MdCGSecure
+    from md_cg.security import Principal
+
+PASS = FAIL = 0
+FAILS = []
+
+_SECRET_COND = "Y侧秘密条件文本YY"
+_SECRET_ID = "Y秘密"
+
+
+def ok(cond, label):
+    global PASS, FAIL
+    if cond:
+        PASS += 1
+        print(f"  OK   {label}")
+    else:
+        FAIL += 1
+        FAILS.append(label)
+        print(f"  FAIL {label}")
+
+
+def _body(name):
+    return (f"# 功能名：{name}\n# 生效条件：无条件\n# 子功能：无\n"
+            f"# 执行：无\n# 验证方式：test\n# 不适用条件：无\n\n正文。")
+
+
+def main():
+    tmp = tempfile.mkdtemp(prefix="mdcg_chain_iso_")
+    try:
+        root = os.path.join(tmp, "kg")
+        # 写者：designer（can_admin → private 档可见），建链 X→Y→Z
+        dw = Principal(actor="designer-1", role="designer", can_write=True,
+                       can_admin=True, clearance="secret")
+        cg = MdCGSecure(root, principal=dw, master_key=bytes(range(32)))
+        cg.add("X苹果", _body("X苹果"), layer="knowledge", sensitivity="internal",
+               edges=[{"target": _SECRET_ID, "relation_type": "causal",
+                       "condition": _SECRET_COND, "confidence": 0.9}])
+        cg.add(_SECRET_ID, _body("Y秘密"), layer="knowledge", sensitivity="private",
+               edges=[{"target": "Z结论", "relation_type": "causal",
+                       "condition": "到Z的显性条件", "confidence": 0.9}])
+        cg.add("Z结论", _body("Z结论"), layer="knowledge", sensitivity="internal")
+        # 可见-可见对照链：A内→B内（reader 应照常展开）
+        cg.add("A内", _body("A内"), layer="knowledge", sensitivity="internal",
+               edges=[{"target": "B内", "relation_type": "causal",
+                       "condition": "显性条件AB", "confidence": 0.8}])
+        cg.add("B内", _body("B内"), layer="knowledge", sensitivity="internal")
+        cg.close()
+
+        # 读者：record 角色，clearance=internal（低于 private），异会话
+        rd = Principal(actor="reader-1", role="record", can_write=True,
+                       can_admin=False, clearance="internal",
+                       layers_allow=["knowledge"], ops_allow=["read"])
+        r = MdCGSecure(root, principal=rd, master_key=bytes(range(32)))
+
+        # R0 基线：get 读隔离本就生效（旧码即过，锁语义）
+        ok(r.get(_SECRET_ID) is None, "R0 基线：reader.get(Y秘密) 隔离生效")
+
+        # R1 链展开：不可见中转节点 id + 边条件文本不得出现在链输出
+        chains = r.causal_chain("X苹果")
+        blob = repr(chains)
+        ok(_SECRET_ID not in blob,
+           "R1a causal_chain(X苹果) 输出不含不可见节点 id")
+        ok(_SECRET_COND not in blob,
+           "R1b causal_chain(X苹果) 输出不含秘密边条件文本")
+
+        # R2 不可见节点起链：应与节点不存在同形（空链）
+        ok(r.causal_chain(_SECRET_ID) == [],
+           "R2 causal_chain(Y秘密) 不可见起点返回空链")
+
+        # R3 解释面：同源 walk，渲染输出不得带秘密
+        ex = r.explain_chain("X苹果")
+        ok(_SECRET_ID not in repr(ex) and _SECRET_COND not in repr(ex),
+           "R3 explain_chain(X苹果) 渲染输出零泄漏")
+
+        # R4 因果路径：经不可见中转的路径不可达
+        cp = r.causal_path("X苹果", "Z结论")
+        ok(not cp.get("reachable") and _SECRET_ID not in repr(cp)
+           and _SECRET_COND not in repr(cp),
+           "R4 causal_path(X苹果→Z结论) 不可达且零泄漏")
+
+        # R5 检索 chain 路：provenance/chain 字段（evidence ⑤ 所指）不得携带
+        # 不可见全链。注意范围：可读节点**自身 frontmatter 的 edges 元数据**
+        # 随节点视图返回是另一回事（读者本就可读该节点的 md 原文），不在
+        # 本缺陷（链展开面）范围。prov 形态：nid → [{"path","rank",
+        # "chain"?,"conditions"?}, …]；结果 4 元组第 4 位同源。
+        res, meta = r.search_rrf("苹果", paths=("lexical", "chain"), record=False)
+        chain_fields = []
+        for entries in ((meta or {}).get("provenance") or {}).values():
+            chain_fields.extend(en for en in entries
+                                if isinstance(en, dict) and en.get("chain"))
+        for t in res:
+            if isinstance(t, tuple) and len(t) >= 4 and isinstance(t[3], list):
+                chain_fields.extend(en for en in t[3]
+                                    if isinstance(en, dict) and en.get("chain"))
+        ok(all(_SECRET_ID not in repr(en.get("chain")) for en in chain_fields),
+           "R5a search_rrf provenance 链不含不可见节点 id")
+        ok(all(_SECRET_COND not in repr(en.get("conditions"))
+               for en in chain_fields),
+           "R5b search_rrf provenance 条件不含秘密文本")
+
+        # G1 可见-可见链照常展开（闸不误伤本职语义）
+        ok(r.causal_chain("A内") != [],
+           "G1a reader 对可见链 A内→B内 照常展开")
+        ok("显性条件AB" in repr(r.causal_chain("A内")),
+           "G1b 可见边条件文本照常返回")
+
+        # G2 designer/admin 可见性不变（private 档链对设计者完整可见）
+        cg2 = MdCGSecure(root, principal=dw, master_key=bytes(range(32)))
+        dch = cg2.causal_chain("X苹果")
+        ok(any(_SECRET_ID in c.get("nodes", []) for c in dch),
+           "G2a designer causal_chain 照常含 private 节点（admin 可见性不变）")
+        ok(any(_SECRET_COND in c.get("conditions", []) for c in dch),
+           "G2b designer 照常见到边条件文本")
+        cg2.close()
+        r.close()
+    finally:
+        shutil.rmtree(tmp, ignore_errors=True)
+
+    print("\n" + "=" * 60)
+    print(f"结果：PASS {PASS} / FAIL {FAIL}")
+    if FAILS:
+        for f in FAILS:
+            print(f"  - {f}")
+    return 0 if FAIL == 0 else 1
+
+
+if __name__ == "__main__":
+    sys.exit(main())

package/md_cg/test_cond_compose_anchors.py

@@ -1,76 +1,76 @@
-# -*- coding: utf-8 -*-
-"""cond_compose 行为锚点（在途 WIP 并集解）探针：脚本式，exit code 定成败。
-
-背景：2026-09-19 收口两线时，工作区残留一处 stash-pop 冲突（md_cg/cond_compose.py）：
-  ours(HEAD)=compose 的「生效条件」注释；theirs(stash)=新增 behavior_anchors()。
-两侧新增互不重叠 → 并集解（本分支）。该函数当前**全库无调用**，故本探针只把
-「冲突解正确 + 函数行为与文档一致」钉住，配线与否由使用者裁决。
-
-用法：python -X utf8 -m md_cg.test_cond_compose_anchors
-"""
-import os
-import sys
-
-sys.path.insert(0, os.path.dirname(os.path.dirname(os.path.abspath(__file__))))
-
-from md_cg import cond_compose as cc  # noqa: E402
-
-passed = 0
-failed = 0
-
-
-def check(name, cond, detail=""):
-    global passed, failed
-    if cond:
-        passed += 1
-        print("  [PASS] " + name)
-    else:
-        failed += 1
-        print("  [FAIL] " + name + "  " + detail)
-
-
-def main():
-    # 1) 并集完整性：冲突两侧的东西都在，且文件里没有冲突标记
-    src = open(cc.__file__, encoding="utf-8").read()
-    check("并集：compose 与 behavior_anchors 同时在",
-          hasattr(cc, "compose") and hasattr(cc, "behavior_anchors"))
-    check("并集：无冲突标记", "<<<<<<<" not in src and ">>>>>>>" not in src)
-    check("并集：compose 的生效条件注释未丢", "调用 compose 时必须提供 rec" in src)
-
-    # 2) behavior_anchors 行为（按实现口径逐条断言）
-    rec = {"name": "f", "doc_head": "  计算 a 的摘要  ",
-           "guards": [{"early": True, "cond": "a"},
-                      {"early": False, "cond": "a"},
-                      {"early": True, "cond": "a and b"}],
-           "returns": ["a.strip()", "LIMIT + 1", "local_only"]}
-    doc, guards, rets = cc.behavior_anchors(rec, {"a"})
-    check("doc 取 doc_head 并去空白", doc == "计算 a 的摘要", repr(doc))
-    # explained_guards 的两道筛：early 必须为真；cond 内标识符必须全在 allowed∪BUILTINS∪self/cls
-    # （故 "a" 入选、"a and b" 因 b 不在 allowed 被剔、"a is None" 会因 is 不是 builtins 被剔）
-    check("guards 只留 early 且标识符合规者（走 explained_guards）",
-          [g.get("cond") for g in guards] == ["a"], str(guards))
-    check("returns 只留含 allowed 标识符者", rets == ["a.strip()"], str(rets))
-    _d2, _g2, rets2 = cc.behavior_anchors(rec, {"a", "LIMIT"})
-    check("allowed 含模块常量时其返回表达式入选（调用方负责传 入参∪常量）",
-          rets2 == ["a.strip()", "LIMIT + 1"], str(rets2))
-
-    # 3) 「只有形参清单、无任何行为锚点」→ 三元组全空（调用方据此可判 BLINDSPOT）
-    empty = cc.behavior_anchors({"name": "g", "guards": [], "returns": []}, {"x"})
-    check("无形为锚点时返回空三元组", empty == ("", [], []), str(empty))
-    check("缺失 doc_head/returns 键不抛异常",
-          cc.behavior_anchors({"name": "h"}, {"x"}) == ("", [], []))
-
-    # 4) 未回归：compose 仍能产出以「。」结尾的条件串
-    s = cc.compose({"name": "f", "required": ["a"], "optional": [], "externals": [],
-                    "guards": [], "returns": ["a.strip()"], "doc_head": "摘要"})
-    check("compose 未回归（非空且以「。」结尾）",
-          isinstance(s, str) and s.endswith("。") and len(s) > 4, s[:60])
-
-    print("\ntest_cond_compose_anchors: %d 通过 / %d 失败" % (passed, failed))
-    return 0 if failed == 0 else 1
-
-
-if __name__ == "__main__":
-    if hasattr(sys.stdout, "reconfigure"):
-        sys.stdout.reconfigure(encoding="utf-8")
-    sys.exit(main())
+# -*- coding: utf-8 -*-
+"""cond_compose 行为锚点（在途 WIP 并集解）探针：脚本式，exit code 定成败。
+
+背景：2026-09-19 收口两线时，工作区残留一处 stash-pop 冲突（md_cg/cond_compose.py）：
+  ours(HEAD)=compose 的「生效条件」注释；theirs(stash)=新增 behavior_anchors()。
+两侧新增互不重叠 → 并集解（本分支）。该函数当前**全库无调用**，故本探针只把
+「冲突解正确 + 函数行为与文档一致」钉住，配线与否由使用者裁决。
+
+用法：python -X utf8 -m md_cg.test_cond_compose_anchors
+"""
+import os
+import sys
+
+sys.path.insert(0, os.path.dirname(os.path.dirname(os.path.abspath(__file__))))
+
+from md_cg import cond_compose as cc  # noqa: E402
+
+passed = 0
+failed = 0
+
+
+def check(name, cond, detail=""):
+    global passed, failed
+    if cond:
+        passed += 1
+        print("  [PASS] " + name)
+    else:
+        failed += 1
+        print("  [FAIL] " + name + "  " + detail)
+
+
+def main():
+    # 1) 并集完整性：冲突两侧的东西都在，且文件里没有冲突标记
+    src = open(cc.__file__, encoding="utf-8").read()
+    check("并集：compose 与 behavior_anchors 同时在",
+          hasattr(cc, "compose") and hasattr(cc, "behavior_anchors"))
+    check("并集：无冲突标记", "<<<<<<<" not in src and ">>>>>>>" not in src)
+    check("并集：compose 的生效条件注释未丢", "调用 compose 时必须提供 rec" in src)
+
+    # 2) behavior_anchors 行为（按实现口径逐条断言）
+    rec = {"name": "f", "doc_head": "  计算 a 的摘要  ",
+           "guards": [{"early": True, "cond": "a"},
+                      {"early": False, "cond": "a"},
+                      {"early": True, "cond": "a and b"}],
+           "returns": ["a.strip()", "LIMIT + 1", "local_only"]}
+    doc, guards, rets = cc.behavior_anchors(rec, {"a"})
+    check("doc 取 doc_head 并去空白", doc == "计算 a 的摘要", repr(doc))
+    # explained_guards 的两道筛：early 必须为真；cond 内标识符必须全在 allowed∪BUILTINS∪self/cls
+    # （故 "a" 入选、"a and b" 因 b 不在 allowed 被剔、"a is None" 会因 is 不是 builtins 被剔）
+    check("guards 只留 early 且标识符合规者（走 explained_guards）",
+          [g.get("cond") for g in guards] == ["a"], str(guards))
+    check("returns 只留含 allowed 标识符者", rets == ["a.strip()"], str(rets))
+    _d2, _g2, rets2 = cc.behavior_anchors(rec, {"a", "LIMIT"})
+    check("allowed 含模块常量时其返回表达式入选（调用方负责传 入参∪常量）",
+          rets2 == ["a.strip()", "LIMIT + 1"], str(rets2))
+
+    # 3) 「只有形参清单、无任何行为锚点」→ 三元组全空（调用方据此可判 BLINDSPOT）
+    empty = cc.behavior_anchors({"name": "g", "guards": [], "returns": []}, {"x"})
+    check("无形为锚点时返回空三元组", empty == ("", [], []), str(empty))
+    check("缺失 doc_head/returns 键不抛异常",
+          cc.behavior_anchors({"name": "h"}, {"x"}) == ("", [], []))
+
+    # 4) 未回归：compose 仍能产出以「。」结尾的条件串
+    s = cc.compose({"name": "f", "required": ["a"], "optional": [], "externals": [],
+                    "guards": [], "returns": ["a.strip()"], "doc_head": "摘要"})
+    check("compose 未回归（非空且以「。」结尾）",
+          isinstance(s, str) and s.endswith("。") and len(s) > 4, s[:60])
+
+    print("\ntest_cond_compose_anchors: %d 通过 / %d 失败" % (passed, failed))
+    return 0 if failed == 0 else 1
+
+
+if __name__ == "__main__":
+    if hasattr(sys.stdout, "reconfigure"):
+        sys.stdout.reconfigure(encoding="utf-8")
+    sys.exit(main())