@furongjun1999/dsh-memory 0.4.6 → 0.4.8

package/md_cg/whitebox_kb/wisdom/md_store.py

@@ -0,0 +1,251 @@
+# -*- coding: utf-8 -*-
+"""MdStore · 智慧之书知识层的 md 真源存储适配器（LayeredStore 读子集等价实现）。
+
+背景（使用者裁定 2026-09-14）
+----------------------------
+「智慧之书知识源本身就是 md 文档，当前的 sql 导致的黑箱化不能接受」。
+md 语料是唯一知识来源（`migrate_wisdom_graph.export()` 导出 + L1-L4
+确定性校验），SQLite 检索库只是可重建派生物。此前 `md_access` 已把
+检索层直查 SQL 切到 md 直读，但 `ConditionDex` 的 25+ 个 `dex_*`
+操作走引擎高层面（`store.get_node / query_nodes / get_*_edges /
+search_content`），仍依赖 sqlite——本模块补齐这块：以 md 语料为
+真源装载内存图，实现 LayeredStore 被依赖的读子集。
+
+等价性设计（对拍守卫 md_cg/test_wisdom_md_store.py）
+----------------------------------------------------
+1. **行同构**：节点行直接复用 `md_access._load_rows`（与
+   `md_whitebox._restore` 逐字段一致），`STNode.from_row` 权威反序列化。
+2. **行序复刻**：遍历序 = (LAYERS 权威序, 相对路径字典序)——与
+   sqlite 无 ORDER BY SELECT 的插入序同构，`query_nodes(limit)` 语义等价。
+3. **边域还原**：fm.edges（causal/similar 等非层级边）+ fm.subgraph.nodes
+   （hierarchical 层级边，source=父）——与派生库 edges 表两大数据源一致；
+   未知 relation_type 诚实跳过（宽容读，严格写）。
+4. **search_content 复刻**：多词 OR 预筛（含同义词扩展，复用
+   `LayeredStore.SYNONYM_GROUPS`；ASCII 折叠对齐 LIKE 大小写语义）→
+   原查询 char-bigram 重叠率 + tag bonus → (-sim, -importance, id)
+   排序——算法逐行对齐 `LayeredStore.search_content`（v1.17 起
+   两侧截断与同分决胜均确定性化：候选池 id 序截断 + id 末键决胜，
+   输出不依赖 sqlite 物理插入序 / md 路径字典序的偶然差异）。
+
+诚实边界
+--------
+- `increment_access`：md 模式下为**进程内统计**（不落盘）。sqlite 版
+  同为统计性质（尽力而为、可容忍失败）；P29 使用频次档案跨进程持久化
+  属后续增量（写放大与价值须单独裁定）。
+- `set_meta`：空操作——md 模式的项目元数据由语料本身承载。
+- 写语句不进本层：知识写走 `ConditionDex` 的 md 分支（MdCGOS.add /
+  append_edge），观测留痕走 `_perceive`（layer=contextual）。
+"""
+from __future__ import annotations
+
+import hashlib
+import json
+import os
+
+from aeis_core import ConditionSpace, EdgeType, MemoryLayer, STEdge, STNode
+from aeis_core import LayeredStore  # SYNONYM_GROUPS 同义词表复用
+from md_access import MdConn
+
+#: 条件空间缺省声明（脏数据兜底——与 wisdom_book._default_cs 同口径的最简形态）
+_CS_FALLBACK = {
+    "observation_position": "智慧之书·md 真源语料",
+    "observation_tool": "MdStore 内存图装载",
+    "time_window": [0.0, 9999999999.0],
+    "existence_constraint": "图谱只声称条件化有效性，不声称真理性",
+}
+
+#: sqlite LIKE 的 ASCII 大小写不敏感折叠（非 ASCII 字符原样）——
+#: 预筛子串匹配与 `LIKE '%t%'` 逐位同构（md_access._like_re 同语义）
+_ASCII_FOLD = str.maketrans(
+    "ABCDEFGHIJKLMNOPQRSTUVWXYZ", "abcdefghijklmnopqrstuvwxyz")
+
+
+def _fold(s):
+    return s.translate(_ASCII_FOLD)
+
+
+def _safe_cs(raw):
+    """fm.condition_space（dict）→ ConditionSpace；脏数据回落固定声明，不炸读路径。"""
+    if isinstance(raw, dict) and raw:
+        try:
+            return ConditionSpace.from_json(json.dumps(raw, ensure_ascii=False))
+        except (ValueError, TypeError):
+            pass
+    try:
+        return ConditionSpace.from_json(json.dumps(_CS_FALLBACK, ensure_ascii=False))
+    except (ValueError, TypeError):
+        return ConditionSpace()
+
+
+class MdStore:
+    """md 语料 → 内存图。实现 LayeredStore 被 `ConditionDex` 依赖的读子集，
+    外加 duck `.conn`（返回内部 MdConn，`md_access.read_conn` 零改动兼容）。"""
+
+    def __init__(self, root):
+        self.root = os.path.abspath(root)
+        self._conn = MdConn(self.root)
+        self._nodes = None     # {id: STNode}
+        self._out = None       # {src_id: [STEdge]}
+        self._in = None        # {dst_id: [STEdge]}
+        self._access = {}      # {nid: count} 进程内使用频次（诚实边界见模块头）
+
+    # ------------------------------------------------------------------
+    # 装载
+    # ------------------------------------------------------------------
+
+    def _ensure(self):
+        """懒加载：行→STNode，边域→STEdge 双向索引。"""
+        if self._nodes is not None:
+            return
+        nodes = {}
+        for r in self._conn._all_rows():
+            try:
+                row = list(r)
+                if isinstance(row[1], str):
+                    # md 正文天然以换行结尾——装载归一到 sqlite content 语义
+                    # （sqlite 版 content 无尾换行；留痕/展示面不应混入空行）
+                    row[1] = row[1].rstrip("\n")
+                n = STNode.from_row(tuple(row))
+            except (ValueError, TypeError, KeyError):
+                continue  # 脏行诚实跳过（不阻断整库装载）
+            nodes[n.id] = n
+        out, inc = {}, {}
+
+        def _link(src, e):
+            ste = self._mk_edge(src, e)
+            if ste is None:
+                return
+            out.setdefault(src, []).append(ste)
+            inc.setdefault(ste.target_id, []).append(ste)
+
+        em, cm = self._conn._edge_domain()
+        for src, edges in em.items():          # causal/similar 等非层级边
+            for e in edges:
+                _link(src, e)
+        for parent, kids in cm.items():        # hierarchical 层级边（source=父）
+            for kid in kids:
+                _link(parent, {"target": kid, "relation_type": "hierarchical"})
+        self._nodes, self._out, self._in = nodes, out, inc
+
+    @staticmethod
+    def _mk_edge(src, e):
+        """fm.edges 边 dict → STEdge；未知关系类型/脏字段返回 None（诚实跳过）。"""
+        try:
+            rel = EdgeType(str(e.get("relation_type") or ""))
+        except ValueError:
+            return None
+        tgt = str(e.get("target") or "")
+        if not tgt:
+            return None
+        eid = "mde_" + hashlib.sha1(
+            f"{src}->{tgt}:{rel.value}".encode("utf-8")).hexdigest()[:12]
+        return STEdge(
+            id=eid, source_id=str(src), target_id=tgt,
+            relation_type=rel,
+            condition_space=_safe_cs(e.get("condition_space")),
+            confidence=float(e.get("confidence", 0.7)),
+            weight=float(e.get("weight", 1.0)),
+            verified=bool(e.get("verified")),
+            source_evidence=str(e.get("source_evidence") or "extracted"))
+
+    def reload(self):
+        """丢弃全部缓存——写入方（add_entry/add_relation）落盘后刷新快照。"""
+        self._conn.reload()
+        self._nodes = self._out = self._in = None
+
+    # ------------------------------------------------------------------
+    # LayeredStore 读子集
+    # ------------------------------------------------------------------
+
+    def get_node(self, node_id):
+        self._ensure()
+        return self._nodes.get(str(node_id))
+
+    def query_nodes(self, layer=None, limit=50):
+        self._ensure()
+        val = layer.value if isinstance(layer, MemoryLayer) else (
+            str(layer) if layer else None)
+        out = [n for n in self._nodes.values()
+               if val is None or n.layer.value == val]
+        return out[:max(0, int(limit))]
+
+    def get_outgoing_edges(self, node_id):
+        self._ensure()
+        return list(self._out.get(str(node_id)) or [])
+
+    def get_incoming_edges(self, node_id):
+        self._ensure()
+        return list(self._in.get(str(node_id)) or [])
+
+    def search_content(self, query, layers=None, limit=20):
+        """复刻 `LayeredStore.search_content`（对拍守卫）：多词 OR 预筛
+        （LIKE 子串语义，ASCII 大小写不敏感）→ 落空回退全池 → bigram
+        重叠率 + tag bonus → (-sim, -importance, id) 排序截断。
+
+        确定性口径（与权威实现 v1.17 同步）：预筛候选与回退池均按
+        **id 升序截断**（对齐 ORDER BY id LIMIT），同分同重要度按 id
+        决胜——两侧输出不依赖各自物理序（sqlite 插入序 / md 路径序）。"""
+        q = (query or "").strip()
+        if not q:
+            return []
+        self._ensure()
+        pool = list(self._nodes.values())
+        if layers:
+            vals = {l.value if isinstance(l, MemoryLayer) else str(l)
+                    for l in layers}
+            pool = [n for n in pool if n.layer.value in vals]
+        terms = LayeredStore.expand_query_terms(q)
+
+        def _hit(n):
+            c = _fold(n.content or "")
+            tj = _fold(json.dumps(n.tags or [], ensure_ascii=False))
+            return any(_fold(t) in c or _fold(t) in tj for t in terms)
+
+        rows = sorted((n for n in pool if _hit(n)),
+                      key=lambda n: n.id)[:300]
+        if not rows:
+            rows = sorted(pool, key=lambda n: n.id)[:500]
+        qb = self._bigrams(q)
+        scored = []
+        for n in rows:
+            nb = self._bigrams(n.content)
+            sim = (len(qb & nb) / len(qb)) if qb else 0.0
+            bonus = 0.05 if any(t in q or q in t for t in (n.tags or [])
+                                ) else 0.0
+            scored.append((n, min(1.0, sim + bonus)))
+        scored.sort(key=lambda x: (-x[1], -x[0].importance, x[0].id))
+        results = scored[:max(0, int(limit))]
+        for n, _ in results:
+            self.increment_access(n.id)
+        return results
+
+    @staticmethod
+    def _bigrams(s):
+        s = "".join((s or "").split())
+        if len(s) <= 1:
+            return {s}
+        return {s[i:i + 2] for i in range(len(s) - 1)}
+
+    def increment_access(self, node_id):
+        """使用频次 +1（进程内统计，不落盘——诚实边界见模块头）。"""
+        nid = str(node_id)
+        self._access[nid] = self._access.get(nid, 0) + 1
+
+    def access_counts(self):
+        """进程内使用频次快照（P29 消费面）。"""
+        return dict(self._access)
+
+    # ------------------------------------------------------------------
+    # 兼容面
+    # ------------------------------------------------------------------
+
+    @property
+    def conn(self):
+        """duck：`md_access.read_conn(dex)` 回落形态（MdConn 只读直读）。"""
+        return self._conn
+
+    def set_meta(self, *_a, **_k):
+        """空操作：md 模式的项目元数据由语料本身承载。"""
+
+    def close(self):
+        """无连接可关（进程内缓存随实例回收）。"""

