@furongjun1999/dsh-memory 0.4.6 → 0.4.8

package/md_cg/test_md_access_parity.py

@@ -0,0 +1,243 @@
+# -*- coding: utf-8 -*-
+"""P45 · md 直读访问层与 SQLite 派生库的逐位对拍守卫。
+
+验证目标
+--------
+1) **查询等价**：白箱检索层全部 ~8 处真实直查 SQL（KCCS 注释索引 /
+   学科路由 / 四要素卡递归 / 知识点对齐 / 卡定位），在 MdConn（md 直读）
+   与 SQLite 派生库上以**多组真实参数**运行，结果逐行逐列逐序相等；
+2) **行序等价**：无 ORDER BY 时 MdConn 返回序 = _restore 插入序
+   （LAYERS 权威序 × os.walk 序）——fetchone / LIMIT 1 语义等价的前提；
+3) **解析等价**：md_access 自包含 frontmatter 解析（独立部署 fallback）
+   与 nodefile 权威解析全库逐字段一致——独立部署形态的守卫；
+4) **fail-closed**：写语句、超文法 SQL、未知列均拒绝不静默。
+
+运行：`python -m md_cg.test_md_access_parity`
+"""
+from __future__ import annotations
+
+import json
+import os
+import sqlite3
+import sys
+import tempfile
+
+_HERE = os.path.dirname(os.path.abspath(__file__))
+sys.path.insert(0, os.path.dirname(_HERE))
+
+from .md_whitebox import DEFAULT_ROOT, build_db_from_md  # noqa: E402
+
+# 平铺导入引导（对齐 whitebox_kb/__init__：md_access 需在 sys.path 注入后导入）
+_WB = os.path.join(_HERE, "whitebox_kb")
+for _p in (_WB, os.path.join(_WB, "wisdom")):
+    if _p not in sys.path:
+        sys.path.insert(0, _p)
+from md_access import LAYERS, MdConn, _parse_node_text  # noqa: E402 平铺导入
+
+_N_ASSERT = 0
+
+
+def _ok(cond, label):
+    global _N_ASSERT
+    _N_ASSERT += 1
+    tag = "PASS" if cond else "FAIL"
+    print(f"  [{tag}] {label}")
+    return bool(cond)
+
+
+# 8 处真实直查 SQL（与检索层源码逐字符一致，参数以 ? 绑定）
+CASES = [
+    # semantic_translate L2519 卡定位
+    ("卡定位", "SELECT id FROM nodes WHERE layer='knowledge' "
+     "AND state_attributes LIKE ? AND tags NOT LIKE '%knowledge_point%' "
+     "LIMIT 1", ['%"name": "{name}"%']),
+    # semantic_translate L2527 卡内知识点扫描
+    ("知识点扫描", "SELECT state_attributes, content FROM nodes "
+     "WHERE layer='knowledge' AND tags LIKE ? AND tags LIKE ?",
+     ['%knowledge_point%', '%card:{prefix}%']),
+    # semantic_translate L2599 整卡行
+    ("整卡行", "SELECT * FROM nodes WHERE layer='knowledge' "
+     "AND state_attributes LIKE ?", ['%"name": "{name}"%']),
+    # semantic_translate L2945 KCCS 注释索引（全库）
+    ("KCCS索引", "SELECT id, state_attributes, content FROM nodes "
+     "WHERE state_attributes LIKE '%\"comment\"%'", []),
+    # semantic_translate L3161 学科路由第一段（全库）
+    ("学科路由", "SELECT state_attributes FROM nodes "
+     "WHERE state_attributes LIKE '%\"comment\"%'", []),
+    # semantic_translate L3244 学科卡扫描
+    ("学科卡", "SELECT id, content, state_attributes FROM nodes "
+     "WHERE state_attributes LIKE '%\"kind\": \"subject_card\"%' LIMIT 200", []),
+    # semantic_translate L3584 知识点直答定位
+    ("kp直答", "SELECT content FROM nodes WHERE tags LIKE ? AND tags LIKE ? "
+     "AND state_attributes LIKE ? LIMIT 1",
+     ['%knowledge_point%', '%card:{prefix}%', '%"name": "{kp}"%']),
+    # wisdom_book L826 卡名预过滤
+    ("卡名预过滤", "SELECT * FROM nodes WHERE layer='knowledge' "
+     "AND state_attributes LIKE '%\"name\"%' "
+     "AND tags NOT LIKE '%knowledge_point%'", []),
+]
+
+
+def _sample_params(md_conn):
+    """从 md 语料提取真实参数样例：卡名 / (card 前缀, 知识点名) 配对。"""
+    names, pairs = [], []
+    rows = md_conn.execute(
+        "SELECT tags, state_attributes FROM nodes WHERE tags LIKE '%card:%' "
+        "LIMIT 60").fetchall()
+    for tags_json, sa_json in rows:
+        try:
+            sa = json.loads(sa_json or "{}")
+            tags = (json.loads(tags_json or "[]")
+                    if isinstance(tags_json, str) else tags_json or [])
+        except Exception:
+            continue
+        nm = sa.get("name") or ""
+        pr = next((t[5:] for t in tags
+                   if isinstance(t, str) and t.startswith("card:")), None)
+        if pr and nm:
+            pairs.append((pr, nm))
+        if len(pairs) >= 4:
+            break
+    card_rows = md_conn.execute(
+        "SELECT state_attributes FROM nodes WHERE layer='knowledge' "
+        "AND state_attributes LIKE ? AND tags NOT LIKE '%knowledge_point%' "
+        "LIMIT 60", ('%"kind": "subject_card"%',)).fetchall()
+    for (sa_json,) in card_rows:
+        try:
+            nm = (json.loads(sa_json or "{}").get("name")) or ""
+        except Exception:
+            continue
+        if nm and nm not in names:
+            names.append(nm)
+        if len(names) >= 3:
+            break
+    return (names,
+            [p for p, _ in pairs],   # prefix 样例（与 kp 名同源配对）
+            [k for _, k in pairs])   # kp 名样例
+
+
+def _param_groups(arg_tpls, samples):
+    """槽位模板列表 → 完整参数组列表。
+
+    含同一占位符的槽位按索引 i 取样例（prefix 与 kp 同源配对不拆散），
+    静态槽原样；每组是合法完整参数向量。
+    """
+    used = {}
+    for t in arg_tpls:
+        for k in ("name", "prefix", "kp"):
+            if "{" + k + "}" in t:
+                used[k] = samples.get(k) or []
+    n = max((len(v) for v in used.values()), default=1)
+    return [[t.format(**{k: v[i % len(v)] for k, v in used.items()})
+             for t in arg_tpls] for i in range(n)]
+
+
+def main():
+    ok = True
+    print("== [1] 重建派生库 + 建 MdConn ==")
+    stats = build_db_from_md(force=True, verbose=True)
+    md_conn = MdConn(DEFAULT_ROOT, layers=LAYERS)
+    sq = sqlite3.connect(f"file:{stats['db']}?mode=ro", uri=True)
+    try:
+        n_sq = sq.execute("SELECT COUNT(*) FROM nodes").fetchone()[0]
+        n_md = len(md_conn._all_rows())
+        print(f"  派生库 nodes={n_sq}  md 直读行={n_md}")
+        ok &= _ok(n_sq == n_md == stats["nodes"] == 4355,
+                  "行数等价且为 4355")
+
+        print("== [2] 8 处真实 SQL 逐位对拍 ==")
+        names, prefixes, kps = _sample_params(md_conn)
+        print(f"  样例：卡名×{len(names)} 前缀×{len(prefixes)} kp名×{len(kps)}")
+        ok &= _ok(bool(names and prefixes and kps), "真实参数样例非空")
+        samples = {"name": names, "prefix": prefixes, "kp": kps}
+        total_bad = 0
+        for label, sql, arg_tpls in CASES:
+            params_list = (_param_groups(arg_tpls, samples)
+                           if arg_tpls else [[]])
+            bad = 0
+            for p in params_list:
+                a = sq.execute(sql, p).fetchall()
+                b = md_conn.execute(sql, p).fetchall()
+                if a != b:
+                    bad += 1
+                    if bad == 1:
+                        print(f"    差异样例 params={p}")
+                        print(f"      sql : {a[:2]}")
+                        print(f"      md  : {b[:2]}")
+            total_bad += bad
+            ok &= _ok(bad == 0, f"{label}：{len(params_list)} 组参数逐位一致")
+        _ok(total_bad == 0, f"对拍总差异 0（实得 {total_bad}）")
+
+        print("== [3] 行序等价（插入序 = rowid 序） ==")
+        # 无 WHERE 的 `SELECT id` 在 SQLite 走覆盖索引（id 字典序），不反映
+        # 插入序；白箱 8 处直查全带谓词（rowid 扫描），行序等价的正确测量
+        # 是 `ORDER BY rowid`（= 插入序）与 MdConn 行序的一致性。
+        a = [r[0] for r in
+             sq.execute("SELECT id FROM nodes ORDER BY rowid").fetchall()]
+        b = [r[0] for r in md_conn._all_rows()]
+        ok &= _ok(a == b, f"插入序一致（{len(a)} 行）")
+
+        print("== [4] 解析等价（自包含 fallback vs nodefile，抽样 500） ==")
+        if _HERE not in sys.path:
+            sys.path.insert(0, _HERE)  # nodefile 平铺导入需 md_cg 目录在 path
+        import nodefile
+        import md_access as _ma
+        checked = diff = 0
+        root = DEFAULT_ROOT
+        for dirpath, _dirs, files in os.walk(root):
+            for fn in files:
+                if not fn.endswith(".md"):
+                    continue
+                checked += 1
+                if checked > 500:
+                    break
+                p = os.path.join(dirpath, fn)
+                try:
+                    text = open(p, encoding="utf-8").read()
+                except OSError:
+                    continue
+                f1, c1 = nodefile.loads(text)
+                saved = _ma._nf_loads
+                try:
+                    _ma._nf_loads = None   # 强制走自包含 fallback 解析
+                    f2, c2 = _parse_node_text(text)
+                finally:
+                    _ma._nf_loads = saved
+                if f1 != f2 or c1 != c2:
+                    diff += 1
+                    if diff == 1:
+                        print(f"    解析差异: {p}")
+                        print(f"      nodefile : {json.dumps(f1, ensure_ascii=False)[:160]}")
+                        print(f"      fallback : {json.dumps(f2, ensure_ascii=False)[:160]}")
+            if checked > 500:
+                break
+        ok &= _ok(diff == 0 and checked > 0,
+                  f"自包含解析与 nodefile 逐字段一致（{checked} 文件，"
+                  f"差异 {diff}）")
+
+        print("== [5] fail-closed ==")
+        try:
+            md_conn.execute("UPDATE nodes SET access_count = 1")
+            ok &= _ok(False, "写语句应拒绝")
+        except NotImplementedError:
+            ok &= _ok(True, "写语句拒绝（NotImplementedError）")
+        try:
+            md_conn.execute("SELECT id FROM edges")
+            ok &= _ok(False, "非 nodes 表应拒绝")
+        except NotImplementedError:
+            ok &= _ok(True, "非 nodes 表拒绝（超文法）")
+        try:
+            md_conn.execute("SELECT no_such_col FROM nodes")
+            ok &= _ok(False, "未知列应拒绝")
+        except NotImplementedError:
+            ok &= _ok(True, "未知列拒绝")
+    finally:
+        sq.close()
+        md_conn.close()
+
+    print(f"\n{'全部通过' if ok else '存在失败项'}（{_N_ASSERT} 断言）")
+    return 0 if ok else 1
+
+
+if __name__ == "__main__":
+    sys.exit(main())

