@furongjun1999/dsh-memory 0.4.6 → 0.4.7

package/md_cg/test_writelimit.py

@@ -0,0 +1,197 @@
+# -*- coding: utf-8 -*-
+"""md_cg · 自动写入限流与同构聚合（流水污染治理）写入侧 + 读侧整理。
+
+覆盖：
+  A 模板签名：同模板异数字同签名 / 长文 None / 短骨架 None
+  B 同构聚合：第 2+ 条并入既有（merge_count+1，不新增节点）
+  C 频率限制：窗口内超量 DEFER；其他 role 不受影响
+  D 保护优先：hint≥0.7 不限流
+  E 层豁免：knowledge 不聚合不限流
+  F env 关闭：MDCG_WRITELIMIT=0 放行
+  G 留痕：_forgetting.jsonl 有 limiter 记录
+  H tidy：已落盘同构组聚合 + 成员降权 + 永不删除
+  I SustainLoop：auto_tidy 参数与调度字段
+
+运行：python -m md_cg.test_writelimit
+"""
+from __future__ import annotations
+
+import json
+import os
+import shutil
+import tempfile
+import time
+
+from .mdcos import MdCGOS
+from . import writelimit
+
+# ---------------------------------------------------------------- 测试脚手架
+
+_d = tempfile.mkdtemp(prefix="mdcg_wl_")
+cg = MdCGOS(_d)
+root = cg.root
+N = [0]
+
+
+def check(name: str, cond, detail: str = "") -> None:
+    assert cond, f"[FAIL] {name} {detail}"
+    print(f"[ok] {name}")
+
+
+def _write(node_id, content, layer="contextual", gated=True,
+           hint=None, role="user"):
+    """remember_gated 快捷封装（单测直接注入固定 id 便于断言）。"""
+    kw = {}
+    if hint is not None:
+        kw["importance_hint"] = hint
+    return cg.remember_gated(node_id, content, layer=layer, role=role,
+                             gated=gated, **kw)
+
+
+# ---------------------------------------------------------------- A 模板签名
+
+check("A1 同模板异数字 → 同签名",
+      writelimit.template_signature("批次247收官记忆")
+      == writelimit.template_signature("批次248收官记忆"))
+check("A2 长文（≥200）→ None（正经记忆不聚合）",
+      writelimit.template_signature("长" * 200) is None)
+check("A3 短骨架（<4）→ None（防「好的/收到」误聚）",
+      writelimit.template_signature("好的 001") is None)
+check("A4 URL/时间戳归一 → 同签名",
+      writelimit.template_signature("同步 2024 完成")
+      == writelimit.template_signature("同步 2025 完成"))
+check("A5 标题模板优先（正文长也聚合）",
+      writelimit.template_signature(
+          "# 功能名：批次247收官记忆\n" + "正文" * 150)
+      == writelimit.template_signature(
+          "# 功能名：批次248收官记忆\n" + "另文" * 150)
+      and writelimit.template_signature(
+          "# 功能名：批次247收官记忆\n" + "正文" * 150) is not None)
+
+# ---------------------------------------------------------------- B 同构聚合
+
+r1 = _write("wl_001", "批次247收官记忆")
+check("B1 首条放行 ACCEPT", r1["verdict"] == "ACCEPT", str(r1.get("gate")))
+r2 = _write("wl_002", "批次248收官记忆")
+check("B2 第二条 CONVERGE→MERGE",
+      r2["verdict"] == "MERGE" and r2.get("merged_into") == "wl_001",
+      str(r2.get("gate")))
+check("B3 聚合不新增节点", cg.get("wl_002") is None)
+tgt = cg.get("wl_001")
+check("B4 正文追加聚合行", "【聚合" in (tgt.get("content") or ""))
+check("B5 merge_count+1",
+      int(tgt["frontmatter"].get("merge_count", 0)) == 1)
+# B6 精确重复 → DROP（模拟会话重启后 hooks 重复 memorize 同一事件）：
+# 与既有节点正文完全一致 = 零新信息，交回旧闸门 DROP 语义（对齐 test_p9
+# 「确定性内部冗余 → DROP 先于 MERGE」），不追加重复聚合行
+r_f1 = _write("wl_f1", "会议纪要模板甲乙丙丁版")
+check("B6a 首写 ACCEPT", r_f1["verdict"] == "ACCEPT", str(r_f1.get("gate")))
+writelimit._save(cg, {"sigs": writelimit._load(cg)["sigs"], "rate": {}})
+r_f2 = _write("wl_f2", "会议纪要模板甲乙丙丁版")   # 与 wl_f1 同文
+check("B6b 精确重复 → DROP（不落库不强化）",
+      r_f2["verdict"] == "DROP" and cg.get("wl_f2") is None
+      and "merge_count" not in cg.get("wl_f1")["frontmatter"],
+      str(r_f2.get("gate")))
+
+# ---------------------------------------------------------------- C 频率限制
+
+# 换不同模板绕开聚合，只压频率：9 条连写，第 9 条应 DEFER（RATE_MAX=8）
+for i in range(8):
+    _write(f"wl_r{i}", f"盘点条目甲乙丙丁戊{i}号")
+r9 = _write("wl_r9", "盘点条目甲乙丙丁戊9号")
+check("C1 窗口超量 DEFER",
+      r9["verdict"] == "DEFER" and "ratelimit" in (r9.get("gate") or {})
+      .get("reason", ""), str(r9.get("gate")))
+# DEFER 节点不落盘
+check("C2 DEFER 不落盘", cg.get("wl_r9") is None)
+# 其他 role 不受影响（各自独立窗口）
+r_other = _write("wl_r10", "盘点条目甲乙丙丁戊10号", role="tool-output")
+check("C3 其他 role 独立窗口",
+      r_other["verdict"] in ("ACCEPT", "MERGE"), str(r_other.get("gate")))
+
+# ---------------------------------------------------------------- D 保护优先
+
+r_hi = _write("wl_hi1", "高价值条目甲乙丙丁1号", hint=0.9)
+r_hi2 = _write("wl_hi2", "高价值条目甲乙丙丁2号", hint=0.9)
+check("D1 hint≥0.7 跳过限流（不聚合）",
+      r_hi2["verdict"] == "ACCEPT" and cg.get("wl_hi2") is not None,
+      str(r_hi2.get("gate")))
+
+# ---------------------------------------------------------------- E 层豁免
+
+writelimit._save(cg, {"sigs": {}, "rate": {}})   # 清状态隔离本节
+r_k1 = _write("wl_k1", "知识条目甲乙丙丁1号", layer="knowledge")
+r_k2 = _write("wl_k2", "知识条目甲乙丙丁2号", layer="knowledge")
+check("E1 knowledge 不聚合不限流",
+      r_k1["verdict"] == "ACCEPT" and r_k2["verdict"] == "ACCEPT",
+      f"{r_k1.get('gate')}/{r_k2.get('gate')}")
+
+# ---------------------------------------------------------------- F env 关闭
+
+writelimit._save(cg, {"sigs": {}, "rate": {}})
+os.environ["MDCG_WRITELIMIT"] = "0"
+try:
+    r_off = _write("wl_off", "批次999收官记忆")
+    check("F1 env 关闭放行", r_off["verdict"] in ("ACCEPT", "MERGE"),
+          str(r_off.get("gate")))
+finally:
+    os.environ.pop("MDCG_WRITELIMIT", None)
+
+# ---------------------------------------------------------------- G 留痕
+
+_log = os.path.join(root, "_forgetting.jsonl")
+lims = []
+if os.path.exists(_log):
+    with open(_log, encoding="utf-8") as f:
+        for line in f:
+            try:
+                rec = json.loads(line)
+            except ValueError:
+                continue
+            if rec.get("limiter"):
+                lims.append(rec)
+check("G1 限流留痕 _forgetting.jsonl",
+      any(r.get("verdict") == "MERGE" for r in lims)
+      and any(r.get("verdict") == "DEFER" for r in lims),
+      f"limiter recs={len(lims)}")
+
+# ---------------------------------------------------------------- H tidy
+
+writelimit._save(cg, {"sigs": {}, "rate": {}})
+os.environ["MDCG_WRITELIMIT"] = "0"      # 绕过写入限流，直造存量同构组
+try:
+    for i in range(5):
+        _write(f"wl_t{i}", f"巡检批次{i}收官记忆")
+finally:
+    os.environ.pop("MDCG_WRITELIMIT", None)
+dry = writelimit.tidy_contextual(cg, apply=False)
+check("H1 dry-run 盘出同构组", dry["groups"] >= 1
+      and dry["members"] >= 4, str(dry["groups"]))
+before = len(cg.index["nodes"])
+tidy = writelimit.tidy_contextual(cg, apply=True, min_group=3)
+check("H2 apply 后节点总数不变（永不删除）",
+      len(cg.index["nodes"]) == before,
+      f"{before}->{len(cg.index['nodes'])}")
+m0 = cg.get("wl_t0")
+m1 = cg.get("wl_t1")
+check("H3 主节点收编成员清单", "整理聚合" in (m0.get("content") or "")
+      and "wl_t1" in (m0.get("content") or ""))
+check("H4 成员降权 + tidy:converged",
+      "tidy:converged" in (m1["frontmatter"].get("tags") or [])
+      and float(m1["frontmatter"]["importance"]) <= 0.3,
+      str(m1["frontmatter"].get("importance")))
+
+# ---------------------------------------------------------------- I SustainLoop
+
+from .sustain import SustainLoop, DEFAULT_TIDY_INTERVAL  # noqa: E402
+
+lp = SustainLoop(cg, name="wl_test", auto_tidy=True,
+                 tidy_interval=111.0)
+check("I1 auto_tidy 透传", lp.auto_tidy is True and lp.tidy_interval == 111.0)
+check("I2 默认间隔 6h", DEFAULT_TIDY_INTERVAL == 21600.0)
+lp.stop()
+
+# ---------------------------------------------------------------- 收尾
+
+print("\nAll writelimit tests passed.")
+shutil.rmtree(_d, ignore_errors=True)

