@furongjun1999/dsh-memory 0.4.7 → 0.4.8

package/md_cg/test_index_durability.py

@@ -0,0 +1,224 @@
+# -*- coding: utf-8 -*-
+"""md_cg · 索引持久化守卫（跨进程可见性 · 进程退出兜底）
+
+运行：python -m md_cg.test_index_durability
+
+背景（2026-09-16 取证，首例=审核裁决通路）：
+  节点 .md 由 `add()` **立即写盘**，但索引条目先进内存 `_dirty`，靠 `flush()` /
+  `close()` 落分片日志。一次性进程（CLI / 脚本）写入 1~2 条、远未达 autoflush(64)
+  阈值即退出 → 日志无记录；而**已有 `_index.json` 的根重开时不重扫目录**
+  （`_load_index`：快照优先，仅重放日志），于是节点「**在盘上但索引无条目**」，
+  其它进程与重载后的长驻进程都检索不到，只能靠某次全量 `rebuild_index()` 偶然救回。
+  表象极易被误判为「写入丢失」——故本测试以**索引可见性**（而非 `get()`）为判据。
+
+固化三处修复 + 一处反证（防测试空转）：
+  ① 库层进程退出兜底（`mdcg._LIVE_CGS` + atexit）：子进程不显式收尾也能落盘；
+  ② `review_decide` 统一收尾：目标节点 **与** 审计记录节点双落盘
+     （accept/edit 写前者、`_record_decision` 写后者；reject 路径**只**写后者）；
+  ③ `review_cli` 显式 `close()`：真实缺陷现场（一次性 CLI 裁决）端到端；
+  ④ 反证组：清空兜底登记 → 复现「索引不可见」，证明 ①② 确在生效。
+
+  `_index.json` 快照是「贴真实库形态」的必要前提：空 root 首开会全扫目录，
+  恰好掩盖本缺陷（这也是首版复现实验失败的教训）。
+"""
+from __future__ import annotations
+
+import os
+import shutil
+import subprocess
+import sys
+import tempfile
+
+from .mdcos import MdCGOS
+
+PASS = FAIL = 0
+FAILS = []
+
+REPO = os.path.dirname(os.path.dirname(os.path.abspath(__file__)))
+
+CCG = ("# 功能名：{n}\n# 生效条件：{c}\n# 子功能：{s}\n# 执行：{e}\n"
+       "# 验证方式：test\n# 不适用条件：{neg}\n\n{body}\n")
+
+
+def check(name, cond, detail=""):
+    global PASS, FAIL
+    if cond:
+        PASS += 1
+        print(f"  [PASS] {name}" + (f"  · {detail}" if detail else ""))
+    else:
+        FAIL += 1
+        FAILS.append(name)
+        print(f"  [FAIL] {name}  · {detail}")
+
+
+def mk(n, cond, body, neg="其它"):
+    return CCG.format(n=n, c=cond, s=body[:20], e=body, neg=neg, body=body)
+
+
+def _child_env():
+    """子进程环境：显式 UTF-8 + PYTHONPATH 指向本仓（纪律 15：不经 Windows shell）。"""
+    env = dict(os.environ)
+    env["PYTHONUTF8"] = "1"
+    env["PYTHONIOENCODING"] = "utf-8"
+    env["PYTHONPATH"] = REPO + os.pathsep + env.get("PYTHONPATH", "")
+    return env
+
+
+def _run_child(code):
+    """以子进程执行一段脚本（argv 列表，shell=False）。"""
+    fd, path = tempfile.mkstemp(suffix=".py", prefix="_idxguard_")
+    with os.fdopen(fd, "w", encoding="utf-8") as f:
+        f.write(code)
+    try:
+        return subprocess.run([sys.executable, path], capture_output=True,
+                              text=True, encoding="utf-8", errors="replace",
+                              env=_child_env(), cwd=REPO)
+    finally:
+        try:
+            os.remove(path)
+        except OSError:
+            pass
+
+
+def _seed(root, nid="seed"):
+    """建一个「已有快照」的库形态（缺陷成立的必要前提）。"""
+    cg = MdCGOS(root, actor="seed")
+    cg.add(nid, mk("种子节点", "问种子", "仅用于建索引快照"),
+           verification_basis="test")
+    cg.flush()
+    cg.rebuild_index()
+    cg.close()
+
+
+def _visible(root, nid):
+    """索引可见性判据：**新实例**（模拟其它进程 / 重载后的长驻进程）索引里是否有该条目。
+
+    刻意不用 `get()`：它夹带密级/密钥可读性判据，会把「索引缺失」与「读不到」混为一谈。
+    """
+    probe = MdCGOS(root, actor="probe")
+    try:
+        return nid in (probe.index.get("nodes") or {})
+    finally:
+        probe.close()
+
+
+CHILD_BODY = (
+    "import sys\n"
+    "sys.path.insert(0, {repo!r})\n"
+    "from md_cg.mdcos import MdCGOS\n"
+    "cg = MdCGOS({root!r}, actor='child', autoflush=64)\n"
+    "cg.add({nid!r}, {content!r}, verification_basis='test')\n"
+)
+
+
+def main():
+    roots = []
+    try:
+        # ---------------- ① 进程退出兜底（atexit） ----------------
+        print("\n【①】库层进程退出兜底：子进程不显式收尾")
+        root_a = tempfile.mkdtemp(prefix="idxdur_a_")
+        roots.append(root_a)
+        _seed(root_a)
+        r = _run_child(CHILD_BODY.format(
+            repo=REPO, root=root_a, nid="n_atexit",
+            content=mk("兜底测试节点", "问兜底", "子进程写一条后直接退出")) +
+            "# 故意不 close：验证进程退出兜底（atexit）\n")
+        check("子进程正常退出", r.returncode == 0, (r.stderr or "")[:200])
+        check("兜底生效：新进程索引可见", _visible(root_a, "n_atexit"))
+
+        # ---------------- ④ 反证组（防测试空转） ----------------
+        print("\n【④】反证组：清空兜底登记 → 复现缺陷")
+        root_b = tempfile.mkdtemp(prefix="idxdur_b_")
+        roots.append(root_b)
+        _seed(root_b)
+        r = _run_child(CHILD_BODY.format(
+            repo=REPO, root=root_b, nid="n_nohook",
+            content=mk("反证测试节点", "问反证", "清空兜底登记后退出")) +
+            "# 反证：摘掉兜底登记（等价于修复前形态）\n"
+            "from md_cg.mdcg import _LIVE_CGS\n"
+            "_LIVE_CGS.clear()\n")
+        check("反证子进程正常退出", r.returncode == 0, (r.stderr or "")[:200])
+        check("反证：索引不可见（缺陷可复现，证明兜底是有效变量）",
+              not _visible(root_b, "n_nohook"))
+
+        # ---------------- ③ 显式 close 对照（原有正路不回归） ----------------
+        print("\n【③】显式收尾对照：close() 仍是正路")
+        root_c = tempfile.mkdtemp(prefix="idxdur_c_")
+        roots.append(root_c)
+        _seed(root_c)
+        r = _run_child(CHILD_BODY.format(
+            repo=REPO, root=root_c, nid="n_close",
+            content=mk("显式收尾节点", "问收尾", "子进程写一条后 close")) +
+            "cg.close()\n")
+        check("显式 close 子进程正常退出", r.returncode == 0, (r.stderr or "")[:200])
+        check("显式 close：新进程索引可见", _visible(root_c, "n_close"))
+
+        # ---------------- ② review_decide 通路统一收尾 ----------------
+        print("\n【②】审核裁决通路：目标节点 + 审计记录节点双落盘")
+        root_d = tempfile.mkdtemp(prefix="idxdur_d_")
+        roots.append(root_d)
+        _seed(root_d, nid="seed_d")
+        osd = MdCGOS(root_d, actor="designer")
+        pid = osd.propose("n_acc", mk("受审节点", "问受审", "审核落盘的目标节点"),
+                          verify={"kind": "test", "assertions": ["断言通过"]})
+        out = osd.review_decide(pid, "accept", reason="测试判据")
+        check("accept 裁决成功", bool(out.get("ok")), str(out)[:160])
+        rec_nid = out.get("record_node_id")
+        probe = MdCGOS(root_d, actor="probe")
+        try:
+            check("accept：目标节点索引可见（新实例）",
+                  out.get("node_id") in probe.index["nodes"], str(out.get("node_id")))
+            check("accept：审计记录节点索引可见（新实例）",
+                  bool(rec_nid) and rec_nid in probe.index["nodes"], str(rec_nid))
+            check("accept：review_records 可列出（复核面不空）",
+                  any(x["id"] == rec_nid for x in probe.review_records(pid=pid)))
+        finally:
+            probe.close()
+
+        pid2 = osd.propose("n_rej", mk("被拒节点", "问被拒", "reject 只记裁决不落目标节点"))
+        out2 = osd.review_decide(pid2, "reject", reason="不通过")
+        check("reject 裁决成功", bool(out2.get("ok")), str(out2)[:160])
+        rec2 = out2.get("record_node_id")
+        check("reject：审计记录节点索引可见（该路径只写它）",
+              bool(rec2) and _visible(root_d, rec2), str(rec2))
+        osd.close()
+
+        # ---------------- ③ review_cli 端到端（真实缺陷现场） ----------------
+        print("\n【③】review_cli 端到端（一次性 CLI 裁决）")
+        root_e = tempfile.mkdtemp(prefix="idxdur_e_")
+        roots.append(root_e)
+        _seed(root_e, nid="seed_e")
+        ose = MdCGOS(root_e, actor="designer")
+        pid_e = ose.propose("n_cli", mk("CLI 裁决节点", "问 CLI",
+                                        "review_cli 落盘的目标节点"))
+        ose.close()
+        r = subprocess.run(
+            [sys.executable, os.path.join(REPO, "scripts", "review_cli.py"),
+             "accept", pid_e, "--root", root_e, "--reason", "端到端守卫测试"],
+            capture_output=True, text=True, encoding="utf-8", errors="replace",
+            env=_child_env(), cwd=REPO)
+        check("review_cli 退出码 0", r.returncode == 0,
+              (r.stdout or r.stderr or "")[:200])
+        check("review_cli：目标节点索引可见（新进程）", _visible(root_e, "n_cli"))
+        probe = MdCGOS(root_e, actor="probe")
+        try:
+            recs = probe.review_records(pid=pid_e)
+            check("review_cli：审计记录节点索引可见",
+                  bool(recs) and all(x["id"] in probe.index["nodes"] for x in recs),
+                  str([x["id"] for x in recs]))
+        finally:
+            probe.close()
+    finally:
+        for r_ in roots:
+            shutil.rmtree(r_, ignore_errors=True)
+
+    print("\n" + "=" * 64)
+    print(f"PASS={PASS}  FAIL={FAIL}")
+    if FAILS:
+        print("失败项：" + "；".join(FAILS))
+    return 0 if FAIL == 0 else 1
+
+
+if __name__ == "__main__":
+    sys.exit(main())
+

