@furongjun1999/dsh-memory 0.4.9 → 0.4.11

package/md_cg/test_mr_m1.py

@@ -1,769 +0,0 @@
-# -*- coding: utf-8 -*-
-"""M1 机械层自测：候选生成 → 捆绑 → 规则装配（确定性、零写入）。
-
-真源：docs/记忆评审系统_立项设计与施工交接_20260915.md §3 前三级 / §5 D3 / §6。
-纪律（吸取 test_p27【9】教训）：**自备数据源**——主测面 = tempfile 合成库；
-真源库仅在**存在时**做集成复核（不存在即 SKIP，外部 clone 下同样全绿）。
-
-覆盖：A 级1 四源/分源开关/同口径交叉核对/轮巡不重不漏/确定性
-      B 级2 模板一包一评/包号确定性/降级/正文回读/切分/血缘/主题
-      C 级3 规则库加载与非法库 fail-closed/matcher 语义/六检查器/数据化零代码改动
-      D CLI run/--out/--full/零写入   E 集成:真源存在才跑（审计基线口径）
-
-运行：python -m md_cg.test_mr_m1
-"""
-from __future__ import annotations
-
-import collections
-import hashlib
-import io
-import json
-import os
-import sys
-import tempfile
-import shutil
-from contextlib import redirect_stdout
-
-from . import conformance as CF
-from .mreview import __main__ as CLI
-from .mreview import bundle as BD
-from .mreview import candidates as CD
-from .mreview import ruleset as RS
-
-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}")
-
-
-# ---------------------------- 合成库 ----------------------------
-
-def node(nid, layer="knowledge", **kw):
-    rec = {"id": nid, "layer": layer, "path": f"{layer}/{nid}.md",
-           "content": f"内容 {nid}", "content_hash": f"hash_{nid}", "tags": []}
-    rec.update(kw)
-    return rec
-
-
-def mkroot(root, nodes, *, access=(), inbox=(), decisions=(), forgetting=(),
-           contents=None, write_files=True):
-    """合成认知图根：索引 + 闸门三日志 + 节点盘文件。"""
-    os.makedirs(root, exist_ok=True)
-    with open(os.path.join(root, "_index.json"), "w", encoding="utf-8") as f:
-        json.dump({"nodes": nodes}, f, ensure_ascii=False)
-    hp = os.path.join(root, "hippocampus")
-    os.makedirs(hp, exist_ok=True)
-    for name, rows in (("inbox.jsonl", inbox), ("decisions.jsonl", decisions)):
-        with open(os.path.join(hp, name), "w", encoding="utf-8") as f:
-            for r in rows:
-                f.write(json.dumps(r, ensure_ascii=False) + "\n")
-    with open(os.path.join(root, CF.ACCESS_LOG), "w", encoding="utf-8") as f:
-        for r in access:
-            f.write(json.dumps(r, ensure_ascii=False) + "\n")
-    with open(os.path.join(root, CD.FORGET_LOG), "w", encoding="utf-8") as f:
-        for r in forgetting:
-            f.write(json.dumps(r, ensure_ascii=False) + "\n")
-    if write_files:
-        for r in nodes.values():
-            if not r.get("path"):
-                continue
-            p = os.path.join(root, r["path"])
-            os.makedirs(os.path.dirname(p), exist_ok=True)
-            with open(p, "w", encoding="utf-8") as f:
-                f.write((contents or {}).get(r["id"], r.get("content", "")))
-    return root
-
-
-# 运行态目录：由常驻进程（MCP server 等）按自身节拍 flush 增量日志，与 M1 无关。
-# 取证（第4条）：静置 6s 真源无变化，跑 M1 前后 _index_log/ 无新文件、逐字节不变；
-# 目录内文件名带写入者 pid（14916/16072/20184/6708），非本进程 pid。
-VOLATILE_DIRS = ("_index_log",)
-
-# 运行态文件（2026-09-16 取证补充）：真源被多 harness 共享时，外部写入者按自身
-# 节拍追加审计/重建引用索引。取证：真源 `_audit.jsonl` 尾部 actor="zcode"
-# （session=sess_775ac68e480e）连续 add code_*/cond_* —— 并发跑套件期间静置
-# 60s 无变化、非常驻写者，写入随外部 agent 活动发生。E10 若把它们计入指纹，
-# 断言对象就变成「全环境静置」而非「本进程零写入」→ 误报。故显式排除，
-# 并以 E10b/E10c（本进程 pid 与 actor 归因）承担「本进程零写入」的可裁决性。
-VOLATILE_FILES = ("_audit.jsonl", "_refindex.json")
-#
-# 运行态面扩充（2026-09-19 取证，第4条）：`VOLATILE_FILES` 只列了审计/引用索引，
-# 漏了同属常驻进程节拍面的状态留痕，致 E10 的降级判据失效——取证：跑 M1 期间
-# `_crypto.jsonl`（crypto.AUDIT_FILE，尾部 actor="codebuddy" 的 open_failed）与
-# `_sustain.jsonl`（sustain.SUSTAIN_LOG，尾部 op="heal"/action="flush_index"/
-# pid=24788）mtime 与 `_audit.jsonl` 同为 20:31:28~30（同秒改写），且**审计行数
-# 未增**（仅内容刷新）→ 「审计新增行」不足以判定外部写入，须以指纹面为准。
-RUN_STATE_FILES = ("_audit.jsonl", "_refindex.json", "_crypto.jsonl",
-                   "_sustain.jsonl")
-
-#: M1 侧可能出现的审计 actor（CLI/管线）。当前 M1 为纯读链路（generate→bundle→
-#: assemble 零写入），故预期新增行恒为空；留作「若将来引入写入」的兜底归因面。
-_M1_ACTORS = ("mreview", "m1", "cli", "test_mr_m1")
-
-
-def _run_state_probe(root):
-    """易变面指纹——「本次运行期间外部写入是否发生」的直接证据。
-
-    与 `snapshot(exclude_files=VOLATILE_FILES)` 互补：这里**只取**运行态面
-    （常驻进程按节拍 flush 的心跳/审计/加密留痕），逐文件 md5；两时刻差异
-    非空即外部写入存在。取证见 RUN_STATE_FILES 上方（同秒改写但审计行数未增）。
-    """
-    out = {}
-    for fn in RUN_STATE_FILES:
-        try:
-            with open(os.path.join(root, fn), "rb") as f:
-                out[fn] = hashlib.md5(f.read()).hexdigest()
-        except OSError:
-            continue
-    return out
-
-
-def _run_state_diff(before, after):
-    return sorted(k for k in set(before) | set(after)
-                  if before.get(k) != after.get(k))
-
-
-def _external_actors(root, tail=200):
-    """环境级「外部写入者存在」证据——与本次观测窗口无关。
-
-    E10 原判据（仅「本次窗口内运行态面变更」）实测**不稳定**：外部写入按心跳
-    节拍间歇发生，是否落在观测窗口内是运气——2026-09-19 实测同一条命令连跑两次，
-    一次 `external` 非空（E10 降级）、一次为空（E10 走断言且恰好通过），而
-    E11 的偏离两次都在。故补环境级判据：审计尾部含非 `_M1_ACTORS` 的 actor，
-    即证明该库被本进程之外的写者持续写入（共享前提成立），偏离可归因外部增长。
-    """
-    p = os.path.join(root, "_audit.jsonl")
-    try:
-        with open(p, "rb") as f:
-            f.seek(0, os.SEEK_END)
-            f.seek(max(0, f.tell() - 65536))   # 尾部 64KB ≈ 数百行，避免全量载入
-            chunk = f.read().decode("utf-8", "replace")
-    except OSError:
-        return []
-    actors = set()
-    for ln in chunk.splitlines()[-tail:]:
-        if not ln.strip():
-            continue
-        try:
-            a = json.loads(ln).get("actor")
-        except Exception:
-            continue                            # 首行可能被窗口截断，跳过不炸
-        if a and a not in _M1_ACTORS:
-            actors.add(str(a))
-    return sorted(actors)
-
-
-def _audit_lines(root):
-    """审计行数（不解析内容，只做增量基数；轮转致行数下降时由调用方判空）。"""
-    p = os.path.join(root, "_audit.jsonl")
-    try:
-        with open(p, "rb") as f:
-            return sum(1 for _ in f)
-    except OSError:
-        return 0
-
-
-def _audit_new_since(root, base_lines):
-    """返回审计新增行（解析失败行跳过）；轮转（行数下降）视为无可归因新增。"""
-    p = os.path.join(root, "_audit.jsonl")
-    try:
-        with open(p, encoding="utf-8", errors="replace") as f:
-            lines = f.readlines()
-    except OSError:
-        return []
-    if len(lines) <= base_lines:
-        return []
-    out = []
-    for ln in lines[base_lines:]:
-        try:
-            out.append(json.loads(ln))
-        except Exception:                     # noqa: BLE001
-            continue
-    return out
-
-
-def _is_atomic_tmp(fn):
-    """原子写的中间态文件（`X.md.tmp-<rand>` / `.<name>.tmp-*`）。
-
-    取证（2026-09-16）：真源被外部写入者（`_audit.jsonl` 尾部 actor="zcode"）
-    以「写 .tmp 再 rename」方式更新，快照恰在窗口内会撞 FileNotFoundError，
-    或把同一份件的两个中间态算成差异——两者都与「M1 是否写入」无关。
-    """
-    return ".tmp-" in fn or fn.startswith(".") and ".md.tmp" in fn
-
-
-def snapshot(root, *, exclude_dirs=(), exclude_files=()):
-    """记忆数据面指纹；排除面必须显式声明且带取证理由（见上方常量）。
-
-    容错：外部写入者的原子写中间态与并发删除**跳过不记**（读取失败即剔除，
-    宁可漏记一次中间态，也不把环境噪声冒充成 M1 写入）。
-    """
-    ex = set(exclude_dirs)
-    exf = set(exclude_files)
-    out = {}
-    for dp, dns, fns in os.walk(root):
-        dns[:] = [d for d in dns if d not in ex]
-        for fn in fns:
-            if fn in exf or _is_atomic_tmp(fn):
-                continue
-            p = os.path.join(dp, fn)
-            try:
-                with open(p, "rb") as f:
-                    out[os.path.relpath(p, root)] = hashlib.md5(f.read()).hexdigest()
-            except OSError:
-                continue
-    return out
-
-
-def _diff(before, after):
-    ch = sorted(k for k in set(before) & set(after) if before[k] != after[k])
-    return "改=%s 增=%s 删=%s" % (ch[:5], sorted(set(after) - set(before))[:5],
-                                sorted(set(before) - set(after))[:5])
-
-
-# 引擎默认 issue_kind（规则 JSON 未显式声明 issue_kind 时的契约值）
-_DEFAULT_KIND = {"field_absent": "missing_field", "evidence_zero": "missing_field",
-                 "field_ratio_below": "package_ratio", "dup_hash_group": "dup_content",
-                 "template_flow_digits_only": "template_flow", "basis_licensed": "weak_source"}
-
-
-def declared_kinds():
-    """规则库声明的 issue_kind 全集——机械分类不得越出此界。"""
-    ks = set()
-    for r in RS.load_rules()["rules"]:
-        for s in (r.get("mechanical") or []):
-            ks.add(s.get("issue_kind") or _DEFAULT_KIND.get(s.get("check"), s.get("check")))
-    return ks
-
-
-def rows_of(bundles):
-    return [e for b in bundles for e in b["entries"]]
-
-
-# A 组语料：knowledge 4（k1 三缺、k3/k4 同指纹）、contextual 1、self 1（legacy 边）
-A_NODES = {
-    "k1": node("k1", role=None, evidence_count=0, verification_basis="", tags=["doc:note"]),
-    "k2": node("k2", role="knowledge-card", evidence_count=2, verification_basis="test"),
-    "k3": node("k3", role="knowledge-card", evidence_count=1, verification_basis="test",
-               content_hash="dup"),
-    "k4": node("k4", role="knowledge-card", evidence_count=1, verification_basis="test",
-               content_hash="dup"),
-    "c1": node("c1", layer="contextual"),
-    "s1": node("s1", layer="self", importance=0.9,
-               edges=[{"type": "part_of", "target": "k2"}]),
-}
-A_ACCESS = ({"t": 1, "ids": ["k2", "c1"], "tier": "core"},)
-TMPL = "# 功能名：批次%d收官记忆\n\n内容各不相同 %d"
-
-
-def _count(items, kind):
-    return sum(1 for i in items if i.get("issue_kind") == kind)
-
-
-# ---------------------------- A 级 1：候选生成 ----------------------------
-
-def phase_a(tmp):
-    print("[A] 级 1 候选生成")
-    rA = mkroot(os.path.join(tmp, "a"), dict(A_NODES), access=A_ACCESS)
-    nodesA = dict(A_NODES)
-
-    gen = CD.generate(rA, nodes=nodesA, now=0.0, patrol_offset=0)
-    kinds = {c["key"]: c["issue_kinds"] for c in gen["candidates"]}
-    ok(gen["by_source"]["assertion"] > 0 and gen["total"] > 0, "A1 断言源产出候选")
-    ok({"missing_field", "mixed_layer", "unanalyzed"} <= set(kinds.get("k1", [])),
-       f"A2 k1 三问题聚合一条候选（实得 {kinds.get('k1')}）")
-    ok("dup_content" in kinds.get("k3", []) and "dup_content" in kinds.get("k4", []),
-       "A3 同指纹两条都进候选")
-
-    items = CD._assertion_items(nodesA)
-    kn = {n: r for n, r in nodesA.items() if str(r.get("layer")) == "knowledge"}
-    cov = CF._coverage_metrics(nodesA)
-    n_role = _count([i for i in items if "role" in i["evidence"]], "missing_field")
-    n_ev = _count([i for i in items if "evidence_count" in i["evidence"]], "missing_field")
-    ok(n_role == round((1 - cov["role_ratio_kn"]) * len(kn)),
-       f"A4 role 条目数 == 覆盖率反推（实得 {n_role}）")
-    ok(n_ev == round((1 - cov["evidence_ratio_kn"]) * len(kn)),
-       f"A5 evidence 条目数 == 覆盖率反推（实得 {n_ev}）")
-    ok(_count(items, "mixed_layer") == cov["mixed_layer"],
-       "A6 混层条目数 == conformance.stratum.mixed_ratio 分子")
-    ok(_count(items, "dup_content") == CF._dup_metrics(nodesA)["nodes"],
-       "A7 重复条目数 == conformance.dup 涉及节点数")
-    ok(_count(items, "unanalyzed") == CF.unanalyzed(nodesA)["count"],
-       "A8 unanalyzed 条目数 == conformance 派生判据")
-    ok(_count(items, "unanalyzed") == 3,
-       f"A9 unanalyzed 全库口径展开=3（实得 {_count(items, 'unanalyzed')}）")
-
-    only = CD.generate(rA, sources=("assertion",), nodes=nodesA, now=0.0)
-    ok(set(only["by_source"]) == {"assertion"}, "A10 分源开关生效（只跑断言源）")
-
-    cold = CD.generate(rA, sources=("cold",), nodes=nodesA, now=0.0, cold_limit=10)
-    cids = {c["node_id"] for c in cold["candidates"]}
-    ok("s1" in cids and "k2" not in cids and "c1" not in cids,
-       f"A11 冷节点=未触达且 importance≥0.6（实得 {sorted(cids)}）")
-    ok(all(c["issue_kinds"] == ["cold"] for c in cold["candidates"]), "A12 冷节点候选仅带 cold")
-
-    p8 = {f"p{i}": node(f"p{i}", importance=0.5) for i in range(8)}
-    w0, w1 = CD._patrol_items(p8, 2, 0), CD._patrol_items(p8, 2, 1)
-    s0, s1 = {x["node_id"] for x in w0}, {x["node_id"] for x in w1}
-    ok(len(s0) == 2 and len(s1) == 2 and not (s0 & s1), "A13 轮巡相邻窗口不重")
-    ok({x["node_id"] for x in CD._patrol_items(p8, 2, 0)} == s0, "A14 轮巡同 offset 可复现")
-    ok({x["node_id"] for x in CD._patrol_items(p8, 2, 4)} == s0,
-       "A15 轮巡整除时环绕回起点（窗口不重不漏闭合）")
-    ok(len({x["node_id"] for x in CD._patrol_items(p8, 3, 2)}) == 3,
-       "A16 轮巡非整除窗口内不重（环绕补足）")
-    ok(all(x["node_id"] in p8 for x in CD._patrol_items(p8, 2, 1)), "A17 轮巡条目不越界")
-
-    rD = mkroot(os.path.join(tmp, "defer"), dict(A_NODES), access=A_ACCESS,
-                inbox=[{"pid": "p1", "id": "k1", "layer": "knowledge",
-                        "content": "提案正文", "tags": ["doc:x"], "payload_hash": "h1"},
-                       {"pid": "p2", "id": "k2", "layer": "knowledge"}],
-                decisions=[{"pid": "p2", "decision": "accept"}],
-                forgetting=[{"verdict": "DEFER", "node_id": "ghost", "reason": "证据不足"},
-                            {"verdict": "DEFER", "node_id": "k2", "reason": "冲突"},
-                            {"verdict": "DROP", "node_id": "k3", "reason": "无关"}])
-    dq = CD.generate(rD, sources=("defer_queue",), nodes=dict(A_NODES), now=0.0)
-    pids = {c.get("proposal_id") for c in dq["candidates"]}
-    ok("p1" in pids and "p2" not in pids,
-       f"A18 被 decisions 覆盖的提案不入候选（实得 {sorted(x for x in pids if x)}）")
-    ok(any(c["node_id"] == "k2" and c["origin"] == "node" for c in dq["candidates"]),
-       "A19 遗忘日志 DEFER 且节点在库 → 入候选")
-    ok(any(s["reason"] == "node_not_landed" for s in dq["skipped"]),
-       "A20 未落盘 DEFER 计入 skipped 不冒充候选")
-    ok("k3" not in {c["node_id"] for c in dq["candidates"]}, "A21 非 DEFER 裁决不入候选")
-
-    g1 = CD.generate(rA, nodes=nodesA, now=0.0, patrol_offset=0)
-    g2 = CD.generate(rA, nodes=nodesA, now=0.0, patrol_offset=0)
-    ok([c["key"] for c in g1["candidates"]] == [c["key"] for c in g2["candidates"]],
-       "A22 候选顺序确定性")
-    ok(json.dumps(g1, ensure_ascii=False, sort_keys=True)
-       == json.dumps(g2, ensure_ascii=False, sort_keys=True), "A23 候选全量逐字节确定")
-    pri = [c["priority"] for c in g1["candidates"]]
-    ok(pri == sorted(pri), "A24 候选按优先级排序（assertion<defer<cold<patrol）")
-
-    wr = CD.generate(rA, nodes=nodesA, now=0.0, with_report=True)
-    rep = CF.check(rA, check_paths=False)
-    ok(wr["assertions"]["verdict"] == rep["verdict"], "A25 with_report verdict 与 conformance 同源")
-    ok(wr["report"] == CF.metrics_of(rep), "A26 with_report 指标与 metrics_of 同源")
-    ok(set(CD.SOURCES) == {"assertion", "defer_queue", "cold", "patrol"}, "A27 四源齐备")
-    ok("report" not in gen and "report" in wr, "A28 报告 opt-in（默认不产出）")
-
-
-# ---------------------------- B 级 2：捆绑 ----------------------------
-
-def _cand(key, tags=(), kinds=("cold",), content=""):
-    return {"key": key, "node_id": key, "tags": list(tags),
-            "issue_kinds": list(kinds), "evidence": [], "content": content}
-
-
-def phase_b(tmp):
-    print("[B] 级 2 捆绑")
-    bnodes = {f"t{i}": node(f"t{i}", tags=["batch:report"]) for i in range(3)}
-    bcands = [_cand(f"t{i}", ["batch:report"], content=TMPL % (i, i)) for i in range(3)]
-    rB = mkroot(os.path.join(tmp, "b"), bnodes, access=())
-    bd = BD.bundle(bcands, nodes=bnodes, root=rB)
-    ok(len(bd["bundles"]) == 1 and bd["bundles"][0]["group_kind"] == "template",
-       f"B1 同模板组一包一评（实得 {[b['group_kind'] for b in bd['bundles']]}）")
-    ok(bd["bundles"][0]["size"] == 3, "B2 同模板三条并入一包")
-    ok(bd["bundles"][0]["group_sig_kind"] == "strong", "B3 标签题命中强模板签名 t:")
-    bd2 = BD.bundle(bcands, nodes=bnodes, root=rB)
-    ok(json.dumps(bd, ensure_ascii=False, sort_keys=True)
-       == json.dumps(bd2, ensure_ascii=False, sort_keys=True), "B4 包号与内容逐字节确定")
-    ok(len({b["bundle_id"] for b in bd["bundles"]}) == len(bd["bundles"]), "B5 包号唯一")
-
-    one = BD.bundle(bcands[:1], nodes=bnodes, root=rB)
-    ok(len(one["bundles"]) == 1 and one["bundles"][0]["group_kind"] == "batch",
-       "B6 单条模板组降级并入 batch（不误聚）")
-
-    lnodes = {"l1": node("l1", branch_id="br1"), "l2": node("l2", branch_id="br1"),
-              "l3": node("l3", branched_from="br1")}
-    rL = mkroot(os.path.join(tmp, "lin"), lnodes, access=(), write_files=False)
-    lbd = BD.bundle([_cand(k, content="") for k in lnodes], nodes=lnodes, root=rL)
-    ok(len(lbd["bundles"]) == 1 and lbd["bundles"][0]["group_kind"] == "lineage",
-       f"B7 同血缘成一组（实得 {[b['group_kind'] for b in lbd['bundles']]}）")
-
-    tnodes = {"q1": node("q1", tags=["goal:alpha"]), "q2": node("q2", tags=["goal:beta"]),
-              "q3": node("q3", tags=["vision:gamma"]), "q4": node("q4", tags=["vision:delta"])}
-    rT = mkroot(os.path.join(tmp, "topic"), tnodes, access=(), write_files=False)
-    tbd = BD.bundle([_cand(k, tnodes[k]["tags"], content="") for k in tnodes],
-                    nodes=tnodes, root=rT)
-    ok(len(tbd["bundles"]) == 2 and all(b["group_kind"] == "topic" for b in tbd["bundles"]),
-       f"B8 不同主题前缀分属不同 topic 组（实得 {[b['group_kind'] for b in tbd['bundles']]}）")
-    ok(sorted(tbd["stats"]["by_group_kind"].items()) == [("topic", 2)],
-       f"B8b 同主题两条合包、异主题分属（实得 {tbd['stats']['by_group_kind']}）")
-
-    big = {f"x{i}": node(f"x{i}") for i in range(60)}
-    bigc = [_cand(k, content=TMPL % (i, i)) for i, k in enumerate(big)]
-    rG = mkroot(os.path.join(tmp, "big"), big, access=())
-    gb = BD.bundle(bigc, nodes=big, root=rG, max_per_bundle=50)
-    ok(len(gb["bundles"]) == 2 and gb["stats"]["largest"] == 50,
-       f"B9 超 max_per_bundle 切分（实得 {[b['size'] for b in gb['bundles']]}）")
-    ok(sum(b["size"] for b in gb["bundles"]) == 60, "B10 切分后条目总数守恒")
-
-    cnodes = {"z1": node("z1", content="盘上正文甲")}
-    zbd = BD.bundle([_cand("z1", content="")], nodes=cnodes,
-                    root=mkroot(os.path.join(tmp, "cont"), cnodes, access=()))
-    ex = zbd["bundles"][0]["entries"][0]["excerpt"]
-    ok(ex and "盘上正文甲" in ex, "B11 索引无正文时按 path 回读盘上正文")
-    ok(zbd["content_missing"] == 0, "B12 回读成功 → content_missing=0")
-
-    rN = mkroot(os.path.join(tmp, "nocont"), cnodes, access=(), write_files=False)
-    nbd = BD.bundle([_cand("z1", content="")], nodes=cnodes, root=rN)
-    ok(nbd["content_missing"] == 1 and nbd["bundles"][0]["entries"][0]["excerpt"] is None,
-       "B13 读盘失败 → content_missing 如实计数、excerpt 置 None")
-
-    e0 = zbd["bundles"][0]["entries"][0]
-    ok({"ref", "node_id", "layer", "role", "evidence_count", "verification_basis",
-        "issue_kinds"} <= set(e0), "B14 条目字段面含机械检查所需全部字段")
-    ok(all(r in {c["key"] for c in bcands} for b in bd["bundles"] for r in b["refs"]),
-       "B15 包内 refs ⊆ 候选集（不凭空造条目）")
-    ok(bd["stats"]["bundles"] == len(bd["bundles"])
-       and bd["stats"]["candidates"] == len(bcands), "B16 stats 与实际一致")
-
-
-# ---------------------------- C 级 3：规则装配 ----------------------------
-
-def _mkpkg(entries, kind="batch"):
-    return {"bundle_id": "bT", "group_kind": kind, "group_key": "g", "entries": entries}
-
-
-def _entry(ref, layer="knowledge", role="knowledge-card", ev=1, basis="test",
-           kinds=(), excerpt="", tags=(), chash=""):
-    return {"ref": ref, "node_id": ref, "layer": layer, "role": role, "evidence_count": ev,
-            "verification_basis": basis, "issue_kinds": list(kinds), "excerpt": excerpt,
-            "content_hash": chash, "tags": list(tags), "importance": 0.5,
-            "writer": "w", "session": "s"}
-
-
-def phase_c(tmp):
-    print("[C] 级 3 规则装配")
-    rl = RS.load_rules()
-    ids = [r["id"] for r in rl["rules"]]
-    ok(rl["count"] == 7, f"C1 仓内规则库 7 条（实得 {rl['count']}）")
-    ok(set(ids) == {"R-DUP-HASH-GROUP", "R-ROLE-MISSING", "R-EVIDENCE-ZERO",
-                    "R-BASIS-MISSING", "R-BASIS-RATIO-PACKAGE", "R-BASIS-LICENSE",
-                    "R-TEMPLATE-FLOW"}, f"C2 规则 id 集合正确（实得 {sorted(ids)}）")
-    ok(all(r["severity"] in RS.SEVERITIES for r in rl["rules"]), "C3 severity 枚举合法")
-    ok(sorted(RS.MECH_CHECKS) == ["basis_licensed", "dup_hash_group", "evidence_zero",
-                                  "field_absent", "field_ratio_below",
-                                  "template_flow_digits_only"],
-       "C4 六检查器注册表齐备（引擎面冻结）")
-    ok(all(r.get("title") for r in rl["rules"]), "C5 规则元信息齐备")
-
-    bad = os.path.join(tmp, "badrules")
-    os.makedirs(bad, exist_ok=True)
-
-    def _bad(doc):
-        for fn in os.listdir(bad):
-            os.remove(os.path.join(bad, fn))
-        with open(os.path.join(bad, "r.json"), "w", encoding="utf-8") as f:
-            json.dump(doc, f, ensure_ascii=False)
-        try:
-            RS.load_rules(bad)
-            return ""
-        except ValueError as e:
-            return str(e)
-
-    m = _bad({"rules": [{"id": "X", "matcher": {}}]})
-    ok("缺字段" in m, f"C6 规则缺 severity → ValueError 不静默降级（{m}）")
-    m = _bad({"rules": [{"id": "X", "matcher": {}, "severity": "FATAL"}]})
-    ok("severity" in m, "C7 severity 非法 → ValueError")
-    m = _bad({"rules": [{"id": "X", "matcher": {}, "severity": "INFO"},
-                        {"id": "X", "matcher": {}, "severity": "INFO"}]})
-    ok("重复" in m, "C8 规则 id 重复 → ValueError")
-    m = _bad({"rules": [{"id": "X", "matcher": {}, "severity": "INFO",
-                         "mechanical": [{"check": "no_such_check"}]}]})
-    ok("未知" in m, "C9 未知检查器 → ValueError（引擎白名单 fail-closed）")
-    ok(_bad({"rules": []}) == "", "C10 空规则库不炸（容错）")
-
-    # matcher / scope
-    asm = RS.assemble(_mkpkg([_entry("a", role=None, ev=0)]), rules=rl)
-    kinds = collections.Counter(i["issue_kind"] for i in asm["mechanical"])
-    ok(kinds["missing_field"] >= 1, "C11 field_absent(role) 命中")
-    ok(any(i.get("field") == "role" and i.get("rule_id") == "R-ROLE-MISSING"
-           for i in asm["mechanical"]),
-       "C12 issue 携带 field 与 rule_id 定位")
-    ok(all(i["ref"] == "a" for i in asm["mechanical"]
-           if i["issue_kind"] != "package_ratio"), "C13 条目级 issue 指回 ref")
-
-    ctx = RS.assemble(_mkpkg([_entry("c", layer="contextual", role=None, ev=0)]), rules=rl)
-    ok(not any(i["issue_kind"] == "missing_field" for i in ctx["mechanical"]),
-       "C14 layer=knowledge 规则不跨层套用 contextual 条目")
-
-    pkg = _mkpkg([_entry("d1", basis=""), _entry("d2", basis="test")])
-    d = RS.assemble(pkg, rules=rl)
-    ok(any(i["issue_kind"] == "package_ratio" and i.get("ref") is None
-           for i in d["mechanical"]),
-       "C15 field_ratio_below 产出包级 issue（ref=None）")
-
-    dup = _mkpkg([_entry("e1", chash="H"), _entry("e2", chash="H"), _entry("e3", chash="H")])
-    dd = RS.assemble(dup, rules=rl)
-    n = sum(1 for i in dd["mechanical"] if i["issue_kind"] == "dup_content")
-    ok(n == 2, f"C16 dup_hash_group 除首条外逐条（3 条同指纹 → 2，实得 {n}）")
-    ok(any(i.get("ref") is not None and "e1" in i.get("evidence", "")
-           for i in dd["mechanical"] if i["issue_kind"] == "dup_content"),
-       "C17 重复 issue 证据点名组首，供 M2 一次裁决")
-    ok(not any(i["issue_kind"] == "dup_content" for i in
-               RS.assemble(_mkpkg([_entry("u1", chash="A"), _entry("u2", chash="B")]),
-                           rules=rl)["mechanical"]),
-       "C17b 指纹不同 → 不误报重复")
-
-    tf = _mkpkg([_entry("f1", excerpt="# 功能名:批次1收官记忆\n证据 1 条"),
-                 _entry("f2", excerpt="# 功能名:批次2收官记忆\n证据 2 条")])
-    tt = RS.assemble(tf, rules=rl)
-    ok(any(i["issue_kind"] == "template_flow" for i in tt["mechanical"]), "C18 去数字骨架相同 → 流水命中")
-    tf2 = _mkpkg([_entry("f1", excerpt="# 功能名:批次1收官记忆"),
-                  _entry("f2", excerpt="# 另一件事:完全不同正文结构")])
-    ok(not any(i["issue_kind"] == "template_flow"
-               for i in RS.assemble(tf2, rules=rl)["mechanical"]), "C19 骨架不同 → 不误报")
-
-    sci = _mkpkg([_entry("g1", basis="textbook", tags=["数学"])])
-    ok(any(i["issue_kind"] == "weak_source" for i in RS.assemble(sci, rules=rl)["mechanical"]),
-       "C20 science 赛道 + textbook 基底 → 来源执照报 weak_source")
-    hum = _mkpkg([_entry("g2", basis="textbook", tags=["文学"])])
-    ok(not any(i["issue_kind"] == "weak_source"
-               for i in RS.assemble(hum, rules=rl)["mechanical"]), "C21 humanities 同基底 → 不报")
-    und = _mkpkg([_entry("g3", basis="textbook", tags=["zzz"])])
-    ok(any(i["issue_kind"] == "weak_source" for i in RS.assemble(und, rules=rl)["mechanical"]),
-       "C22 赛道未定 → 机械面一律报（crosscheck「一律不发放」语义，供 M2 复核）")
-
-    # 规则数据化：新增一条自定义规则，引擎零改动即生效
-    cust = os.path.join(tmp, "custrules")
-    os.makedirs(cust, exist_ok=True)
-    RS.load_rules()  # 预热
-    src = RS.RULES_DIR
-    shutil.copytree(src, cust, dirs_exist_ok=True)
-    with open(os.path.join(cust, "zz_custom.json"), "w", encoding="utf-8") as f:
-        json.dump({"spec_version": 1, "domain": "custom", "rules": [
-            {"id": "R-CUSTOM-ROLE", "title": "自定规则", "severity": "INFO",
-             "matcher": {"layer": ["knowledge"]},
-             "mechanical": [{"check": "field_absent", "field": "role",
-                             "issue_kind": "custom_role"}],
-             "llm": [], "remedy": "noop"}]}, f, ensure_ascii=False)
-    rl2 = RS.load_rules(cust)
-    ok(rl2["count"] == 8, f"C23 规则库热加一条 → 8 条（实得 {rl2['count']}）")
-    a2 = RS.assemble(_mkpkg([_entry("h1", role=None)]), rules=rl2)
-    ok(any(i["issue_kind"] == "custom_role" for i in a2["mechanical"]),
-       "C24 新规则零代码改动即生效（G2 数据化）")
-
-    # assemble_all 汇总口径
-    res = {"candidates": [{"key": "a"}, {"key": "b"}],
-           "bundles": [{"bundle_id": "b1", "group_kind": "batch", "group_key": "g",
-                        "entries": [_entry("a", role=None)]},
-                       {"bundle_id": "b2", "group_kind": "batch", "group_key": "g",
-                        "entries": [_entry("b", ev=0)]}],
-           "stats": {}}
-    allr = RS.assemble_all(res, rules=rl)
-    tot = sum(len(p["mechanical"]) for p in allr["packages"])
-    ok(allr["stats"]["mechanical_total"] == tot, "C25 assemble_all 汇总 == 各包之和")
-    ok(allr["stats"]["llm_checks"] == sum(len(p["llm"]) for p in allr["packages"]),
-       "C26 llm 计数同口径")
-    ok(allr["packages"][0]["bundle_id"] == "b1"
-       and allr["stats"]["bundles"] == 2, "C27 包序与包数稳定")
-    ok(allr["stats"]["rules"] == [r["id"] for r in rl["rules"]],
-       "C28 汇总内嵌生效规则清单（可复算）")
-    ok(all(p["llm"] == [] or all("scope_refs" in c for c in p["llm"])
-           for p in allr["packages"]), "C29 LLM 检查清单带 scope_refs 供 M2 圈定范围")
-    ok(all(not p["matched"] or all({"id", "severity", "scope", "remedy"} <= set(m)
-                                   for m in p["matched"]) for p in allr["packages"]),
-       "C30 matched 记录规则命中理由/范围/处方")
-
-    a_list = RS.assemble(_mkpkg([_entry("m1", role=None)]), rules=rl["rules"])
-    a_dict = RS.assemble(_mkpkg([_entry("m1", role=None)]), rules=rl)
-    ok(a_list == a_dict, "C31 rules 入参防呆：列表与 load_rules 结果等价")
-    try:
-        RS.assemble(_mkpkg([_entry("m2")]), rules={"count": 0})
-        ok(False, "C32 规则入参形态错误 → 明确报错不静默")
-    except ValueError as e:
-        ok("rules" in str(e), "C32 规则入参形态错误 → 明确报错不静默")
-
-
-# ---------------------------- D CLI ----------------------------
-
-def phase_d(tmp):
-    print("[D] CLI")
-    rC = mkroot(os.path.join(tmp, "cli"), dict(A_NODES), access=A_ACCESS)
-    d = CLI.run(rC)
-    ok({"root", "candidates", "bundles", "bundle_stats", "assemble_stats",
-        "mechanical_by_rule", "llm_checks"} <= set(d),
-       f"D1 run 返回结构齐备（实得 {sorted(d)}）")
-    ok(d["candidates"]["total"] > 0 and d["bundle_stats"]["bundles"] > 0,
-       "D2 run 产出候选与包")
-    ok(d["assemble_stats"]["mechanical_total"] >= 1 and d["mechanical_by_rule"],
-       "D3 run 含规则装配结果（逐规则计数）")
-    ok(d["bundle_stats"]["candidates"] == d["candidates"]["total"], "D4 捆绑条目数与候选同口径")
-
-    out = os.path.join(tmp, "m1.json")
-    rc = CLI.main(["--root", rC, "--out", out])
-    ok(rc == 0, f"D5 main 正常退出码 0（实得 {rc}）")
-    ok(os.path.exists(out), "D6 --out 落盘产物存在")
-    with open(out, encoding="utf-8") as f:
-        jd = json.load(f)
-    ok(jd["candidates"]["total"] == d["candidates"]["total"], "D7 落盘内容与 run 同源")
-    ok(not ({"candidates_full", "bundles_full", "packages_full"} & set(jd)),
-       "D8 默认产物只含摘要不含逐条明细")
-
-    s = io.StringIO()
-    with redirect_stdout(s):
-        CLI.main(["--root", rC, "--full", "--out", os.path.join(tmp, "full.json")])
-    ok("机械检查" in s.getvalue() and "包" in s.getvalue(), "D9 摘要含机械聚合与包清单")
-    with open(os.path.join(tmp, "full.json"), encoding="utf-8") as f:
-        jf = json.load(f)
-    ok({"candidates_full", "bundles_full", "packages_full"} <= set(jf),
-       "D10 --full 追加三类明细")
-
-    before = snapshot(rC)
-    CD.generate(rC)
-    BD.bundle(CD.generate(rC)["candidates"], root=rC)
-    CLI.run(rC)
-    ok(snapshot(rC) == before, "D11 全链路零写入（库指纹不变）")
-
-
-# ---------------------------- E 集成（真源存在才跑） ----------------------------
-
-def _real_root():
-    cands = [os.environ.get("MDCG_ROOT")]
-    try:
-        from .datapath import mdcg_root
-        cands.append(mdcg_root())
-    except Exception:
-        pass
-    cands.append("D:/Program Files/2_ai/AEIS/data/mdcg")
-    for r in cands:
-        if r and os.path.exists(os.path.join(r, "_index.json")):
-            return r
-    return None
-
-
-def phase_e():
-    print("[E] 集成（真源存在才跑）")
-    root = _real_root()
-    if not root:
-        print("  SKIP 真源库不可用（外部 clone 环境）——非失败")
-        return
-    before = snapshot(root, exclude_dirs=VOLATILE_DIRS, exclude_files=VOLATILE_FILES)
-    vol_before = _run_state_probe(root)
-    audit_before = _audit_lines(root)
-    d = CLI.run(root, cold_limit=200)
-    nodes = CF.load_index(root) or {}
-    bb = d["bundle_stats"]
-    ok(bb["candidates"] == d["candidates"]["total"] and bb["candidates"] > 0,
-       "E1 捆绑条目数与候选同口径")
-    ok(8000 <= d["candidates"]["total"] <= 20000,
-       f"E2 真源欠账规模与基线 11195 同量级（实得 {d['candidates']['total']}）")
-    ok(bb["bundles"] <= 3000, f"E3 包数在可评审规模内（实得 {bb['bundles']}）")
-    ok(len(nodes) > 0 and d["candidates"]["total"] <= len(nodes) * 4,
-       "E4 候选量级与真源节点数相容")
-    asm = d["assemble_stats"]
-    ok(asm["mechanical_total"] > 0, "E5 真源机械 issue 非空")
-    ok(set(asm["mechanical_by_kind"]) <= declared_kinds(),
-       f"E6 机械分类 ⊆ 规则库声明（实得 {sorted(asm['mechanical_by_kind'])}）")
-    ok({"missing_field", "dup_content", "weak_source"} <= set(asm["mechanical_by_kind"]),
-       f"E6b 真源三类核心 issue 必现（实得 {sorted(asm['mechanical_by_kind'])}）")
-    ok(all(k in d["candidates"]["by_source"] for k in CD.SOURCES), "E7 四源统计齐备")
-    rep = d.get("assertions") or {}
-    ok(rep.get("verdict") in ("PASS", "WARN", "FAIL"),
-       f"E8 断言集 verdict 合法（{rep.get('verdict')}）")
-    ok(d["llm_checks"] and all(isinstance(t, (list, tuple)) and len(t) == 2
-                               for t in d["llm_checks"]), "E9 LLM 待检清单可枚举（供 M2 排期）")
-    after = snapshot(root, exclude_dirs=VOLATILE_DIRS, exclude_files=VOLATILE_FILES)
-    external = _run_state_diff(vol_before, _run_state_probe(root))
-    ext_actors = _external_actors(root)
-    # 「外部写入存在」= 本次窗口内确有变更 **或** 环境级存在非本进程写入者。
-    # 只用前者不稳定（节拍间歇，见 _external_actors 注释），只用后者过于宽泛，
-    # 取或并逐条报告证据来源。
-    shared_writes = bool(external or ext_actors)
-    logs = (os.listdir(os.path.join(root, "_index_log"))
-            if os.path.isdir(os.path.join(root, "_index_log")) else [])
-    _pidpref = str(os.getpid()) + "-"
-    ok(not any(s.startswith(_pidpref) for s in logs),
-       "E10b M1 未在真源留下本进程增量日志（写入者归属外部）")
-    # E10c：把「本进程零写入」从「全环境静置」里分离出来——审计新增行逐条按
-    # actor/pid 归因，只认本进程的行（VOLATILE_FILES 已排除的外部写入不背锅）。
-    new_audit = _audit_new_since(root, audit_before)
-    mine = [r for r in new_audit
-            if r.get("actor") in _M1_ACTORS or str(r.get("pid") or "") == str(os.getpid())]
-    ok(not mine, "E10c 审计新增行归属本进程为 0（实得 %d，新增 %d 行全部外部）"
-       % (len(mine), len(new_audit)))
-    if shared_writes:
-        # 环境共享前提不成立：E10 的字节级不变已不可归因于 M1，明确降级为
-        # 「不适用」并报告证据——不静默通过，也不把环境噪声判成本进程违规。
-        # 判据取证（2026-09-19，第4条）：旧判据「审计新增行非空」漏判——实测外部
-        # 写入（_crypto/_sustain 被同秒改写）发生而同刻审计行数未增，E10 因此误报；
-        # 单用「本次窗口变更」又随心跳节拍不稳定（见 _external_actors 注释）。
-        print("  E10 不适用：真源被外部写入者并发写入（运行态文件本次变更 %s；"
-              "审计尾部外部 actor %s；新增审计 %d 行）"
-              "——本进程零写入由 E10b/E10c 承担"
-              % (external or ["-"], ext_actors or ["-"], len(new_audit)))
-    else:
-        ok(after == before, "E10 真源只读（记忆数据面指纹不变，" + _diff(before, after) + "）")
-
-    # ---- E11~ 审计基线复现（§6 M1 验收口径）----
-    # 基线（2026-09-15 审计 node_26b0973a）：混层 57.9% / role 空 99.99% /
-    # evidence_count 仅 6 条 / 精确重复 90 条 / 欠账 11195。库在增长，用容差区间。
-    # 降级判据（2026-09-19，与 E10 同构）：E11~E16 断言的是**数据面快照统计量**，
-    # 其分子分母均由外部写入者推动——mixed_ratio = knowledge 层带 doc∪code 标签数 /
-    # knowledge 总数，新增一个 code_*/doc_* 节点即同时推高分子分母；比率变化方向有
-    # 闭式判据：Δratio 的符号 = 新增批次混层占比 p − 当前 ratio。实测 p≈96.6%
-    # ≫ 0.579，故比率单调上行、容差区间必被击穿（现场 0.6302 越上界 1.03pp）。
-    # 外部写入存在（shared_writes）时该区间已不描述本进程可控面 → 明确降级为
-    # 「不适用」并报告现场值（不静默通过，也不把外部增长判成本进程违规）。
-    # 边界如实标注：隔离/冻结库（无外部写入者）下仍照常判红——此时偏离即基线过期，
-    # 须人工重定基线，不豁免；这也意味着共享库上本组断言长期呈「不适用」，若需恢复
-    # 可裁决性，应改趋势判据（与本地上次快照比不劣化），属验收口径变更待定夺。
-    cov = CF.metrics_of(CF.check(root, check_paths=False))
-    kn = [k for k, v in nodes.items() if (v.get("layer") or "") == "knowledge"]
-    n_ev = sum(1 for k in kn if CF._as_int(nodes[k].get("evidence_count")) > 0)
-    if shared_writes:
-        print("  E11~E16 不适用：审计基线为 2026-09-15 快照，真源被外部写入者"
-              "并发写入（本次变更 %s；审计尾部外部 actor %s）→ 数据面统计量由外部"
-              "写入推动；现场值 混层 %.4f / role_ratio_kn %.6f / evidence %d / "
-              "dup %d 组 / knowledge %d / reach %.4f"
-              % (external or ["-"], ext_actors or ["-"],
-                 cov["mixed_ratio"], cov["role_ratio_kn"], n_ev,
-                 cov["dup_groups"], len(kn), cov["reach_ratio"]))
-    else:
-        ok(0.55 <= cov["mixed_ratio"] <= 0.62,
-           f"E11 复现混层率 57.9%（实得 {cov['mixed_ratio']:.4f}）")
-        ok(cov["role_ratio_kn"] < 0.001,
-           f"E12 复现 role 近乎全空（有 role 占比 {cov['role_ratio_kn']:.6f}）")
-        ok(n_ev == 6, f"E13 复现 evidence_count 仅 6 条（实得 {n_ev}）")
-        ok(85 <= cov["dup_groups"] <= 105,
-           f"E14 复现精确重复 ~90 组（实得 {cov['dup_groups']}）")
-        ok(10000 <= len(kn) <= 13000,
-           f"E15 复现 knowledge 存量 11195 量级（实得 {len(kn)}）")
-        ok(cov["reach_ratio"] < 0.15,
-           f"E16 复现召回率低（reach_ratio {cov['reach_ratio']:.4f}）")
-    # 边界如实标注（不猜测、不硬凑）：基线「同模板冗余 233 条」无固化判据函数——实测两候选
-    # 口径均不等（writelimit.template_signature 全量分组冗余 1949；本引擎 template_flow
-    # 严格「只换数字」口径 13），故不纳入机械断言，留待 M3 定位模块抽样核对后固化。
-
-
-# ---------------------------- main ----------------------------
-
-def main():
-    tmp = tempfile.mkdtemp(prefix="mrev_")
-    try:
-        for ph in (phase_a, phase_b, phase_c, phase_d):
-            ph(tmp)
-        phase_e()
-    finally:
-        shutil.rmtree(tmp, ignore_errors=True)
-    print(f"\n== M1 机械层自测：{PASS} 通过 / {FAIL} 失败 ==")
-    if FAILS:
-        for f in FAILS:
-            print("  - " + f)
-        return 1
-    return 0
-
-
-if __name__ == "__main__":
-    sys.exit(main())
-