@furongjun1999/dsh-memory 0.4.4 → 0.4.6

package/md_cg/test_p17_predict.py

@@ -0,0 +1,341 @@
+# -*- coding: utf-8 -*-
+"""md_cg · 第 17 篇：生成式预测 + 因果推理
+
+理论出处（对齐 AEIS 原 MCP 服务）：
+  · `docker/aeis_context/prediction.py`（PREDICTION-COMPLETION-PLAN-REV1-20260813-001）
+    四通道预测引擎的通道 3（生成式·因果路线图）+ 通道 4（语义式，经因果过滤门）
+  · `md_cg/chain.py`：causal = 条件依赖因果（A 是 B 成立的条件），链 = 条件序列
+
+覆盖：
+  A D-001 局部路径生成 + uncertainty_bound（候选未来，非必然未来）
+  B D-002 伪因果过滤门（因果链 / 共同父节点 / 拒绝纯语义邻近）
+  C D-003 局部线性近似 + extrapolation_validity（smooth/jump/unknown）
+  D D-004 T_pred 四维评分（trend .40 / boundary .20 / verification .25 / balance .15）
+  E D-005 AttentionPolicy 适配 + 降级
+  F D-006 命中率动态校准（命中 → 边 +0.05；未命中 → rejected）
+  G 盲区驱动（unresolved / 不可预测声明拒绝生成）
+  H 因果路径推理（可达性 = 伪因果防护的完整语义）
+  I MCP 入口（mdcg_predict / mdcg_causal / cg op=predict|causal）
+  J 自描述
+
+运行：python -m md_cg.test_p17_predict
+"""
+from __future__ import annotations
+
+import tempfile
+
+from .mdcos import MdCGOS
+from . import predict
+from . import chain
+
+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}")
+
+
+class _Pol:
+    """D-005 AttentionPolicy 适配器（duck-typed get_weights）。"""
+
+    def __init__(self, weights):
+        self._w = weights
+
+    def get_weights(self):
+        return dict(self._w)
+
+
+def _edge_conf(cg, src, tgt):
+    for t, e in chain.adjacency(cg).get(src) or []:
+        if t == tgt:
+            try:
+                return float(e.get("confidence", 1.0))
+            except (TypeError, ValueError):
+                return 1.0
+    return None
+
+
+def _find_route(routes, path):
+    for r in routes:
+        if r["path"] == path:
+            return r
+    return None
+
+
+def main():
+    root = tempfile.mkdtemp(prefix="mdcg_p17_")
+    cg = MdCGOS(root)
+
+    # ---------- 图：a→b→c,d（因果/时序），p1→b,x（共同父节点），x 语义邻近 a ----------
+    cg.add("a", "# 功能名：数据库连接池配置与超时参数\n"
+                "# 生效条件：高并发时\n# 不适用条件：单机无并发\n",
+           layer="knowledge", tags=["boundary"], importance=0.6,
+           verification_basis="test",
+           edges=[{"target": "b", "relation_type": "causal",
+                   "condition": "需要 A 成立", "confidence": 0.8}])
+    cg.add("b", "# 功能名：B 依赖 A 成立\n# 生效条件：A 可用\n",
+           layer="knowledge", importance=0.6, verification_basis="test",
+           edges=[{"target": "c", "relation_type": "causal",
+                   "condition": "需要 B 成立", "confidence": 0.9},
+                  {"target": "d", "relation_type": "sequential",
+                   "condition": "随后执行", "confidence": 0.7}])
+    cg.add("c", "# 功能名：C 依赖 B 成立\n",
+           layer="knowledge", importance=0.6, verification_basis="test")
+    cg.add("d", "# 功能名：D 在 B 之后执行\n",
+           layer="knowledge", importance=0.6, verification_basis="test")
+    cg.add("x", "# 功能名：数据库连接池配置与超时参数（近义描述）\n"
+                "# 生效条件：高并发时\n",
+           layer="knowledge", importance=0.6, verification_basis="test")
+    cg.add("p1", "# 功能名：公共前提\n",
+           layer="knowledge", importance=0.6, verification_basis="test",
+           edges=[{"target": "b", "relation_type": "causal",
+                   "condition": "公共前提", "confidence": 0.7},
+                  {"target": "x", "relation_type": "causal",
+                   "condition": "公共前提", "confidence": 0.7}])
+
+    # ---------- A. D-001 局部路径生成 ----------
+    print("\n[A] D-001 局部路径生成 + uncertainty_bound")
+    res = cg.predict_routes(start_id="a", horizon=2, semantic=False)
+    check("A1 生成成功", res["status"] == "ok" and res["start_id"] == "a",
+          res["status"])
+    check("A2 三条局部路线（a→b / a→b→c / a→b→d）",
+          res["meta"]["n_routes"] == 3
+          and all(_find_route(res["routes"], p) is not None
+                  for p in (["a", "b"], ["a", "b", "c"], ["a", "b", "d"])),
+          str([r["path"] for r in res["routes"]]))
+    r_abc = _find_route(res["routes"], ["a", "b", "c"])
+    check("A3 置信度为边置信度连乘（0.8×0.9=0.72）",
+          r_abc and abs(r_abc["confidence"] - 0.72) < 1e-6,
+          str(r_abc and r_abc["confidence"]))
+    check("A4 uncertainty_bound 字段齐备",
+          r_abc and set(r_abc["uncertainty_bound"]) == {
+              "confidence", "lower", "upper", "method"},
+          str(r_abc and sorted(r_abc["uncertainty_bound"])))
+    check("A5 不确定带上下界 = conf ± (1-conf)/2",
+          r_abc and abs(r_abc["uncertainty_bound"]["lower"] - 0.58) < 1e-6
+          and abs(r_abc["uncertainty_bound"]["upper"] - 0.86) < 1e-6,
+          str(r_abc and r_abc["uncertainty_bound"]))
+    check("A6 明示「候选未来，非必然未来」",
+          "候选未来" in res["meta"].get("note", ""), res["meta"].get("note"))
+    res_big = cg.predict_routes(start_id="a", horizon=999, semantic=False)
+    check("A7 horizon 硬上限裁剪", res_big["meta"]["horizon"] == predict.HORIZON_HARD,
+          str(res_big["meta"]["horizon"]))
+    check("A8 起点不存在 → start_not_found",
+          cg.predict_routes(start_id="nope")["status"] == "start_not_found",
+          cg.predict_routes(start_id="nope")["status"])
+
+    # ---------- B. D-002 伪因果过滤门 ----------
+    print("\n[B] D-002 伪因果过滤门（语义邻近须能说清关系）")
+    ok, why = cg.causal_gate("a", "b")
+    check("B1 因果/时序边直通", ok is True and why == "causal_link", why)
+    ok, why = cg.causal_gate("b", "x")
+    check("B2 共同父节点 → 结构模式豁免",
+          ok is True and why == "structural_pattern", why)
+    ok, why = cg.causal_gate("a", "x")
+    check("B3 纯语义邻近 → 拒绝（伪因果）",
+          ok is False and why == "rejected_semantic_only", why)
+    res_sem = cg.predict_routes(start_id="a", horizon=1, semantic=True)
+    check("B4 无策略时语义候选不进路线",
+          _find_route(res_sem["routes"], ["a", "x"]) is None,
+          str([r["path"] for r in res_sem["routes"]]))
+
+    # ---------- C. D-003 外推有效性 ----------
+    print("\n[C] D-003 局部线性近似 + extrapolation_validity")
+    check("C1 单跳 → unknown",
+          predict.extrapolation_validity({"confs": [0.8]}) == "unknown", "")
+    check("C2 平滑衰减 → smooth",
+          predict.extrapolation_validity({"confs": [0.9, 0.7]}) == "smooth", "")
+    check("C3 跳变 → jump",
+          predict.extrapolation_validity({"confs": [0.9, 0.4]}) == "jump", "")
+    check("C4 路线带 extrapolation_validity 字段",
+          "extrapolation_validity" in res["routes"][0],
+          str(res["routes"][0].get("extrapolation_validity")))
+
+    # ---------- D. D-004 T_pred 四维评分 ----------
+    print("\n[D] D-004 T_pred 四维评分")
+    sc = r_abc["score"]
+    check("D1 四维 + composite 齐备",
+          set(("trend", "boundary", "verification", "balance", "composite"))
+          <= set(sc), str(sorted(sc)))
+    check("D2 权重 = 0.40/0.20/0.25/0.15",
+          abs(sc["weights"]["trend"] - 0.40) < 1e-9
+          and abs(sc["weights"]["boundary"] - 0.20) < 1e-9
+          and abs(sc["weights"]["verification"] - 0.25) < 1e-9
+          and abs(sc["weights"]["balance"] - 0.15) < 1e-9,
+          str(sc["weights"]))
+    expect = (0.40 * sc["trend"] + 0.20 * sc["boundary"]
+              + 0.25 * sc["verification"] + 0.15 * sc["balance"])
+    check("D3 composite 可由四维复算",
+          abs(sc["composite"] - round(expect, 4)) < 1e-6,
+          f"{sc['composite']} vs {round(expect, 4)}")
+    check("D4 排序键 composite 单调不增",
+          all(res["routes"][i]["score"]["composite"]
+              >= res["routes"][i + 1]["score"]["composite"]
+              for i in range(len(res["routes"]) - 1)),
+          str([r["score"]["composite"] for r in res["routes"]]))
+
+    # ---------- E. D-005 AttentionPolicy 适配 + 降级 ----------
+    print("\n[E] D-005 AttentionPolicy 适配器 + 降级")
+    check("E1 无策略 → 偏好权重 0.0（降级）",
+          predict.preference_weight(cg, "x") == 0.0,
+          str(predict.preference_weight(cg, "x")))
+    cg.attention_policy = _Pol({"x": 0.9})
+    ok, why = cg.causal_gate("a", "x")
+    check("E2 偏好权重 > 0.5 → 准入", ok is True and why == "preference_weight", why)
+    res_pol = cg.predict_routes(start_id="a", horizon=1, semantic=True)
+    check("E3 有策略时语义候选进路线（source=semantic_induced）",
+          _find_route(res_pol["routes"], ["a", "x"]) is not None
+          and _find_route(res_pol["routes"], ["a", "x"])["last_source"]
+          == "semantic_induced",
+          str([(r["path"], r["last_source"]) for r in res_pol["routes"]]))
+    del cg.attention_policy
+
+    # ---------- F. D-006 命中率动态校准 ----------
+    print("\n[F] D-006 命中 → 边置信度 +0.05；未命中 → rejected")
+    before = _edge_conf(cg, "a", "b")
+    fb = cg.predict_feedback("b", actual_node_id="b", hit=True)
+    after = _edge_conf(cg, "a", "b")
+    check("F1 命中 → 因果边置信度 +0.05",
+          fb["hit"] is True and before is not None and after is not None
+          and abs(after - (before + predict.EDGE_BOOST)) < 1e-6,
+          f"{before} → {after}")
+    check("F2 boosted 报告被提升的源节点", "a" in (fb.get("boosted") or []),
+          str(fb.get("boosted")))
+    fb2 = cg.predict_feedback("b", actual_node_id="c", hit=False,
+                              note="实际走了 C")
+    check("F3 未命中 → 登记负记忆 rejected",
+          fb2["hit"] is False and bool(fb2.get("rejected_id")),
+          str(fb2.get("rejected_id")))
+    check("F4 样本 < 50 → 不触发反思，阈值 = 基线",
+          fb2["reflect"] is False
+          and abs(fb2["threshold"] - predict.BASE_HIT_RATE) < 1e-9
+          and fb2["samples"] < predict.MIN_SAMPLES,
+          f"samples={fb2['samples']} threshold={fb2['threshold']}")
+    st = cg.predict_stats(limit=5)
+    check("F5 stats 统计调用/反馈/命中率",
+          st["calls"] >= 4 and st["feedback_samples"] == 2 and st["hits"] == 1,
+          f"calls={st['calls']} fb={st['feedback_samples']} hits={st['hits']}")
+
+    # ---------- G. 盲区驱动 ----------
+    print("\n[G] 盲区驱动（unresolved / 不可预测声明）")
+    bs_unknown = cg.add_unresolved(
+        "如何在没有历史数据时预测数据库容量 # 可预测性：unknowable")
+    found = predict.find_blindspot(cg, bs_unknown)
+    check("G1 find_blindspot 命中 unresolved",
+          found is not None and found["kind"] == "unresolved",
+          str(found and found["kind"]))
+    check("G2 predictability 解析为 unknowable",
+          predict.predictability(found) == "unknowable",
+          predict.predictability(found))
+    r_un = cg.predict_routes(blindspot_id=bs_unknown)
+    check("G3 不可预测 → 拒绝生成路线（不编造）",
+          r_un["status"] == "unpredictable" and r_un["routes"] == [],
+          r_un["status"])
+    bs_known = cg.add_unresolved("数据库连接池配置与超时参数")
+    r_bs = cg.predict_routes(blindspot_id=bs_known, horizon=1)
+    check("G4 可预测 → 由锚点生成路线",
+          r_bs["status"] == "ok" and r_bs["meta"].get("anchor") == "a"
+          and len(r_bs["routes"]) >= 1,
+          f"status={r_bs['status']} anchor={r_bs['meta'].get('anchor')}")
+    check("G5 盲区不存在 → blindspot_not_found",
+          cg.predict_routes(blindspot_id="no_such_blindspot")["status"]
+          == "blindspot_not_found", "")
+
+    # ---------- H. 因果路径推理 ----------
+    print("\n[H] 因果路径推理（可达性 = 伪因果防护的完整语义）")
+    p = cg.causal_path("a", "c")
+    check("H1 a→c 可达，路径 [a,b,c]",
+          p["reachable"] is True and p["path"] == ["a", "b", "c"]
+          and p["length"] == 2, str(p.get("path")))
+    check("H2 每跳带条件（链 = 条件序列）",
+          [c["condition"] for c in p["conditions"]]
+          == ["需要 A 成立", "需要 B 成立"],
+          str([c["condition"] for c in p["conditions"]]))
+    p2 = cg.causal_path("c", "a")
+    check("H3 方向性：c→a 不可达", p2["reachable"] is False, str(p2.get("path")))
+    p3 = cg.causal_path("a", "x")
+    check("H4 a→x 不可达（纯语义邻近不是因果）",
+          p3["reachable"] is False, str(p3.get("note")))
+    p4 = cg.causal_path("", "a")
+    check("H5 缺参 → ok=False", p4["ok"] is False, str(p4.get("error")))
+    ch = cg.causal_chain("a", max_depth=3)
+    check("H6 causal_chain 沿因果链展开", bool(ch), str(type(ch).__name__))
+
+    # ---------- I. MCP 入口 ----------
+    print("\n[I] MCP 入口（mdcg_predict / mdcg_causal / cg op）")
+    from . import mcp_server as ms
+    check("I1 注册 mdcg_predict",
+          any(t["name"] == "mdcg_predict" for t in ms.TOOLS), "")
+    check("I2 注册 mdcg_causal",
+          any(t["name"] == "mdcg_causal" for t in ms.TOOLS), "")
+    m1 = ms._predict_call(cg, {"action": "routes", "start_id": "a",
+                               "horizon": 1, "semantic": False})
+    check("I3 mdcg_predict routes", m1["status"] == "ok" and m1["routes"], "")
+    m2 = ms._predict_call(cg, {"action": "catalog"})
+    check("I4 mdcg_predict catalog", m2["module"] == "predict", "")
+    m3 = ms._causal_call(cg, {"action": "path", "a": "a", "b": "c"})
+    check("I5 mdcg_causal path", m3["reachable"] is True, str(m3.get("path")))
+    m4 = ms._causal_call(cg, {"action": "gate", "a": "a", "b": "b"})
+    check("I6 mdcg_causal gate", m4["admitted"] is True, m4["reason"])
+    m5 = ms._cg_call(cg, {"op": "predict", "action": "stats"})
+    check("I7 cg op=predict", "hit_rate" in m5 and "dynamic" in m5, "")
+    m6 = ms._cg_call(cg, {"op": "causal", "action": "catalog"})
+    check("I8 cg op=causal", m6["module"] == "causal"
+          and "causal" in m6["types"], str(m6.get("types")))
+    m7 = ms._predict_call(cg, {"action": "feedback",
+                               "predicted_node_id": "c",
+                               "actual_node_id": "c"})
+    check("I9 mdcg_predict feedback", m7["ok"] and m7["hit"] is True, "")
+
+    # ---------- J. 自描述 ----------
+    print("\n[J] 自描述")
+    cat = cg.predict_catalog()
+    check("J1 六条决策齐备",
+          all(d in cat["decisions"] for d in
+              ("D-001", "D-002", "D-003", "D-004", "D-005", "D-006")),
+          str(sorted(cat["decisions"])))
+    check("J2 标注与 AEIS 的三处差异",
+          len(cat["differs_from_aeis"]) == 3, str(cat["differs_from_aeis"]))
+    check("J3 四维权重和 = 1.0",
+          abs(sum(cat["weights"].values()) - 1.0) < 1e-9, str(cat["weights"]))
+    check("J4 校准参数对齐 D-006",
+          cat["calibration"]["min_samples"] == predict.MIN_SAMPLES
+          and abs(cat["calibration"]["edge_boost"] - 0.05) < 1e-9,
+          str(cat["calibration"]))
+
+    # ---------- K. 命中回写不得破坏源节点 frontmatter ----------
+    print("\n[K] D-006 命中回写保留原 frontmatter（密级/模态/证据计数）")
+    cg.add("m1", "# 功能名：被回写的因果源节点\n",
+           layer="knowledge", sensitivity="public", modality="image",
+           importance=0.5, verification_basis="test",
+           edges=[{"target": "m2", "relation_type": "causal",
+                   "condition": "需要 m1 成立", "confidence": 0.5}])
+    cg.add("m2", "# 功能名：命中目标节点\n",
+           layer="knowledge", importance=0.5, verification_basis="test")
+    cg.predict_feedback("m2", actual_node_id="m2", hit=True)
+    fm1 = (cg.get("m1") or {}).get("frontmatter") or {}
+    check("K1 密级不被降级（public 保持）",
+          fm1.get("sensitivity") == "public", str(fm1.get("sensitivity")))
+    check("K2 模态不被重置为 text",
+          fm1.get("modality") == "image", str(fm1.get("modality")))
+    check("K3 边置信度确已 +0.05（0.5→0.55）",
+          abs((_edge_conf(cg, "m1", "m2") or 0.0) - 0.55) < 1e-6,
+          str(_edge_conf(cg, "m1", "m2")))
+
+    print(f"\n{'=' * 60}\n通过 {PASS} / {PASS + FAIL}")
+    if FAILS:
+        print("失败：" + "、".join(FAILS))
+    return FAIL == 0
+
+
+if __name__ == "__main__":
+    import sys
+    sys.exit(0 if main() else 1)

package/md_cg/test_p18_whitebox.py

@@ -0,0 +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)

package/md_cg/test_p19_migrate_roleplay.py

@@ -0,0 +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)