@furongjun1999/dsh-memory 0.4.6 → 0.4.8

package/md_cg/whitebox_kb/data/verify_cache.json

@@ -1869,5 +1869,33 @@
   "reason": "",
   "verified_at": "2026-09-10 20:11:01",
   "version": 6
+ },
+ "83a381e1f246fb91a048afe63cd6067b": {
+  "ok": true,
+  "checks": [
+   {
+    "level": "L1语法",
+    "ok": true,
+    "evidence": "语法通过（1 个函数定义）"
+   },
+   {
+    "level": "L2样例",
+    "ok": true,
+    "evidence": "3 组样例全部通过"
+   },
+   {
+    "level": "L3边界",
+    "ok": true,
+    "evidence": "无额外边界用例"
+   },
+   {
+    "level": "规范符合性",
+    "ok": true,
+    "evidence": "结构规范 + 语义对齐 + 条件论注释通过"
+   }
+  ],
+  "reason": "",
+  "verified_at": "2026-09-16 10:51:36",
+  "version": 6
  }
 }

package/md_cg/whitebox_kb/data/verify_savings.jsonl

@@ -8048,3 +8048,49 @@
 {"t": "2026-09-11 15:12:36", "payload_chars": 586, "table_chars": 423723, "saved_chars": 424309, "saved_tokens": 318231, "hit": true}
 {"t": "2026-09-11 15:12:36", "payload_chars": 402, "table_chars": 423723, "saved_chars": 424125, "saved_tokens": 318093, "hit": true}
 {"t": "2026-09-11 15:12:37", "payload_chars": 751, "table_chars": 423723, "saved_chars": 424474, "saved_tokens": 318355, "hit": true}