package/md_cg/whitebox_kb/wisdom/pattern_separation.py

@@ -29,9 +29,16 @@ SA_FIELDS = ("edu_level", "domain", "kind", "source")
 
 
 def _cs_dict(node):
-    """条件空间对象→可序列化字典（观测位·工具·时间窗·存在约束）。"""
+    """条件空间对象→可序列化字典（观测位·工具·时间窗·存在约束）。
+
+    双形态兼容：sqlite ConditionSpace（.to_json()）与 md 行 dict
+    （md 真源模式下 shim 节点的 condition_space 已是 dict）。
+    """
+    cs = getattr(node, "condition_space", None)
+    if isinstance(cs, dict):
+        return cs
     try:
-        return json.loads(node.condition_space.to_json()) if node.condition_space else {}
+        return json.loads(cs.to_json()) if cs else {}
     except Exception:
         return {}
 
@@ -82,14 +89,62 @@ def separation_note(a_name, b_name, a_node, b_node):
 class PatternSeparation:
     """模式分离器：相似节点对 → 分离边（条件差异显式化）"""
 
-    def __init__(self, engine):
-        """模式分离器初始化：挂载灵枢引擎引用。"""
+    def __init__(self, engine=None, cg=None):
+        """双模初始化（写路径收口 · md 真源裁定）。
+
+        - `cg` 给定 → **md 真源模式**：节点输入读 `md_access.MdConn`
+          （知识层行），分离边写经 `cg.append_edge` / `cg.set_edge_condition`
+          （mdcg 边域窄原语，唯一写入闸门）。engine 可为 None。
+        - `engine` 给定且无 cg → sqlite 派生库旧路（兜底）。
+        """
         self.engine = engine