package/md_cg/test_md_writepath.py

@@ -0,0 +1,345 @@
+# -*- coding: utf-8 -*-
+"""写路径收口测试：mdcg 边域三原语 + knowledge_points md 真源模式。
+
+对应用户裁定「2.写md真源」——白箱工具写 md 语料的唯一正路：
+- mdcg.append_edge / append_subgraph_node / set_edge_condition（边域窄原语）
+- KnowledgePointSplitter(cg=...) md 真源模式 vs sqlite 旧路双模等价
+
+运行: python -X utf8 -m md_cg.test_md_writepath
+"""
+
+import json
+import os
+import sqlite3
+import sys
+import tempfile
+
+_HERE = os.path.dirname(os.path.abspath(__file__))
+_ROOT = os.path.dirname(_HERE)
+for _p in (_ROOT, _HERE):
+    if _p not in sys.path:
+        sys.path.insert(0, _p)
+
+from md_cg.mdcg import MdCG  # noqa: E402
+
+_WB = os.path.join(_HERE, "whitebox_kb")
+for _p in (_WB, os.path.join(_WB, "wisdom")):
+    if _p not in sys.path:
+        sys.path.insert(0, _p)
+from knowledge_points import KnowledgePointSplitter  # noqa: E402
+from md_access import MdConn  # noqa: E402
+
+_PASS = 0
+_FAIL = 0
+
+
+def _ok(cond, label):
+    global _PASS, _FAIL
+    if cond:
+        _PASS += 1
+        print(f"  PASS  {label}")
+    else:
+        _FAIL += 1
+        print(f"  FAIL  {label}")
+    return bool(cond)
+
+
+def _make_card(cg, cid="card_test_1", name="物理基础"):
+    content = ("1. 浮力: 浸在流体中的物体受到流体向上的托力\n"
+               "2. 密度: 单位体积物质的质量")
+    cg.add(cid, content, layer="knowledge", tags=["subject_card"],
+           condition_space={"observation_position": "测试卡",
+                            "observation_tool": "writepath 测试"},
+           importance=0.7, confidence=0.9,
+           state_attributes={"name": name, "domain": "physics",
+                             "edu_level": "初中"},
+           verification_basis="textbook")
+    return content
+
+
+def test_primitives(cg):
+    print("== [1] mdcg 边域三原语 ==")
+    cg.add("n_src", "源节点", layer="knowledge", tags=[],
+           importance=0.5, confidence=0.6)
+    # append_edge
+    ok1 = cg.append_edge("n_src", {"target": "n_t", "relation_type": "causal",
+                                   "confidence": 0.6, "verified": 0,
+                                   "condition_space": {"a": 1}})
+    _ok(ok1 is True, "append_edge 首次追加 True")
+    node = cg.get("n_src")
+    edges = (node.get("frontmatter") or {}).get("edges") or []
+    _ok(len(edges) == 1 and edges[0]["target"] == "n_t",
+        "落盘 fm.edges 含新边")
+    entry = cg.index["nodes"].get("n_src") or {}
+    _ok(len(entry.get("edges") or []) == 1, "索引 entry.edges 同步")
+    _ok(cg.append_edge("n_src", {"target": "n_t", "relation_type": "causal",
+                                 "confidence": 0.9}) is False,
+        "append_edge 同 target 同关系去重 False")
+    _ok(cg.append_edge("n_ghost", {"target": "x", "relation_type": "causal"})
+        is False, "append_edge 不存在节点 False")
+    # append_subgraph_node
+    _ok(cg.append_subgraph_node("n_src", "n_child") is True,
+        "append_subgraph_node 首次 True")
+    _ok(cg.append_subgraph_node("n_src", "n_child") is False,
+        "append_subgraph_node 去重 False")
+    sg = (cg.get("n_src").get("frontmatter") or {}).get("subgraph") or {}
+    _ok(sg.get("nodes") == ["n_child"], "落盘 subgraph.nodes 正确")
+    _ok((cg.index["nodes"].get("n_src") or {}).get("subgraph") is not None,
+        "索引 entry.subgraph 同步")
+    # set_edge_condition
+    ok2 = cg.set_edge_condition("n_src", "n_t", "causal",
+                                {"observation_position": "新位置"})
+    _ok(ok2 is True, "set_edge_condition 匹配 True")
+    e0 = (cg.get("n_src").get("frontmatter").get("edges"))[0]
+    _ok(e0["condition_space"] == {"observation_position": "新位置"},
+        "condition_space 已更新")
+    _ok(cg.set_edge_condition("n_src", "n_none", "causal", {}) is False,
+        "set_edge_condition 无匹配 False")
+
+
+def test_kp_md_mode(cg):
+    print("== [2] knowledge_points md 真源模式 ==")
+    content = _make_card(cg)
+    sp = KnowledgePointSplitter(cg=cg)
+    r = sp.split_card("card_test_1", "物理基础", "physics", "初中",
+                      content, 0.7)
+    _ok(r["added"] == 2 and r["skipped"] == 0,
+        f"split_card 拆出 2 知识点（{r}）")
+    kps = [nid for nid in cg.index["nodes"] if nid.startswith("kp_")]
+    _ok(len(kps) == 2, "kp 节点已入索引")
+    kp_fm = (cg.get(kps[0]).get("frontmatter") or {})
+    sa = kp_fm.get("state_attributes") or {}
+    _ok(sa.get("kind") == "knowledge_point"
+        and sa.get("parent_card") == "card_test_1",
+        "kp state_attributes 落盘")
+    _ok("knowledge_point" in (kp_fm.get("tags") or [])
+        and f"card:card_test_1" in (kp_fm.get("tags") or []),
+        "kp tags 含 card 前缀关联")
+    _ok(kp_fm.get("importance") == 0.63,
+        f"kp importance=卡×0.9（{kp_fm.get('importance')}）")
+    _ok(kp_fm.get("verification_basis") == "textbook",
+        "kp verification_basis=textbook")
+    cs = kp_fm.get("condition_space") or {}
+    _ok("time_window" in cs and cs.get("observation_tool") == "学科知识卡拆分",
+        "kp condition_space 落盘")
+    # 层级边：卡 subgraph.nodes 含 kp
+    card_fm = (cg.get("card_test_1").get("frontmatter") or {})
+    subs = (card_fm.get("subgraph") or {}).get("nodes") or []
+    _ok(sorted(subs) == sorted(kps), f"卡 subgraph.nodes 含 2 kp（{subs}）")
+    # 幂等重跑
+    r2 = sp.split_card("card_test_1", "物理基础", "physics", "初中",
+                       content, 0.7)
+    _ok(r2["added"] == 0 and r2["skipped"] == 2,
+        f"幂等重跑 added=0 skipped=2（{r2}）")
+    # find_points（走 MdConn，加载时 kp 已落盘）
+    hits = sp.find_points("浮力")
+    _ok(any(h["name"] == "浮力" for h in hits),
+        f"find_points('浮力') 命中（{[h['name'] for h in hits]}）")
+    return sp
+
+
+def test_mdconn_edge_domain(cg, sp):
+    print("== [3] MdConn 边域访问器 ==")
+    md = sp._md_conn()
+    _ok(md.children_of("card_test_1") and
+        len(md.children_of("card_test_1")) == 2,
+        "children_of 经 subgraph 落点读到 2 kp")
+    _ok(md.has_edge("card_test_1", "whatever", "hierarchical") is False,
+        "has_edge 层级边不在 fm.edges（落点=subgraph）如实 False")
+    # causal 边走 fm.edges
+    cg.append_edge("n_src2", {"target": "n_t2", "relation_type": "causal",
+                              "confidence": 0.6}, ) if cg.get("n_src2") else None
+    # 用测试专用节点验证 has_edge
+    cg.add("n_a", "苹果是水果", layer="knowledge", tags=[],
+           importance=0.5, confidence=0.6)
+    cg.add("n_b", "苹果富含维生素并且内容更长一些", layer="knowledge", tags=[],
+           importance=0.8, confidence=0.6)
+    cg.append_edge("n_a", {"target": "n_b", "relation_type": "causal"})
+    md.reload()  # 写入后刷新快照
+    _ok(md.has_edge("n_a", "n_b", "causal") is True,
+        "has_edge 经 fm.edges 读到 causal 边")
+    _ok(md.has_edge("n_a", "n_x", "causal") is False, "has_edge 未命中 False")
+    top = md.top_content_match("苹果", None)
+    _ok(top == ("n_b",),
+        f"top_content_match 高 importance 优先（{top}）")
+    top2 = md.top_content_match("苹果", "n_b")
+    _ok(top2 == ("n_a",), f"top_content_match exclude 生效（{top2}）")
+
+
+def test_sqlite_legacy():
+    print("== [4] sqlite 旧路（兜底）不破坏 ==")
+    tmp = tempfile.mkdtemp(prefix="wbwp_sql_")
+    db = os.path.join(tmp, "t.db")
+    con = sqlite3.connect(db)
+    con.execute(
+        "CREATE TABLE nodes (id TEXT PRIMARY KEY, content TEXT, modality TEXT,"
+        " spatial_coordinates TEXT, temporal_coordinate REAL, condition_space"
+        " TEXT, importance REAL, confidence REAL, layer TEXT, access_count"
+        " INTEGER, last_access REAL, created_at REAL, tags TEXT,"
+        " semantic_coordinates TEXT, state_attributes TEXT, entity_id TEXT)")
+    con.execute(
+        "CREATE TABLE edges (id TEXT PRIMARY KEY, source_id TEXT, target_id"
+        " TEXT, relation_type TEXT, condition_space TEXT, confidence REAL,"
+        " weight REAL, verified INTEGER, created_at REAL, last_verified REAL,"
+        " source_evidence TEXT)")
+    con.commit()
+    con.close()
+    sp = KnowledgePointSplitter(db_path=db)
+    content = _make_card.__doc__ or ""
+    r = sp.split_card("card_sql_1", "化学基础", "chemistry", "高中",
+                      "1. 摩尔: 物质的量的单位\n2. 阿伏伽德罗: 常数约为6.02e23",
+                      0.7)
+    _ok(r["added"] == 2, f"sqlite 模式 split_card added=2（{r}）")
+    con = sqlite3.connect(db)
+    n = con.execute("SELECT COUNT(*) FROM nodes WHERE layer='knowledge'"
+                    ).fetchone()[0]
+    e = con.execute("SELECT COUNT(*) FROM edges WHERE "
+                    "relation_type='hierarchical'").fetchone()[0]
+    _ok(n == 2 and e == 2, f"sqlite 落库 nodes={n} edges={e}")
+    con.close()
+    sp.close()
+
+
+def test_pattern_md_mode():
+    print("== [5] pattern_separation md 真源模式 ==")
+    from pattern_separation import PatternSeparation
+    tmp = tempfile.mkdtemp(prefix="wbwp_pat_")
+    cg = MdCG(root=tmp)  # 独立 root：scan 全库扫描不受其他组节点干扰
+    # 两个高相似知识层节点（标签差异 → separation_note 非空）
+    cg.add("p_a", "苹果是一种常见的水果，富含维生素与水分", layer="knowledge",
+           tags=["知识", "水果"], importance=0.5, confidence=0.6,
+           condition_space={"observation_position": "水果观察"},
+           state_attributes={"name": "苹果", "domain": "生物"})
+    cg.add("p_b", "苹果是一种常见的水果，富含维生素和水分较多", layer="knowledge",
+           tags=["知识", "坚果"], importance=0.5, confidence=0.6,
+           condition_space={"observation_position": "水果观察"},
+           state_attributes={"name": "苹果干", "domain": "生物"})
+    ps = PatternSeparation(cg=cg)  # 纯 md 模式（engine=None）
+    _ok(ps.store is None and ps.cg is cg, "纯 md 模式构造（无 engine）")
+    r = ps.scan(limit=50)
+    _ok(r.get("created") == 1 and r.get("scanned") == 1,
+        f"scan 建一条分离边（{r}）")
+    md = ps._md_conn()
+    md.reload()  # scan 已显式 flush；同实例快照仍需刷新（正式语义）
+    edges = md.edges_between("p_a", "p_b", "similar")
+    _ok(len(edges) == 1, "edges_between 读到 similar 边")
+    if edges:
+        e = edges[0]
+        cs = e.get("condition_space") or {}
+        _ok(cs.get("observation_position") == "模式分离",
+            "分离边 observation_position=模式分离")
+        _ok("坚果" in (cs.get("existence_constraint") or ""),
+            "差异注记含标签区分维度")
+        _ok(e.get("source_evidence") == "inferred"
+            and e.get("verified") == 0, "边形态对齐引擎默认（inferred/未验证）")
+    _ok(md.edges_between("p_b", "p_a", "similar") == [],
+        "edges_between 反向无命中（边是 a→b 出边）")
+    # 幂等重跑：已存在 separation 边 → 走更新支路
+    r2 = ps.scan(limit=50)
+    _ok(r2.get("created") == 0 and r2.get("updated") == 1,
+        f"幂等重跑走更新支路（{r2}）")
+
+
+class _StubEngine:
+    """最小信号源 stub：只供 causal 信号面（被拒路径清单）。
+
+    causal md 模式的 engine 职责收窄为运行时信号消费——
+    候选/边/追踪全在 md，sqlite 全家桶无须实例化（依赖面显式化）。
+    """
+
+    def __init__(self, paths):
+        self._paths = paths
+
+    def list_rejected_paths(self, status=None):
+        return [p for p in self._paths
+                if status is None or p.get("status") == status]
+
+
+def test_causal_md_mode():
+    print("== [6] causal_discover md 真源模式 ==")
+    from causal_discover import CausalDiscoverer
+    # update_tags 原语直测
+    cg_ut = MdCG(root=tempfile.mkdtemp(prefix="wbwp_ut_"))
+    cg_ut.add("ut_n", "update tags 测试节点", layer="contextual",
+              tags=["a", "b"], importance=0.3)
+    _ok(cg_ut.update_tags("ut_n", add=["c"], remove=["a"]) is True,
+        "update_tags 增删 True")
+    _ok(cg_ut.update_tags("ut_n", add=["c"]) is False,
+        "update_tags 无实质变更 False（幂等）")
+    _ok(cg_ut.update_tags("ghost", add=["x"]) is False,
+        "update_tags 不存在节点 False")
+    ft = (cg_ut.get("ut_n").get("frontmatter") or {}).get("tags")
+    _ok(ft == ["b", "c"], f"update_tags 落盘保序（{ft}）")
+    # causal md 端到端
+    tmp = tempfile.mkdtemp(prefix="wbwp_causal_")
+    cg = MdCG(root=tmp)
+    eng = _StubEngine([{
+        "path_type": "query",
+        "description": "用户问「水为什么烧开」检索不到沸点知识",
+        "reason": "翻译表缺沸点→沸腾映射", "status": "open",
+        "evidence": "wbwp"}])
+    cg.add("node_boil", "水的沸点在一标准大气压下为100摄氏度",
+           layer="knowledge", importance=0.8, confidence=0.9,
+           verification_basis="textbook")
+    cd = CausalDiscoverer(eng, cg=cg)
+    r = cd.discover(limit=3)
+    cands = r.get("candidates") or []
+    _ok(len(cands) >= 1, f"discover 产出候选（{len(cands)}）")
+    cc_id = (cands[0] or {}).get("candidate_id") or ""
+    node = cg.get(cc_id) if cc_id else None
+    fm = (node or {}).get("frontmatter") or {}
+    _ok(node is not None and fm.get("layer") == "contextual",
+        f"候选节点入 md contextual 层（id={cc_id}）")
+    ftags = fm.get("tags") or []
+    _ok("causal_candidate" in ftags and "status:candidate_open" in ftags,
+        "候选 tags 含 causal_candidate/open")
+    n_before = len([k for k in cg.index["nodes"] if k.startswith("cc_")])
+    cd.discover(limit=3)
+    n_after = len([k for k in cg.index["nodes"] if k.startswith("cc_")])
+    _ok(n_before == n_after, f"重复 discover 幂等不重建（{n_before}）")
+    # 被拒路径置 consumed（信号源状态变更）
+    eng._paths[0]["status"] = "consumed"
+    r2 = cd.verify_candidates()
+    _ok(r2.get("resolved") == 1, f"verify 因果确认 resolved=1（{r2}）")
+    fm2 = ((cg.get(cc_id) or {}).get("frontmatter") or {})
+    ftags2 = fm2.get("tags") or []
+    _ok("status:causal_confirmed" in ftags2
+        and "status:candidate_open" not in ftags2,
+        "tag 状态迁移（open→confirmed）")
+    md = cd._md_conn()
+    md.reload()  # verify 内部 has_edge 已建快照，append 后须刷新（读面语义）
+    edges = md.edges_between(cc_id, "node_boil", "causal")
+    _ok(len(edges) == 1, "causal 边落盘（cc→target，「沸点」词命中）")
+    if edges:
+        e = edges[0]
+        _ok(e.get("verified") == 0.6
+            and e.get("source_evidence") == "extracted",
+            "边形态 verified=0.6/extracted（对齐引擎语义）")
+    r3 = cd.verify_candidates()
+    _ok(r3.get("resolved") == 0 and r3.get("tracked") >= 1,
+        f"幂等重跑 resolved=0（{r3}）")
+
+
+def main():
+    tmp = tempfile.mkdtemp(prefix="wbwp_md_")
+    cg = MdCG(root=tmp)
+    print(f"md 真源根: {tmp}")
+    test_primitives(cg)
+    sp = test_kp_md_mode(cg)
+    test_mdconn_edge_domain(cg, sp)
+    test_pattern_md_mode()
+    test_causal_md_mode()
+    cg.flush()
+    # flush 后重开实例验证持久化
+    cg2 = MdCG(root=tmp)
+    sg = (cg2.get("card_test_1").get("frontmatter") or {}).get("subgraph")
+    _ok(sg and len(sg.get("nodes") or []) == 2,
+        "flush 后重开实例 subgraph 持久化")
+    test_sqlite_legacy()
+    print(f"\n==== 写路径收口测试: PASS {_PASS} / FAIL {_FAIL} ====")
+    sys.exit(1 if _FAIL else 0)
+
+
+if __name__ == "__main__":
+    sys.stdout.reconfigure(encoding="utf-8")
+    main()