@furongjun1999/dsh-memory 0.4.7 → 0.4.9

package/md_cg/test_action_derive.py

@@ -0,0 +1,203 @@
+# -*- coding: utf-8 -*-
+"""test_action_derive · action 缺省静默降级防呆（与 op 推导同构）
+
+背景：`op` 传了、`action` 漏了 → 各分支按字面量默认 action 执行。若默认恰是
+读类（list / routes / stat / outlook / ping），写意图会被**静默吞掉**且返回
+形似正常的结果。最典型是文档化契约 `cg(op=review, pid, decision, reason)`
+（不带 action，见 docs/mdcg/主代理子代理记忆架构设计.md）实际静默走
+review_list —— 裁决从未落盘，属契约与实现漂移。
+
+修复（md_cg/mcp_server.py `_ACTION_SIGS` / `_action_sig` / `_cg_call`）：
+  ① 签名明确指向非默认 action → 按签名推导并补进 args（不再被默认吞掉）；
+  ② 无签名可依 → 维持默认执行，但透出 action_derived + hint_action（不再静默）；
+  ③ 判据用「键存在且非 None」——False / 0 / "" 属显式传入，避免真值判断误吞；
+  ④ `_ACTION_DEFAULT` 是「分支缺省 action 字面量」的唯一登记表，本测试含
+     **同源守卫**（表 ↔ 源码双向比对），防表与实现漂移。
+
+边界：action 仍是可选参数；推导只在「缺 action 且签名明确」时生效，显式传
+action 的行为逐位不变；`ingest` 的 path→类型推导取**保守优先**（file 最保守：
+若实为目录会报错可见，而不会误把整棵目录树摄进来）。
+"""
+import os
+import re
+import sys
+import tempfile
+
+sys.path.insert(0, os.path.dirname(os.path.dirname(os.path.abspath(__file__))))
+
+# Windows cmd 默认 GBK：带圈数字等非 GBK 字符打印即 UnicodeEncodeError，且崩在
+# 断言之后、报告之前 —— 同一测试「因环境而异」。自带 UTF-8 兜底。
+if hasattr(sys.stdout, "reconfigure"):
+    sys.stdout.reconfigure(encoding="utf-8", errors="replace")
+
+from md_cg import mcp_server as M
+from md_cg.mdcos import MdCGSecure
+from md_cg.security import DEFAULT_SENSITIVITY, Principal
+
+_ok = 0
+_fail = []
+
+
+def check(name, cond, detail=""):
+    global _ok
+    if cond:
+        _ok += 1
+        print("[PASS] " + name)
+    else:
+        _fail.append(name)
+        print("[FAIL] %s  · %s" % (name, str(detail)[:240]))
+
+
+def _p(actor="tester", session="sess_a"):
+    return Principal(actor=actor, clearance=DEFAULT_SENSITIVITY,
+                     can_write=True, can_admin=True, role="designer",
+                     session=session, harness="test-harness")
+
+
+def _raises(fn):
+    try:
+        fn()
+        return None
+    except Exception as e:                                   # noqa: BLE001
+        return e
+
+
+# ==================== A. 纯函数：签名推导 ====================
+SIG = M._action_sig
+
+check("A1 review+decision→decide（契约漂移核心）",
+      SIG({"decision": "accept"}, "review") == ("decide", "decision"))
+check("A2 review+node_id→verify_record",
+      SIG({"node_id": "n1"}, "review") == ("verify_record", "node_id"))
+check("A3 review 仅 pid 不猜（保持 list，避免误判 rounds/records）",
+      SIG({"pid": "p1"}, "review") == (None, None))
+check("A4 recent+text→add", SIG({"text": "hi"}, "recent") == ("add", "text"))
+check("A4b recent+content→add",
+      SIG({"content": "hi"}, "recent") == ("add", "content"))
+check("A5 goal+goal→add", SIG({"goal": "G"}, "goal") == ("add", "goal"))
+check("A6 predict+hit=False 仍推导（键存在即签名，非真值判断）",
+      SIG({"hit": False}, "predict") == ("feedback", "hit"))
+check("A7 predict 空参数→不猜", SIG({}, "predict") == (None, None))
+check("A8 session+summary→note",
+      SIG({"summary": "s"}, "session") == ("note", "summary"))
+check("A9 insight+statement→record",
+      SIG({"statement": "x"}, "insight") == ("record", "statement"))
+check("A10 whitebox+question→ask",
+      SIG({"question": "q"}, "whitebox") == ("ask", "question"))
+check("A10b whitebox+questions→verify_existing",
+      SIG({"questions": ["q"]}, "whitebox") == ("verify_existing", "questions"))
+check("A11 ingest+*.jsonl→jsonl",
+      SIG({"path": "a/b.jsonl"}, "ingest") == ("jsonl", "path(*.jsonl)"))
+check("A12 ingest+patterns→dir",
+      SIG({"path": "d", "patterns": ["*.md"]}, "ingest") == ("dir", "patterns"))
+check("A13 ingest 裸 path→file（保守优先，不猜 dir）",
+      SIG({"path": "d"}, "ingest") == ("file", "path"))
+check("A14 ingest 空 path→不猜", SIG({"path": "   "}, "ingest") == (None, None))
+check("A15 非推导 op 不猜", SIG({"decision": "accept"}, "link") == (None, None))
+check("A16 显式 None 不算签名",
+      SIG({"decision": None, "node_id": "n1"}, "review") == ("verify_record", "node_id"))
+
+
+# ==================== B. 同源守卫：表 ↔ 源码双向 ====================
+_MCP_SRC = open(M.__file__, encoding="utf-8", errors="replace").read()
+_WB_SRC = open(os.path.join(os.path.dirname(M.__file__), "whitebox.py"),
+               encoding="utf-8", errors="replace").read()
+# 源码中所有 `a.get("action") or "<默认>"` 形式的缺省字面量
+_pairs = set(re.findall(r'a\.get\("action"\)\s*or\s*"([a-z_]+)"', _MCP_SRC))
+# ccg 的嵌套形态：`o.get("action") or a.get("action") or "<默认>"`
+_oc = set(re.findall(r'o\.get\("action"\)\s*or\s+a\.get\("action"\)\s*or\s*"([a-z_]+)"',
+                     _MCP_SRC))
+_wb_pairs = set(re.findall(r'a\.get\("action"\)\s*or\s*"([a-z_]+)"', _WB_SRC))
+_src_vals = _pairs | _oc | _wb_pairs
+_table_vals = set(M._ACTION_DEFAULT.values())
+check("B1 源码每个缺省 action 都在 _ACTION_DEFAULT 值域内（防漏列）",
+      _src_vals <= _table_vals, sorted(_src_vals - _table_vals))
+check("B2 _ACTION_DEFAULT 每项都在源码中真实出现（防幻影表）",
+      _table_vals <= _src_vals, sorted(_table_vals - _src_vals))
+check("B3 whitebox dispatch 的缺省 action=ping 真实存在（跨文件守卫）",
+      'ping' in re.findall(r'a\.get\("action"\)\s*or\s*"([a-z_]+)"', _WB_SRC), _wb_pairs)
+# 推导规则的目标 action 必须真实存在于对应分支识别面（抽样防幻影推导）
+for _op, _acts in M._ACTION_SIGS.items():
+    _missing = [act for _, act in _acts
+                if ('"%s"' % act) not in _MCP_SRC and ('"%s"' % act) not in _WB_SRC]
+    check("B4 推导目标 action 在分支中被识别：%s" % _op, not _missing, _missing)
+
+
+# ==================== C. 端到端：不再静默吞意图 ====================
+root = tempfile.mkdtemp(prefix="mdcg_act_")
+try:
+    cg = MdCGSecure(root, principal=_p())
+
+    # C1 review 契约漂移：带 decision 但不带 action（文档化契约形态）
+    out = M._cg_call(cg, {"op": "review", "pid": "no_such_pid",
+                          "decision": "accept", "reason": "防呆测试"})
+    check("C1 review+decision 不再静默走 list（旧行为返回 pending）",
+          "pending" not in out, out)
+    check("C1b 确实进了 decide 分支（pid_not_found 属预期）",
+          out.get("error") == "pid_not_found", out)
+    check("C1c 透出 action_derived + hint_action",
+          out.get("action_derived") is True and bool(out.get("hint_action")), out)
+
+    # C2 全链路：真实提案 → 不传 action 裁决 accept → 必须真实落盘
+    pid = cg.propose("act_probe_1", "防呆测试候选内容（裁决真实落盘）",
+                     layer="knowledge")
+    out2 = M._cg_call(cg, {"op": "review", "pid": pid, "decision": "accept",
+                           "reason": "防呆测试：不带 action 的契约形态"})
+    check("C2 不带 action 的裁决真实落盘", out2.get("ok") is True, out2)
+    check("C2b 裁决后队列清空", len(cg.review_list()) == 0, cg.review_list())
+    got = cg.get("act_probe_1")
+    check("C2c 候选节点已按裁决写入", bool(got) and
+          "防呆测试候选内容" in (got.get("content") or ""), got)
+
+    # C3 recent + text 不再静默走 list（事件必须落盘）
+    out3 = M._cg_call(cg, {"op": "recent", "text": "防呆事件A"})
+    check("C3 recent+text 推导 add（旧行为返回 events 列表）",
+          "events" not in out3 and "event" in out3, out3)
+    _evs = cg.recent_events(limit=5)
+    check("C3b 事件确实写入近况窗口",
+          any("防呆事件A" in (e.get("text") or "") for e in _evs), _evs)
+    check("C3c 透出 action_derived", out3.get("action_derived") is True, out3)
+
+    # C4 goal + goal 不再静默走 list
+    out4 = M._cg_call(cg, {"op": "goal", "goal": "防呆目标G"})
+    check("C4 goal+goal 推导 add（旧行为返回 goals 列表）",
+          out4.get("ok") is True and bool(out4.get("id")), out4)
+    check("C4b 目标确实落盘",
+          any("防呆目标G" in (g.get("goal") or "") for g in cg.active_goals(limit=10)),
+          cg.active_goals(limit=10))
+
+    # C5 显式 action 零回归（推导不得覆盖显式意图）
+    out5 = M._cg_call(cg, {"op": "review", "action": "list"})
+    check("C5 显式 action=list 行为逐位不变",
+          "pending" in out5 and "action_derived" not in out5, out5)
+
+    # C6 无签名缺省：维持默认但可见（不再静默）
+    out6 = M._cg_call(cg, {"op": "review"})
+    check("C6 无签名缺省走默认 list 且透出",
+          "pending" in out6 and out6.get("action_derived") is True
+          and out6.get("action") == "list", out6)
+    check("C6b hint_action 点名默认 action 便于纠偏",
+          "list" in (out6.get("hint_action") or ""), out6)
+
+    # C7 未知 op 仍 fail-closed（不静默）
+    check("C7 未知 op fail-closed 抛错",
+          _raises(lambda: M._cg_call(cg, {"op": "not_an_op", "query": "x"})) is not None)
+
+    # C8 stg 缺 op fail-closed 且提示可操作
+    _e8 = _raises(lambda: M._stg_call(None, {"op": ""}))
+    check("C8 stg 缺 op fail-closed 且提示必填",
+          _e8 is not None and "必填" in str(_e8), _e8)
+
+    # C9 op 缺省推导仍工作（本轮不回归）
+    out9 = M._cg_call(cg, {"content": "op 推导回归探针", "layer": "knowledge"})
+    check("C9 op 缺省推导仍透出 op_derived",
+          out9.get("op_derived") is True and out9.get("op") == "write", out9)
+finally:
+    import shutil
+    shutil.rmtree(root, ignore_errors=True)
+
+print("=" * 60)
+print("action_derive：%d 通过 / %d 失败" % (_ok, len(_fail)))
+if _fail:
+    print("失败项：" + "; ".join(_fail))
+sys.exit(1 if _fail else 0)