+{"t": "2026-09-16 10:51:36", "payload_chars": 526, "table_chars": 423723, "saved_chars": 424249, "saved_tokens": 318186, "hit": true}
+{"t": "2026-09-16 10:51:36", "payload_chars": 590, "table_chars": 423723, "saved_chars": 424313, "saved_tokens": 318234, "hit": true}
+{"t": "2026-09-16 10:51:36", "payload_chars": 372, "table_chars": 423723, "saved_chars": 424095, "saved_tokens": 318070, "hit": true}
+{"t": "2026-09-16 10:51:36", "payload_chars": 546, "table_chars": 423723, "saved_chars": 424269, "saved_tokens": 318201, "hit": false}
+{"t": "2026-09-16 10:51:36", "payload_chars": 606, "table_chars": 423723, "saved_chars": 424329, "saved_tokens": 318246, "hit": true}
+{"t": "2026-09-16 10:51:37", "payload_chars": 470, "table_chars": 423723, "saved_chars": 424193, "saved_tokens": 318144, "hit": true}
+{"t": "2026-09-16 10:51:37", "payload_chars": 713, "table_chars": 423723, "saved_chars": 424436, "saved_tokens": 318327, "hit": true}
+{"t": "2026-09-16 10:51:37", "payload_chars": 522, "table_chars": 423723, "saved_chars": 424245, "saved_tokens": 318183, "hit": true}
+{"t": "2026-09-16 10:51:39", "payload_chars": 516, "table_chars": 423723, "saved_chars": 424239, "saved_tokens": 318178, "hit": true}
+{"t": "2026-09-16 10:51:39", "payload_chars": 372, "table_chars": 423723, "saved_chars": 424095, "saved_tokens": 318070, "hit": true}
+{"t": "2026-09-16 10:51:39", "payload_chars": 456, "table_chars": 423723, "saved_chars": 424179, "saved_tokens": 318133, "hit": true}
+{"t": "2026-09-16 10:51:39", "payload_chars": 685, "table_chars": 423723, "saved_chars": 424408, "saved_tokens": 318306, "hit": true}
+{"t": "2026-09-16 10:51:39", "payload_chars": 437, "table_chars": 423723, "saved_chars": 424160, "saved_tokens": 318120, "hit": true}
+{"t": "2026-09-16 10:51:39", "payload_chars": 367, "table_chars": 423723, "saved_chars": 424090, "saved_tokens": 318067, "hit": true}
+{"t": "2026-09-16 10:51:39", "payload_chars": 586, "table_chars": 423723, "saved_chars": 424309, "saved_tokens": 318231, "hit": true}
+{"t": "2026-09-16 10:51:39", "payload_chars": 402, "table_chars": 423723, "saved_chars": 424125, "saved_tokens": 318093, "hit": true}
+{"t": "2026-09-16 10:51:39", "payload_chars": 506, "table_chars": 423723, "saved_chars": 424229, "saved_tokens": 318171, "hit": true}
+{"t": "2026-09-16 10:51:39", "payload_chars": 441, "table_chars": 423723, "saved_chars": 424164, "saved_tokens": 318123, "hit": true}
+{"t": "2026-09-16 10:51:39", "payload_chars": 543, "table_chars": 423723, "saved_chars": 424266, "saved_tokens": 318199, "hit": true}
+{"t": "2026-09-16 10:51:39", "payload_chars": 332, "table_chars": 423723, "saved_chars": 424055, "saved_tokens": 318040, "hit": true}
+{"t": "2026-09-16 10:51:39", "payload_chars": 1181, "table_chars": 423723, "saved_chars": 424904, "saved_tokens": 318678, "hit": true}
+{"t": "2026-09-16 10:51:39", "payload_chars": 1181, "table_chars": 423723, "saved_chars": 424904, "saved_tokens": 318678, "hit": true}
+{"t": "2026-09-16 10:51:39", "payload_chars": 1181, "table_chars": 423723, "saved_chars": 424904, "saved_tokens": 318678, "hit": true}
+{"t": "2026-09-16 10:51:39", "payload_chars": 1181, "table_chars": 423723, "saved_chars": 424904, "saved_tokens": 318678, "hit": true}
+{"t": "2026-09-16 10:51:39", "payload_chars": 1181, "table_chars": 423723, "saved_chars": 424904, "saved_tokens": 318678, "hit": true}
+{"t": "2026-09-16 10:51:39", "payload_chars": 1181, "table_chars": 423723, "saved_chars": 424904, "saved_tokens": 318678, "hit": true}
+{"t": "2026-09-16 10:51:39", "payload_chars": 1181, "table_chars": 423723, "saved_chars": 424904, "saved_tokens": 318678, "hit": true}
+{"t": "2026-09-16 10:51:39", "payload_chars": 1181, "table_chars": 423723, "saved_chars": 424904, "saved_tokens": 318678, "hit": true}
+{"t": "2026-09-16 10:51:39", "payload_chars": 1181, "table_chars": 423723, "saved_chars": 424904, "saved_tokens": 318678, "hit": true}
+{"t": "2026-09-16 10:51:39", "payload_chars": 1181, "table_chars": 423723, "saved_chars": 424904, "saved_tokens": 318678, "hit": true}
+{"t": "2026-09-16 10:51:39", "payload_chars": 1181, "table_chars": 423723, "saved_chars": 424904, "saved_tokens": 318678, "hit": true}
+{"t": "2026-09-16 10:51:39", "payload_chars": 1181, "table_chars": 423723, "saved_chars": 424904, "saved_tokens": 318678, "hit": true}
+{"t": "2026-09-16 10:51:40", "payload_chars": 631, "table_chars": 423723, "saved_chars": 424354, "saved_tokens": 318265, "hit": true}
+{"t": "2026-09-16 10:51:40", "payload_chars": 631, "table_chars": 423723, "saved_chars": 424354, "saved_tokens": 318265, "hit": true}
+{"t": "2026-09-16 10:51:40", "payload_chars": 631, "table_chars": 423723, "saved_chars": 424354, "saved_tokens": 318265, "hit": true}
+{"t": "2026-09-16 10:51:40", "payload_chars": 631, "table_chars": 423723, "saved_chars": 424354, "saved_tokens": 318265, "hit": true}
+{"t": "2026-09-16 10:51:40", "payload_chars": 569, "table_chars": 423723, "saved_chars": 424292, "saved_tokens": 318219, "hit": true}
+{"t": "2026-09-16 10:51:41", "payload_chars": 1181, "table_chars": 423723, "saved_chars": 424904, "saved_tokens": 318678, "hit": true}
+{"t": "2026-09-16 10:51:41", "payload_chars": 1048, "table_chars": 423723, "saved_chars": 424771, "saved_tokens": 318577, "hit": true}
+{"t": "2026-09-16 10:51:41", "payload_chars": 1322, "table_chars": 423723, "saved_chars": 425045, "saved_tokens": 318783, "hit": true}
+{"t": "2026-09-16 10:51:41", "payload_chars": 372, "table_chars": 423723, "saved_chars": 424095, "saved_tokens": 318070, "hit": true}
+{"t": "2026-09-16 10:51:41", "payload_chars": 484, "table_chars": 423723, "saved_chars": 424207, "saved_tokens": 318154, "hit": true}
+{"t": "2026-09-16 10:51:41", "payload_chars": 637, "table_chars": 423723, "saved_chars": 424360, "saved_tokens": 318270, "hit": true}
+{"t": "2026-09-16 10:51:41", "payload_chars": 1181, "table_chars": 423723, "saved_chars": 424904, "saved_tokens": 318678, "hit": true}
+{"t": "2026-09-16 10:51:41", "payload_chars": 590, "table_chars": 423723, "saved_chars": 424313, "saved_tokens": 318234, "hit": true}
+{"t": "2026-09-16 10:51:41", "payload_chars": 1181, "table_chars": 423723, "saved_chars": 424904, "saved_tokens": 318678, "hit": true}