-        self.store = engine.store
+        self.cg = cg
+        self.store = engine.store if engine is not None else None
+        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
+
+    class _NV:
+        """md 行 → 节点视图 shim（separation_note/_tag_diff 所需最小面）。
+
+        MdConn 行的 json 列（tags/condition_space/state_attributes）为
+        字符串原值（同构指列位），在此反序列化为 dict/list。
+        """
+
+        @staticmethod
+        def _js(v):
+            if isinstance(v, (dict, list)) or v is None:
+                return v or ({} if not isinstance(v, list) else [])
+            try:
+                return json.loads(v)
+            except Exception:
+                return {}
+
+        def __init__(self, row):
+            from md_access import COLS
+            d = dict(zip(COLS, row))
+            self.id = d["id"]
+            self.content = d["content"] or ""
+            self.tags = self._js(d["tags"]) or []
+            self.state_attributes = self._js(d["state_attributes"]) or {}
+            self.condition_space = self._js(d["condition_space"]) or {}
+
+    def _is_sep_dict(self, edge):
+        """md 边 dict 的分离判据（observation_position=模式分离）。"""
+        cs = edge.get("condition_space") or {}
+        return isinstance(cs, dict) and cs.get(
+            "observation_position") == "模式分离"
 
     def scan(self, limit=200, tag_only=False):
         """扫描相似节点对，建立分离边（similar + 差异注记）。
         参与节点：全部知识层节点（含无 name 的感知节点——它们最需要分离）。"""