package/md_cg/test_audit_rotate.py

@@ -0,0 +1,270 @@
+# -*- coding: utf-8 -*-
+"""审计日志分片轮转验证（治本：给无上界增长装上界）。
+
+背景（第 4 条取证，2026-09-16）：审计日志无上界增长——实测 ~2 条/s 持续写入、
+累计 ~21.5 M 条 / 4.0 GB，且单文件形态使任何「读它」的操作随运行时长线性劣化。
+上一轮把**体检读数**降为 O(1) 元数据口径（_log_scale），只让「指标与代价错配」
+不再显形；**有界性的来源是轮转**：单文件 ≤ AUDIT_ROTATE_BYTES、分片数 ≤
+AUDIT_KEEP_SHARDS ⇒ 单片读取代价与总量都有上界。
+
+断言面：
+  ① 未达阈值不轮转（不产生空转切分）
+  ② 达阈值切分：产生归档分片、活动文件被重建
+  ③ 切分无损：轮转前记录序列是轮转后序列的前缀（rename 不动字节）
+  ④ 轮转自述留痕（首条新记录 op=audit_rotate，不静默）
+  ⑤ audit_scale 聚合口径 == 全量写入条数（分片走索引 + 活动实时）
+  ⑥ audit_records 跨分片按时间序合并 / limit 取尾部
+  ⑦ 保留策略：超 keep 淘汰最旧分片且索引同步
+  ⑧ health_os 透出轮转面（shards/total_bytes/total_exact）
+  ⑨ 可关闭：ROTATE_BYTES=0 → 不切分（退回无上界，供对照/应急）
+  ⑩ 超大历史分片分档读数：exact=False 且**零全量计数**（O(n) 守卫——否则刚修好的
+     「一次调用堵死通道」会在轮转路径上原样复现）
+  ⑪ 稳态 O(1)：二次 audit_scale 不重数分片（索引缓存生效）
+  ⑫ 归档目录不在 LAYERS → 不参与节点索引
+
+运行：python -m md_cg.test_audit_rotate
+"""
+from __future__ import annotations
+
+import os
+import shutil
+import tempfile
+
+from . import mdcos as mdcos_mod
+from .mdcos import MdCGOS
+
+PASS = FAIL = 0
+FAILS = []
+
+
+def ok(cond, label):
+    global PASS, FAIL
+    if cond:
+        PASS += 1
+    else:
+        FAIL += 1
+        FAILS.append(label)
+        print(f"  FAIL {label}")
+
+
+class _Spy:
+    """记录 mdcos 模块级 count_jsonl / read_jsonl 的调用路径（O(n) 守卫）。"""
+
+    def __enter__(self):
+        self.read, self.count = [], []
+        self._read, self._count = mdcos_mod.read_jsonl, mdcos_mod.count_jsonl
+        spy = self
+
+        def _r(p, *a, **k):
+            spy.read.append(p)
+            return spy._read(p, *a, **k)
+
+        def _c(p, *a, **k):
+            spy.count.append(p)
+            return spy._count(p, *a, **k)
+
+        mdcos_mod.read_jsonl, mdcos_mod.count_jsonl = _r, _c
+        return self
+
+    def __exit__(self, *exc):
+        mdcos_mod.read_jsonl, mdcos_mod.count_jsonl = self._read, self._count
+        return False
+
+
+def _mk(tmp, name, rotate=2048, keep=8, probe=1, count_max=None):
+    root = os.path.join(tmp, name)
+    os.makedirs(root, exist_ok=True)
+    cg = MdCGOS(root)
+    cg.AUDIT_ROTATE_BYTES = rotate
+    cg.AUDIT_KEEP_SHARDS = keep
+    cg.AUDIT_PROBE_EVERY = probe
+    if count_max is not None:
+        cg.AUDIT_COUNT_MAX_BYTES = count_max
+    return cg
+
+
+def _fill(cg, n, tag="x"):
+    for i in range(n):
+        cg._audit("add", "node_%s_%d" % (tag, i), pad="z" * 160)
+
+
+def main():
+    tmp = tempfile.mkdtemp(prefix="mdcg_rotate_")
+    try:
+        # ================= A：基本轮转 + 无损 + 聚合 + 尾部读 =================
+        cg = _mk(tmp, "a", rotate=(1 << 30))       # 先给超大阈值 → 不轮转
+        _fill(cg, 20, "p")
+
+        # ---------- ① 未达阈值不轮转 ----------
+        ok(not cg._audit_shards(),
+           "①未达阈值 → 零分片（无空转切分）")
+        ok(os.path.getsize(cg.audit_log) > 0 and len(cg.audit_records()) == 20,
+           "①b活动文件承载全部记录（20 条），不提前分片")
+
+        before = [r.get("id") for r in cg.audit_records()]
+
+        # ---------- ② 达阈值切分 ----------
+        cg.AUDIT_ROTATE_BYTES = 2048
+        _fill(cg, 20, "q")
+        shards = cg._audit_shards()
+        ok(len(shards) >= 1,
+           "②达阈值 → 产生归档分片（%s）" % (shards or "无"))
+        ok(all(n.startswith("_audit.") and n.endswith(".jsonl") for n in shards),
+           "②b分片命名规范（_audit.<6位序号>.jsonl，字典序==时间序）")
+        ok(os.path.exists(cg.audit_log),
+           "②c活动文件被重建（最新记录始终在 _audit.jsonl，读尾调用方不受影响）")
+
+        # ---------- ③ 切分无损 ----------
+        after = cg.audit_records()
+        ids = [r.get("id") for r in after if r.get("op") != "audit_rotate"]
+        ok(ids[:len(before)] == before,
+           "③轮转不丢记录：轮转前序列是轮转后序列的前缀（%d→%d 条）"
+           % (len(before), len(after)))
+        ok(len(after) == len(before) + 20 + len([r for r in after
+                                                 if r.get("op") == "audit_rotate"]),
+           "③b条数守恒：轮转前 %d + 新增 20 + 自述 %d == %d"
+           % (len(before), len([r for r in after if r.get("op") == "audit_rotate"]),
+              len(after)))
+
+        # ---------- ④ 自述留痕 ----------
+        marks = [r for r in after if r.get("op") == "audit_rotate"]
+        ok(bool(marks) and marks[0].get("id") in shards,
+           "④轮转自述留痕（op=audit_rotate，id 指向分片名，不静默）")
+
+        # ---------- ⑤ 聚合口径 ----------
+        sc = cg.audit_scale()
+        ok(sc["total_events"] == len(after) and sc["total_exact"] is True,
+           "⑤audit_scale 聚合 == 全量写入条数（%s vs %d），且标注精确"
+           % (sc["total_events"], len(after)))
+        ok(sc["shards"] == len(shards) and sc["oversized"] == 0,
+           "⑤b分片计数 + 零超大分片（阈值内分片走精确计数）")
+        ok(sc["total_bytes"] == sc["bytes"] + sc["shard_bytes"],
+           "⑤c总量字节 = 活动 + 分片（%d = %d + %d）"
+           % (sc["total_bytes"], sc["bytes"], sc["shard_bytes"]))
+        ok(sc["rotate_bytes"] == 2048 and sc["keep_shards"] == 8,
+           "⑤d读数透出轮转参数（有界性可观测，不用猜配置）")
+
+        # ---------- ⑥ 跨分片合并 / limit 尾部读 ----------
+        tail = cg.audit_records(limit=3)
+        ok(len(tail) == 3 and [r.get("id") for r in tail]
+           == [r.get("id") for r in after[-3:]],
+           "⑥limit=3 取尾部 3 条（巡检不必把有界日志读成全量）")
+
+        # ---------- ⑧ health_os 透出轮转面 ----------
+        o = cg.health_os()["os"]
+        ok(o["audit_shards"] == len(shards) and o["audit_total_exact"] is True
+           and o["audit_total_bytes"] == sc["total_bytes"],
+           "⑧health_os 透出轮转面（shards/total_bytes/total_exact）")
+
+        # ---------- ⑪ 稳态 O(1)：索引缓存生效 ----------
+        # 口径：守的是「分片不被重数」（分片走索引缓存）；活动文件的精确计数是
+        # **有界**代价（size ≤ AUDIT_ROTATE_BYTES），属设计内。
+        with _Spy() as spy:
+            sc2 = cg.audit_scale()
+        ok(not any(os.path.basename(p) in shards for p in spy.count),
+           "⑪二次 audit_scale 未重数任何分片（走索引缓存）[count=%s]" % spy.count)
+        ok(sc2["total_events"] == sc["total_events"],
+           "⑪b稳态读数一致（%s == %s），缓存不改变结论"
+           % (sc2["total_events"], sc["total_events"]))
+
+        # ---------- ⑫ 归档目录不参与节点索引 ----------
+        ok(not any("_audit" in k for k in cg.index["nodes"]),
+           "⑫归档目录不在 LAYERS → 分片不参与节点索引（检索面零污染）")
+
+        cg.close()
+
+        # ================= B：保留策略（淘汰最旧分片） =================
+        cgb = _mk(tmp, "b", rotate=2048, keep=2)
+        _fill(cgb, 60, "b")
+        sb = cgb._audit_shards()
+        ok(len(sb) == 2,
+           "⑦分片数受 keep 约束（保留最近 2 片，实际 %d）" % len(sb))
+        pruned = [r for r in cgb.audit_records() if r.get("op") == "audit_rotate"
+                  and r.get("pruned")]
+        ok(bool(pruned) and len(pruned[0]["pruned"]) >= 1,
+           "⑦b淘汰非静默：pruned 名单写进审计（%s）"
+           % (pruned[0]["pruned"] if pruned else "无"))
+        idx = cgb._load_audit_index()
+        ok(all(n in idx for n in sb) and all(n in sb for n in idx),
+           "⑦c索引与磁盘分片对齐（淘汰即摘索引，不留悬空项）")
+        cgb.close()
+
+        # ================= C：可关闭（退回无上界） =================
+        cgc = _mk(tmp, "c", rotate=0)
+        _fill(cgc, 40, "c")
+        ok(not cgc._audit_shards() and os.path.getsize(cgc.audit_log) > 0,
+           "⑨ROTATE_BYTES=0 → 不切分（应急/对照可退回无上界形态）")
+        cgc.close()
+
+        # ================= D：超大历史分片分档（O(n) 守卫） =================
+        cgd = _mk(tmp, "d", rotate=2048, keep=8, count_max=512)
+        _fill(cgd, 20, "d")
+        sd = cgd._audit_shards()
+        ok(bool(sd), "⑩超大分档前置：至少产生 1 个分片（%s）" % (sd or "无"))
+        with _Spy() as spy:
+            scd = cgd.audit_scale()
+        ok(scd["oversized"] >= 1 and scd["total_exact"] is False,
+           "⑩b历史超大分片 → oversized=%d、total_exact=False（不假装精确）"
+           % scd["oversized"])
+        ok(not any(os.path.basename(p) in sd for p in spy.count),
+           "⑩c超大分片零全量计数（走 _log_scale 元数据口径）——"
+           "否则「一次调用堵死通道」会在轮转路径上复现")
+        cgd.close()
+
+        # ================= E：真实规模（~113 MB 活动文件）轮转不得全量解析 =====
+        # 这是「4.0 GB 历史日志」场景的等价缩小版：轮转必须只做 rename（O(1)），
+        # 绝不能在写路径上解析整个文件——否则刚修好的「通道被堵死」原样复现。
+        import json as _json
+        import time as _time
+
+        cge = _mk(tmp, "e", rotate=64 << 20, keep=8, probe=1)
+        line = _json.dumps({"t": 1.0, "op": "add", "id": "bulk",
+                            "pad": "z" * 200}) + "\n"
+        with open(cge.audit_log, "w", encoding="utf-8") as f:
+            for _ in range(70):                 # 70 × ~1.6 MB ≈ 113 MB
+                f.write(line * 7000)
+        size_bulk = os.path.getsize(cge.audit_log)
+        rss0 = None
+        try:
+            import psutil
+            rss0 = psutil.Process(os.getpid()).memory_info().rss
+        except Exception:                       # noqa: BLE001 —— 无 psutil 则不假装
+            pass
+        t0 = _time.time()
+        cge._audit("add", "after_bulk")         # 探测到超阈值 → 触发轮转
+        rotate_dt = _time.time() - t0
+        ok(rotate_dt < 5.0,
+           "⑬超大活动文件（%.0f MB）轮转在秒级完成（%.2fs）——rename O(1)，"
+           "写路径不解析全量" % (size_bulk / 1048576.0, rotate_dt))
+        se = cge._audit_shards()
+        idxe = cge._load_audit_index()
+        ok(len(se) == 1 and idxe[se[0]]["bytes"] == size_bulk,
+           "⑬b超大分片登记字节 == 轮转前大小（%d），内容未重写"
+           % size_bulk)
+        ok(idxe[se[0]]["exact"] is False,
+           "⑬c超大分片条数走元数据口径（exact=False，不假装精确）")
+        t1 = _time.time()
+        sce = cge.audit_scale()
+        scale_dt = _time.time() - t1
+        ok(sce["oversized"] == 1 and sce["total_bytes"] >= size_bulk,
+           "⑬d体检识别 oversized=%d、总量 %.0f MB（历史分片仍在总量核算内）"
+           % (sce["oversized"], sce["total_bytes"] / 1048576.0))
+        if rss0 is not None:
+            import psutil
+            rss_delta = psutil.Process(os.getpid()).memory_info().rss - rss0
+            ok(rss_delta < (300 << 20) and scale_dt < 2.0,
+               "⑬e轮转+体检 RSS 增量 %.0f MB < 300 MB、体检 %.2fs —— 不物化不阻塞"
+               % (rss_delta / 1048576.0, scale_dt))
+        cge.close()
+    finally:
+        shutil.rmtree(tmp, ignore_errors=True)
+
+    print(f"\naudit_rotate: {PASS} pass / {FAIL} fail")
+    if FAILS:
+        for f in FAILS:
+            print(f" - {f}")
+    raise SystemExit(1 if FAIL else 0)
+
+
+if __name__ == "__main__":
+    main()

