@furongjun1999/dsh-memory 0.5.0 → 0.5.1

package/md_cg/test_retr_score_once.py

@@ -0,0 +1,208 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+"""生产 search T2/T3 重打分守卫（v7 N51 留档复测·修复，缺陷迭代第 14 轮）。
+
+缺陷形态（缺陷报告/v9.md:111 留档，600 节点临时库实测逐位复现）：
+  生产 MdCGOS.search 的 try_stage（mdcos.py）无 scored 形参——T2/T3 均为
+  「打分截断后又对 picked 重打」：cut_by_relevance(hits, self._score(hits))
+  之后 try_stage(hits) 内部再 _score 一遍；T3 再对 picked 重打。实测无交集
+  查询 _score 恰 4 调、per-call docs=[0,0,600,500]、共打分 1100 文档——
+  500/1100≈45% 打分工作量冗余（GLOBAL_CAP=500）。基类 try_stage 早有
+  scored=None 形参（mdcg.py P2-4，批次 31，reach 分支已用）未回移生产覆写。
+
+修复口径：生产 try_stage 照基类 P2-4 模板补 scored=None 形参；T2 hits 腿
+（截断打分结果经 doc_key 键表回填）与 T3 picked 腿、reach hits_r 腿一并
+透传——同一 _score 纯函数（单次 search 内 docs/q/qb/pool_cfg 均不变），
+透传不改变任何分值与输出。
+
+本守卫（调用计数/复杂度断言形态，非时间阈值）：
+  T3 段（无交集查询，600 节点）：_score 恰 2 调、per-call [0,600]、共 600
+     文档（旧实现 4 调 [0,0,600,500]=1100 → 红）；tier/scanned/结果规模
+     不变；
+  T2 段（有交集查询）：_score 恰 1 调、共 600 文档（旧实现 2 调
+     [600,500]=1100 → 红）；
+  纯度段：对计数包装记录的每笔 (docs, scored) 复算 _score 逐位相等
+     （透传值 ≡ 现算值——不改结果的直接证据）；
+  确定性段：同查询连跑两轮结果 id 序与分值逐位一致。
+
+运行：python -m md_cg.test_retr_score_once
+"""
+import os
+import shutil
+import sys
+import tempfile
+
+sys.path.insert(0, os.path.dirname(os.path.dirname(os.path.abspath(__file__))))
+
+from md_cg.mdcos import MdCGOS              # noqa: E402
+
+PASS = 0
+FAIL = 0
+FAILS = []
+
+N = 600
+QUERY_MISS = "完全无交集查询词项甲乙丙"       # LIKE 零命中 → T3 全量兜底
+QUERY_HIT = "蜂群调度"                      # 有交集 → T2 命中
+
+
+def check(name, cond, detail=""):
+    global PASS, FAIL
+    if cond:
+        PASS += 1
+        print(f"  OK   {name}")
+    else:
+        FAIL += 1
+        FAILS.append(name)
+        print(f"  FAIL {name}  {detail}")
+
+
+def build_lib(root):
+    cg = MdCGOS(root)
+    for i in range(N):
+        cg.add("mem_%04d" % i,
+               "# 功能名：打分样本 %d\n# 正文：%s 节点 %d" % (i, QUERY_HIT, i),
+               layer="knowledge")
+    cg.flush()
+    return cg
+
+
+def count_score(cg, fn):
+    """包装实例 _score：记录每笔 (docs 数, scored)；另存 docs 引用于旁表。"""
+    calls = []            # [docs_n]
+    pairs = []            # [(docs, scored)]
+    real = MdCGOS._score
+
+    def _spy(self, docs, *a, **kw):
+        out = real(self, docs, *a, **kw)
+        calls.append(len(docs))
+        # 记录时拷贝：_emit 会对 scored 列表原地排序（记录引用会被事后变更）
+        pairs.append((list(docs), list(out)))
+        return out
+
+    cg._score = _spy.__get__(cg, MdCGOS)
+    try:
+        return fn(), calls, pairs
+    finally:
+        del cg._score                     # 还原类属性查找
+
+
+def main():
+    os.environ.pop("MDCG_READ_CACHE", None)
+    root = tempfile.mkdtemp(prefix="mdcg_score_once_")
+    cg = None
+    try:
+        cg = build_lib(root)
+        cg.search(QUERY_MISS)             # 预热（读缓存装载，非度量面）
+
+        print("== T3 无交集查询：打分恰一次/文档 ==")
+        for rep in range(2):
+            (res, meta), calls, _ = count_score(
+                cg, lambda: cg.search(QUERY_MISS))
+            check("T3a rep%d _score 调用数 == 2（旧 4）" % rep,
+                  len(calls) == 2, f"calls={calls}")
+            check("T3b rep%d per-call docs == [0, 600]（旧 [0,0,600,500]）" % rep,
+                  calls == [0, 600], f"calls={calls}")
+            check("T3c rep%d 共打分 600 文档（旧 1100，省 45）" % rep,
+                  sum(calls) == 600, f"total={sum(calls)}")
+            check("T3d rep%d tier/scanned/结果规模不变" % rep,
+                  meta.get("tier") == "T3_global_scan"
+                  and meta.get("scanned") == N and len(res) == 20,
+                  f"tier={meta.get('tier')} scanned={meta.get('scanned')} "
+                  f"n={len(res)}")
+
+        print("== T2 有交集查询：打分恰一次/文档 ==")
+        for rep in range(2):
+            (res, meta), calls, _ = count_score(
+                cg, lambda: cg.search(QUERY_HIT))
+            check("T2a rep%d _score 调用数 == 1（旧 2）" % rep,
+                  len(calls) == 1, f"calls={calls}")
+            check("T2b rep%d 共打分 600 文档（旧 1100）" % rep,
+                  calls == [600], f"calls={calls}")
+            check("T2c rep%d tier 不变（T2_global_like）" % rep,
+                  meta.get("tier") == "T2_global_like",
+                  f"tier={meta.get('tier')}")
+
+        print("== 纯度：透传 scored ≡ 现算 _score（不改结果的直接证据）==")
+        (res, meta), calls, pairs = count_score(
+            cg, lambda: cg.search(QUERY_MISS))
+        # 与 search 同口径重建 q/qb（mdcos.py:751-773 的打分输入）
+        from md_cg.mdcg import bigrams, normalize_en, en_zh_bigrams
+        from md_cg.semantic.unify import unify_query
+        q_p = unify_query(QUERY_MISS)
+        qb_p = bigrams(normalize_en(q_p)) | en_zh_bigrams(q_p)
+        pure = True
+        for i, (docs, scored) in enumerate(pairs):
+            again = MdCGOS._score(cg, docs, q_p, qb_p, None)
+            if again != scored:
+                pure = False
+                print(f"    第{i}笔复算不一致: {len(docs)} docs")
+        check("P1a 每笔 (docs→scored) 复算逐位相等（_score 纯函数）", pure)
+
+        print("== 确定性：同查询两轮结果逐位一致 ==")
+        r1, m1 = cg.search(QUERY_MISS)
+        r2, m2 = cg.search(QUERY_MISS)
+        ids1 = [(x[0].get("id"), round(x[1], 12)) for x in r1]
+        ids2 = [(x[0].get("id"), round(x[1], 12)) for x in r2]
+        check("D1a 两轮结果 id 序与分值逐位一致", ids1 == ids2,
+              f"n={len(ids1)}/{len(ids2)}")
+        rh1, _ = cg.search(QUERY_HIT)
+        rh2, _ = cg.search(QUERY_HIT)
+        check("D1b T2 路径两轮结果逐位一致",
+              [(x[0].get("id"), round(x[1], 12)) for x in rh1]
+              == [(x[0].get("id"), round(x[1], 12)) for x in rh2])
+
+        print("== reach 腿（MDCG_REACH=1）：P2-4 模板形态修复 ==")
+        # 相邻缺陷（本轮 stash 取证）：基类 reach 分支旧 _smap 模板对 scored
+        # 的 card dict 调 pooling.doc_key（形参须 (entry,fm,content) 三元组）
+        # → MDCG_REACH=1 + 命中集非空即 KeyError: 1（HEAD 原生在位）。
+        from md_cg.mdcg import MdCG
+        os.environ["MDCG_REACH"] = "1"
+        try:
+            root2 = tempfile.mkdtemp(prefix="mdcg_score_reach_")
+            cg2 = MdCGOS(root2)
+            for i in range(30):
+                cg2.add("rm_%03d" % i,
+                        "# 功能名：reach 样本\n# 正文：%s 节点 %d" % (QUERY_HIT, i),
+                        layer="knowledge")
+            cg2.flush()
+            try:
+                (res_r, meta_r), calls_r, _ = count_score(
+                    cg2, lambda: cg2.search(QUERY_HIT))
+                check("R1a 生产 reach 腿不再 KeyError（HEAD 实测崩）且有结果",
+                      len(res_r) >= 1, f"n={len(res_r)} tier={meta_r.get('tier')}")
+                check("R1b 生产 reach 腿打分 ≤ 2 调（透传无重打）",
+                      len(calls_r) <= 2, f"calls={calls_r}")
+            finally:
+                cg2.close()
+                shutil.rmtree(root2, ignore_errors=True)
+            root3 = tempfile.mkdtemp(prefix="mdcg_score_reachb_")
+            cg3 = MdCG(root3)
+            for i in range(30):
+                cg3.add("bm_%03d" % i,
+                        "# 功能名：reach 样本\n# 正文：%s 节点 %d" % (QUERY_HIT, i),
+                        layer="knowledge")
+            cg3.flush()
+            try:
+                res_b, meta_b = cg3.search(QUERY_HIT)
+                check("R2a 基类 reach 分支不再 KeyError（stash 取证 HEAD 崩）",
+                      len(res_b) >= 1, f"n={len(res_b)} tier={meta_b.get('tier')}")
+            finally:
+                cg3.close()
+                shutil.rmtree(root3, ignore_errors=True)
+        finally:
+            os.environ.pop("MDCG_REACH", None)
+        cg.close()
+    finally:
+        os.environ.pop("MDCG_READ_CACHE", None)
+        shutil.rmtree(root, 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_review_onepass.py

@@ -0,0 +1,170 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+"""review 治理面单次调用复用一次解析守卫（issue：同一 jsonl 单调用内重复全量读）。
+
+缺陷形态（缺陷报告实测 + 当前代码复核）：review_stats 链路每次全量读
+decisions 1 遍（by_decision 统计）+ review_list 全量读 inbox 1 遍；
+review_decide 线性扫 inbox 找 pid + _cascade_dedup 再全量读 inbox 一遍；
+verify_review_record 无 pid 索引线性扫全量 decisions 找单条——解析量随
+M/D 线性放大（M=D=4000 实测 review_stats 15.97ms / decide 21.31ms /
+verify 28.92ms）。
+
+本守卫断言（调用计数/对账形态，非时间阈值）：
+  R1 稳态 review_stats 零全量读：预热装载后 read_jsonl 调用 == 0
+     （旧代码每次 decisions+inbox 各 1 次 → 红）；
+  R2 稳态 review_decide(reject) 零全量读：同上（旧代码 inbox 2 次 → 红）；
+  R3 稳态 verify_review_record 零全量读：同上（旧代码 decisions 1 次 → 红）；
+  R4 增量不漏账：外部（他进程形态）append 新裁决/新提案后，统计口径与
+     队列视图立即可见；
+  R5 语义对账：review_stats 的 records/by_decision/pending/closed 与
+     手工全量直读的独立口径逐项一致（缓存不改变结果，只改变速度）。
+"""
+import os
+import shutil
+import sys
+import tempfile
+
+sys.path.insert(0, os.path.dirname(os.path.dirname(os.path.abspath(__file__))))
+
+import md_cg.mdcos as mdcos_mod               # noqa: E402
+from md_cg.fsutil import append_jsonl, read_jsonl as fs_read_jsonl  # noqa: E402
+from md_cg.mdcos import MdCGOS, _sig          # noqa: E402
+
+PASS = 0
+FAIL = 0
+FAILS = []
+
+
+def check(name, cond, detail=""):
+    global PASS, FAIL
+    if cond:
+        PASS += 1
+        print(f"  OK   {name}")
+    else:
+        FAIL += 1
+        FAILS.append(name)
+        print(f"  FAIL {name}  {detail}")
+
+
+def count_full_reads(fn):
+    n = 0
+    real = mdcos_mod.read_jsonl
+
+    def _spy(path, *a, **kw):
+        nonlocal n
+        n += 1
+        return real(path, *a, **kw)
+
+    mdcos_mod.read_jsonl = _spy
+    try:
+        return fn(), n
+    finally:
+        mdcos_mod.read_jsonl = real
+
+
+def build(root, m=8, d=5):
+    cg = MdCGOS(root)
+    for i in range(m):
+        c = "存量提案 %d 蜂群调度 %d" % (i, i)
+        append_jsonl(cg.inbox_log,
+                     {"t": 1.0, "pid": "prop_g%03d" % i, "id": "n%03d" % i,
+                      "content": c, "layer": "knowledge", "tags": [],
+                      "condition_space": {}, "verify": {},
+                      "payload_hash": _sig(c), "actor": "g"})
+    for j in range(d):
+        append_jsonl(cg.decisions_log,
+                     {"t": 1.0, "pid": "prop_g%03d" % j, "decision": "accept",
+                      "status": "accepted", "round": 1, "actor": "g"})
+    return cg
+
+
+def main():
+    root = tempfile.mkdtemp(prefix="mdcg_review_guard_")
+    try:
+        cg = build(root)
+        cg.review_stats()                       # 预热装载（不计数）
+
+        # R1 稳态 review_stats 零全量读
+        print("== R1 稳态 review_stats 零全量读 ==")
+        st1, n1 = count_full_reads(lambda: cg.review_stats())
+        check("R1a 预热后 review_stats 全量 read_jsonl==0（旧每次 2 次）",
+              n1 == 0, f"full_reads={n1}")
+        check("R1b 统计口径 sane（records≥d、pending≥1）",
+              st1["records"] >= 5 and st1["pending"] >= 1, str(st1)[:100])
+
+        # R2 稳态 review_decide(reject) 零全量读
+        print("== R2 稳态 review_decide(reject) 零全量读 ==")
+        def _decide():
+            _decide.i += 1
+            pid = cg.propose("c1", "纯 pending 候选 星云编译 %d" % _decide.i)
+            return cg.review_decide(pid, "reject", reason="g")
+        _decide.i = 0
+        _decide()                                # 预热：装载 phash 索引 +
+        out2, n2 = count_full_reads(_decide)     # decisions 创建后的 pid 状态缓存
+        check("R2a decide(reject) 全量 read_jsonl==0（旧 inbox 2 次；"
+              "首装装载属预期不在此窗）",
+              n2 == 0, f"full_reads={n2}")
+        check("R2b 裁决 ok", out2.get("ok"), str(out2)[:80])
+
+        # R3 稳态 verify_review_record 零全量读
+        print("== R3 稳态 verify_review_record 零全量读 ==")
+        def _verify():
+            _verify.i += 1
+            pid = cg.propose("c2", "复核候选 信任聚合 %d" % _verify.i)
+            out = cg.review_decide(pid, "accept", reason="g")
+            assert out.get("ok"), out
+            return cg.verify_review_record(out["record_node_id"])
+        _verify.i = 0
+        _verify()                                # 预热同上
+        ok3, n3 = count_full_reads(_verify)
+        check("R3a verify 链路全量 read_jsonl==0（旧 decisions 1 次扫全量找单条）",
+              n3 == 0, f"full_reads={n3}")
+        check("R3b 复核通过", ok3.get("ok") is True, str(ok3)[:80])
+
+        # R4 增量不漏账：他进程形态 append
+        print("== R4 跨进程 append 增量并入 ==")
+        append_jsonl(cg.inbox_log,
+                     {"t": 2.0, "pid": "prop_ext_x", "id": "nx",
+                      "content": "外部新提案 水位信箱", "layer": "knowledge",
+                      "tags": [], "condition_space": {}, "verify": {},
+                      "payload_hash": _sig("外部新提案 水位信箱"),
+                      "actor": "ext"})
+        append_jsonl(cg.decisions_log,
+                     {"t": 2.0, "pid": "prop_ext_x", "decision": "noop",
+                      "status": "noop", "round": 1, "actor": "ext"})
+        st4 = cg.review_stats()
+        check("R4a 外部新裁决进统计（by_decision.noop=1）",
+              st4["by_decision"].get("noop") == 1, str(st4["by_decision"]))
+        pend_ids = [r.get("pid") for r in cg.review_list()]
+        check("R4b 外部新裁决立即可见（prop_ext_x 已关闭，不在 pending）",
+              "prop_ext_x" not in pend_ids, f"pending={pend_ids}")
+
+        # R5 语义对账：与独立全量直读口径逐项一致
+        print("== R5 统计口径独立对账 ==")
+        by = {}
+        for r in fs_read_jsonl(cg.decisions_log):
+            d_ = str(r.get("decision") or "").strip() or "unknown"
+            by[d_] = by.get(d_, 0) + 1
+        n_pid = len({r.get("pid") for r in fs_read_jsonl(cg.decisions_log)
+                     if r.get("pid")})
+        st5 = cg.review_stats()
+        check("R5a records/by_decision 与独立直读一致",
+              st5["records"] == sum(by.values())
+              and st5["by_decision"] == by,
+              f"got={st5['by_decision']} want={by}")
+        check("R5b proposals 与独立直读 pid 数一致",
+              st5["proposals"] == n_pid,
+              f"got={st5['proposals']} want={n_pid}")
+    finally:
+        shutil.rmtree(root, 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_rrf_graph_seed_cache.py

@@ -0,0 +1,154 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+"""search_rrf 图路种子读缓存守卫（v9:92 / v13 留档复测·修复，第 14 轮）。
+
+缺陷形态（缺陷报告实测，40 带 tags/edges 节点临时库，逐位复现）：
+  _path_graph 种子腿 mdcos.py `node = self.get(n["id"])` 在边循环前执行——
+  get 裸 open+nodefile.loads（mdcg.py get 不在 readcache 包装面，install 只包
+  cg._read），search_rrf 默认 paths 含 graph → 每查询固定 ≤5 次盘读
+  （Q1 loads=45=词法 40+种子 5；Q2 增量恰 5、get 恒 5/查；graph 零产出也
+  在边循环前发生）。边目标（:1017）早已走 self._read 同形。
+
+修复口径：种子读改走 self._read(by_id[...])（读缓存覆盖，Q2 增量归零）；
+种子 fm.id≠文件名等 by_id 不含形态回落 get 保旧口径（冷路径，正确性优先）。
+种子来自 lexical（entries/_candidates 派生，MdCGSecure._candidates 已过
+_readable）——绕过 get 的读隔离门无损失；图路扩展产物本就由
+MdCGSecure.search_rrf 终态二次过滤兜底。
+
+本守卫（调用计数断言形态，非时间阈值）：
+  S1 热缓存后同查询 loads 增量 == 0（旧实现恒 5 → 红）；
+  S2 热缓存后同查询 get 调用 == 0（旧实现恒 5 → 红）；
+  S3 图路功能在位：词法零命中的「幽灵」节点经种子边一跳进入结果
+     （graph 路不是被静默关掉）；
+  S4 两轮查询结果 ids 逐位一致（确定性）；meta.paths 含四路计数；
+  S5 开/关读缓存（MDCG_READ_CACHE=1 vs 0）同库同查询 ids 逐位一致
+     （缓存只改速度不改结果）。
+
+运行：python -m md_cg.test_rrf_graph_seed_cache
+"""
+import os
+import shutil
+import sys
+import tempfile
+
+sys.path.insert(0, os.path.dirname(os.path.dirname(os.path.abspath(__file__))))
+
+from md_cg import nodefile                     # noqa: E402
+from md_cg.mdcos import MdCGOS                 # noqa: E402
+
+PASS = 0
+FAIL = 0
+FAILS = []
+
+QUERY = "蜂群调度"
+
+
+def check(name, cond, detail=""):
+    global PASS, FAIL
+    if cond:
+        PASS += 1
+        print(f"  OK   {name}")
+    else:
+        FAIL += 1
+        FAILS.append(name)
+        print(f"  FAIL {name}  {detail}")
+
+
+def build_lib(root, n=40):
+    cg = MdCGOS(root)
+    for i in range(n):
+        edges = []
+        if i % 4 == 0:                 # 部分节点带边（指向池内目标）
+            edges = [{"target": "mem_%03d" % ((i + 1) % n),
+                      "relation_type": "related_to"}]
+        if i == 0:
+            # 幽灵目标：词法零命中（正文无查询词），只经种子边一跳可达
+            edges.append({"target": "ghost_x", "relation_type": "related_to"})
+        cg.add("mem_%03d" % i,
+               "# 功能名：图路样本 %d\n# 正文：%s 节点 %d" % (i, QUERY, i),
+               layer="knowledge",
+               tags=["tag_%d" % (i % 5)] if i % 3 == 0 else None,
+               edges=edges)
+    cg.add("ghost_x", "# 功能名：幽灵目标\n# 正文：完全不相关的孤岛内容",
+           layer="knowledge")
+    cg.flush()
+    return cg
+
+
+def counters(cg, fn):
+    """同时计数 nodefile.loads 与实例 get。"""
+    st = {"loads": 0, "gets": 0}
+    real_loads = nodefile.loads
+    real_get = MdCGOS.get
+
+    def _spy_loads(*a, **kw):
+        st["loads"] += 1
+        return real_loads(*a, **kw)
+
+    def _spy_get(self, node_id):
+        st["gets"] += 1
+        return real_get(self, node_id)
+
+    nodefile.loads = _spy_loads
+    cg.get = _spy_get.__get__(cg, MdCGOS)
+    try:
+        return fn(), st
+    finally:
+        nodefile.loads = real_loads
+        del cg.get
+
+
+def main():
+    root = tempfile.mkdtemp(prefix="mdcg_rrf_seed_")
+    cg = None
+    try:
+        os.environ.pop("MDCG_READ_CACHE", None)
+        cg = build_lib(root)
+        (r1, m1), c1 = counters(cg, lambda: cg.search_rrf(QUERY))
+        ids1 = [x[0].get("id") for x in r1]
+        check("S0a 首查正常（40+1 节点池，词法+图路融合）",
+              len(r1) >= 1 and c1["loads"] > 0,
+              f"n={len(r1)} loads={c1['loads']}")
+
+        (r2, m2), c2 = counters(cg, lambda: cg.search_rrf(QUERY))
+        ids2 = [x[0].get("id") for x in r2]
+        check("S1a 热缓存后同查询 loads 增量 == 0（旧实现恒 5）",
+              c2["loads"] == 0, f"loads={c2['loads']}")
+        check("S2a 热缓存后同查询 get 调用 == 0（旧实现恒 5，种子改走 _read）",
+              c2["gets"] == 0, f"gets={c2['gets']}")
+        check("S3a 图路功能在位：词法零命中的 ghost 经种子边一跳进入结果",
+              "ghost_x" in ids1, f"ghost in={('ghost_x' in ids1)}")
+        paths_meta = (m2.get("paths") or {})
+        check("S3b meta.paths 四路计数在位（graph 未被静默关掉）",
+              {"lexical", "graph"} <= set(paths_meta),
+              f"paths={paths_meta}")
+        check("S4a 两轮查询结果 ids 逐位一致", ids1 == ids2,
+              f"n={len(ids1)}/{len(ids2)}")
+
+        # S5 开/关读缓存结果一致（新实例同库同查询）
+        r_on = ids2
+        os.environ["MDCG_READ_CACHE"] = "0"
+        try:
+            cg0 = MdCGOS(root)
+            r_off, _ = cg0.search_rrf(QUERY)
+            cg0.close()
+            check("S5a 读缓存开/关同库同查询 ids 逐位一致",
+                  [x[0].get("id") for x in r_off] == r_on,
+                  f"off={[x[0].get('id') for x in r_off][:5]}")
+        finally:
+            os.environ.pop("MDCG_READ_CACHE", None)
+        cg.close()
+    finally:
+        os.environ.pop("MDCG_READ_CACHE", None)
+        shutil.rmtree(root, 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_security_audit.py

@@ -0,0 +1,155 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+"""安全审计修复守卫（批次 24，外部审查报告 P0-1/P1-1/P2-1/P1-8）。
+
+P0-1：node_id 是模型可控输入、直接拼落盘路径——`..` 穿越出 root、
+Windows 绝对路径（os.path.join 丢弃前缀）= 任意 .md 覆盖。修复 = 白名单
++ realpath 纵深闸。守卫断言（能红修复前实现）：
+  - 穿越/绝对路径/超长/空 id 必 ValueError；
+  - 合法 id（存量形态）照常写入。
+P1-1：mdcg_* 工具此前完全绕过 ops_allow 白名单——只读令牌可经
+mdcg_remember 写入。守卫断言（能红修复前实现）：
+  - ops_allow=["read"] 的 principal 调 mdcg_remember 必 AccessDenied；
+  - ops_allow=None（不限）令牌照常放行（兼容性）；
+  - 读工具在 read 令牌下放行。
+P1-8：tarfile filter="data"（静态断言 + import 回归）。
+"""
+import os
+import sys
+import tempfile
+
+sys.path.insert(0, os.path.dirname(os.path.dirname(os.path.abspath(__file__))))
+
+PASS = 0
+FAIL = 0
+FAILS = []
+
+
+def check(name, cond, detail=""):
+    global PASS, FAIL
+    if cond:
+        PASS += 1
+        print(f"  OK   {name}")
+    else:
+        FAIL += 1
+        FAILS.append(name)
+        print(f"  FAIL {name}  {detail}")
+
+
+def main():
+    from md_cg.mdcg import _NODE_ID_RE
+    from md_cg.mdcos import MdCGSecure
+    from md_cg.mcp_server import _dispatch, _MDCG_OP_REQUIRE
+
+    root = tempfile.mkdtemp(prefix="mdcg_secaudit_")
+    # 生产形态（MdCGSecure——mdcg_search 分支走 OS 层签名，基类 MdCG 无
+    # roles 参数；P1-1c 因此必须用安全实例而非基类）
+    cg = MdCGSecure(root)
+
+    print("== P0-1 node_id 白名单 + realpath 纵深闸 ==")
+    bad_ids = [
+        (".. 穿越", "../evil"),
+        ("多层穿越", "sub/../../../evil"),
+        ("Windows 绝对路径", "C:/Users/test/evil"),
+        ("类 Unix 绝对路径", "/etc/evil"),
+        ("隐式 ..", "a/../b..c"),
+        ("空 id", ""),
+        ("超长 id", "a" * 129),
+    ]
+    for label, nid in bad_ids:
+        try:
+            cg.add(nid, "# 功能名：x\n# 正文：y", layer="knowledge")
+            check(f"P0-1 拒绝 {label}", False, "未抛异常且写入成功")
+        except ValueError:
+            check(f"P0-1 拒绝 {label}", True)
+        except Exception as e:  # noqa: BLE001
+            check(f"P0-1 拒绝 {label}", False, f"异常类型错误: {type(e).__name__}: {e}")
+
+    ok_ids = ["mem_1790156428627", "n00001", "mde_abcdef123456",
+              "uuid-4f2b-9c.a-d", "a" * 128]
+    ok = True
+    for i, nid in enumerate(ok_ids):
+        try:
+            cg.add(nid, f"# 功能名：合法 {i}\n# 正文：白名单内存活样本 {i}",
+                   layer="knowledge")
+        except Exception as e:  # noqa: BLE001
+            ok = False
+            check(f"P0-1 合法 id {nid[:16]}… 照常写入", False,
+                  f"{type(e).__name__}: {e}")
+    check("P0-1 合法 id（存量 5 形态）照常写入", ok and _NODE_ID_RE.match("mem_1"))
+
+    print("== P1-1 mdcg_* op 闸（能红无闸实现）==")
+    from md_cg.security import Principal
+
+    def principal_with(ops):
+        return Principal(actor="auditor", clearance="secret",
+                         can_write=True, role="recorder", auth_mode="test",
+                         ops_allow=ops)
+
+    # 只读令牌：mdcg_remember 必拒（能红：修复前无闸直接写入）
+    cg.principal = principal_with(["read"])
+    try:
+        _dispatch(cg, "mdcg_remember", {"content": "# 功能名：越权\n# 正文：x",
+                                        "layer": "contextual"})
+        check("P1-1a 只读令牌 mdcg_remember 必拒", False, "未抛 AccessDenied")
+    except Exception as e:  # noqa: BLE001
+        check("P1-1a 只读令牌 mdcg_remember 必拒（AccessDenied）",
+              type(e).__name__ == "AccessDenied",
+              f"{type(e).__name__}: {e}")
+
+    # ops_allow=None（不限）令牌：放行（兼容性——存量直构形态零影响；
+    # _in_scope(None)=True 是「未声明=不限制」的既有语义）
+    saved = cg.principal
+    cg.principal = principal_with(None)
+    try:
+        res = _dispatch(cg, "mdcg_remember",
+                        {"content": "# 功能名：兼容\n# 正文：不限令牌照常",
+                         "layer": "contextual"})
+        check("P1-1b ops_allow=None（不限）令牌照常放行", True)
+    except Exception as e:  # noqa: BLE001
+        check("P1-1b ops_allow=None（不限）令牌照常放行", False,
+              f"{type(e).__name__}: {e}")
+    finally:
+        cg.principal = saved
+
+    # 读令牌：读工具放行
+    cg.principal = principal_with(["read"])
+    try:
+        res = _dispatch(cg, "mdcg_search", {"query": "星云"})
+        check("P1-1c 读令牌读工具放行", not isinstance(res, dict) or not res.get("error"),
+              str(res)[:120])
+    except Exception as e:  # noqa: BLE001
+        check("P1-1c 读令牌读工具放行", False, f"{type(e).__name__}: {e}")
+    cg.principal = None
+
+    # 映射完备性：mdcg_* 全部注册工具都被映射覆盖（防未来新增工具漏闸）
+    from md_cg import mcp_server as ms
+    import re as _re
+    src = open(os.path.join(os.path.dirname(os.path.abspath(__file__)),
+                            "mcp_server.py"), encoding="utf-8").read()
+    registered = set(_re.findall(r'"name": "(mdcg_[a-z_]+)"', src))
+    uncovered = sorted(registered - set(_MDCG_OP_REQUIRE) - {"mdcg_service_info"})
+    check("P1-1d mdcg_* 注册工具全覆盖（除自描述 service_info）",
+          not uncovered, f"uncovered={uncovered}")
+
+    print("== P1-8 tarfile filter ==")
+    src_cf = open(os.path.join(os.path.dirname(os.path.dirname(
+        os.path.abspath(__file__))), "scripts", "criteria_fingerprint.py"),
+        encoding="utf-8").read()
+    check("P1-8 extractall 显式 filter=\"data\"", 'extractall(tmp, filter="data")'
+          in src_cf)
+
+    # 清理
+    import shutil
+    shutil.rmtree(root, 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())