@furongjun1999/dsh-memory 0.4.11 → 0.5.1

package/md_cg/test_p18_whitebox.py

@@ -1,171 +1,171 @@
-# -*- coding: utf-8 -*-
-"""P18：md_cg 显式调用白箱 + 能力验证（`whitebox.py`）。
-
-背景（2026-09-10）：白箱 LLM provider 已下线，AEIS 降为**能力库**；
-改由 md_cg 通过 `cg(op=whitebox)` 显式调用白箱，并验证其：
-  · 编码能力（remember → 追问命中）
-  · 已有知识回答能力（route=self 且回答非空）
-
-本测试不依赖真实 AEIS（用 FakeClient 注入），验证协议/判定/留痕/分发逻辑。
-"""
-import os
-
-from . import whitebox
-
-PASS = FAIL = 0
-
-
-def check(name, cond, detail=""):
-    global PASS, FAIL
-    if cond:
-        PASS += 1
-        print(f"  [PASS] {name}" + (f"  · {detail}" if detail else ""))
-    else:
-        FAIL += 1
-        print(f"  [FAIL] {name}" + (f"  · {detail}" if detail else ""))
-
-
-# --------------------------------------------------------------------------
-# 测试替身
-# --------------------------------------------------------------------------
-
-class FakeClient:
-    def __init__(self, answer="", route="self", remember_ok=True, fail=False):
-        self.answer = answer
-        self.route = route
-        self.remember_ok = remember_ok
-        self.fail = fail
-        self.started = False
-        self.closed = False
-        self.remembered = []
-
-    def start(self):
-        if self.fail:
-            raise RuntimeError("whitebox offline")
-        self.started = True
-        return self
-
-    def close(self):
-        self.closed = True
-
-    def ask(self, message, session_id="md_cg-whitebox-verify"):
-        if self.fail:
-            raise RuntimeError("whitebox offline")
-        return {"ok": True, "route": self.route, "reply": self.answer, "raw": {}}
-
-    def remember(self, content, importance=0.9, tags=None):
-        if self.fail:
-            raise RuntimeError("whitebox offline")
-        self.remembered.append(content)
-        return {"ok": self.remember_ok, "raw": {}}
-
-    def call(self, name, args):
-        if self.fail:
-            raise RuntimeError("whitebox offline")
-        return {"isError": False, "text": "{}", "data": {"tool": name}}
-
-
-class FakeCG:
-    def __init__(self):
-        self.nodes = []
-
-    def add(self, nid, content, **kw):
-        self.nodes.append({"id": nid, "content": content, "frontmatter": kw})
-        return nid
-
-    def search(self, query, **kw):
-        return ([(n, 1.0, {}) for n in self.nodes], {"k": len(self.nodes)})
-
-
-def main():
-    # ---------- A. 协议与解析 ----------
-    print("\n[A] 客户端协议与结果归一化")
-    saved = {k: os.environ.get(k) for k in ("MDCG_WHITEBOX_CMD", "MDCG_WHITEBOX_ARGS")}
-    try:
-        os.environ["MDCG_WHITEBOX_CMD"] = "python3"
-        os.environ["MDCG_WHITEBOX_ARGS"] = "-m aeis.mcp.server --x"
-        check("A1 启动命令可用环境变量覆盖",
-              whitebox._launch_cmd() == ["python3", "-m", "aeis.mcp.server", "--x"])
-    finally:
-        for k, v in saved.items():
-            if v is None:
-                os.environ.pop(k, None)
-            else:
-                os.environ[k] = v
-    check("A2 route 解析", whitebox._extract_route({"route": "self"}) == "self")
-    check("A3 reply 多键解析",
-          whitebox._extract_reply({"answer": "hi"}) == "hi"
-          and whitebox._extract_reply({"text": "yo"}) == "yo")
-    check("A4 reply 嵌套解析",
-          whitebox._extract_reply({"data": {"reply": "deep"}}) == "deep")
-    check("A5 缺字段回落", whitebox._extract_reply({}, "fallback") == "fallback")
-
-    # ---------- B. 验证·编码能力 ----------
-    print("\n[B] 验证「编码能力」（remember → 追问命中）")
-    cg = FakeCG()
-    hit = FakeClient(answer="口令ABC")
-    r1 = whitebox.verify_encoding(cg, client=hit, marker="口令ABC")
-    check("B1 编码成功且追问命中 → ok",
-          r1["ok"] and r1["encoded"] and r1["recalled"], str(r1.get("route")))
-    check("B2 编码后写入留痕节点", bool(r1.get("node_id")))
-    miss = FakeClient(answer="我不知道")
-    r2 = whitebox.verify_encoding(cg, client=miss, marker="口令XYZ")
-    check("B3 追问未命中 → 失败", (not r2["ok"]) and r2["encoded"]
-          and (not r2["recalled"]))
-    r3 = whitebox.verify_encoding(cg, client=FakeClient(fail=True), marker="X")
-    check("B4 白箱不可用 → 如实失败且不抛",
-          (not r3["ok"]) and "error" in r3)
-
-    # ---------- C. 验证·已有知识回答能力 ----------
-    print("\n[C] 验证「已有知识回答能力」（route=self 且非空）")
-    cg = FakeCG()
-    r4 = whitebox.verify_existing(cg, client=FakeClient(answer="我是灵枢", route="self"))
-    check("C1 route=self 且非空 → ok", r4["ok"])
-    r5 = whitebox.verify_existing(cg, client=FakeClient(answer="…", route="llm"))
-    check("C2 route=llm → 未通过（非白箱自答）", not r5["ok"])
-    r6 = whitebox.verify_existing(cg, client=FakeClient(answer="", route="self"))
-    check("C3 空回答 → 未通过", not r6["ok"])
-
-    # ---------- D. 留痕与报告 ----------
-    print("\n[D] 验证结论留痕 + 报告")
-    cg = FakeCG()
-    whitebox.verify_encoding(cg, client=FakeClient(answer="口令D"), marker="口令D")
-    whitebox.verify_existing(cg, client=FakeClient(answer="我是灵枢"))
-    check("D1 结论写入 self 层", len(cg.nodes) == 2
-          and all(n["frontmatter"].get("layer") == "self" for n in cg.nodes))
-    check("D2 留痕带 whitebox:verify 标签",
-          all(whitebox.VERIFY_TAG in n["frontmatter"].get("tags", [])
-              for n in cg.nodes))
-    rep = whitebox.report(cg)
-    check("D3 报告可读回验证留痕", rep["ok"] and rep["count"] == 2)
-    check("D4 无 cg 时报告不抛", whitebox.report(None)["ok"] is False)
-
-    # ---------- E. MCP 分发 ----------
-    print("\n[E] cg(op=whitebox) 分发")
-    saved_cls = whitebox.WhiteboxClient
-    try:
-        whitebox.WhiteboxClient = (lambda *a, **k: FakeClient(answer="我是灵枢",
-                                                              route="self"))
-        check("E1 action=ping",
-              whitebox.dispatch(None, {"action": "ping"})["ok"])
-        check("E2 action=ask",
-              whitebox.dispatch(None, {"action": "ask",
-                                       "question": "你好"})["reply"] == "我是灵枢")
-        enc = whitebox.dispatch(FakeCG(), {"action": "verify_encoding",
-                                           "marker": "M"})
-        check("E3 action=verify_encoding", enc["kind"] == "encoding")
-        try:
-            whitebox.dispatch(None, {"action": "nope"})
-            check("E4 未知 action → 抛错", False)
-        except ValueError:
-            check("E4 未知 action → 抛错", True)
-    finally:
-        whitebox.WhiteboxClient = saved_cls
-
-    print(f"\n==== P18 结果：{PASS} 通过 / {FAIL} 失败 ====")
-    return FAIL
-
-
-if __name__ == "__main__":
-    import sys
-    sys.exit(1 if main() else 0)
+# -*- coding: utf-8 -*-
+"""P18：md_cg 显式调用白箱 + 能力验证（`whitebox.py`）。
+
+背景（2026-09-10）：白箱 LLM provider 已下线，AEIS 降为**能力库**；
+改由 md_cg 通过 `cg(op=whitebox)` 显式调用白箱，并验证其：
+  · 编码能力（remember → 追问命中）
+  · 已有知识回答能力（route=self 且回答非空）
+
+本测试不依赖真实 AEIS（用 FakeClient 注入），验证协议/判定/留痕/分发逻辑。
+"""
+import os
+
+from . import whitebox
+
+PASS = FAIL = 0
+
+
+def check(name, cond, detail=""):
+    global PASS, FAIL
+    if cond:
+        PASS += 1
+        print(f"  [PASS] {name}" + (f"  · {detail}" if detail else ""))
+    else:
+        FAIL += 1
+        print(f"  [FAIL] {name}" + (f"  · {detail}" if detail else ""))
+
+
+# --------------------------------------------------------------------------
+# 测试替身
+# --------------------------------------------------------------------------
+
+class FakeClient:
+    def __init__(self, answer="", route="self", remember_ok=True, fail=False):
+        self.answer = answer
+        self.route = route
+        self.remember_ok = remember_ok
+        self.fail = fail
+        self.started = False
+        self.closed = False
+        self.remembered = []
+
+    def start(self):
+        if self.fail:
+            raise RuntimeError("whitebox offline")
+        self.started = True
+        return self
+
+    def close(self):
+        self.closed = True
+
+    def ask(self, message, session_id="md_cg-whitebox-verify"):
+        if self.fail:
+            raise RuntimeError("whitebox offline")
+        return {"ok": True, "route": self.route, "reply": self.answer, "raw": {}}
+
+    def remember(self, content, importance=0.9, tags=None):
+        if self.fail:
+            raise RuntimeError("whitebox offline")
+        self.remembered.append(content)
+        return {"ok": self.remember_ok, "raw": {}}
+
+    def call(self, name, args):
+        if self.fail:
+            raise RuntimeError("whitebox offline")
+        return {"isError": False, "text": "{}", "data": {"tool": name}}
+
+
+class FakeCG:
+    def __init__(self):
+        self.nodes = []
+
+    def add(self, nid, content, **kw):
+        self.nodes.append({"id": nid, "content": content, "frontmatter": kw})
+        return nid
+
+    def search(self, query, **kw):
+        return ([(n, 1.0, {}) for n in self.nodes], {"k": len(self.nodes)})
+
+
+def main():
+    # ---------- A. 协议与解析 ----------
+    print("\n[A] 客户端协议与结果归一化")
+    saved = {k: os.environ.get(k) for k in ("MDCG_WHITEBOX_CMD", "MDCG_WHITEBOX_ARGS")}
+    try:
+        os.environ["MDCG_WHITEBOX_CMD"] = "python3"
+        os.environ["MDCG_WHITEBOX_ARGS"] = "-m aeis.mcp.server --x"
+        check("A1 启动命令可用环境变量覆盖",
+              whitebox._launch_cmd() == ["python3", "-m", "aeis.mcp.server", "--x"])
+    finally:
+        for k, v in saved.items():
+            if v is None:
+                os.environ.pop(k, None)
+            else:
+                os.environ[k] = v
+    check("A2 route 解析", whitebox._extract_route({"route": "self"}) == "self")
+    check("A3 reply 多键解析",
+          whitebox._extract_reply({"answer": "hi"}) == "hi"
+          and whitebox._extract_reply({"text": "yo"}) == "yo")
+    check("A4 reply 嵌套解析",
+          whitebox._extract_reply({"data": {"reply": "deep"}}) == "deep")
+    check("A5 缺字段回落", whitebox._extract_reply({}, "fallback") == "fallback")
+
+    # ---------- B. 验证·编码能力 ----------
+    print("\n[B] 验证「编码能力」（remember → 追问命中）")
+    cg = FakeCG()
+    hit = FakeClient(answer="口令ABC")
+    r1 = whitebox.verify_encoding(cg, client=hit, marker="口令ABC")
+    check("B1 编码成功且追问命中 → ok",
+          r1["ok"] and r1["encoded"] and r1["recalled"], str(r1.get("route")))
+    check("B2 编码后写入留痕节点", bool(r1.get("node_id")))
+    miss = FakeClient(answer="我不知道")
+    r2 = whitebox.verify_encoding(cg, client=miss, marker="口令XYZ")
+    check("B3 追问未命中 → 失败", (not r2["ok"]) and r2["encoded"]
+          and (not r2["recalled"]))
+    r3 = whitebox.verify_encoding(cg, client=FakeClient(fail=True), marker="X")
+    check("B4 白箱不可用 → 如实失败且不抛",
+          (not r3["ok"]) and "error" in r3)
+
+    # ---------- C. 验证·已有知识回答能力 ----------
+    print("\n[C] 验证「已有知识回答能力」（route=self 且非空）")
+    cg = FakeCG()
+    r4 = whitebox.verify_existing(cg, client=FakeClient(answer="我是灵枢", route="self"))
+    check("C1 route=self 且非空 → ok", r4["ok"])
+    r5 = whitebox.verify_existing(cg, client=FakeClient(answer="…", route="llm"))
+    check("C2 route=llm → 未通过（非白箱自答）", not r5["ok"])
+    r6 = whitebox.verify_existing(cg, client=FakeClient(answer="", route="self"))
+    check("C3 空回答 → 未通过", not r6["ok"])
+
+    # ---------- D. 留痕与报告 ----------
+    print("\n[D] 验证结论留痕 + 报告")
+    cg = FakeCG()
+    whitebox.verify_encoding(cg, client=FakeClient(answer="口令D"), marker="口令D")
+    whitebox.verify_existing(cg, client=FakeClient(answer="我是灵枢"))
+    check("D1 结论写入 self 层", len(cg.nodes) == 2
+          and all(n["frontmatter"].get("layer") == "self" for n in cg.nodes))
+    check("D2 留痕带 whitebox:verify 标签",
+          all(whitebox.VERIFY_TAG in n["frontmatter"].get("tags", [])
+              for n in cg.nodes))
+    rep = whitebox.report(cg)
+    check("D3 报告可读回验证留痕", rep["ok"] and rep["count"] == 2)
+    check("D4 无 cg 时报告不抛", whitebox.report(None)["ok"] is False)
+
+    # ---------- E. MCP 分发 ----------
+    print("\n[E] cg(op=whitebox) 分发")
+    saved_cls = whitebox.WhiteboxClient
+    try:
+        whitebox.WhiteboxClient = (lambda *a, **k: FakeClient(answer="我是灵枢",
+                                                              route="self"))
+        check("E1 action=ping",
+              whitebox.dispatch(None, {"action": "ping"})["ok"])
+        check("E2 action=ask",
+              whitebox.dispatch(None, {"action": "ask",
+                                       "question": "你好"})["reply"] == "我是灵枢")
+        enc = whitebox.dispatch(FakeCG(), {"action": "verify_encoding",
+                                           "marker": "M"})
+        check("E3 action=verify_encoding", enc["kind"] == "encoding")
+        try:
+            whitebox.dispatch(None, {"action": "nope"})
+            check("E4 未知 action → 抛错", False)
+        except ValueError:
+            check("E4 未知 action → 抛错", True)
+    finally:
+        whitebox.WhiteboxClient = saved_cls
+
+    print(f"\n==== P18 结果：{PASS} 通过 / {FAIL} 失败 ====")
+    return FAIL
+
+
+if __name__ == "__main__":
+    import sys
+    sys.exit(1 if main() else 0)