package/md_cg/test_autonomy.py

@@ -7,6 +7,8 @@
      提案携带证据明细
   ③ 全链路：提案 → learn_blindspots 五态终判 → 留痕 _explore.jsonl
   ④ 幂等：重复 explore 终态一致、gap 回写不重复（gap_<sha1(bid)> 幂等）
+  ⑤ D_meta 排序加分：只进 sort_score 与证据，不改 score、不改资格
+     （零信号查询仍不提案；加分每轮一次、循环内复用）
 
 运行：python -m md_cg.test_autonomy
 """
@@ -103,6 +105,30 @@ def main():
                "④b gap 回写幂等（第二次 written=None，节点已存在）")
         else:
             ok(True, "④b本终态无回写动作，幂等性由判定确定性保证")
+
+        # ---------- ⑤ D_meta 排序加分（只影响排序，不改资格） ----------
+        root5 = os.path.join(tmp, "root5")
+        os.makedirs(root5, exist_ok=True)
+        cg5 = MdCGOS(root5)
+        for i in range(50):
+            append_jsonl(cg5.recent_log, {"i": i})
+        _sig(cg5, 1.0, "零信号查询", 0.0, {})
+        _sig(cg5, 2.0, "反应堆冷却方案", 0.9, {"BLINDSPOT": 2})
+        pr5 = autonomy.proposals(cg5, limit=3)
+        ps5 = pr5["proposals"]
+        ok(len(ps5) == 1 and pr5["n_signals"] == 2,
+           "⑤零信号查询仍不提案、n_signals 按原始信号计（加分不改资格）")
+        p0 = ps5[0]
+        ok(p0["score"] == round(autonomy.W_D2 * p0["d2_abs"]
+                                + autonomy.W_BLINDSPOT * p0["blindspot"]
+                                + autonomy.W_DEFER * p0["defer"], 4),
+           "⑤bscore 仍是纯 ΔD 定价（口径零变更）")
+        ok(p0["sort_score"] == round(p0["score"] + p0["d_meta_bonus"], 4)
+           and p0["d_meta_bonus"] == pr5["d_meta"]["bonus"],
+           "⑤c排序键 = ΔD + D_meta 加分（每轮一次、循环内复用）")
+        ok(p0["d_meta_bonus"] > 0 and "D_meta" in p0["reason"]
+           and "不合成" in p0["reason"],
+           "⑤d加分生效且 reason 追加证据并声明不合成（可审计）")
     finally:
         shutil.rmtree(tmp, ignore_errors=True)
 

package/md_cg/test_bench_governance.py

@@ -0,0 +1,102 @@
+# -*- coding: utf-8 -*-
+"""bench_governance 评估器断言测试：语料守卫/指标定义/确定性/输出结构。"""
+import json
+import os
+import shutil
+import tempfile
+import time
+
+from . import bench_governance as bg
+
+_FAILED = []
+
+
+def ok(cond, label):
+    if not cond:
+        print("FAIL", label)
+        _FAILED.append(label)
+    else:
+        print("pass", label)
+
+
+def main():
+    # ① 语料守卫：当前语料必须合法
+    try:
+        bg._assert_material(time.time())
+        ok(True, "① 语料守卫通过（当前语料合法）")
+    except AssertionError as exc:
+        ok(False, f"① 语料守卫意外失败：{exc}")
+
+    # ② 篡改语料必须被守卫拦截（不可答题泄漏语料词面）
+    saved = list(bg.UNANSWERABLE)
+    try:
+        bg.UNANSWERABLE.append("蜂巢心跳间隔是多少")
+        try:
+            bg._assert_material(time.time())
+            ok(False, "② 篡改语料未被拦截")
+        except AssertionError:
+            ok(True, "② 篡改语料被守卫拦截")
+    finally:
+        bg.UNANSWERABLE[:] = saved
+
+    # ③ 全流程跑通 + 指标定义断言
+    report, root = bg.run()
+    try:
+        g1 = report["g1_correction_propagation"]
+        ok(g1["value"] == 1.0, f"③a g1 完美传播=1.0（got {g1['value']}）")
+        ok(g1["detail"]["dependents"] == 4 and g1["detail"]["updated"] == 4,
+           "③b g1 依赖索引=4 且全部同步")
+
+        g2 = report["g2_contradiction_handling"]
+        ok(g2["value"] == 1.0, f"③c g2 矛盾裁决全对=1.0（got {g2['value']}，detail={g2['detail']}）")
+        ok(all(j["state"] == "REJECT" for j in g2["detail"]["judged"]),
+           "③d 否定节点定点裁决全 REJECT")
+        ok(g2["detail"]["retrieval"]["leaked_negatives"] == [],
+           "③e 检索防线 top-k 无否定节点冒充")
+
+        g3 = report["g3_expired_recall"]
+        ok(g3["value"] == 0.0, f"③f g3 validity 防线残留=0（got {g3['value']}）")
+        ok(g3["detail"]["raw"]["stale_hits"], "③g 默认面确实暴露过期节点（同题竞争成立）")
+        ok(not g3["detail"]["guard"]["stale_hits"], "③h guard 面 top-k 无过期节点")
+
+        g4 = report["g4_refusal_f1"]
+        d4 = g4["detail"]
+        ok(d4["tp"] + d4["fn"] == len(bg.UNANSWERABLE), "③i 不可答集计数守恒")
+        ok(d4["fp"] + d4["tn"] == len(bg.FACTS), "③j 可答集计数守恒")
+        ok(g4["value"] is not None and 0.0 <= g4["value"] <= 1.0,
+           f"③k g4 F1 在 [0,1]（got {g4['value']}）")
+
+        ok(report["meta"]["corpus_nodes"] >= 20, "③l 语料规模守卫")
+        ok(all(report[g]["value"] is not None for g in
+               ("g1_correction_propagation", "g2_contradiction_handling",
+                "g3_expired_recall", "g4_refusal_f1")), "③m 四指标均可计算")
+    finally:
+        shutil.rmtree(root, ignore_errors=True)
+
+    # ④ 确定性：重跑逐位一致
+    r1, root1 = bg.run()
+    r2, root2 = bg.run()
+    shutil.rmtree(root1, ignore_errors=True)
+    shutil.rmtree(root2, ignore_errors=True)
+    strip = lambda r: {g: r[g]["value"] for g in r if g.startswith("g")}  # noqa: E731
+    ok(strip(r1) == strip(r2), "④ 两次运行四指标逐位一致")
+
+    # ⑤ main 输出 JSON 可写且结构完整
+    tmp_dir = tempfile.mkdtemp(prefix="gov_out_")
+    try:
+        tmp_out = os.path.join(tmp_dir, "baseline.json")
+        rc = bg.main(["--out", tmp_out])
+        with open(tmp_out, encoding="utf-8") as f:
+            data = json.load(f)
+        ok(rc == 0 and {"meta", "g1_correction_propagation", "g2_contradiction_handling",
+                        "g3_expired_recall", "g4_refusal_f1",
+                        "baseline_reference"} <= set(data), "⑤ 输出 JSON 结构完整且 exit 0")
+    finally:
+        shutil.rmtree(tmp_dir, ignore_errors=True)
+
+    print("\nbench_governance selftest: %d failed" % len(_FAILED))
+    return 1 if _FAILED else 0
+
+
+if __name__ == "__main__":
+    raise SystemExit(main())