package/md_cg/whitebox_kb/aeis_core/api.py

@@ -690,10 +690,15 @@ class Agent:
 
     def preflight(self, text: str) -> Dict:
         """输出前反思钩子：内容与价值观一致性检查（冲突词拦截）。
-        推理强化：重要输出对外发布前调用，失调内容前置拦截。"""
+        推理强化：重要输出对外发布前调用，失调内容前置拦截。
+        fail-closed（矩阵 v0.2 #29）：组件未装配 = 检查未执行 ≠ 通过——
+        返回 ok:False 拦截并携带装配错误，杜绝「未验证被冒充为已验证」。"""
         sc = getattr(self.engine, "_self_cognition", None)
         if sc is None:
-            return {"ok": True, "note": "自我认知组件未装配"}
+            return {"ok": False, "status": "fail_closed",
+                    "reason": "self_cognition_not_ready",
+                    "note": "自我认知组件未装配，输出前检查未执行（fail-closed：未验证不放行）",
+                    "error": str(getattr(self.engine, "_self_cognition_error", "") or "")}
         return sc.preflight(text)
 
     def see(self, image_path: str, conf_threshold: float = 0.35,

package/md_cg/whitebox_kb/aeis_core/core.py

@@ -964,16 +964,20 @@ class LayeredStore:
         like_cond = "(" + " OR ".join(like_parts) + ")"
         where = " AND ".join(conds + [like_cond]) if conds else like_cond
         c = self.conn.cursor()
-        c.execute(f"SELECT * FROM nodes WHERE {where} LIMIT 300", params + like_params)
+        # 截断确定性（v1.17）：无 ORDER BY 的 LIMIT 依赖 sqlite 物理插入序
+        # （VACUUM/重建即漂移，跨后端不可复现）——ORDER BY id 固化候选池。
+        c.execute(f"SELECT * FROM nodes WHERE {where} ORDER BY id LIMIT 300",
+                  params + like_params)
         rows = c.fetchall()
         if not rows:
             # 检索增强（v1.12.1 · AEIS-BENCH-01 发现）：LIKE 预筛落空
             # （查询为重组短语，原文无连续子串命中）→ 回退全表二元组 Jaccard。
             # 节点量级小（千级），全表计算代价可忽略；消除连续性漏检。
             if conds:
-                c.execute(f"SELECT * FROM nodes WHERE {' AND '.join(conds)} LIMIT 500", params)
+                c.execute(f"SELECT * FROM nodes WHERE {' AND '.join(conds)} "
+                          f"ORDER BY id LIMIT 500", params)
             else:
-                c.execute("SELECT * FROM nodes LIMIT 500")
+                c.execute("SELECT * FROM nodes ORDER BY id LIMIT 500")
             rows = c.fetchall()
         scored = []
         # 评分用原查询二元组重叠率（召回导向）；扩展词只负责预筛召回不稀释评分
@@ -987,8 +991,9 @@ class LayeredStore:
                 sim = 0.0
             tag_bonus = 0.05 if any(t in q or q in t for t in node.tags) else 0.0
             scored.append((node, min(1.0, sim + tag_bonus)))
-        # 同分按重要性降序（高质量记忆优先，避免并列截断排挤重要节点）
-        scored.sort(key=lambda x: (-x[1], -x[0].importance))
+        # 同分按重要性降序（高质量记忆优先，避免并列截断排挤重要节点）；
+        # 末键 id 确定性决胜——同分同重要度的相对序不依赖候选遍历序（物理序）
+        scored.sort(key=lambda x: (-x[1], -x[0].importance, x[0].id))
         results = scored[:limit]
         for node, _ in results:
             self.increment_access(node.id)

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

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