package/md_cg/test_p19_migrate_roleplay.py

@@ -1,149 +1,149 @@
-# -*- coding: utf-8 -*-
-"""P19：角色扮演 / 互维数据迁移到认知图（`migrate_roleplay.py`）。
-
-用合成数据验证：读取归一化 → 落图（层/标签/内容）→ 回读等价 → 幂等。
-不依赖真实 roleplay_data / ~/.lingxu_net。
-"""
-import io
-import json
-import os
-import shutil
-import tempfile
-
-from . import migrate_roleplay as M
-from .mdcos import MdCGSecure
-from .security import Principal
-
-PASS = FAIL = 0
-
-
-def check(name, cond, detail=""):
-    global PASS, FAIL
-    if cond:
-        PASS += 1
-        print(f"  [PASS] {name}" + (f"  · {detail}" if detail else ""))
-    else:
-        FAIL += 1
-        print(f"  [FAIL] {name}" + (f"  · {detail}" if detail else ""))
-
-
-def _write(path, obj_or_text):
-    os.makedirs(os.path.dirname(path), exist_ok=True)
-    with io.open(path, "w", encoding="utf-8") as f:
-        if isinstance(obj_or_text, str):
-            f.write(obj_or_text)
-        else:
-            json.dump(obj_or_text, f, ensure_ascii=False)
-
-
-def _build_fixture(base):
-    data = os.path.join(base, "roleplay_data")
-    _write(os.path.join(data, "roleplay", "_roles.json"), {
-        "alice": {
-            "name": "Alice", "scenario": "雨夜咖啡馆", "first_mes": "欢迎光临",
-            "memory_items": [{"content": "Alice 喜欢猫"}],
-            "anchors_items": [{"content": "Alice 永不背叛"}],
-            "values_items": [{"content": "诚实优先"}],
-        },
-        "bob": {"name": "Bob", "scenario": ""},
-    })
-    lines = [
-        json.dumps({"time": 1700000000000, "role": "user", "text": "你好"},
-                   ensure_ascii=False),
-        json.dumps({"time": 1700000001000, "role": "bot", "text": "你好呀",
-                    "route": "self"}, ensure_ascii=False),
-    ]
-    _write(os.path.join(data, "transcripts", "alice__shared.jsonl"),
-           "\n".join(lines) + "\n")
-
-    net = os.path.join(base, "lingxu_net", "tasks")
-    _write(os.path.join(net, "task-t1.json"),
-           {"id": "t1", "payload": {"claim": "地球是圆的", "source_ref": "wiki"}})
-    _write(os.path.join(net, "result-t1.json"),
-           {"task_id": "t1", "verdict": "pass", "at": 1700000002,
-            "whitebox": {"judgment": "采纳", "best": "地球是圆的"}})
-    _write(os.path.join(net, "task-t2.json"),
-           {"id": "t2", "payload": {"claim": "月亮是奶酪做的"}})
-    return data, os.path.dirname(net)
-
-
-def main():
-    base = tempfile.mkdtemp(prefix="mdcg_p19_")
-    try:
-        data, net = _build_fixture(base)
-        root = os.path.join(base, "mdcg_root")
-
-        # ---------- A. 读取归一化 ----------
-        print("\n[A] 源数据读取与归一化")
-        roles = M.load_roles(os.path.join(data, "roleplay"))
-        check("A1 角色字典", set(roles) == {"alice", "bob"})
-        turns = M.load_transcripts(os.path.join(data, "transcripts"))
-        check("A2 转录逐行读取", len(turns) == 2 and turns[0][0] == "alice"
-              and turns[0][1] == "shared")
-        mut = M.load_mutual(net)
-        check("A3 互维任务/裁决配对", len(mut) == 2
-              and any(m[0] == "t1" and m[2] for m in mut)
-              and any(m[0] == "t2" and m[2] is None for m in mut))
-
-        # ---------- B. 迁移落图 ----------
-        print("\n[B] 迁移落图 + 回读等价")
-        rep = M.migrate(data, root, mutual_dir=net, verbose=False)
-        # 角色 2 + 三导入 3 + 转录 2 + 互维 2 = 9
-        check("B1 计划节点数", rep["planned_nodes"] == 9, str(rep["planned_nodes"]))
-        check("B2 无字段失配", rep["field_mismatches"] == 0,
-              str(rep["samples"]))
-        # 回读必须用同一 (tenant, actor)：私有内容按身份派生 DEK 加密，
-        # 换身份读取视为「不可读即不存在」（security.py 的物理/逻辑隔离）。
-        cg = MdCGSecure(root, principal=Principal(
-            tenant="default", actor="dsh-memory", clearance="private",
-            can_write=True, can_admin=True))
-        role = cg.get("roleplay_role_alice")
-        check("B3 角色节点落 knowledge 层",
-              bool(role) and role["frontmatter"].get("layer") == "knowledge")
-        mem = cg.get("roleplay_alice_memory_0")
-        anchor = cg.get("roleplay_alice_anchors_0")
-        value = cg.get("roleplay_alice_values_0")
-        check("B4 三导入映射到 knowledge/self/structural",
-              mem["frontmatter"]["layer"] == "knowledge"
-              and anchor["frontmatter"]["layer"] == "self"
-              and value["frontmatter"]["layer"] == "structural")
-        turn = cg.get("roleplay_turn_alice_shared_1")
-        check("B5 转录落 contextual 层且保留 turn 标签",
-              bool(turn) and turn["frontmatter"]["layer"] == "contextual"
-              and "turn:assistant" in turn["frontmatter"]["tags"])
-        task = cg.get("mutual_task_t1")
-        check("B6 互维裁决落图且 basis=test（强依据）",
-              bool(task) and task["frontmatter"].get("verification_basis") == "test")
-        pending = cg.get("mutual_task_t2")
-        check("B7 无裁决任务标记 pending",
-              bool(pending) and "state:pending" in pending["frontmatter"]["tags"])
-        cg.close()
-
-        # ---------- C. 幂等 ----------
-        print("\n[C] 幂等（重复迁移不产生重复节点）")
-        rep2 = M.migrate(data, root, mutual_dir=net, verbose=False)
-        cg = MdCGSecure(root, principal=Principal(
-            tenant="default", actor="dsh-memory", clearance="private",
-            can_write=True, can_admin=True))
-        check("C1 重复迁移节点总数不变", rep2["md_nodes_total"] == rep["md_nodes_total"],
-              f'{rep["md_nodes_total"]} → {rep2["md_nodes_total"]}')
-        check("C2 重复迁移仍无失配", rep2["field_mismatches"] == 0)
-        cg.close()
-
-        # ---------- D. dry-run ----------
-        print("\n[D] dry-run 不落盘")
-        root2 = os.path.join(base, "mdcg_root_dry")
-        repd = M.migrate(data, root2, mutual_dir=net, dry_run=True, verbose=False)
-        check("D1 dry-run 报告计划数但不写入",
-              repd["planned_nodes"] == 9 and repd["written"] == 0
-              and repd["md_nodes_total"] == 0)
-    finally:
-        shutil.rmtree(base, ignore_errors=True)
-
-    print(f"\n==== P19 结果：{PASS} 通过 / {FAIL} 失败 ====")
-    return FAIL
-
-
-if __name__ == "__main__":
-    import sys
-    sys.exit(1 if main() else 0)
+# -*- coding: utf-8 -*-
+"""P19：角色扮演 / 互维数据迁移到认知图（`migrate_roleplay.py`）。
+
+用合成数据验证：读取归一化 → 落图（层/标签/内容）→ 回读等价 → 幂等。
+不依赖真实 roleplay_data / ~/.lingxu_net。
+"""
+import io
+import json
+import os
+import shutil
+import tempfile
+
+from . import migrate_roleplay as M
+from .mdcos import MdCGSecure
+from .security import Principal
+
+PASS = FAIL = 0
+
+
+def check(name, cond, detail=""):
+    global PASS, FAIL
+    if cond:
+        PASS += 1
+        print(f"  [PASS] {name}" + (f"  · {detail}" if detail else ""))
+    else:
+        FAIL += 1
+        print(f"  [FAIL] {name}" + (f"  · {detail}" if detail else ""))
+
+
+def _write(path, obj_or_text):
+    os.makedirs(os.path.dirname(path), exist_ok=True)
+    with io.open(path, "w", encoding="utf-8") as f:
+        if isinstance(obj_or_text, str):
+            f.write(obj_or_text)
+        else:
+            json.dump(obj_or_text, f, ensure_ascii=False)
+
+
+def _build_fixture(base):
+    data = os.path.join(base, "roleplay_data")
+    _write(os.path.join(data, "roleplay", "_roles.json"), {
+        "alice": {
+            "name": "Alice", "scenario": "雨夜咖啡馆", "first_mes": "欢迎光临",
+            "memory_items": [{"content": "Alice 喜欢猫"}],
+            "anchors_items": [{"content": "Alice 永不背叛"}],
+            "values_items": [{"content": "诚实优先"}],
+        },
+        "bob": {"name": "Bob", "scenario": ""},
+    })
+    lines = [
+        json.dumps({"time": 1700000000000, "role": "user", "text": "你好"},
+                   ensure_ascii=False),
+        json.dumps({"time": 1700000001000, "role": "bot", "text": "你好呀",
+                    "route": "self"}, ensure_ascii=False),
+    ]
+    _write(os.path.join(data, "transcripts", "alice__shared.jsonl"),
+           "\n".join(lines) + "\n")
+
+    net = os.path.join(base, "lingxu_net", "tasks")
+    _write(os.path.join(net, "task-t1.json"),
+           {"id": "t1", "payload": {"claim": "地球是圆的", "source_ref": "wiki"}})
+    _write(os.path.join(net, "result-t1.json"),
+           {"task_id": "t1", "verdict": "pass", "at": 1700000002,
+            "whitebox": {"judgment": "采纳", "best": "地球是圆的"}})
+    _write(os.path.join(net, "task-t2.json"),
+           {"id": "t2", "payload": {"claim": "月亮是奶酪做的"}})
+    return data, os.path.dirname(net)
+
+
+def main():
+    base = tempfile.mkdtemp(prefix="mdcg_p19_")
+    try:
+        data, net = _build_fixture(base)
+        root = os.path.join(base, "mdcg_root")
+
+        # ---------- A. 读取归一化 ----------
+        print("\n[A] 源数据读取与归一化")
+        roles = M.load_roles(os.path.join(data, "roleplay"))
+        check("A1 角色字典", set(roles) == {"alice", "bob"})
+        turns = M.load_transcripts(os.path.join(data, "transcripts"))
+        check("A2 转录逐行读取", len(turns) == 2 and turns[0][0] == "alice"
+              and turns[0][1] == "shared")
+        mut = M.load_mutual(net)
+        check("A3 互维任务/裁决配对", len(mut) == 2
+              and any(m[0] == "t1" and m[2] for m in mut)
+              and any(m[0] == "t2" and m[2] is None for m in mut))
+
+        # ---------- B. 迁移落图 ----------
+        print("\n[B] 迁移落图 + 回读等价")
+        rep = M.migrate(data, root, mutual_dir=net, verbose=False)
+        # 角色 2 + 三导入 3 + 转录 2 + 互维 2 = 9
+        check("B1 计划节点数", rep["planned_nodes"] == 9, str(rep["planned_nodes"]))
+        check("B2 无字段失配", rep["field_mismatches"] == 0,
+              str(rep["samples"]))
+        # 回读必须用同一 (tenant, actor)：私有内容按身份派生 DEK 加密，
+        # 换身份读取视为「不可读即不存在」（security.py 的物理/逻辑隔离）。
+        cg = MdCGSecure(root, principal=Principal(
+            tenant="default", actor="dsh-memory", clearance="private",
+            can_write=True, can_admin=True))
+        role = cg.get("roleplay_role_alice")
+        check("B3 角色节点落 knowledge 层",
+              bool(role) and role["frontmatter"].get("layer") == "knowledge")
+        mem = cg.get("roleplay_alice_memory_0")
+        anchor = cg.get("roleplay_alice_anchors_0")
+        value = cg.get("roleplay_alice_values_0")
+        check("B4 三导入映射到 knowledge/self/structural",
+              mem["frontmatter"]["layer"] == "knowledge"
+              and anchor["frontmatter"]["layer"] == "self"
+              and value["frontmatter"]["layer"] == "structural")
+        turn = cg.get("roleplay_turn_alice_shared_1")
+        check("B5 转录落 contextual 层且保留 turn 标签",
+              bool(turn) and turn["frontmatter"]["layer"] == "contextual"
+              and "turn:assistant" in turn["frontmatter"]["tags"])
+        task = cg.get("mutual_task_t1")
+        check("B6 互维裁决落图且 basis=test（强依据）",
+              bool(task) and task["frontmatter"].get("verification_basis") == "test")
+        pending = cg.get("mutual_task_t2")
+        check("B7 无裁决任务标记 pending",
+              bool(pending) and "state:pending" in pending["frontmatter"]["tags"])
+        cg.close()
+
+        # ---------- C. 幂等 ----------
+        print("\n[C] 幂等（重复迁移不产生重复节点）")
+        rep2 = M.migrate(data, root, mutual_dir=net, verbose=False)
+        cg = MdCGSecure(root, principal=Principal(
+            tenant="default", actor="dsh-memory", clearance="private",
+            can_write=True, can_admin=True))
+        check("C1 重复迁移节点总数不变", rep2["md_nodes_total"] == rep["md_nodes_total"],
+              f'{rep["md_nodes_total"]} → {rep2["md_nodes_total"]}')
+        check("C2 重复迁移仍无失配", rep2["field_mismatches"] == 0)
+        cg.close()
+
+        # ---------- D. dry-run ----------
+        print("\n[D] dry-run 不落盘")
+        root2 = os.path.join(base, "mdcg_root_dry")
+        repd = M.migrate(data, root2, mutual_dir=net, dry_run=True, verbose=False)
+        check("D1 dry-run 报告计划数但不写入",
+              repd["planned_nodes"] == 9 and repd["written"] == 0
+              and repd["md_nodes_total"] == 0)
+    finally:
+        shutil.rmtree(base, ignore_errors=True)
+
+    print(f"\n==== P19 结果：{PASS} 通过 / {FAIL} 失败 ====")
+    return FAIL
+
+
+if __name__ == "__main__":
+    import sys
+    sys.exit(1 if main() else 0)