@furongjun1999/dsh-memory 0.4.3 → 0.4.5

package/md_cg/test_p2.py

@@ -0,0 +1,205 @@
+# -*- coding: utf-8 -*-
+"""md_cg · P2 记忆 OS 验收（7 项能力 + MCP 前置）
+
+运行：python -m md_cg.test_p2
+"""
+from __future__ import annotations
+
+import json
+import os
+import shutil
+import sys
+import tempfile
+import time
+
+from .mdcos import MdCGOS, WORK_ROLES, est_tokens
+
+PASS = FAIL = 0
+FAILS = []
+
+
+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}")
+
+
+CCG = ("# 功能名：{n}\n# 生效条件：{c}\n# 子功能：{s}\n# 执行：{e}\n"
+       "# 验证方式：test\n# 不适用条件：{neg}\n\n{body}\n")
+
+
+def mk(n, cond, body, neg="其它"):
+    return CCG.format(n=n, c=cond, s=body[:20], e=body, neg=neg, body=body)
+
+
+def main():
+    root = tempfile.mkdtemp(prefix="mdcgos_")
+    try:
+        cg = MdCGOS(root, actor="test")
+
+        # ---------------- 0. 观测时间（条件论「观测时间」栏） ----------------
+        print("\n【0】观测时间（条件论）")
+        cg.add("ts1", mk("无观测时间参数", "问观测", "调用方未提供 condition_space"))
+        fm1 = cg.get("ts1")["frontmatter"]
+        cs1 = fm1.get("condition_space") or {}
+        tw1 = cs1.get("time_window")
+        check("写入自动补 time_window", isinstance(tw1, list) and len(tw1) == 2, str(tw1))
+        check("time_window 锚定写入时刻",
+              bool(tw1) and abs(tw1[0] - fm1.get("created_at", 0)) < 1e-6,
+              f"tw[0]={tw1[0] if tw1 else None} created_at={fm1.get('created_at')}")
+        check("默认观测窗口为 1 小时", bool(tw1) and abs((tw1[1] - tw1[0]) - 3600) < 1e-6,
+              f"跨度={tw1[1]-tw1[0] if tw1 else None}")
+
+        cg.add("ts2", mk("显式观测时间", "问观测", "调用方给了 time_window"),
+               condition_space={"observation_position": "测试", "time_window": [1000.0, 2000.0]})
+        tw2 = (cg.get("ts2")["frontmatter"].get("condition_space") or {}).get("time_window")
+        check("显式 time_window 被保留", tw2 == [1000.0, 2000.0], str(tw2))
+
+        cg.add("ts3", mk("指定 created_at", "问观测", "回填历史时间"), created_at=1700000000.0)
+        fm3 = cg.get("ts3")["frontmatter"]
+        tw3 = (fm3.get("condition_space") or {}).get("time_window")
+        check("created_at 回填时 time_window 同步锚定",
+              bool(tw3) and abs(tw3[0] - 1700000000.0) < 1e-6, str(tw3))
+
+        # ---------------- 2. role 分层索引 ----------------
+        print("\n【2】role 分层索引")
+        cg.add("k1", mk("红按钮移动", "问红按钮", "红按钮控制角色左移"), role="knowledge")
+        cg.add("w1", mk("工具输出噪声", "问红按钮", "红按钮工具输出：左移成功"), role="tool-output")
+        cg.add("w2", mk("命令记录", "问红按钮", "npm test 执行了红按钮测试"), role="command")
+        r_default, _ = cg.search("红按钮", k=10)
+        ids_default = {r[0]["id"] for r in r_default}
+        r_work, _ = cg.search("红按钮", k=10, include_work=True)
+        ids_work = {r[0]["id"] for r in r_work}
+        check("默认检索剔除 work 角色", "w1" not in ids_default and "w2" not in ids_default,
+              f"默认={sorted(ids_default)}")
+        check("include_work=True 时可见 work 角色", "w1" in ids_work or "w2" in ids_work,
+              f"含work={sorted(ids_work)}")
+        r_roles, _ = cg.search("红按钮", k=10, roles=("tool-output",))
+        check("按 roles 精确过滤", all(r[0]["id"].startswith("w") for r in r_roles) and r_roles,
+              f"{[r[0]['id'] for r in r_roles]}")
+
+        # ---------------- 3. RRF 并行多路召回 ----------------
+        print("\n【3】RRF 并行多路召回")
+        cg.add("k2", mk("蓝按钮开门", "问蓝按钮", "蓝按钮打开门"), role="knowledge",
+               tags=["game"], condition_space={"关卡": 1})
+        res, meta = cg.search_rrf("红按钮", k=5, context={"关卡": 1})
+        check("search_rrf 返回结果", len(res) > 0, f"{len(res)} 条")
+        check("meta 自报各路候选数", set(meta.get("paths", {})) >= {"lexical"},
+              json.dumps(meta.get("paths"), ensure_ascii=False))
+        check("结果带 provenance（可审计）", all(len(r) == 4 for r in res),
+              f"元素长度={[len(r) for r in res]}")
+
+        # ---------------- 7. budget-driven pack ----------------
+        print("\n【7】budget-driven pack")
+        big = mk("超长条目", "问超长", "超长内容" * 500)
+        cg.add("big1", big, role="knowledge")
+        small = mk("小条目", "问小条目", "小内容")
+        cg.add("small1", small, role="knowledge")
+        rec = cg.recall("超长 小内容", budget_tokens=200, k=10)
+        check("recall 遵守 token 预算", rec["tokens_used"] <= rec["budget"],
+              f"used={rec['tokens_used']}/{rec['budget']}")
+        check("超大条目被跳过而非停下", any(s["id"] == "big1" for s in rec["skipped"]),
+              f"skipped={[s['id'] for s in rec['skipped']]}")
+        check("跳过超大后仍装入小条目", any(p["id"] == "small1" for p in rec["pack"]),
+              f"pack={[p['id'] for p in rec['pack']]}")
+
+        # ---------------- 1. Fix pairs 自动挖掘 ----------------
+        print("\n【1】Fix pairs 自动挖掘")
+        events = [
+            {"role": "user", "text": "跑测试报错了"},
+            {"role": "tool-output", "text": "Traceback (most recent call last):\n  File x, line 1\nModuleNotFoundError: No module named 'foo'"},
+            {"role": "assistant", "text": "pip install foo"},
+            {"role": "user", "text": "好了"},
+        ]
+        fp = cg.mine_fix_pairs(events)
+        check("挖掘出错误→修复对", len(fp["pairs"]) >= 1, json.dumps(fp["pairs"], ensure_ascii=False)[:120])
+        check("产出可路由修复知识", len(fp["knowledge_ids"]) >= 1, str(fp["knowledge_ids"]))
+        check("产出负记忆（不必深挖根因）", len(fp["rejected_ids"]) >= 1, str(fp["rejected_ids"]))
+        # 修复知识应可被检索命中
+        r_fix, _ = cg.search("ModuleNotFoundError", k=5)
+        check("修复知识可被检索命中", any("fix_" in r[0]["id"] for r in r_fix),
+              f"{[r[0]['id'] for r in r_fix]}")
+        # 幂等：重复挖掘不重复记录
+        fp2 = cg.mine_fix_pairs(events)
+        check("重复挖掘幂等（不重复建节点）",
+              all(rid in fp["rejected_ids"] for rid in fp2["rejected_ids"]),
+              f"第二次={fp2['rejected_ids']}")
+
+        # ---------------- 4. 审核队列 edit/merge ----------------
+        print("\n【4】审核队列 edit/merge")
+        pid = cg.propose("p1", mk("候选知识", "问候选", "候选内容"), tags=["t1"])
+        check("propose 进入 inbox", any(r["pid"] == pid for r in cg.review_list()),
+              f"pending={len(cg.review_list())}")
+        d1 = cg.review_decide(pid, "accept")
+        check("accept 落库", d1.get("ok") and cg.get("p1") is not None, str(d1))
+        check("已裁决项从 inbox 移除", not any(r["pid"] == pid for r in cg.review_list()))
+
+        pid2 = cg.propose("p2", mk("待编辑", "问编辑", "旧内容"))
+        d2 = cg.review_decide(pid2, "edit", edits={"content": mk("待编辑", "问编辑", "新内容")})
+        check("edit 用修改后内容落库", d2.get("ok") and "新内容" in cg.get("p2")["content"], str(d2))
+
+        pid3 = cg.propose("p3", mk("待合并", "问合并", "追加内容"))
+        d3 = cg.review_decide(pid3, "merge", merge_into="k1")
+        merged = cg.get("k1")
+        check("merge 内容追加进目标节点", d3.get("ok") and "追加内容" in merged["content"],
+              f"ok={d3.get('ok')}")
+
+        pid4 = cg.propose("p4", mk("待拒绝", "问拒绝", "垃圾"))
+        d4 = cg.review_decide(pid4, "reject")
+        check("reject 不落节点", d4.get("ok") and cg.get("p4") is None, str(d4))
+        check("decisions 日志有 4 条裁决", len(cg.decisions()) >= 4, str(len(cg.decisions())))
+
+        # ---------------- 5. tombstone + 恢复检查 ----------------
+        print("\n【5】tombstone + 恢复时删除检查")
+        cg.add("t1", mk("待删除", "问删除", "将被软删"), role="knowledge")
+        fg = cg.forget("t1", reason="测试删除")
+        check("forget 软删除成功", fg.get("ok") and cg.get("t1") is None, str(fg))
+        check("节点文件移入 trash/", os.path.exists(os.path.join(root, "trash", "t1.md")))
+        check("删除清单记录墓碑", cg.is_tombstoned("t1"), str(cg.deletions()[-1:]))
+        rs = cg.restore("t1")
+        check("恢复被删除检查拦截", not rs.get("ok") and rs.get("error") == "tombstoned", str(rs))
+        rs2 = cg.restore("t1", force=True)
+        check("force=True 可恢复", rs2.get("ok") and cg.get("t1") is not None, str(rs2))
+
+        # ---------------- 6. payload-free 审计 ----------------
+        print("\n【6】payload-free 审计")
+        audits = cg.audit_records()
+        check("审计有记录", len(audits) > 0, f"{len(audits)} 条")
+        leaked = []
+        for a in audits:
+            blob = json.dumps(a, ensure_ascii=False)
+            if "红按钮控制角色左移" in blob or "超长内容" in blob:
+                leaked.append(a.get("op"))
+        check("审计不含内容（payload-free）", not leaked, f"泄漏={leaked}")
+        check("审计含载荷哈希", all("payload_hash" in a or a.get("op") in
+                                ("forget", "review_decide", "restore") for a in audits),
+              f"样例={audits[0]}")
+
+        # ---------------- OS 健康度 ----------------
+        print("\n【8】OS 健康度")
+        h = cg.health_os()
+        check("health_os 报告 role 分布", "roles" in h.get("os", {}),
+              json.dumps(h["os"].get("roles"), ensure_ascii=False))
+        check("health_os 报告审核/墓碑/审计计数",
+              all(k in h["os"] for k in ("review_pending", "tombstones", "audit_events")),
+              json.dumps({k: h["os"][k] for k in ("review_pending", "tombstones", "audit_events")}))
+
+        cg.close()
+    finally:
+        shutil.rmtree(root, ignore_errors=True)
+
+    print("\n" + "=" * 68)
+    print(f"通过 {PASS} / 失败 {FAIL}")
+    if FAILS:
+        print("失败项：" + ", ".join(FAILS))
+    print("=" * 68)
+    return 0 if FAIL == 0 else 1
+
+
+if __name__ == "__main__":
+    sys.exit(main())