package/md_cg/whitebox_kb/wisdom/audit_log/chain_heat.json

@@ -5,7 +5,7 @@
  "初中数学知识点内容（按骨架填充）→小学数学知识点内容（按骨架填充）→高中数学知识点内容（按骨架填充）": 2,
  "单卡:初中数学知识点内容（按骨架填充）": 2,
  "单卡:小学数学知识点内容（按骨架填充）": 2,
- "单卡:高中数学知识点内容（按骨架填充）": 25,
+ "单卡:高中数学知识点内容（按骨架填充）": 136,
  "小学科学→数学→初中物理": 9,
  "单卡:小学科学": 9,
  "单卡:数学": 9,
@@ -14,15 +14,15 @@
  "单卡:数学物理方法": 9,
  "单卡:理论力学": 9,
  "单卡:物理学·综合": 9,
- "单卡:打喷嚏（健康与身体·通识知识卡）": 23,
- "单卡:质数（数学·通识知识卡）": 23,
- "常见家电的功率（物理学·通识知识卡）→日食与月食的成因（天文学·通识知识卡）": 23,
- "单卡:常见家电的功率（物理学·通识知识卡）": 23,
- "单卡:日食与月食的成因（天文学·通识知识卡）": 23,
- "数学分析知识点内容（按骨架填充）→高中数学知识点内容（按骨架填充）→测度论与物理离散性": 7,
- "单卡:数学分析知识点内容（按骨架填充）": 23,
- "单卡:测度论与物理离散性": 23,
- "高中数学知识点内容（按骨架填充）→数学分析知识点内容（按骨架填充）→测度论与物理离散性": 16,
+ "单卡:打喷嚏（健康与身体·通识知识卡）": 134,
+ "单卡:质数（数学·通识知识卡）": 134,
+ "常见家电的功率（物理学·通识知识卡）→日食与月食的成因（天文学·通识知识卡）": 134,
+ "单卡:常见家电的功率（物理学·通识知识卡）": 134,
+ "单卡:日食与月食的成因（天文学·通识知识卡）": 134,
+ "数学分析知识点内容（按骨架填充）→高中数学知识点内容（按骨架填充）→测度论与物理离散性": 62,
+ "单卡:数学分析知识点内容（按骨架填充）": 134,
+ "单卡:测度论与物理离散性": 134,
+ "高中数学知识点内容（按骨架填充）→数学分析知识点内容（按骨架填充）→测度论与物理离散性": 72,
  "协议-知识飞轮→白箱测试定义→价值理论与AI对齐": 1,
  "单卡:协议-知识飞轮": 1,
  "单卡:白箱测试定义": 1,

package/md_cg/whitebox_kb/wisdom/causal_discover.py

@@ -28,10 +28,28 @@ sys.path.insert(0, HERE)
 class CausalDiscoverer:
     """条件论七操作对自身：行为数据 → 因果候选 → 可验证预测。"""
 
-    def __init__(self, engine, dex=None):
-        """因果发现器初始化（候选机制集与置信先验挂入）。"""
+    def __init__(self, engine, dex=None, cg=None):
+        """因果发现器初始化（候选机制集与置信先验挂入）。
+
+        双模（写路径收口 · md 真源裁定）：
+        - `cg` 给定 → 候选节点/状态迁移/causal 边全写 md 语料
+          （cg.add episodic / cg.update_tags / cg.append_edge）。
+          **engine 仍必挂**：异常信号（被拒路径/hit_history）是引擎
+          运行时过程数据，非知识真源物，维持 engine 消费——形态与
+          pattern_separation（engine 可 None）不同，如实标注。
+        - `cg` 为 None → sqlite 派生库旧路（兜底）。
+        """
         self.engine = engine
         self.dex = dex  # 智慧之书 ConditionDex（供分离/逆转检查）