package/md_cg/test_lifecycle.py

@@ -0,0 +1,309 @@
+# -*- coding: utf-8 -*-
+"""test_lifecycle · 节点显式生命周期状态机（Pi 可学习优点 ②）
+
+背景：状态散落四处各说各话——`writelimit` 用 tag `tidy:converged`、`forgetting`
+用 importance 升降、`protect` 用 `fm.protected`、`_evolution/ledger.md` 记账本；
+**没有任何地方校验「这一步迁移合不合法」**。本测试覆盖唯一真源 `lifecycle.py`
+及其四条收口路径。
+
+覆盖：① 纯函数裁决 ② 索引快照带状态（内存+磁盘） ③ 合法逐级迁移（历史+审计）
+④ 非法迁移拒绝（负路由，且拒绝不留痕） ⑤ 幂等 ⑥ 受保护豁免降级 / 回升不受限
+⑦ add 全量重建 fm 时的状态继承 ⑧ 存量回填 backfill ⑨ 收口点（writelimit /
+forgetting） ⑩ 边界（节点不存在 / 永不删除）
+
+运行：python -m md_cg.test_lifecycle
+"""
+from __future__ import annotations
+
+import json
+import os
+import shutil
+import tempfile
+
+from . import lifecycle, writelimit
+from .forgetting import reinforce
+from .mdcos import MdCGOS
+
+_root = tempfile.mkdtemp(prefix="mdcg_life_")
+cg = MdCGOS(_root)
+
+_ok = 0
+_fail = []
+
+
+def check(name, cond, detail=""):
+    global _ok
+    if cond:
+        _ok += 1
+        print("[ok] " + name)
+    else:
+        _fail.append(name)
+        print("[FAIL] %s  · %s" % (name, str(detail)[:240]))
+
+
+def _fm(nid):
+    return ((cg.get(nid) or {}).get("frontmatter")) or {}
+
+
+def _idx(nid):
+    return (cg.index.get("nodes") or {}).get(nid) or {}
+
+
+def _disk_index():
+    """读**磁盘** `_index.json`——「免读文件可查」的硬验收面。"""
+    p = os.path.join(cg.root, "_index.json")
+    if not os.path.exists(p):
+        return {}
+    with open(p, encoding="utf-8", errors="replace") as f:
+        return json.load(f)
+
+
+def _index_log():
+    """读**增量索引日志**（ShardedLog 分片）——`flush()` 的实际落点（`_index.json`
+    是快照，由 `rebuild_index()` 写）。"""
+    out = []
+    d = os.path.join(cg.root, "_index_log")
+    if not os.path.isdir(d):
+        return out
+    for fn in sorted(os.listdir(d)):
+        p = os.path.join(d, fn)
+        if not os.path.isfile(p):
+            continue
+        with open(p, encoding="utf-8", errors="replace") as f:
+            for line in f:
+                if not line.strip():
+                    continue
+                try:
+                    out.append(json.loads(line))
+                except Exception:
+                    pass
+    return out
+
+
+def _audit():
+    p = os.path.join(cg.root, lifecycle.AUDIT_FILE)
+    out = []
+    if os.path.exists(p):
+        with open(p, encoding="utf-8", errors="replace") as f:
+            for line in f:
+                if line.strip():
+                    out.append(json.loads(line))
+    return out
+
+
+# ------------------------------------------------------------ ① 纯函数裁决
+check("①1 缺字段 / 未知值 / 非 dict → active（存量兼容，不猜测）",
+      lifecycle.state_of({}) == "active"
+      and lifecycle.state_of({lifecycle.STATE_FIELD: "frozen"}) == "active"
+      and lifecycle.state_of(None) == "active")
+check("①2 状态集内值原样返回",
+      all(lifecycle.state_of({lifecycle.STATE_FIELD: s}) == s
+          for s in lifecycle.STATES))
+check("①3 合法迁移对可通行（逐级降级 + 逐级回升）",
+      lifecycle.can_transition("active", "converged")
+      and lifecycle.can_transition("converged", "demoted")
+      and lifecycle.can_transition("demoted", "archived")
+      and lifecycle.can_transition("archived", "active"))
+check("①4 跳级迁移一律不通",
+      not lifecycle.can_transition("active", "archived")
+      and not lifecycle.can_transition("converged", "archived")
+      and not lifecycle.can_transition("archived", "demoted"))
+check("①5 同状态幂等可通行", lifecycle.can_transition("demoted", "demoted"))
+check("①6 check 未知状态 → unknown_state",
+      lifecycle.check("active", "frozen")[:2] == (False, "unknown_state"))
+check("①7 check 同状态 → noop",
+      lifecycle.check("active", "active")[:2] == (True, "noop"))
+check("①8 check 跳级 → illegal_transition",
+      lifecycle.check("active", "archived")[:2]
+      == (False, "illegal_transition"))
+check("①9 check 受保护降级 → protected；override 放行",
+      lifecycle.check("active", "demoted", protected=True)[:2]
+      == (False, "protected")
+      and lifecycle.check("active", "demoted", protected=True,
+                          override=True)[:2] == (True, "ok"))
+check("①10 is_downgrade 方向正确（回升不算降级）",
+      lifecycle.is_downgrade("active", "archived")
+      and not lifecycle.is_downgrade("archived", "active"))
+
+# ------------------------------------------------------------ ② 新节点与索引
+n1 = cg.add("lc_n1", "生命周期状态机测试节点甲", layer="knowledge")
+check("②1 新节点**显式**落 active（不再依赖缺省约定）",
+      _fm(n1).get(lifecycle.STATE_FIELD) == "active", _fm(n1))
+check("②2 索引快照带状态（内存）",
+      _idx(n1).get(lifecycle.STATE_FIELD) == "active", _idx(n1))
+cg.flush()
+check("②3 增量日志（_index_log）带状态",
+      any((r.get("e") or {}).get(lifecycle.STATE_FIELD) == "active"
+          for r in _index_log() if r.get("id") == n1), _index_log())
+cg.rebuild_index()
+check("②4 磁盘 _index.json 快照带状态（免读文件即可回答「这节点什么状态」）",
+      ((_disk_index().get("nodes") or {}).get(n1) or {}
+       ).get(lifecycle.STATE_FIELD) == "active")
+
+# ------------------------------------------------------------ ③ 合法逐级迁移
+r1 = cg.set_state(n1, "converged", reason="同构聚合定型", actor="test")
+check("③1 active→converged 通过且落盘",
+      r1.get("ok") and r1.get("changed")
+      and _fm(n1).get(lifecycle.STATE_FIELD) == "converged", r1)
+check("③2 索引同步到 converged",
+      _idx(n1).get(lifecycle.STATE_FIELD) == "converged")
+r2 = cg.set_state(n1, "demoted", reason="弱化", actor="test")
+r3 = cg.set_state(n1, "archived", reason="归档", actor="test")
+check("③3 converged→demoted→archived 逐级通过",
+      r2.get("ok") and r3.get("ok")
+      and _fm(n1).get(lifecycle.STATE_FIELD) == "archived")
+h1 = _fm(n1).get(lifecycle.HISTORY_FIELD) or []
+check("③4 迁移历史逐条留痕（from/to/reason/actor）",
+      len(h1) == 3 and h1[-1]["from"] == "demoted"
+      and h1[-1]["to"] == "archived" and h1[-1]["reason"] == "归档"
+      and h1[-1]["actor"] == "test", h1)
+check("③5 审计 _lifecycle.jsonl 留痕 3 条",
+      len([a for a in _audit() if a.get("node_id") == n1]) == 3, _audit())
+check("③6 永不删除：archived 后节点文件仍在且可读",
+      bool(cg.get(n1))
+      and os.path.exists(os.path.join(cg.root, cg.get(n1)["path"])))
+
+# ------------------------------------------------------------ ④ 非法迁移拒绝
+n2 = cg.add("lc_n2", "生命周期状态机测试节点乙", layer="knowledge")
+bad = cg.set_state(n2, "archived", reason="跳级归档", actor="test")
+check("④1 跳级 active→archived 被拒（负路由，不抛）",
+      (not bad.get("ok")) and bad.get("error") == "illegal_transition", bad)
+check("④2 拒绝后 frontmatter 未被改动（不留痕）",
+      _fm(n2).get(lifecycle.STATE_FIELD) in (None, "active")
+      and not (_fm(n2).get(lifecycle.HISTORY_FIELD) or []), _fm(n2))
+check("④3 拒绝后索引未被改动",
+      _idx(n2).get(lifecycle.STATE_FIELD) in (None, "active"))
+check("④4 未知状态被拒",
+      cg.set_state(n2, "frozen").get("error") == "unknown_state")
+check("④5 节点不存在如实上报（不静默创建）",
+      cg.set_state("lc_missing", "converged").get("error") == "node_not_found")
+try:
+    lifecycle.require_transition("active", "archived")
+    _hard = False
+except lifecycle.TransitionError:
+    _hard = True
+check("④6 require_transition 硬拒（写路径抛异常）", _hard)
+try:
+    cg.add("lc_n2", "覆写并试图跳级归档", state="archived")
+    _add_hard = False
+except lifecycle.TransitionError:
+    _add_hard = True
+check("④7 add 覆写显式非法状态 → 硬拒", _add_hard)
+check("④8 硬拒后磁盘内容未被改写（校验先于写盘）",
+      _fm(n2).get(lifecycle.STATE_FIELD) in (None, "active"))
+
+# ------------------------------------------------------------ ⑤ 幂等
+h_before = len(_fm(n1).get(lifecycle.HISTORY_FIELD) or [])
+aud_before = len([a for a in _audit() if a.get("node_id") == n1])
+same = cg.set_state(n1, "archived", reason="重复归档", actor="test")
+check("⑤1 同状态幂等（noop / changed=False）",
+      same.get("ok") and same.get("changed") is False
+      and same.get("code") == "noop", same)
+check("⑤2 幂等不刷历史",
+      len(_fm(n1).get(lifecycle.HISTORY_FIELD) or []) == h_before)
+check("⑤3 幂等不写审计",
+      len([a for a in _audit() if a.get("node_id") == n1]) == aud_before)
+
+# ------------------------------------------------------------ ⑥ 受保护豁免降级
+n3 = cg.add("lc_n3", "受保护节点丙", layer="knowledge", importance=0.8)
+check("⑥0 新建即自动受保护（importance≥0.7）",
+      _fm(n3).get("protected") is True, _fm(n3))
+prot = cg.set_state(n3, "demoted", reason="试图降级", actor="test")
+check("⑥1 受保护节点降级被拒 → protected 码",
+      (not prot.get("ok")) and prot.get("error") == "protected", prot)
+check("⑥2 拒绝后状态未变（保护 = 不可遗忘）",
+      _fm(n3).get(lifecycle.STATE_FIELD) == "active")
+ov = cg.set_state(n3, "demoted", reason="显式放行", actor="test",
+                  override=True)
+check("⑥3 override=True 放行降级",
+      ov.get("ok") and _fm(n3).get(lifecycle.STATE_FIELD) == "demoted", ov)
+up = cg.set_state(n3, "active", reason="回升不受限", actor="test")
+check("⑥4 回升不受保护限制（无需 override）",
+      up.get("ok") and _fm(n3).get(lifecycle.STATE_FIELD) == "active")
+
+# ------------------------------------------------------------ ⑦ add 状态继承
+n4 = cg.add("lc_n4", "状态继承节点丁", layer="knowledge")
+cg.set_state(n4, "converged", reason="定型", actor="test")
+cg.add("lc_n4", "覆写内容（裸 add，不带状态）", layer="knowledge")
+check("⑦1 裸 add 覆写**继承**旧状态（不静默打回 active）",
+      _fm(n4).get(lifecycle.STATE_FIELD) == "converged", _fm(n4))
+check("⑦2 继承后索引仍是 converged",
+      _idx(n4).get(lifecycle.STATE_FIELD) == "converged")
+cg.add("lc_n4", "覆写并合法回升", layer="knowledge", state="active")
+check("⑦3 显式合法迁移放行（converged→active）",
+      _fm(n4).get(lifecycle.STATE_FIELD) == "active")
+check("⑦4 新节点显式状态从 active 起算（active→converged 合法）",
+      _fm(cg.add("lc_n5", "显式定型节点", layer="knowledge",
+                 state="converged")).get(lifecycle.STATE_FIELD) == "converged")
+
+# ------------------------------------------------------------ ⑧ 存量回填
+node4 = cg.get(n4)
+fm4 = dict(node4["frontmatter"])
+fm4.pop(lifecycle.STATE_FIELD, None)                 # 造「旧库缺字段」形态
+cg._write_node(n4, os.path.join(cg.root, node4["path"]), fm4,
+               node4.get("content") or "")
+_idx(n4).pop(lifecycle.STATE_FIELD, None)
+check("⑧0 旧库形态成立（字段已摘除）",
+      lifecycle.STATE_FIELD not in _fm(n4))
+pre = lifecycle.backfill(cg, apply=False)
+check("⑧1 dry-run 盘点缺失且不改盘",
+      pre.get("dry_run") and n4 in (pre.get("planned") or [])
+      and lifecycle.STATE_FIELD not in _fm(n4), pre)
+app = lifecycle.backfill(cg, apply=True)
+check("⑧2 apply 回填为显式 active",
+      app.get("backfilled", 0) >= 1
+      and _fm(n4).get(lifecycle.STATE_FIELD) == "active", app)
+check("⑧3 回填幂等（第二次无缺失）",
+      lifecycle.backfill(cg, apply=True).get("backfilled") == 0)
+check("⑧4 缺字段节点在回填前也按 active 工作（state_of 缺省）",
+      lifecycle.state_of({}) == "active")
+
+# ------------------------------------------------------------ ⑨ 收口点
+n6 = cg.add("lc_n6", "同构聚合成员节点", layer="contextual", importance=0.4)
+node6 = cg.get(n6)
+e6 = {"id": n6, "path": node6["path"],
+      "frontmatter": dict(node6["frontmatter"]),
+      "content": node6.get("content") or ""}
+writelimit._demote(cg, e6)
+check("⑨1 tidy 降权 → lifecycle_state=converged",
+      _fm(n6).get(lifecycle.STATE_FIELD) == "converged", _fm(n6))
+check("⑨2 兼容别名 tidy:converged tag 保留（历史数据不破）",
+      "tidy:converged" in (_fm(n6).get("tags") or []))
+check("⑨3 降权后索引同步 converged",
+      _idx(n6).get(lifecycle.STATE_FIELD) == "converged")
+_imp_before = float(_fm(n6).get("importance") or 0)
+reinforce(cg, n6)
+check("⑨4 MERGE 强化 → 逐级回升 active",
+      _fm(n6).get(lifecycle.STATE_FIELD) == "active", _fm(n6))
+check("⑨5 回升与 importance 强化同批落盘（+delta）",
+      float(_fm(n6).get("importance") or 0) > _imp_before)
+h6 = _fm(n6).get(lifecycle.HISTORY_FIELD) or []
+check("⑨6 两处收口共用同一迁移历史（active→converged→active 两条，同一 actor 面）",
+      len(h6) == 2 and (h6[0]["from"], h6[0]["to"]) == ("active", "converged")
+      and (h6[1]["from"], h6[1]["to"]) == ("converged", "active")
+      and h6[0]["actor"] == "sustain_tidy"
+      and h6[1]["actor"] == "forgetting:reinforce", h6)
+n7 = cg.add("lc_n7", "普通节点庚", layer="knowledge")
+h7_before = len(_fm(n7).get(lifecycle.HISTORY_FIELD) or [])
+reinforce(cg, n7)
+check("⑨7 强化 active 节点：状态幂等（不刷历史、不误降）",
+      _fm(n7).get(lifecycle.STATE_FIELD) == "active"
+      and len(_fm(n7).get(lifecycle.HISTORY_FIELD) or []) == h7_before)
+
+# ------------------------------------------------------------ ⑩ 边界
+check("⑩1 状态字段名与裁决四态 state 不撞名（消歧）",
+      lifecycle.STATE_FIELD == "lifecycle_state"
+      and lifecycle.STATE_FIELD != "state")
+check("⑩2 set_state 返回体恒带 from/to/code（可审计）",
+      set(("from", "to", "code")) <= set(cg.set_state(n7, "active").keys()))
+check("⑩3 迁移历史滚动上限（不无界膨胀）",
+      lifecycle.HISTORY_KEEP > 0
+      and len(_fm(n1).get(lifecycle.HISTORY_FIELD) or [])
+      <= lifecycle.HISTORY_KEEP)
+
+print("=" * 58)
+print("test_lifecycle: %d 通过 / %d 失败" % (_ok, len(_fail)))
+if _fail:
+    print("失败项：" + "、".join(_fail))
+shutil.rmtree(cg.root, ignore_errors=True)
+raise SystemExit(1 if _fail else 0)