package/md_cg/test_p20_evolution.py

@@ -0,0 +1,315 @@
+# -*- coding: utf-8 -*-
+"""md_cg · 第 20 篇：演化账本（md 载体 · 记录规律与状态 · 可回滚）
+
+设计立场：演化记录的价值不在机器回放，而在**认知规律可读**。
+  · 载体是 md（`_evolution/ledger.md`），人类可读，单一真相源
+  · 每一次修改 = 对一条缺失条件的补充（pattern 规律 + missing 缺失条件）
+  · 记录的是认知规律与状态，不是实现细节（实现属于 git）
+  · 回滚把状态撤回 before，且撤销本身也记一条条目（不可静默）
+
+覆盖：
+  A 载体与格式：md 生成 · 中文标签人类可读 · 状态快照内嵌可解析 · append-only
+  B 规律统计：按缺失条件维度聚类 · top_patterns · evolution/rollback 分账
+  C 回滚：状态撤回 before · 删除改动后才出现的字段 · 撤销留痕 · dry_run · 拒绝条件
+  D 与 consolidate 联动：固化 = 补缺失条件 → 自动落账 + 可回滚
+  E 自描述与 MCP：catalog / summary / health / mdcg_evolution / cg op / 管理权
+  F 幂等与并发：多次追加不丢
+
+运行：python -m md_cg.test_p20_evolution
+"""
+from __future__ import annotations
+
+import json
+import os
+import shutil
+import tempfile
+
+from . import consolidate, evolution
+from .mdcos import MdCGOS, MdCGSecure
+from .security import AccessDenied, Principal
+
+PASS = FAIL = 0
+FAILS = []
+
+
+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}")
+
+
+# ---------------- consolidate 的假双模型（同 P6 口径） ----------------
+BODY = ("# 功能名：微分方程应用\n"
+        "微分方程应用：建模与求解，使用数值方法迭代求解，需给定边界条件\n")
+CAND = {"生效条件": ["微分方程", "数值方法"], "子功能": ["建模", "求解"],
+        "执行": "使用数值方法迭代求解", "不适用条件": ["边界条件缺失"]}
+
+
+def fake_reflect(prompt):
+    return "```json\n" + json.dumps(CAND, ensure_ascii=False) + "\n```"
+
+
+def fake_verify(prompt):
+    out = {f: {"keep": v if isinstance(v, list) else [v], "drop": [],
+               "reason": "逐条核验"} for f, v in CAND.items()}
+    return json.dumps(out, ensure_ascii=False)
+
+
+def main():
+    root = tempfile.mkdtemp(prefix="mdcg_p20_")
+    cg = MdCGOS(root)
+
+    # ================= A. 载体与格式 =================
+    print("\n[A] 载体与格式（md 人类可读 · 状态内嵌可解析 · append-only）")
+
+    cg.add("n1", "# 功能名：示例节点\n用于演化账本测试\n", layer="knowledge",
+           importance=0.5, confidence=0.6)
+
+    raised = False
+    try:
+        cg.evolution_record(node_id="n1", pattern="", missing="执行")
+    except ValueError:
+        raised = True
+    check("A1 缺「规律」被拒（没有规律就没有可复用认知）", raised)
+
+    raised = False
+    try:
+        cg.evolution_record(node_id="n1", pattern="规律X", kind="不存在的类型")
+    except ValueError:
+        raised = True
+    check("A2 未知演化类型被拒", raised)
+
+    e1 = cg.evolution_record(
+        node_id="n1", pattern="缺时间窗口的条件在跨季度查询里被误召回",
+        missing="conditions.time_window", change="补充生效条件的时间窗口",
+        evidence="replay通过", source="manual",
+        before={"confidence": 0.6, "importance": 0.5},
+        after={"confidence": 0.55, "importance": 0.5})
+
+    led = os.path.join(root, evolution.EVOLUTION_DIR, evolution.LEDGER_NAME)
+    check("A3 账本落在 _evolution/ledger.md", os.path.exists(led), led)
+
+    text = evolution.read_ledger(cg)
+    check("A4 正文是人类可读中文标签",
+          all(f"**{k}**" in text for k in ("规律", "缺失条件", "动作", "状态", "证据")),
+          text[:0] or "")
+    check("A5 规律原文入账", "跨季度查询里被误召回" in text)
+    check("A6 状态差异人可读", "confidence 0.6→0.55" in text,
+          [l for l in text.split("\n") if "状态" in l][:1])
+
+    blocks = evolution._STATE_RE.findall(text)
+    parsed_state = json.loads(blocks[0]) if blocks else {}
+    check("A7 状态快照内嵌 json 块且可解析",
+          parsed_state.get("before", {}).get("confidence") == 0.6
+          and parsed_state.get("kind") == "condition_gap",
+          str(parsed_state)[:80])
+
+    e2 = cg.evolution_record(node_id="n1", pattern="缺执行维的节点无法判定适用性",
+                             missing="execution", change="补执行", source="manual")
+    text2 = evolution.read_ledger(cg)
+    check("A8 append-only：旧条目不被覆盖",
+          e1["entry_id"] in text2 and e2["entry_id"] in text2)
+    check("A9 账本头部说明只出现一次",
+          text2.count("# 演化账本 · md_cg") == 1)
+
+    ents = cg.evolution_entries(limit=10)["entries"]
+    check("A10 entries 倒序（最新在前）", ents and ents[0]["entry_id"] == e2["entry_id"])
+    check("A11 entries limit 生效",
+          len(cg.evolution_entries(limit=1)["entries"]) == 1)
+    check("A12 show 取单条", cg.evolution_show(e1["entry_id"])["entry"]["node_id"] == "n1")
+
+    # ================= B. 规律统计 =================
+    print("\n[B] 规律统计（认知功能记录规律：看清反复缺什么）")
+
+    cg.evolution_record(node_id="n1", pattern="缺时间窗口的条件在跨季度查询里被误召回",
+                        missing="conditions.time_window", source="consolidate")
+    pat = cg.evolution_patterns()
+    check("B1 按缺失条件维度聚类", pat["by_missing"].get("conditions.time_window") == 2,
+          str(pat["by_missing"]))
+    check("B2 top_patterns 计数重复规律",
+          pat["top_patterns"] and pat["top_patterns"][0]["count"] == 2,
+          str(pat["top_patterns"][:1]))
+    check("B3 来源统计", pat["by_source"].get("manual") == 2
+          and pat["by_source"].get("consolidate") == 1, str(pat["by_source"]))
+    check("B4 evolution 与 rollback 分账（此时无回滚）",
+          pat["evolutions"] == 3 and pat["rollbacks"] == 0, str(pat["total"]))
+
+    # ================= C. 回滚 =================
+    print("\n[C] 回滚（撤回补充 · 撤销留痕 · 拒绝条件）")
+
+    fm0 = cg.get("n1")["frontmatter"]
+    fm0["non_applicable_conditions"] = ["边界条件缺失"]
+    fm0["confidence"] = 0.55
+    cg._write_node("n1", os.path.join(root, cg.get("n1")["path"]), fm0,
+                   cg.get("n1")["content"])
+
+    before = {"confidence": 0.6, "importance": 0.5}
+    after = {"confidence": 0.55, "importance": 0.5,
+             "non_applicable_conditions": ["边界条件缺失"]}
+    e3 = cg.evolution_record(node_id="n1", pattern="补负条件以防误召回",
+                             missing="non_applicable_conditions",
+                             change="补充不适用条件", source="manual",
+                             before=before, after=after)
+
+    dry = cg.evolution_rollback(e3["entry_id"], dry_run=True)
+    check("C1 dry_run 预演列出将删除的字段",
+          dry["ok"] and dry["would_remove"] == ["non_applicable_conditions"],
+          str(dry.get("would_remove")))
+    check("C2 dry_run 不落盘", cg.get("n1")["frontmatter"].get("confidence") == 0.55)
+    n_before = len(cg.evolution_entries(limit=0)["entries"])
+    check("C3 dry_run 不写条目",
+          len(cg.evolution_entries(limit=0)["entries"]) == n_before)
+
+    rb = cg.evolution_rollback(e3["entry_id"])
+    fm1 = cg.get("n1")["frontmatter"]
+    check("C4 回滚把状态撤回 before", fm1.get("confidence") == 0.6, str(fm1.get("confidence")))
+    check("C5 回滚删除「改动后才出现」的字段（真的撤回补充）",
+          "non_applicable_conditions" not in fm1, str(fm1.get("non_applicable_conditions")))
+    check("C6 回滚本身记一条条目且不可静默",
+          rb["rollback_entry"]["kind"] == evolution.KIND_ROLLBACK
+          and rb["rollback_entry"]["rollback_of"] == e3["entry_id"],
+          str(rb["rollback_entry"].get("rollback_of")))
+    pat2 = cg.evolution_patterns()
+    check("C7 回滚计入 rollbacks 分账", pat2["rollbacks"] == 1, str(pat2))
+
+    again = cg.evolution_rollback(rb["rollback_entry"]["entry_id"])
+    check("C8 不能回滚一条回滚记录", again["ok"] is False, str(again.get("error")))
+
+    e4 = cg.evolution_record(node_id="n1", pattern="无状态快照的条目")
+    no_state = cg.evolution_rollback(e4["entry_id"])
+    check("C9 无 before 的条目拒绝回滚", no_state["ok"] is False, str(no_state.get("error")))
+
+    missing = cg.evolution_rollback("evo-19700101-000000-dead")
+    check("C10 不存在的条目拒绝回滚", missing["ok"] is False, str(missing.get("error")))
+
+    # 层迁移回滚
+    cg._move_layer("n1", "contextual", reason="p20 test")
+    e5 = cg.evolution_record(node_id="n1", pattern="上下文相关，降级到 contextual",
+                             missing="conditions", change="层间迁移",
+                             source="manual",
+                             before={"layer": "knowledge"},
+                             after={"layer": "contextual"})
+    rb5 = cg.evolution_rollback(e5["entry_id"])
+    check("C11 回滚层迁移（contextual → knowledge）",
+          "layer" in rb5["applied"] and cg.get("n1")["frontmatter"].get("layer") == "knowledge",
+          str(rb5["applied"]))
+
+    # ================= D. 与 consolidate 联动 =================
+    print("\n[D] 与 consolidate 联动（每一次固化 = 补一条缺失条件）")
+
+    root2 = tempfile.mkdtemp(prefix="mdcg_p20c_")
+    try:
+        cg2 = MdCGOS(root2)
+        cg2.add("n1", BODY, layer="knowledge")
+        n0 = len(cg2.evolution_entries(limit=0)["entries"])
+        rep = consolidate.consolidate(root2, apply=True, reflect_fn=fake_reflect,
+                                      verify_fn=fake_verify, verification_basis="测试依据",
+                                      verbose=False)
+        ents = cg2.evolution_entries(limit=0)["entries"]
+        check("D1 固化前账本为空", n0 == 0, str(n0))
+        check("D2 固化后自动落账 1 条", len(ents) == 1 and rep["written"] == 1,
+              f"entries={len(ents)} written={rep['written']}")
+        ce = ents[0]
+        check("D3 来源标记 consolidate", ce["source"] == "consolidate", str(ce.get("source")))
+        check("D4 缺失条件记全（含执行维）",
+              all(f in ce["missing"] for f in ("执行", "生效条件", "不适用条件")),
+              str(ce.get("missing")))
+        check("D5 状态快照记下补充后的负条件",
+              (ce["state"].get("after") or {}).get("non_applicable_conditions") == ["边界条件缺失"],
+              str(ce["state"].get("after")))
+        check("D6 规律可读且非空", len(ce["pattern"]) > 8, ce["pattern"])
+
+        rb = cg2.evolution_rollback(ce["entry_id"])
+        fm = cg2.get("n1")["frontmatter"]
+        check("D7 consolidate 的补充可回滚（负条件被撤回）",
+              rb["ok"] and not fm.get("non_applicable_conditions"),
+              str(fm.get("non_applicable_conditions")))
+        cg2.close()
+    finally:
+        shutil.rmtree(root2, ignore_errors=True)
+
+    # ================= E. 自描述与 MCP =================
+    print("\n[E] 自描述与 MCP（可发现 · 可路由 · 管理权）")
+
+    cat = cg.evolution_catalog()
+    check("E1 原则含「每一次修改 = 对一条缺失条件的补充」",
+          any("缺失条件" in p for p in cat["principles"]), str(cat["principles"][:1]))
+    check("E2 自描述写清回滚范围与未覆盖项",
+          "scope" in cat["rollback"] and cat["rollback"].get("not_covered"),
+          str(cat["rollback"].get("not_covered")))
+    check("E3 自描述列出状态字段与条件维度",
+          "confidence" in cat["state_fields"] and "execution" in cat["condition_dims"])
+
+    s = cg.evolution_summary()
+    check("E4 summary 一句话 + 最近条目", "演化" in s["text"] and s["recent"],
+          s["text"])
+    h = cg.health_os()
+    check("E5 health_os 并入 evolution 面", "evolution" in h["os"],
+          str(list(h["os"].keys()))[:60])
+
+    from . import mcp_server as ms
+    names = {t["name"] for t in ms.TOOLS}
+    check("E6 MCP 注册 mdcg_evolution", "mdcg_evolution" in names)
+    r = ms._cg_call(cg, {"op": "evolution", "action": "catalog"})
+    check("E7 cg op=evolution 路由到账本", r.get("module") == "evolution",
+          str(r.get("module")))
+    r2 = ms._evolution_call(cg, {"action": "patterns", "limit": 3})
+    check("E8 细粒度入口与 cg op 同源", "by_missing" in r2, str(list(r2.keys())))
+
+    root3 = tempfile.mkdtemp(prefix="mdcg_p20s_")
+    try:
+        cg_s = MdCGSecure(root3, principal=Principal(
+            tenant="private", actor="op", clearance="private",
+            can_write=True, can_admin=False))
+        cg_s.add("n1", "# 受管节点\n", layer="knowledge")
+        es = cg_s.evolution_record(node_id="n1", pattern="管理权测试",
+                                   before={"confidence": 0.6},
+                                   after={"confidence": 0.5})
+        denied = False
+        try:
+            cg_s.evolution_rollback(es["entry_id"])
+        except AccessDenied:
+            denied = True
+        check("E9 回滚需 can_admin（直接 API 亦拦截）", denied)
+        cg_s.close()
+    finally:
+        shutil.rmtree(root3, ignore_errors=True)
+
+    # ================= F. 幂等与并发 =================
+    print("\n[F] 幂等与并发（append-only 不丢）")
+
+    root4 = tempfile.mkdtemp(prefix="mdcg_p20f_")
+    try:
+        cg4 = MdCGOS(root4)
+        cg4.add("n1", "# 节点\n", layer="knowledge")
+        ids = [cg4.evolution_record(node_id="n1", pattern=f"规律{i}",
+                                    missing="execution")["entry_id"]
+               for i in range(10)]
+        got = {e["entry_id"] for e in cg4.evolution_entries(limit=0)["entries"]}
+        check("F1 连续 10 次追加全部保留", set(ids) <= got and len(got) == 10,
+              f"got={len(got)}")
+        cg4.evolution_record(node_id="other", pattern="别的节点", missing="conditions")
+        hh = cg4.evolution_history("n1")
+        check("F2 history 按节点过滤", len(hh["entries"]) == 10, str(len(hh["entries"])))
+        check("F3 账本可被重新解析（幂等读取）",
+              len(cg4.evolution_entries(limit=0)["entries"]) == 11)
+        cg4.close()
+    finally:
+        shutil.rmtree(root4, ignore_errors=True)
+
+    cg.close()
+    shutil.rmtree(root, ignore_errors=True)
+
+    print(f"\n结果：PASS={PASS}  FAIL={FAIL}")
+    if FAILS:
+        print("失败项：" + "、".join(FAILS))
+    return 0 if FAIL == 0 else 1
+
+
+if __name__ == "__main__":
+    raise SystemExit(main())