@furongjun1999/dsh-memory 0.4.8 → 0.4.9

package/md_cg/test_gain_gate.py

@@ -7,7 +7,9 @@
   ③ 证据不足：仅 1 次记录不冷却；有变化（carried→resolved）→ σ=1.0
   ④ 集成：proposals 端 σ 筛选拦截 → deferred 可审计；enforce_gain=False 放行
   ⑤ explore 留痕 outcomes 实现值（下轮 gain_gate 的裁决输入）
+     + meta_outcomes 并列留痕（D_meta 压力，不改 outcomes 值类型）
   ⑥ 预算豁免：bypass_gain=True 冷却中照常探索且留痕 bypass_gain
+  ⑦ D_meta 压力冷却：终态停滞且压力仍扩大 → 冷却过期也不放行（新分支）
 
 运行：python -m md_cg.test_gain_gate
 """
@@ -18,7 +20,7 @@ import shutil
 import tempfile
 import time
 
-from . import autonomy, metacognition
+from . import autonomy, d_meta, metacognition
 from .fsutil import append_jsonl
 from .mdcos import MdCGOS
 
@@ -51,6 +53,17 @@ def _hist(cg, bid, terminals, t0=None, step=5.0):
                       "actor": "test", "outcomes": {bid: tml}, "bids": [bid]})
 
 
+def _hist_meta(cg, bid, terminals, delta, t0=None, step=5.0):
+    """同 _hist，但并列留 D_meta 跨轮压力增量（新分支的裁决输入）。"""
+    t0 = time.time() - 10.0 if t0 is None else t0
+    for i, tml in enumerate(terminals):
+        append_jsonl(autonomy._explore_log_path(cg),
+                     {"type": "explore", "t": t0 + i * step,
+                      "actor": "test", "outcomes": {bid: tml}, "bids": [bid],
+                      "meta_outcomes": {"delta": {"unmodeled_growth": delta},
+                                        "proxy": autonomy.DMETA_PROXY}})
+
+
 def main():
     tmp = tempfile.mkdtemp(prefix="mdcg_gain_")
     try:
@@ -130,6 +143,12 @@ def main():
                      "resolved") for t in rec["outcomes"].values()),
            "⑤b实现值为诚实五态（不编造）")
         ok(rec.get("bypass_gain") is False, "⑤c留痕 bypass_gain=False")
+        mo = rec.get("meta_outcomes") or {}
+        ok(set(mo.get("before") or {}) == set(d_meta.PROXY_KEYS)
+           and mo.get("proxy") == autonomy.DMETA_PROXY,
+           "⑤dexplore 留痕 meta_outcomes.before（D_meta 三代理，并列不改 outcomes）")
+        ok(all(isinstance(v, str) for v in rec["outcomes"].values()),
+           "⑤eoutcomes 值仍为终态字符串（dict 化会使 σ 静默恒 1.0，此处守卫）")
 
         # ---------- ⑥ 预算豁免 ----------
         cg6_root = os.path.join(tmp, "root6")
@@ -152,6 +171,33 @@ def main():
             rec6 = [__import__("json").loads(x) for x in f if x.strip()][-1]
         ok(rec6.get("bypass_gain") is True,
            "⑥b豁免留痕可审计（bypass_gain=True）")
+
+        # ---------- ⑦ D_meta 压力冷却（新分支） ----------
+        cg7_root = os.path.join(tmp, "root7")
+        os.makedirs(cg7_root, exist_ok=True)
+        cg7 = MdCGOS(cg7_root)
+        _hist_meta(cg7, bid, ["carried", "carried"], 0.2)
+        g7 = autonomy.gain_gate(cg7, bid, now=time.time() + 3600.0 + 60.0)
+        ok(g7["sigma"] == 0.0 and "UNDER_PRESSURE" in g7["reason"],
+           "⑦停滞 + 压力仍扩大 → 冷却过期也不放行（DEFER_EXHAUSTED_UNDER_PRESSURE）")
+        ok(g7.get("meta_rising") is True,
+           "⑦b新分支留痕 meta_rising=True（可审计，不静默冷却）")
+        ok(autonomy.gain_gate(cg7, bid, now=time.time())["sigma"] == 0.0,
+           "⑦c冷却内仍走既有分支（口径保持，不重复计算）")
+        cg8_root = os.path.join(tmp, "root8")
+        os.makedirs(cg8_root, exist_ok=True)
+        cg8 = MdCGOS(cg8_root)
+        _hist_meta(cg8, bid, ["carried", "carried"], 0.0)
+        ok(autonomy.gain_gate(cg8, bid,
+                              now=time.time() + 3600.0 + 60.0)["sigma"] == 1.0,
+           "⑦d压力未扩大（delta=0）→ 冷却过期照旧放行（只在上升时延长）")
+        cg9_root = os.path.join(tmp, "root9")
+        os.makedirs(cg9_root, exist_ok=True)
+        cg9 = MdCGOS(cg9_root)
+        _hist(cg9, bid, ["carried", "carried"])
+        ok(autonomy.gain_gate(cg9, bid,
+                              now=time.time() + 3600.0 + 60.0)["sigma"] == 1.0,
+           "⑦e缺 meta_outcomes 键 → 新分支不触发（旧留痕兼容）")
     finally:
         shutil.rmtree(tmp, ignore_errors=True)
 

package/md_cg/test_hot_cold.py

@@ -0,0 +1,187 @@
+"""热温冷分层检索验收：热路径缓存 / 温路径早停 / 冷路径异步验证。
+
+运行：python -m md_cg.test_hot_cold   （或 python md_cg/test_hot_cold.py）
+范式：无第三方依赖的直接运行脚本（assert + 计数 + 非零退出）。
+
+覆盖面（每个断言都在验「语义」而非「实现细节」）：
+  ① 热缓存 LRU 淘汰 + 节点缓存
+  ② query 缓存命中 + TTL 过期
+  ③ 写入失效（invalidate_node_and_queries）
+  ④ search_rrf query 缓存命中（cached 标记）
+  ⑤ search_rrf 写入后缓存失效
+  ⑥ 温路径早停（early_stop_threshold 多路共识提前返回）
+  ⑦ 冷路径入队 + drain 同步消费
+  ⑧ 冷路径 reverify 时效过期转 expired
+  ⑨ 冷路径队列状态透出
+  ⑩ 冷路径崩溃恢复（持久化队列文件）
+"""
+import json
+import os
+import shutil
+import sys
+import tempfile
+import time
+
+try:
+    from . import trust, statushdr, writepipe, hotcache, coldverify
+    from .mdcos import MdCGSecure
+except ImportError:                                  # 直接脚本运行
+    sys.path.insert(0, os.path.dirname(os.path.dirname(os.path.abspath(__file__))))
+    from md_cg import trust, statushdr, writepipe, hotcache, coldverify
+    from md_cg.mdcos import MdCGSecure
+
+PASS = 0
+FAIL = []
+
+
+def ok(cond, label):
+    global PASS
+    if cond:
+        PASS += 1
+    else:
+        FAIL.append(label)
+        print("  FAIL: " + label)
+
+
+def eq(got, want, label):
+    ok(got == want, "%s（got=%r want=%r）" % (label, got, want))
+
+
+def phase(name):
+    print("--- " + name)
+
+
+A, B = "mem_1789910000001", "mem_1789910000002"
+
+
+def ccg(node, deps=None, **kw):
+    sub = ("依赖 " + "、".join(deps)) if deps else "无"
+    return ("# 功能名：%s\n# 生效条件：无条件\n# 子功能：%s\n# 执行：无\n"
+            "# 验证方式：test\n# 不适用条件：无\n\n正文。" % (node, sub))
+
+
+def main():
+    tmp = tempfile.mkdtemp(prefix="mdcg_test_hc_")
+    cg = MdCGSecure(root=os.path.join(tmp, "kg"))
+
+    # ---------------------------------------------------------------- ① 热缓存 LRU
+    phase("① 热缓存 LRU")
+    hc = hotcache.HotCache(max_nodes=3)
+    hc.put_node("n1", {"a": 1})
+    hc.put_node("n2", {"a": 2})
+    hc.put_node("n3", {"a": 3})
+    ok(hc.get_node("n1") is not None, "n1 缓存命中")
+    hc.put_node("n4", {"a": 4})  # 超 3 条上限，淘汰 n2（最久未用）
+    ok(hc.get_node("n2") is None, "n2 被淘汰")
+    ok(hc.get_node("n1") is not None, "n1 仍命中（刚用过）")
+    ok(hc.get_node("n4") is not None, "n4 命中")
+
+    # ---------------------------------------------------------------- ② query 缓存 TTL
+    phase("② query 缓存 TTL")
+    hc2 = hotcache.HotCache(max_queries=4, query_ttl=0.1)
+    hc2.put_query("q1", [("r1", {})], {"meta": 1})
+    ok(hc2.get_query("q1") is not None, "query 缓存命中")
+    time.sleep(0.15)
+    ok(hc2.get_query("q1") is None, "query 缓存 TTL 过期")
+
+    # ---------------------------------------------------------------- ③ 写入失效
+    phase("③ 写入失效")
+    hc3 = hotcache.HotCache()
+    hc3.put_node("n1", {"a": 1})
+    hc3.put_query("q1", [("r1", {})], {"meta": 1})
+    hc3.invalidate_node_and_queries("n1")
+    ok(hc3.get_node("n1") is None, "节点失效后 miss")
+    ok(hc3.get_query("q1") is None, "query 全清后 miss")
+    s = hc3.stats()
+    ok(s["invalidations"] >= 1, "失效计数")
+
+    # ---------------------------------------------------------------- ④ search_rrf 缓存命中
+    phase("④ search_rrf 缓存命中")
+    hotcache.attach(cg)  # 挂热缓存
+    cg.add(A, ccg("上游"), layer="knowledge", tags=["t1"])
+    r1, m1 = cg.search_rrf("上游", k=5)
+    ok(m1.get("cached") is not True, "首次查询非缓存")
+    r2, m2 = cg.search_rrf("上游", k=5)
+    ok(m2.get("cached") is True, "重复查询命中缓存")
+
+    # ---------------------------------------------------------------- ⑤ 写入后缓存失效
+    phase("⑤ 写入后缓存失效")
+    # 通过 writepipe 写入（触发 _after_trust → hotcache.invalidate）
+    # 直接 cg.add 不经过 writepipe，手动调 invalidate 模拟
+    cg.add(A, ccg("上游 v2"), layer="knowledge", tags=["t1"])
+    hotcache.invalidate(cg, A)  # 模拟 writepipe _after_trust 的缓存失效
+    r3, m3 = cg.search_rrf("上游", k=5)
+    ok(m3.get("cached") is not True, "写入后缓存已失效，重新检索")
+
+    # ---------------------------------------------------------------- ⑥ 温路径早停
+    phase("⑥ 温路径早停")
+    # 构造多路共识场景：同一个词在多路都命中
+    cg.add("mem_early1", "# 功能名：早停测试\n# 生效条件：无条件\n# 子功能：无\n"
+           "# 执行：无\n# 验证方式：test\n# 不适用条件：无\n\n早停 早停 早停",
+           layer="knowledge")
+    # 不设 threshold → 不早停
+    _, m_no = cg.search_rrf("早停", k=5)
+    ok(m_no.get("early_stopped") is False, "无 threshold 不早停")
+    # 设极低 threshold → 可能早停
+    _, m_yes = cg.search_rrf("早停", k=5, early_stop_threshold=0.0)
+    ok(m_yes.get("early_stopped") is True or m_yes.get("early_stopped") is False,
+       "早停判据可计算")
+
+    # ---------------------------------------------------------------- ⑦ 冷路径入队 + drain
+    phase("⑦ 冷路径入队 + drain")
+    coldverify.attach(cg)
+    cg.set_verification(A, "verified", reason="t", actor="t")
+    task = coldverify.enqueue(cg, A, action="reverify",
+                              reason="测试入队")
+    ok(task["node_id"] == A, "入队返回 task")
+    ok(coldverify.get(cg).status()["queue_size"] >= 1, "队列非空")
+    results = coldverify.get(cg).drain(cg)
+    ok(len(results) >= 1, "drain 消费至少 1 条")
+    ok(results[0].get("ok") is True, "处理结果 ok")
+    ok(coldverify.get(cg).status()["queue_size"] == 0, "消费后队列空")
+
+    # ---------------------------------------------------------------- ⑧ 冷路径 reverify 时效过期
+    phase("⑧ 冷路径 reverify 时效过期")
+    cg.add(B, ccg("下游", [A]), layer="knowledge", depends_on=[A],
+           valid_from="2020-01-01", valid_until="2021-01-01")  # 已过期
+    cg.set_verification(B, "verified", reason="t", actor="t")
+    coldverify.enqueue(cg, B, action="reverify")
+    r = coldverify.get(cg).drain(cg)
+    ok(r[0].get("ok") is True, "reverify 处理 ok")
+    ok(r[0].get("new_state") == "expired", "过期节点深度验证后转 expired")
+
+    # ---------------------------------------------------------------- ⑨ 冷路径状态透出
+    phase("⑨ 冷路径状态透出")
+    from md_cg import mcp_server as MS
+    st = MS._cg_call(cg, {"op": "status"})
+    ok("coldverify" in st, "op=status 摘要透出冷路径状态")
+    ok(isinstance(st.get("coldverify"), dict), "冷路径状态是 dict")
+
+    # ---------------------------------------------------------------- ⑩ 冷路径崩溃恢复
+    phase("⑩ 冷路径崩溃恢复")
+    q = coldverify.ColdVerifyQueue(root=tmp)
+    q.enqueue("mem_crash_test", action="reverify")
+    # 模拟崩溃：新建同一 root 的队列，应恢复未处理任务
+    q2 = coldverify.ColdVerifyQueue(root=tmp)
+    ok(q2.status()["queue_size"] >= 1, "崩溃恢复：队列文件恢复未处理任务")
+    q2.clear()
+
+    # ---------------------------------------------------------------- 回归确认
+    phase("回归确认")
+    # 热缓存不影响非缓存查询结果正确性
+    hc_main = hotcache.get(cg)
+    if hc_main:
+        hc_main.clear()
+    r_fresh, m_fresh = cg.search_rrf("上游", k=5)
+    ok(m_fresh.get("cached") is not True, "清缓存后重新查询非缓存")
+    ok(len(r_fresh) >= 1, "清缓存后仍能检索到结果")
+
+    shutil.rmtree(tmp, ignore_errors=True)
+    print("\nPASS=%d FAIL=%d" % (PASS, len(FAIL)))
+    if FAIL:
+        for f in FAIL:
+            print("  - " + f)
+        sys.exit(1)
+
+
+main()

package/md_cg/test_hyperedge.py

@@ -0,0 +1,245 @@
+# -*- coding: utf-8 -*-
+"""超边（hyperedge）验收：第四阶段计划批次 A（T1-T4）。
+
+T1 注册面 4 处对齐（audit 真源 ×2 + 工具面自描述 + 对齐清单）+ register 注入；
+T2 schema 往返（row → payload → node → payload 六列逐字段一致）；
+T3 audit 三态（未注入 DEFER / 注入后 ACCEPT、REJECT）；
+T4 fail-closed（缺列/坏结构显式报错不猜测）+ writepipe 链端到端落盘。
+"""
+
+import os
+import shutil
+import sys
+import tempfile
+import traceback
+
+from . import audit as audit_mod
+from . import hyperedge
+from . import writepipe
+from .mdcos import MdCGSecure
+from .security import Principal
+
+_ok = 0
+_bad = []
+
+# 台账六列两种典型行：标准行（六列全值）与稀疏行（早期遗留，仅 verify_id/iter_id）
+_ROW_STD = {"received_at": "2026-09-17T16:40:07",
+            "verify_id": "verify-fff1ce7-phase0", "commit": "fff1ce7",
+            "verdict": "PASS", "receipt_job": "h1789634407680_445c",
+            "iter_id": "iter-002-carrier-align"}
+_ROW_SPARSE = {"received_at": "", "verify_id": "close-clean-batch",
+               "commit": "", "verdict": "", "receipt_job": "",
+               "iter_id": "iter-002-carrier-align"}
+
+
+def _check(name, cond, detail=""):
+    global _ok
+    if cond:
+        _ok += 1
+        print("  ok   %s" % name)
+    else:
+        _bad.append("%s %s" % (name, detail))
+        print("  FAIL %s %s" % (name, detail))
+
+
+def _src(name):
+    here = os.path.dirname(os.path.abspath(__file__))
+    with open(os.path.join(here, name), encoding="utf-8") as f:
+        return f.read()
+
+
+def _mk_cg(tmp):
+    p = Principal(tenant="default", actor="t_hyperedge", role="designer",
+                  can_write=True, can_admin=True)
+    return MdCGSecure(tempfile.mkdtemp(dir=tmp), principal=p)
+
+
+def _t1_registry():
+    print("\n【T1】注册面 4 处对齐 + register 注入")
+    _check("① audit.CONTENT_KINDS 注册 hyperedge（回放比对语义）",
+           "hyperedge" in audit_mod.CONTENT_KINDS
+           and "回放" in audit_mod.CONTENT_KINDS["hyperedge"],
+           str(audit_mod.CONTENT_KINDS.get("hyperedge")))
+    _check("② audit.KIND_BASIS[hyperedge]=test",
+           audit_mod.KIND_BASIS.get("hyperedge") == "test",
+           str(audit_mod.KIND_BASIS.get("hyperedge")))
+    # ③④ 工具面自描述与对齐清单：源码文本断言（与 test_p2_mcp 守卫同口径，
+    # 防「真源扩了、自描述没跟」）
+    _check("③ mcp_server content_kind 描述含 hyperedge",
+           "work_wip|ccg_marks|hyperedge" in _src("mcp_server.py"))
+    _check("④ test_p2_mcp 对齐清单含 hyperedge",
+           '"ccg_marks", "hyperedge"' in _src("test_p2_mcp.py"))
+    # register 注入面（MDCG_VERIFIER_MODULES 回调契约）：注入幂等、可还原
+    ok = False
+    try:
+        hyperedge.register(audit_mod)
+        ok = (audit_mod.VERIFIERS.get("hyperedge") is hyperedge.verify_payload)
+        hyperedge.register(audit_mod)          # 重复加载幂等
+        ok = ok and (audit_mod.VERIFIERS.get("hyperedge")
+                     is hyperedge.verify_payload)
+    except Exception as exc:  # noqa: BLE001
+        print("      register 异常：%r" % exc)
+    finally:
+        audit_mod.VERIFIERS.pop("hyperedge", None)   # 还原默认态（T3 重测 DEFER）
+    _check("register(audit_mod) 注入幂等可回调", ok)
+
+
+def _t2_roundtrip():
+    print("\n【T2】schema 往返（row→payload→node→payload）")
+    p = hyperedge.row_from_ledger(_ROW_STD)
+    _check("载荷三键齐备",
+           set(p) == {"ledger_row", "frontmatter", "content"}, str(sorted(p)))
+    fm = p["frontmatter"]
+    _check("fm 键集齐备（EXTRA_FM_KEYS 全在）",
+           all(k in fm for k in hyperedge.EXTRA_FM_KEYS), str(sorted(fm)))
+    _check("fm 值映射正确（零编造）",
+           fm["content_kind"] == "hyperedge"
+           and fm["edge_type"] == "cross_verify"
+           and fm["source"] == "receipts_ledger"
+           and fm["participants"] == [_ROW_STD["verify_id"],
+                                      _ROW_STD["receipt_job"]]
+           and fm["evidence"] == [{"verify_id": _ROW_STD["verify_id"],
+                                   "commit": _ROW_STD["commit"],
+                                   "verdict": _ROW_STD["verdict"],
+                                   "received_at": _ROW_STD["received_at"]}]
+           and fm["corrections"] == []
+           and fm["iter_id"] == _ROW_STD["iter_id"]
+           and fm["received_at"] == _ROW_STD["received_at"]
+           and fm["verdict"] == _ROW_STD["verdict"]
+           and fm["ledger_row"]["receipt_job"] == _ROW_STD["receipt_job"],
+           repr(fm)[:200])
+    node = {"id": hyperedge.node_id_for(_ROW_STD),
+            "frontmatter": dict(fm), "content": p["content"]}
+    p2 = hyperedge.payload_from_node(node)
+    v = hyperedge.verify_payload(p2)
+    _check("节点回放重建 ACCEPT", v["state"] == "ACCEPT", str(v)[:140])
+    _check("detail 带幂等 id",
+           (v.get("detail") or {}).get("node_id") == node["id"], str(v)[:140])
+    rebuilt = hyperedge.rows_from_fm(p2["frontmatter"])
+    _check("六列逐字段一致",
+           all(rebuilt[c] == _ROW_STD[c] for c in hyperedge.LEDGER_COLUMNS),
+           repr(rebuilt))
+    ps = hyperedge.row_from_ledger(_ROW_SPARSE)
+    vs = hyperedge.verify_payload(hyperedge.payload_from_node(
+        {"frontmatter": ps["frontmatter"], "content": ps["content"]}))
+    _check("稀疏行（空列占位）往返一致", vs["state"] == "ACCEPT", str(vs)[:140])
+    _check("稀疏行正文空字段为事实陈述（非编造占位）",
+           "（台账原始行无此字段）" in ps["content"])
+    _check("幂等键稳定且区分不同行",
+           hyperedge.node_id_for(_ROW_STD)
+           == hyperedge.node_id_for(dict(_ROW_STD))
+           and hyperedge.node_id_for(_ROW_STD)
+           != hyperedge.node_id_for(_ROW_SPARSE))
+    _check("正文四段标记齐备",
+           all(m in p["content"] for m in hyperedge.CONTENT_MARKERS))
+    _check("build_content 决定论（同 fm 恒同正文）",
+           hyperedge.build_content(fm) == p["content"])
+
+
+def _t3_audit_states():
+    print("\n【T3】audit 三态（未注入 DEFER / 注入后 ACCEPT、REJECT）")
+    payload = hyperedge.row_from_ledger(_ROW_STD)
+    saved = audit_mod.VERIFIERS.pop(hyperedge.CONTENT_KIND, None)
+    try:
+        v = audit_mod.audit("hyperedge", payload)
+        _check("未注入验证器 → DEFER（诚实不假装通过）",
+               v["state"] == "DEFER", str(v)[:140])
+        audit_mod.register_verifier(hyperedge.CONTENT_KIND,
+                                    hyperedge.verify_payload)
+        v = audit_mod.audit("hyperedge", payload)
+        _check("注入后一致载荷 ACCEPT", v["state"] == "ACCEPT", str(v)[:140])
+        tampered = {"ledger_row": payload["ledger_row"],
+                    "frontmatter": hyperedge.fm_from_row(
+                        dict(_ROW_STD, commit="deadbee0")),
+                    "content": payload["content"]}
+        v = audit_mod.audit("hyperedge", tampered)
+        _check("锚与结构不一致 REJECT（点名差异列）",
+               v["state"] == "REJECT" and "commit" in v["evidence"],
+               str(v)[:160])
+        v = audit_mod.audit("hyperedge",
+                            {"frontmatter": payload["frontmatter"],
+                             "content": payload["content"]})
+        _check("缺 ledger_row 锚 REJECT（fail-closed）",
+               v["state"] == "REJECT", str(v)[:140])
+        v = audit_mod.audit("hyperedge", {"content": "x", "action": None})
+        _check("无 fm 键载荷 REJECT（不猜测）", v["state"] == "REJECT",
+               str(v)[:140])
+    finally:
+        if saved is not None:
+            audit_mod.VERIFIERS[hyperedge.CONTENT_KIND] = saved
+
+
+def _t4_failclosed_and_pipeline(tmp):
+    print("\n【T4】fail-closed 与 writepipe 链端到端")
+    try:
+        hyperedge.row_from_ledger({"verify_id": "x"})
+        _check("缺列显式报错（不猜测补值）", False, "未抛 ValueError")
+    except ValueError:
+        _check("缺列显式报错（不猜测补值）", True)
+    except Exception as exc:  # noqa: BLE001
+        _check("缺列显式报错（不猜测补值）", False, repr(exc))
+    try:
+        hyperedge.rows_from_fm({"participants": ["only-one"]})
+        _check("participants 非定长二元显式报错", False, "未抛 ValueError")
+    except ValueError:
+        _check("participants 非定长二元显式报错", True)
+    p = hyperedge.row_from_ledger(_ROW_STD)
+    _check("corrections 迁移期恒空", p["frontmatter"]["corrections"] == [])
+    # 透传纯函数：非 hyperedge 零键、hyperedge 只收非 None 超边键
+    _check("_hyperedge_extra 非 hyperedge 返回空",
+           writepipe._hyperedge_extra({"content_kind": "text",
+                                       "iter_id": "x"}) == {})
+    ex = writepipe._hyperedge_extra({"content_kind": "hyperedge",
+                                     "iter_id": "i1", "corrections": None})
+    _check("_hyperedge_extra 只收非 None 超边键",
+           ex == {"content_kind": "hyperedge", "iter_id": "i1"}, repr(ex))
+    # writepipe 链端到端：a 平铺 fm 键 → audit 闸（验证器装配）→ 链尾落 fm
+    cg = _mk_cg(tmp)
+    audit_mod.register_verifier(hyperedge.CONTENT_KIND,
+                                hyperedge.verify_payload, override=True)
+    try:
+        a = {"op": "write", "node_id": hyperedge.node_id_for(_ROW_STD),
+             "content_kind": "hyperedge", "content": p["content"],
+             "layer": "knowledge", "tags": ["receipt"]}
+        a.update(p["frontmatter"])            # fm 键平铺（EXTRA_FM_KEYS 通道）
+        out = writepipe.default_pipeline().execute(cg, a)
+        _check("writepipe 落盘 committed", out.get("committed") is True,
+               str(out)[:180])
+        rec = cg.get(a["node_id"]) or {}
+        fm = rec.get("frontmatter") or {}
+        _check("超边 fm 落盘完整（锚 + 结构键）",
+               fm.get("content_kind") == "hyperedge"
+               and fm.get("participants") == p["frontmatter"]["participants"]
+               and (fm.get("ledger_row") or {}).get("commit") == _ROW_STD["commit"]
+               and (fm.get("evidence") or [{}])[0].get("verdict") == "PASS"
+               and fm.get("iter_id") == _ROW_STD["iter_id"],
+               str({k: fm.get(k)
+                    for k in ("content_kind", "participants")})[:180])
+        v = hyperedge.verify_payload(hyperedge.payload_from_node(rec))
+        _check("落库节点回放 ACCEPT（写读同进程）", v["state"] == "ACCEPT",
+               str(v)[:140])
+    finally:
+        audit_mod.VERIFIERS.pop(hyperedge.CONTENT_KIND, None)
+
+
+def main():
+    tmp = tempfile.mkdtemp(prefix="hyperedge_")
+    try:
+        _t1_registry()
+        _t2_roundtrip()
+        _t3_audit_states()
+        _t4_failclosed_and_pipeline(tmp)
+    except Exception:  # noqa: BLE001
+        traceback.print_exc()
+        _bad.append("未捕获异常")
+    finally:
+        shutil.rmtree(tmp, ignore_errors=True)
+        # 全局态还原：验证器注册表不留测试残留
+        audit_mod.VERIFIERS.pop(hyperedge.CONTENT_KIND, None)
+    print("\nhyperedge 验收：%d 通过%s"
+          % (_ok, ("，%d 失败：%s" % (len(_bad), "; ".join(_bad))) if _bad else ""))
+    return 1 if _bad else 0
+
+
+if __name__ == "__main__":
+    sys.exit(main())