+        self.cg = cg
+        self._mdc = None
+
+    def _md_conn(self):
+        """md 模式只读连接（懒加载，root 取 cg.root）。"""
+        if self._mdc is None:
+            from md_access import MdConn
+            self._mdc = MdConn(self.cg.root)
+        return self._mdc
 
     # ---------------- 识别（反向·识别操作） ----------------
     def _scan_anomalies(self, limit=8):
@@ -122,8 +140,12 @@ class CausalDiscoverer:
         如果因果成立（A→B），则在 X 条件下应观察到 Y；预测可执行/可观测。
         交 prediction_feedback 验证：命中强化 / 未命中否决。"""
         desc = (candidate.get("source_anomaly") or {}).get("description", "")
+        # 稳定 id：str hash 随进程随机化，md 模式下 candidate_id 兼作
+        # 节点 id（跨轮 verify 追踪），须用内容稳定摘要
+        import zlib
+        cid = f"cc_{zlib.crc32(candidate['claim'].encode('utf-8')) % 10**8:08d}"
         return {
-            "candidate_id": f"cc_{abs(hash(candidate['claim'])) % 10**8}",
+            "candidate_id": cid,
             "claim": candidate["claim"],
             "source_anomaly": candidate.get("source_anomaly"),
             "predictions": [
@@ -145,6 +167,8 @@ class CausalDiscoverer:
           - 已 consumed（被修复/补足）→ 因果确认（resolve）
           - 超过 window 轮仍无变化 → 保持待验证（不误杀）
         返回状态统计。候选存观测层（tags: causal_candidate）。"""
+        if self.cg is not None:
+            return self._verify_md()
         from aeis_core import MemoryLayer
         now = time.time()
         open_paths = set()
@@ -192,17 +216,84 @@ class CausalDiscoverer:
         return {"tracked": tracked, "resolved": resolved, "still_open": still_open,
                 "note": "验证闭环：被拒路径 consumed=因果确认（入 causal 边）；仍 open=候选成立待修复"}
 
+    # ---------------- md 真源支（写路径收口） ----------------
+    def _verify_md(self):
+        """md 真源验证闭环：候选追踪（MdConn 行标签过滤，判据留调用侧）
+        → 状态迁移（cg.update_tags）→ 因果确认边（cg.append_edge，
+        verified=0.6 对齐引擎 verify_edge 语义）。被拒路径状态仍读 engine。
+        """
+        import json as _json
+        from md_access import COLS
+        md = self._md_conn()
+        open_paths, consumed = set(), set()
+        try:
+            for p in self.engine.list_rejected_paths() or []:
+                key = ((p.get("description") or "")[:20]).strip("「」 \t")
+                if p.get("status") == "consumed":
+                    consumed.add(key)
+                else:
+                    open_paths.add(key)
+        except Exception:
+            pass
+        resolved = still_open = tracked = 0
+        for r in md._all_rows():
+            d = dict(zip(COLS, r))
+            try:
+                tags = (_json.loads(d["tags"])
+                        if isinstance(d["tags"], str) else (d["tags"] or []))
+            except Exception:
+                tags = []
+            if "causal_candidate" not in tags:
+                continue
+            tracked += 1
+            key = None
+            for t in tags:
+                if t.startswith("cc_key:"):
+                    key = t[7:].strip("「」 \t")
+            if key and key in consumed:
+                # 幂等：已迁移（无实质变更）不重复计数
+                if self.cg.update_tags(d["id"],
+                                       add=["status:causal_confirmed"],
+                                       remove=["status:candidate_open"]):
+                    resolved += 1
+                target_id = self._resolve_causal_target_md(
+                    d["content"] or "", d["id"])
+                if target_id and not md.has_edge(d["id"], target_id, "causal"):
+                    self.cg.append_edge(d["id"], {
+                        "target": target_id, "relation_type": "causal",
+                        "confidence": 0.6, "verified": 0.6,
+                        "source_evidence": "extracted"})
+            elif key and key in open_paths:
+                still_open += 1
+        try:
+            self.cg.flush()  # 批次持久化边界（autoflush 裂缝纪律）
+        except Exception:
+            pass
+        return {"tracked": tracked, "resolved": resolved,
+                "still_open": still_open,
+                "note": "验证闭环（md 真源）：被拒路径 consumed=因果确认"
+                        "（causal 边 verified 入 md）；仍 open=候选成立待修复"}
+
+    def _resolve_causal_target_md(self, content, self_id):
+        """md 真源 target 解析：实体词 → top_content_match
+        （LIKE 同序等价：importance DESC, length ASC, LIMIT 1）。"""
+        md = self._md_conn()
+        for w in self._extract_entity_words(content):
+            try:
+                hit = md.top_content_match(w, exclude_id=self_id)
+            except Exception:
+                hit = None
+            if hit:
+                return hit[0] if isinstance(hit, (tuple, list)) else hit
+        return None
+
     # ---------------- causal 边目标解析 ----------------