+        if self.cg is not None:
+            return self._scan_md(limit)
         created, updated = 0, 0
         try:
             from aeis_core import LayeredStore
@@ -151,6 +206,83 @@ class PatternSeparation:
                 break
         return {"created": created, "updated": updated, "scanned": done}
 
+    def _scan_md(self, limit=200):
+        """md 真源扫描：节点输入=MdConn 知识层行，
+        分离边写=cg.append_edge / cg.set_edge_condition（唯一写入闸门）。
+
+        与 sqlite 版同判据（SIM_THRESHOLD / 0.99 去重上界 / separation_note
+        有差异才建边），边 dict 形态对齐迁移语料（confidence=引擎默认 0.5、
+        verified=0、source_evidence=inferred）。
+        """
+        md = self._md_conn()
+        try:
+            from aeis_core import LayeredStore
+        except Exception:
+            return {"created": 0, "updated": 0, "error": "no LayeredStore"}
+        rows = md.execute(
+            "SELECT * FROM nodes WHERE layer='knowledge' LIMIT 400").fetchall()
+        nodes = [self._NV(r) for r in rows
+                 if (r[1] or "") and len(r[1] or "") > 10]
+        created = updated = done = 0
+        now = time.time()
+        for i in range(len(nodes)):
+            for j in range(i + 1, len(nodes)):
+                if done >= limit:
+                    break
+                a, b = nodes[i], nodes[j]
+                sim = LayeredStore.char_bigram_jaccard(a.content, b.content)
+                if sim < SIM_THRESHOLD or sim >= 0.99:
+                    continue
+                a_name = a.state_attributes.get("name") or a.content[:12]
+                b_name = b.state_attributes.get("name") or b.content[:12]
+                note, diffs = separation_note(a_name, b_name, a, b)
+                if not note:
+                    # 无真实差异 → 纯内容重叠（去重问题），不建分离边
+                    continue
+                try:
+                    sep_cs = {"observation_position": "模式分离",
+                              "observation_tool": "条件空间对比",
+                              "time_window": [now, now + 3600.0],
+                              "existence_constraint": note}
+                    hit = self._find_sep_edge_md(a.id, b.id)
+                    if hit is not None:
+                        src, tgt = hit
+                        if self.cg.set_edge_condition(src, tgt, "similar",
+                                                      sep_cs):
+                            updated += 1
+                    else:
+                        if self.cg.append_edge(a.id, {
+                                "target": b.id, "relation_type": "similar",
+                                "confidence": 0.5, "verified": 0,
+                                "condition_space": sep_cs,
+                                "source_evidence": "inferred"}):
+                            created += 1
+                except Exception:
+                    pass
+                done += 1
+            if done >= limit:
+                break
+        # 批次持久化边界：写走 cg 脏缓冲（唯一闸门），scan 完成即显式落盘——
+        # 否则 autoflush 阈值前磁盘无文件，同工具内的 MdConn 读面看不到边。
+        try:
+            self.cg.flush()
+        except Exception:
+            pass
+        return {"created": created, "updated": updated, "scanned": done}
+
+    def _find_sep_edge_md(self, a_id, b_id):
+        """md 真源：定位 a-b 之间的 separation 边，返回 (source, target)。
+
+        双向语义对齐 sqlite 版（a→b 出边或 b→a 出边均可承载分离注记）。
+        无命中返回 None。
+        """
+        md = self._md_conn()
+        for src, tgt in ((a_id, b_id), (b_id, a_id)):
+            for e in md.edges_between(src, tgt, "similar"):
+                if self._is_sep_dict(e):
+                    return (src, tgt)
+        return None
+
     def _find_sep_edge(self, a_id, b_id):
         """为相似节点对定位分离边候选：条件差异显式化的落点。"""
         try:
@@ -175,7 +307,11 @@ class PatternSeparation:
             return False
 
     def retrieve_with_separation(self, query, limit=5):
-        """检索 + 分离提示：命中节点若带 separation 边，附差异注记。"""
+        """检索 + 分离提示：命中节点若带 separation 边，附差异注记。
+
+        边界：该读面走 engine 派生库快照（md 真源模式下快照可能滞后），
+        运行时检索面的读路径收口属 md_access 专项，本方法不重复建设。
+        """
         results = []
         try:
             from aeis_core import LayeredStore
@@ -204,19 +340,36 @@ class PatternSeparation:
 
 def main():
     sys.path.insert(0, os.path.dirname(os.path.abspath(__file__)))
-    from aeis_core import SpacetimeMemoryEngine
-
-    db = os.environ.get("AEIS_DB", os.path.join("data", "lingshu.db"))
-    engine = SpacetimeMemoryEngine(db_path=db, identity="灵枢", role="PRIMARY")
-    ps = PatternSeparation(engine)
+    cg = None
+    engine = None
+    if (os.environ.get("WB_MD_DIRECT") == "1"
+            and os.environ.get("WB_MD_ROOT")):
+        # md 真源模式：分离边写入 md 语料（WB_MD_ROOT 即语料根）
+        _root_parent = os.path.dirname(os.path.dirname(os.path.dirname(
+            os.path.abspath(__file__))))
+        if _root_parent not in sys.path:
+            sys.path.insert(0, _root_parent)
+        from md_cg.mdcg import MdCG
+        cg = MdCG(root=os.environ["WB_MD_ROOT"])
+        print(f"[md] 真源根: {cg.root}")
+        ps = PatternSeparation(cg=cg)
+    else:
+        from aeis_core import SpacetimeMemoryEngine
+        db = os.environ.get("AEIS_DB", os.path.join("data", "lingshu.db"))
+        engine = SpacetimeMemoryEngine(db_path=db, identity="灵枢",
+                                       role="PRIMARY")
+        ps = PatternSeparation(engine=engine)
     if "--scan" in sys.argv:
         r = ps.scan(limit=200)
         print(json.dumps(r, ensure_ascii=False, indent=1))
     else:
-        q = " ".join(sys.argv[1:]) or "物理"
+        q = " ".join(a for a in sys.argv[1:] if not a.startswith("--")) or "物理"
         r = ps.retrieve_with_separation(q, limit=5)
         print(json.dumps(r, ensure_ascii=False, indent=1))
-    engine.close()
+    if cg is not None:
+        cg.flush()
+    elif engine is not None:
+        engine.close()
 
 
 if __name__ == "__main__":

package/md_cg/whitebox_kb/wisdom/semantic_translate.py

@@ -22,6 +22,10 @@ import os
 import re
 import sys
 