-    def _resolve_causal_target(self, candidate_node) -> Optional[str]:
-        """确认的候选 → causal 边 target：从候选 claim 提取真实知识节点。
-        prediction 类候选 claim 含 node_xxx（直接提取）；query 类候选无节点 id，
-        从「」引号段提取实体词 → SQL LIKE 图谱检索（去噪音词）。"""
-        import re
-        content = candidate_node.content or ""
-        nids = re.findall(r"node_[a-f0-9_]+", content)
-        if nids:
-            return nids[-1]  # 实际节点（claim 尾部）
-        # query 类：提取「」引号段 → 实体词 → LIKE 检索
+    @staticmethod
+    def _extract_entity_words(content):
+        """候选 claim → 实体词序列（「」段→noise 剥离→短词优先）。
+
+        sqlite/md 双路共用的纯函数段（检索端各自实现）。
+        """
         quoted = re.findall(r"「([^」]+)」", content)
         noise = {"用户问", "检索不到", "翻译表缺", "图谱无此", "常识卡缺失",
                  "可能存在", "因果相关", "重复失败", "机制性原因", "预测未命中",
@@ -221,6 +312,19 @@ class CausalDiscoverer:
                         words.append(w)
         # 短实体词优先（2-4 字 = 主题词；长串易 miss 或命中泛节点）
         words.sort(key=len)
+        return words
+
+    def _resolve_causal_target(self, candidate_node) -> Optional[str]:
+        """确认的候选 → causal 边 target：从候选 claim 提取真实知识节点。
+        prediction 类候选 claim 含 node_xxx（直接提取）；query 类候选无节点 id，
+        从「」引号段提取实体词 → SQL LIKE 图谱检索（去噪音词）。"""
+        import re
+        content = candidate_node.content or ""
+        nids = re.findall(r"node_[a-f0-9_]+", content)
+        if nids:
+            return nids[-1]  # 实际节点（claim 尾部）
+        # query 类：提取「」引号段 → 实体词 → LIKE 检索
+        words = self._extract_entity_words(content)
         conn = self.engine.store.conn
         self_id = getattr(candidate_node, "id", "") or ""
         for w in words:
@@ -268,15 +372,28 @@ class CausalDiscoverer:
                 key = (c.get("source_anomaly") or {}).get("description", "")[:20]
                 # 规范化匹配键：全角引号「」是 claim 排版，非描述内容（v1.16 修 cc_key bug）
                 key = key.strip("「」 \t") or (c.get("claim") or "")[:20]
-                try:
-                    self.engine.add_perception(
-                        f"[因果候选] {c['claim'][:60]}",
-                        importance=0.7,
-                        tags=["观测层", "causal_candidate",
-                              f"cc_key:{key}", "status:candidate_open"],
-                        condition_space=None)
-                except Exception:
-                    pass
+                tags = ["观测层", "causal_candidate",
+                        f"cc_key:{key}", "status:candidate_open"]
+                if self.cg is not None:
+                    # md 真源：候选节点入 contextual 层（mdcg 层体系无
+                    # episodic，情境观测落 contextual），id=candidate_id
+                    # （内容稳定摘要）→ 显式查重幂等（同异常重复 discover 不重建）
+                    cc_id = c.get("candidate_id") or ""
+                    if cc_id and self.cg.index["nodes"].get(cc_id):
+                        continue
+                    try:
+                        self.cg.add(cc_id, f"[因果候选] {c['claim'][:60]}",
+                                    layer="contextual", tags=tags,
+                                    importance=0.7)
+                    except Exception:
+                        pass
+                else:
+                    try:
+                        self.engine.add_perception(
+                            f"[因果候选] {c['claim'][:60]}",
+                            importance=0.7, tags=tags, condition_space=None)
+                    except Exception:
+                        pass
         return {
             "candidates": outputs,
             "note": ("条件论对自身的使用：七操作处理自身行为数据（被拒路径/预测未命中）"

package/md_cg/whitebox_kb/wisdom/csre.py

@@ -58,12 +58,20 @@ class Csre:
                   when最强信号，正文 what 减半）
         """
         from semantic_translate import ALL_TABLE, _card_bigrams  # noqa: E402
+        from md_access import md_conn_or_none  # noqa: E402
 
-        conn = sqlite3.connect(self.db_path)
-        rows = conn.execute(
-            "SELECT id, content, state_attributes FROM nodes "
-            "WHERE tags LIKE '%knowledge_point%'").fetchall()
-        conn.close()
+        # md 直读优先（WB_MD_DIRECT=1），回落派生库直连——与检索层同开关
+        _md = md_conn_or_none()
+        if _md is not None:
+            rows = _md.execute(
+                "SELECT id, content, state_attributes FROM nodes "
+                "WHERE tags LIKE '%knowledge_point%'").fetchall()
+        else:
+            conn = sqlite3.connect(self.db_path)
+            rows = conn.execute(
+                "SELECT id, content, state_attributes FROM nodes "
+                "WHERE tags LIKE '%knowledge_point%'").fetchall()
+            conn.close()
 
         vocab_rows = []
         for nid, _content, sa in rows:

package/md_cg/whitebox_kb/wisdom/knowledge_points.py

@@ -38,13 +38,85 @@ _KP_RE = re.compile(r"^\s*(\d+)\.\s+(.+?)[:：]\s*(.*)$")
 
 
 class KnowledgePointSplitter:
-    """知识卡 content → 知识点节点 + 卡⊃知识点 hierarchical 边"""
+    """知识卡 content → 知识点节点 + 卡⊃知识点 hierarchical 边
 
-    def __init__(self, db_path: str = DEFAULT_DB):
-        """知识点库连接初始化（缺表自愈创建）。"""
+    双模（写路径收口 · md 真源裁定）：
+    - `cg` 给定 → **md 真源模式**：写经 `cg.add`（mdcg 唯一写入闸门）+
+      `cg.append_subgraph_node`（层级边落点=父节点 subgraph.nodes，与迁移
+      导出形态一致）；读经 `md_access.MdConn`（WB 同款只读访问层）。
+    - `cg=None` → sqlite 派生库旧路（兜底：无 md_cg 环境仍可运行）。
+    """
+
+    # nodes 表 16 列序（md 行 tuple → dict 的键序，与 md_access 行同构一致）
+    _COLS = ("id", "content", "modality", "spatial_coordinates",
+             "temporal_coordinate", "condition_space", "importance",
+             "confidence", "layer", "access_count", "last_access",
+             "created_at", "tags", "semantic_coordinates",
+             "state_attributes", "entity_id")
+
+    def __init__(self, db_path: str = DEFAULT_DB, cg=None):
+        """`cg`（MdCG/MdCGSecure）给定走 md 真源，否则 sqlite 连接初始化。"""
         self.db_path = db_path
-        self.conn = sqlite3.connect(db_path, timeout=15)
-        self.conn.row_factory = sqlite3.Row
+        self.cg = cg
+        self._mdc = None
+        if cg is None:
+            self.conn = sqlite3.connect(db_path, timeout=15)
+            self.conn.row_factory = sqlite3.Row
+        else:
+            self.conn = None
+
+    def _md_conn(self):
+        """md 模式的只读连接（懒加载，root 取 cg.root）。"""
+        if self._mdc is None:
+            from md_access import MdConn
+            self._mdc = MdConn(self.cg.root)
+        return self._mdc
+
+    def _query(self, sql: str):
+        """按模式执行只读查询，返回支持 row[列名] 访问的行列表。
+
+        md 模式把 SELECT 列表规范化为 *（16 列 dict），谓词不变——
+        三条查询（tags LIKE 单/双谓词）均在 md_access 只读文法内。
+        """
+        if self.cg is None:
+            return self.conn.execute(sql).fetchall()
+        sql_star = re.sub(r"SELECT\s+.+?\s+FROM", "SELECT * FROM",
+                          sql, count=1, flags=re.I | re.S)
+        return [dict(zip(self._COLS, r))
+                for r in self._md_conn().execute(sql_star).fetchall()]
+
+    def _write_point(self, pid, pcontent, tags, cs, sa, card_id,
+                     card_imp, now, pname):
+        """写一个知识点节点 + 卡⊃知识点层级边（按模式分派）。"""
+        if self.cg is not None:
+            self.cg.add(pid, pcontent, layer="knowledge", tags=tags,
+                        condition_space=json.loads(cs),
+                        importance=round(card_imp * 0.9, 2), confidence=0.6,
+                        modality="text", spatial={}, temporal=now,
+                        semantic_coordinates={},
+                        state_attributes=json.loads(sa),
+                        verification_basis="textbook", edges=[])
+            # 卡 -hierarchical-> 知识点：md 落点=父节点 subgraph.nodes
+            self.cg.append_subgraph_node(card_id, pid)
+        else:
+            c = self.conn.cursor()
+            c.execute(
+                "INSERT INTO nodes (id, content, modality, spatial_coordinates, "
+                "temporal_coordinate, condition_space, importance, confidence, layer, "
+                "access_count, last_access, created_at, tags, semantic_coordinates, "
+                "state_attributes) VALUES (?,?,?,?,?,?,?,?,?,?,?,?,?,?,?)",
+                (pid, pcontent, "text", "{}", now, cs,
+                 round(card_imp * 0.9, 2), 0.6, "knowledge", 0, None, now,
+                 json.dumps(tags, ensure_ascii=False), "{}", sa))
+            # 卡 -hierarchical-> 知识点（verified：知识点继承已验证卡）
+            eid = f"edge_kp_{abs(hash(card_id + pname)) % 10**10}_{int(now * 1000)}"
+            c.execute(
+                "INSERT INTO edges (id, source_id, target_id, relation_type, "
+                "condition_space, confidence, weight, verified, created_at, "
+                "last_verified, source_evidence) VALUES (?,?,?,?,?,?,?,?,?,?,?)",
+                (eid, card_id, pid, "hierarchical", cs, 0.9, 0.9, 1, now,
+                 now, "extracted"))
+            self.conn.commit()
 
     # ---------------- 拆分 ----------------
     def parse_points(self, content: str) -> List[tuple]:
@@ -82,19 +154,34 @@ class KnowledgePointSplitter:
     def split_card(self, card_id: str, name: str, domain: str, edu: str,
                    content: str, card_imp: float, dry_run: bool = False) -> Dict:
         """拆一张卡 → 知识点节点 + hierarchical 边（幂等）"""
-        c = self.conn.cursor()
         points = self.parse_points(content)
-        # 已存在的知识点名（幂等）
+        # 已存在的知识点名（幂等）。md 模式走 cg index 直查（不走 MdConn
+        # 快照——本进程刚写入的 kp 必须立即可见），sqlite 模式实时 SQL。
         existing = set()
-        for row in c.execute(
-                "SELECT state_attributes FROM nodes WHERE tags LIKE ?",
-                ("%card:" + card_id[:16] + "%",)).fetchall():
-            try:
-                nm = json.loads(row["state_attributes"] or "{}").get("name", "")
-                if nm:
-                    existing.add(nm)
-            except Exception:
-                pass
+        if self.cg is not None:
+            pref = f"card:{card_id[:16]}"
+            for nid, e in self.cg.index["nodes"].items():
+                if pref not in (e.get("tags") or []):
+                    continue
+                try:
+                    node = self.cg.get(nid) or {}
+                    fm = node.get("frontmatter") or {}
+                    nm = (fm.get("state_attributes") or {}).get("name", "")
+                    if nm:
+                        existing.add(nm)
+                except Exception:
+                    pass
+        else:
+            for row in self.conn.execute(
+                    "SELECT state_attributes FROM nodes WHERE tags LIKE ?",
+                    ("%card:" + card_id[:16] + "%",)).fetchall():
+                try:
+                    nm = json.loads(row["state_attributes"] or "{}").get(
+                        "name", "")
+                    if nm:
+                        existing.add(nm)
+                except Exception:
+                    pass
         added = 0
         skipped = 0
         now = time.time()
@@ -118,36 +205,19 @@ class KnowledgePointSplitter:
                              "time_window": [0.0, 9999999999.0],
                              "existence_constraint": "通用规律/知识（开源非盈利知识库）"},
                             ensure_ascii=False)
-            c.execute(
-                "INSERT INTO nodes (id, content, modality, spatial_coordinates, "
-                "temporal_coordinate, condition_space, importance, confidence, layer, "
-                "access_count, last_access, created_at, tags, semantic_coordinates, "
-                "state_attributes) VALUES (?,?,?,?,?,?,?,?,?,?,?,?,?,?,?)",
-                (pid, pcontent, "text", "{}", now, cs,
-                 round(card_imp * 0.9, 2), 0.6, "knowledge", 0, None, now,
-                 json.dumps(tags, ensure_ascii=False), "{}", sa))
-            # 卡 -hierarchical-> 知识点（verified：知识点继承已验证卡）
-            eid = f"edge_kp_{abs(hash(card_id + pname)) % 10**10}_{int(now * 1000)}"
-            c.execute(
-                "INSERT INTO edges (id, source_id, target_id, relation_type, "
-                "condition_space, confidence, weight, verified, created_at, "
-                "last_verified, source_evidence) VALUES (?,?,?,?,?,?,?,?,?,?,?)",
-                (eid, card_id, pid, "hierarchical", cs, 0.9, 0.9, 1, now,
-                 now, "extracted"))
+            self._write_point(pid, pcontent, tags, cs, sa, card_id,
+                              card_imp, now, pname)
             added += 1
-        if not dry_run:
-            self.conn.commit()
         return {"card": name, "points": len(points), "added": added,
                 "skipped": skipped}
 
     def split_all(self, dry_run: bool = False) -> Dict:
         """全库拆分（扫描 subject_card 卡）"""
-        c = self.conn.cursor()
         report = {"cards": 0, "points_total": 0, "added": 0, "skipped": 0,
                   "no_format": []}
-        cards = c.execute(
+        cards = self._query(
             "SELECT id, state_attributes, content, importance FROM nodes "
-            "WHERE tags LIKE '%subject_card%' AND tags NOT LIKE '%knowledge_point%'").fetchall()
+            "WHERE tags LIKE '%subject_card%' AND tags NOT LIKE '%knowledge_point%'")
         for row in cards:
             sa = json.loads(row["state_attributes"] or "{}")
             name = sa.get("name", "")
@@ -168,7 +238,6 @@ class KnowledgePointSplitter:
     # ---------------- 知识点级精确检索 ----------------
     def find_points(self, query: str, limit: int = 8) -> List[Dict]:
         """问题 → 知识点精确命中（encode 规范词 LIKE 匹配 name/content）"""
-        c = self.conn.cursor()
         fp = {}
         try:
             sys.path.insert(0, HERE)
@@ -177,9 +246,9 @@ class KnowledgePointSplitter:
         except Exception:
             pass
         scored = []
-        for row in c.execute(
+        for row in self._query(
                 "SELECT id, content, state_attributes, importance, tags "
-                "FROM nodes WHERE tags LIKE '%knowledge_point%'").fetchall():
+                "FROM nodes WHERE tags LIKE '%knowledge_point%'"):
             sa = json.loads(row["state_attributes"] or "{}")
             name = sa.get("name", "")
             text = name + " " + (row["content"] or "")
@@ -219,13 +288,25 @@ class KnowledgePointSplitter:
         return scored[:limit]
 
     def close(self):
-        """关闭数据库连接。"""
-        self.conn.close()
+        """收尾：md 模式 flush 持久化索引；sqlite 模式关连接。"""
+        if self.cg is not None:
+            self.cg.flush()
+        else:
+            self.conn.close()
 
 
 if __name__ == "__main__":
     sys.stdout.reconfigure(encoding="utf-8")
-    sp = KnowledgePointSplitter()
+    _cg = None
+    if (os.environ.get("WB_MD_DIRECT") == "1"
+            and os.environ.get("WB_MD_ROOT")):
+        # md 真源模式：WB_MD_ROOT 即语料根（拆分结果写入 md 语料）
+        sys.path.insert(0, os.path.dirname(os.path.dirname(os.path.dirname(
+            os.path.abspath(__file__)))))
+        from md_cg.mdcg import MdCG
+        _cg = MdCG(root=os.environ["WB_MD_ROOT"])
+        print(f"[md] 真源根: {_cg.root}")
+    sp = KnowledgePointSplitter(cg=_cg)
     dry = "--dry-run" in sys.argv
     rep = sp.split_all(dry_run=dry)
     print(json.dumps(rep, ensure_ascii=False, indent=1))