+# md 直读访问层：检索读路径统一入口（WB_MD_DIRECT=1 走 md 语料，
+# 否则回落派生库）——对拍守卫 md_cg/test_md_access_parity.py
+from md_access import read_conn
+
 # ============================================================
 # 翻译表：日常表达 → 规范知识词（编码字典）
 # 结构：规范词 -> [该词的日常说法/俗语/近义表达]
@@ -2516,7 +2520,7 @@ def recursive_item_answer(dex, card_name, fp, question):
     # v1.16 知识点级精确命中（卡⊃知识点嵌套子图）：
     # 问题规范词直接命中该卡的知识点子节点 → 精确答案（比卡 content 整卡解析更准）
     try:
-        card_row = dex.store.conn.execute(
+        card_row = read_conn(dex).execute(
             "SELECT id FROM nodes WHERE layer='knowledge' "
             "AND state_attributes LIKE ? AND tags NOT LIKE '%knowledge_point%' "
             "LIMIT 1", ('%"name": "' + card_name + '%',)).fetchone()
@@ -2524,7 +2528,7 @@ def recursive_item_answer(dex, card_name, fp, question):
             card_prefix = card_row[0][:16]
             best_kp, best_s = None, 0.0
             best_name_hit = False  # 名命中（强）：fp 词 in 知识点名 或 名 in 问题
-            for r in dex.store.conn.execute(
+            for r in read_conn(dex).execute(
                     "SELECT state_attributes, content FROM nodes WHERE layer='knowledge' "
                     "AND tags LIKE ? AND tags LIKE ?",
                     ('%knowledge_point%', '%card:' + card_prefix + '%')).fetchall():
@@ -2596,7 +2600,7 @@ def recursive_item_answer(dex, card_name, fp, question):
         pass
     # v1.16 修复：主库 11045 节点，limit=500 可能不含目标卡 → SQL 精确预过滤
     try:
-        _rows = dex.store.conn.execute(
+        _rows = read_conn(dex).execute(
             "SELECT * FROM nodes WHERE layer='knowledge' AND state_attributes LIKE ?",
             ('%"name": "' + card_name + '%',)).fetchall()
         _targets = [_STNode.from_row(tuple(r)) for r in _rows]
@@ -2942,7 +2946,7 @@ def _card_route_impl(dex, question, limit=5):
         # 从库中取带 comment 的 kp 节点（index 层——KCCS 注释即索引）
         # v1.39：去掉 LIMIT（全库 2839 注释 kp 必须全扫——之前 LIMIT 500
         # 漏掉 2000+ 个 kp，两阶段索引覆盖不全）
-        rows = dex.store.conn.execute(
+        rows = read_conn(dex).execute(
             "SELECT id, state_attributes, content FROM nodes "
             "WHERE state_attributes LIKE '%\"comment\"%'").fetchall()
         scored = []
@@ -3158,7 +3162,7 @@ def two_stage_retrieve(dex, question, top_domains=3, limit=5):
     domain_scores = {}
     domain_hits = {}
     try:
-        rows = dex.store.conn.execute(
+        rows = read_conn(dex).execute(
             "SELECT state_attributes FROM nodes "
             "WHERE state_attributes LIKE '%\"comment\"%'").fetchall()
         for (sa_json,) in rows:
@@ -3241,7 +3245,7 @@ def two_stage_retrieve(dex, question, top_domains=3, limit=5):
     # fp 规范词命中学科卡 content → 该卡 domain → 大域加分，并预取条目答案
     # （两阶段第二阶段的域内数据源——「1+1等于几」→ 加法命中小学数学卡）。
     try:
-        _cards = dex.store.conn.execute(
+        _cards = read_conn(dex).execute(
             "SELECT id, content, state_attributes FROM nodes "
             "WHERE state_attributes LIKE '%\"kind\": \"subject_card\"%' "
             "LIMIT 200").fetchall()
@@ -3581,7 +3585,7 @@ def graph_retrieve(dex, question, limit=10):
                 _kp_name = _parts[-1] if len(_parts) > 1 else _nm
                 _row = None
                 try:
-                    _row = dex.store.conn.execute(
+                    _row = read_conn(dex).execute(
                         "SELECT content FROM nodes WHERE tags LIKE ? AND tags LIKE ? "
                         "AND state_attributes LIKE ? LIMIT 1",
                         ('%knowledge_point%', '%card:' + _card_prefix + '%',