@furongjun1999/dsh-memory 0.4.4 → 0.4.6

package/md_cg/whitebox_kb/wisdom/card_validator.py

@@ -0,0 +1,223 @@
+# -*- coding: utf-8 -*-
+"""灵枢 · 卡校验器 card_validator（自生长闭环第一步 · v1.16）
+
+对 LLM 写的候选卡做机械五查（结构闸门）：
+  1. 字段完整性：name/domain/level/response{trigger,action,counters}/
+     condition_space 四要素/content 非空；学科卡必带 edu_level
+  2. 条件空间四要素：observation_position/observation_tool/
+     time_window/existence_constraint 全声明
+  3. counters 冲突：新卡 counters 与现有卡 counters 交叉匹配
+     （二元组交集 ≥4 视为潜在冲突 → 提示设计者）
+  4. 学科域/教育层级归属：domain 可识别；edu_level ∈ E1-E5；学科卡必带层级
+  5. 测试用例可执行性（★ 物理信息基底闸门的前置）：tests 字段存在且
+     含可观测判据（observable/topic/expected 或 propositions+observable）
+
+输出：{verdict: pass/needs_revision/fail, checks, pending_designer}
+pass → pending_designer（人工终裁，方向闸门）
+needs_revision → 打回 LLM 重写（带检查报告）
+fail → 拒绝（结构致命缺失）
+
+设计边界：校验器只做机械检查（结构/格式/冲突信号），不裁决知识真理性——
+真理由物理信息基底裁决（测试用例实际执行），方向由设计者终裁。
+"""
+import json
+import os
+import sys
+
+HERE = os.path.dirname(os.path.abspath(__file__))
+
+# 教育层级
+EDU_LEVELS = {"E1", "E2", "E3", "E4", "E5"}
+# 条件空间四要素
+CS_FIELDS = ["observation_position", "observation_tool",
+             "time_window", "existence_constraint"]
+# 学科卡必带字段（response 三件套）
+RESP_FIELDS = ["trigger", "action", "counters"]
+# 卡必带 state_attributes
+SA_REQUIRED = ["name", "domain", "level", "response"]
+
+
+def _bigram_set(text):
+    """二元组集合（去非中文/字母数字）。"""
+    import re
+    t = re.sub(r"[^\u4e00-\u9fffA-Za-z0-9]", "", text or "")
+    return {t[i:i + 2] for i in range(len(t) - 1)}
+
+
+def load_existing_counters(dex=None):
+    """现有 138 卡 counters 文本集合（供冲突检测）。"""
+    out = []
+    if dex is None:
+        return out
+    try:
+        from aeis_core import MemoryLayer
+        for n in dex.store.query_nodes(layer=MemoryLayer.KNOWLEDGE, limit=500):
+            sa = n.state_attributes
+            if not sa.get("name"):
+                continue
+            c = (sa.get("response") or {}).get("counters", "") or ""
+            if c:
+                out.append((sa.get("name"), c))
+    except Exception:
+        pass
+    return out
+
+
+def validate(card, dex=None, existing_counters=None):
+    """五查机械校验。card: dict（LLM 写的候选卡）或 ConditionDex 节点 dict。
+    返回 {verdict, checks: [{check, passed, detail}], pending_designer}。"""
+    checks = []
+    # ---------- 1. 字段完整性 ----------
+    missing = []
+    for f in SA_REQUIRED:
+        if not card.get(f):
+            missing.append(f)
+    resp = card.get("response") or {}
+    for f in RESP_FIELDS:
+        if not resp.get(f):
+            missing.append(f"response.{f}")
+    if not (card.get("content") or card.get("claim")):
+        missing.append("content/claim")
+    # 学科卡（domain 不是协议层）必带 edu_level
+    is_protocol = card.get("domain") in (
+        "智能论", "条件论", "存在论", "信息论", "负反馈系统", "认知双过程",
+        "情感-信任连接", "自我增强回路", "自我意识", "决策论", "博弈论",
+        "统计学", "概率论", "形式逻辑", "科学方法论", "控制论", "机制设计",
+        "时空记忆图", "情感情绪仿真", "价值理论与AI对齐", "复杂系统与涌现",
+        "自我实现预言", "智能推荐算法", "预测误差学习", "演化论与模因",
+        "政治经济学", "热力学/耗散结构", "人类观察者")
+    if not is_protocol and not card.get("edu_level"):
+        missing.append("edu_level（学科卡必带教育层级）")
+    checks.append({
+        "check": "1.字段完整性", "passed": not missing,
+        "detail": f"缺失: {missing}" if missing else "全部就位",
+    })
+
+    # ---------- 2. 条件空间四要素 ----------
+    cs = card.get("condition_space") or card.get("cs") or {}
+    if isinstance(cs, str):
+        try:
+            cs = json.loads(cs)
+        except Exception:
+            cs = {}
+    cs_missing = [f for f in CS_FIELDS if not cs.get(f)]
+    checks.append({
+        "check": "2.条件空间四要素", "passed": not cs_missing,
+        "detail": f"缺失: {cs_missing}" if cs_missing else "四要素齐备",
+    })
+
+    # ---------- 3. counters 冲突（与现有卡） ----------
+    conflict = []
+    new_counters = resp.get("counters", "") or ""
+    if existing_counters is None:
+        existing_counters = load_existing_counters(dex)
+    new_cb = _bigram_set(new_counters)
+    for name, c in existing_counters:
+        if name == card.get("name"):
+            continue
+        inter = len(new_cb & _bigram_set(c))
+        if inter >= 4:
+            conflict.append(f"{name}(交集{inter})")
+    checks.append({
+        "check": "3.counters冲突", "passed": not conflict,
+        "detail": f"潜在冲突: {conflict[:3]}" if conflict else "无冲突信号",
+    })
+
+    # ---------- 4. 学科域/教育层级归属 ----------
+    dom = card.get("domain", "")
+    edu = card.get("edu_level")
+    dom_issues = []
+    if not dom:
+        dom_issues.append("domain 为空")
+    if is_protocol and edu is not None and edu not in EDU_LEVELS:
+        dom_issues.append(f"协议层卡不应带 edu_level={edu}")
+    if not is_protocol:
+        if edu not in EDU_LEVELS:
+            dom_issues.append(f"edu_level={edu} 不在 E1-E5")
+    checks.append({
+        "check": "4.学科域/层级归属", "passed": not dom_issues,
+        "detail": "; ".join(dom_issues) if dom_issues else f"domain={dom} edu={edu or '通用'}",
+    })
+
+    # ---------- 5. 测试用例可执行性（物理基底闸门 · v1.16 升级为真执行） ----------
+    # 格式检查（可观测判据存在）是前置；tests.executable（lang/code）存在时
+    # **真跑**——代码运行/编译结果 = 物理信息基底裁决（爸爸外部参照）。
+    tests = card.get("tests") or card.get("test_cases")
+    tests_ok = True
+    tests_detail = "无 tests 字段"
+    if tests:
+        if isinstance(tests, dict):
+            t_keys = [k for k in ("topic", "expected", "observable", "propositions") if tests.get(k)]
+            tests_ok = bool(t_keys)
+            tests_detail = f"tests 含: {t_keys}" if t_keys else "tests 字段缺可观测判据"
+            # 真执行：tests.executable 存在 → 物理基底校准（代码类卡）
+            ex = tests.get("executable")
+            if ex and isinstance(ex, dict) and ex.get("lang") and ex.get("code"):
+                try:
+                    from code_test_runner import CodeTestRunner
+                    run_r = CodeTestRunner().run_card({"name": card.get("name"), "tests": tests})
+                    status = run_r.get("status", "error")
+                    if status == "pass":
+                        tests_ok = True
+                        tests_detail = (f"物理基底真跑 PASS: {run_r.get('detail','')}"
+                                        f"{' | out: '+run_r['output'][:40] if run_r.get('output') else ''}")
+                    elif status == "env_missing":
+                        tests_ok = True  # 环境缺失不判卡错（D-005 诚实降级），
+                        # 但标记待环境——格式仍通过，设计者终裁时可见
+                        tests_detail = f"物理基底：环境缺失（{run_r.get('detail','')[:50]}）——待环境"
+                    else:
+                        tests_ok = False
+                        tests_detail = f"物理基底真跑 FAIL: {run_r.get('detail','')[:120]}"
+                except Exception as e:
+                    tests_ok = False
+                    tests_detail = f"物理基底执行异常: {str(e)[:100]}"
+        elif isinstance(tests, list) and tests:
+            tests_ok = any(isinstance(t, dict) and ("observable" in t or "expected" in t)
+                           for t in tests)
+            tests_detail = "tests 列表含可观测判据" if tests_ok else "tests 列表缺可观测判据"
+    else:
+        tests_ok = False
+    checks.append({
+        "check": "5.测试用例可执行性", "passed": tests_ok,
+        "detail": tests_detail,
+    })
+
+    # ---------- 汇总 ----------
+    passed_all = all(c["passed"] for c in checks)
+    fail_count = sum(1 for c in checks if not c["passed"])
+    if fail_count == 0:
+        verdict = "pass"
+    elif fail_count <= 2 and not any(c["check"].startswith("1.") for c in checks if not c["passed"]):
+        verdict = "needs_revision"
+    else:
+        verdict = "fail"
+    return {
+        "verdict": verdict,
+        "checks": checks,
+        "pending_designer": verdict == "pass",
+        "summary": f"{verdict}: {sum(1 for c in checks if c['passed'])}/5 通过",
+    }
+
+
+# ---------------- 自测 ----------------
+if __name__ == "__main__":
+    sys.stdout.reconfigure(encoding="utf-8")
+    GOOD = {
+        "name": "测试卡", "domain": "物理学", "level": 2, "edu_level": "E2",
+        "response": {"trigger": "涉及测试议题", "action": "以测试知识回应",
+                     "counters": "越级使用未学概念"},
+        "condition_space": {"observation_position": "测试位",
+                            "observation_tool": "测试工具",
+                            "time_window": [0.0, 9999999999.0],
+                            "existence_constraint": "测试约束"},
+        "content": "测试内容",
+        "tests": {"topic": "测试主题", "observable": "可观测判据"},
+    }
+    BAD = {"name": "残缺卡", "domain": "未知领域"}
+    for label, c in [("GOOD", GOOD), ("BAD", BAD)]:
+        r = validate(c)
+        print(f"[{label}] {r['summary']}")
+        for ch in r["checks"]:
+            mark = "✓" if ch["passed"] else "✗"
+            print(f"  {mark} {ch['check']}: {ch['detail']}")
+        print(f"  pending_designer={r['pending_designer']}")

package/md_cg/whitebox_kb/wisdom/causal_discover.py

@@ -0,0 +1,315 @@
+# -*- coding: utf-8 -*-
+"""灵枢 · 因果候选生成器 causal_discover（v1.16 · R 维进化）
+
+设计（爸爸：条件论对自身的使用）：
+  用条件论七操作处理**系统自身的行为数据**（被拒路径/预测未命中），
+  生成因果假设 → 结合物理信息基底校准（可观测预测 → 验证回路）给出因果分析。
+
+七操作映射：
+  识别 ← 扫描被拒路径/预测未命中 → 异常模式（系统失败的输入=未知因果线索）
+  声明 ← 异常 → 候选因果主张（带条件空间）
+  组合 ← 相似被拒路径聚合 → 同原因多次失败 = 强因果信号
+  分离 ← dex_analyze 七操作剥离混淆（逆转测试查因果方向/统计卡查证据）
+  逆转 ← 因果方向检查（A→B 还是 B→A 还是第三变量）
+  循环 ← 输出可观测预测 → 验证回路（物理基底）→ 命中强化/未命中否决
+
+输出：因果候选（条件空间声明 + 可验证预测），交验证回路 + 设计者终裁 → causal 边入图。
+"""
+import os
+import sys
+import re
+import time
+from typing import Optional
+
+HERE = os.path.dirname(os.path.abspath(__file__))
+sys.path.insert(0, HERE)
+
+
+class CausalDiscoverer:
+    """条件论七操作对自身：行为数据 → 因果候选 → 可验证预测。"""
+
+    def __init__(self, engine, dex=None):
+        """因果发现器初始化（候选机制集与置信先验挂入）。"""
+        self.engine = engine
+        self.dex = dex  # 智慧之书 ConditionDex（供分离/逆转检查）
+
+    # ---------------- 识别（反向·识别操作） ----------------
+    def _scan_anomalies(self, limit=8):
+        """扫描异常模式：open 被拒路径（系统在这些输入上失败）。
+        被拒路径 = 预测/处理失败的输入——未知因果的线索。"""
+        anomalies = []
+        try:
+            paths = self.engine.list_rejected_paths(status="open") if hasattr(
+                self.engine, "list_rejected_paths") else []
+            # 按 description 聚类（同原因多次失败）
+            clusters = {}
+            for p in paths:
+                desc = (p.get("description") or "")[:60]
+                key = desc[:20]
+                clusters.setdefault(key, []).append(p)
+            for key, group in clusters.items():
+                anomalies.append({
+                    "type": "rejected_path_cluster",
+                    "description": key,
+                    "count": len(group),
+                    "reasons": list(dict.fromkeys(
+                        (p.get("reason") or "")[:30] for p in group))[:3],
+                    "evidence": group[0].get("evidence", ""),
+                })
+        except Exception:
+            pass
+        # 预测未命中（hit_history 尾部 false）
+        try:
+            hist = getattr(getattr(self.engine, "_prediction", None),
+                           "_hit_history", []) or []
+            misses = sum(1 for h in hist[-20:] if not h)
+            if misses >= 3:
+                anomalies.append({
+                    "type": "prediction_miss",
+                    "description": f"近20次预测未命中 {misses} 次",
+                    "count": misses,
+                    "reasons": ["预测-验证闭环持续未命中=未知机制"],
+                    "evidence": "hit_history",
+                })
+        except Exception:
+            pass
+        return anomalies[:limit]
+
+    # ---------------- 声明（反向·声明操作） ----------------
+    def _declare_candidate(self, anomaly):
+        """异常 → 候选因果主张（条件空间声明）。"""
+        desc = anomaly["description"] or ""
+        reason = (anomaly.get("reasons") or ["未知"])[0]
+        return {
+            "claim": f"「{desc}」与「{reason}」可能存在因果相关（重复失败=机制性原因而非偶然）",
+            "type": "causal_candidate",
+            "condition_space": {
+                "observation_position": "灵枢行为观测层（被拒路径/预测反馈）",
+                "observation_tool": "rejected_paths 聚类 + hit_history 分析",
+                "time_window": [0.0, time.time()],
+                "existence_constraint": f"候选未验证——仅在重复失败 {anomaly.get('count',1)} 次的证据下成立，需物理基底验证",
+            },
+            "source_anomaly": anomaly,
+        }
+
+    # ---------------- 分离 + 逆转（dex_analyze 七操作） ----------------
+    def _separate_invert(self, candidate):
+        """剥离混淆 + 因果方向检查（复用智慧之书 dex_analyze 的七操作）。
+        逆转：排除逆向因果与第三变量（_t_invert 语义）。"""
+        checks = []
+        if self.dex is not None:
+            try:
+                ana = self.dex.dex_analyze(candidate["claim"], limit=3)
+                premises = ana.get("premises", [])
+                has_causal = any(p.get("type") == "因果声称" for p in premises)
+                checks.append({"check": "因果声称识别", "found": has_causal})
+                invert = ana.get("invert", {}).get("status", "")
+                checks.append({"check": "逆转测试", "status": invert})
+            except Exception as e:
+                checks.append({"check": "dex_analyze", "error": str(e)[:40]})
+        else:
+            # 无 dex：规则化逆转检查（含因果词且可证伪）
+            has_causal = bool(re.search(r"因果|导致|相关|因为", candidate["claim"]))
+            checks.append({"check": "因果声称识别", "found": has_causal})
+            checks.append({"check": "逆转测试",
+                           "status": "需验证：因果方向非唯一，需排除逆向因果与第三变量"})
+        candidate["separation_checks"] = checks
+        return candidate
+
+    # ---------------- 循环（可观测预测 → 物理基底） ----------------
+    def _cycle_predictions(self, candidate):
+        """生成可观测预测——物理信息基底校准的输入。
+        如果因果成立（A→B），则在 X 条件下应观察到 Y；预测可执行/可观测。
+        交 prediction_feedback 验证：命中强化 / 未命中否决。"""
+        desc = (candidate.get("source_anomaly") or {}).get("description", "")
+        return {
+            "candidate_id": f"cc_{abs(hash(candidate['claim'])) % 10**8}",
+            "claim": candidate["claim"],
+            "source_anomaly": candidate.get("source_anomaly"),
+            "predictions": [
+                {"observable": f"重复处理同特征输入，若机制性原因存在，失败模式应可复现",
+                 "verify_method": "prediction_feedback（验证回路）",
+                 "expected": "复现→强化候选；不复现→否决（偶然）"},
+                {"observable": f"补足缺失知识后，同类输入应转为成功",
+                 "verify_method": "设计者终裁 + 图谱检索",
+                 "expected": "补足后成功→因果确认；仍失败→候选错误"},
+            ],
+            "condition_space": candidate["condition_space"],
+            "note": "物理基底校准：因果候选必须通过可观测预测验证，非仅逻辑自洽",
+        }
+
+    # ---------------- 验证闭环（v1.16 · 物理基底校准） ----------------
+    def verify_candidates(self, window=50):
+        """追踪已存观测层的因果候选状态：
+          - 候选对应的被拒路径仍 open（未修复）→ 候选成立（保持）
+          - 已 consumed（被修复/补足）→ 因果确认（resolve）
+          - 超过 window 轮仍无变化 → 保持待验证（不误杀）
+        返回状态统计。候选存观测层（tags: causal_candidate）。"""
+        from aeis_core import MemoryLayer
+        now = time.time()
+        open_paths = set()
+        consumed = 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, 0, 0
+        for n in self.engine.store.query_nodes(layer=MemoryLayer.KNOWLEDGE, limit=500):
+            tags = n.tags or []
+            if "causal_candidate" not in tags:
+                continue
+            tracked += 1
+            content = (n.content or "")
+            # 候选对应的异常描述（存观测层时写入的键）
+            key = None
+            for t in tags:
+                if t.startswith("cc_key:"):
+                    key = t[7:].strip("「」 \t")
+            if key and key in consumed:
+                n.tags = [t for t in n.tags if t != "status:candidate_open"]
+                n.tags = list(dict.fromkeys(n.tags + ["status:causal_confirmed"]))
+                self.engine.store.add_node(n)
+                resolved += 1
+                # 因果确认 → 写入 verified causal 边（v1.16 补断链：
+                # 确认只改 tag 从不入图 → 主库 causal 边永远为 0）
+                try:
+                    target_id = self._resolve_causal_target(n)
+                    if target_id and not self._has_causal_edge(n.id, target_id):
+                        from aeis_core import EdgeType
+                        edge = self.engine.add_edge(
+                            n.id, target_id, relation_type=EdgeType.CAUSAL,
+                            confidence=0.6, source_evidence="extracted")
+                        self.engine.verify_edge(edge.id, 0.6)
+                except Exception:
+                    pass
+            elif key and key in open_paths:
+                still_open += 1
+        return {"tracked": tracked, "resolved": resolved, "still_open": still_open,
+                "note": "验证闭环：被拒路径 consumed=因果确认（入 causal 边）；仍 open=候选成立待修复"}
+
+    # ---------------- 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 检索
+        quoted = re.findall(r"「([^」]+)」", content)
+        noise = {"用户问", "检索不到", "翻译表缺", "图谱无此", "常识卡缺失",
+                 "可能存在", "因果相关", "重复失败", "机制性原因", "预测未命中",
+                 "实际节点", "未知因果", "的线索"}
+        words = []
+        for seg in quoted:
+            seg_clean = seg.replace("「", "").replace("」", "")
+            for piece in re.split(r"[→\-、，。！？\s]+", seg_clean):
+                # 剥离 noise 前缀（如「翻译表缺沸点」→「沸点」）
+                for np_ in sorted(noise, key=len, reverse=True):
+                    if piece.startswith(np_):
+                        piece = piece[len(np_):]
+                        break
+                for w in re.findall(r"[\u4e00-\u9fff]{2,6}", piece):
+                    if w not in noise and w not in words:
+                        words.append(w)
+        # 短实体词优先（2-4 字 = 主题词；长串易 miss 或命中泛节点）
+        words.sort(key=len)
+        conn = self.engine.store.conn
+        self_id = getattr(candidate_node, "id", "") or ""
+        for w in words:
+            try:
+                row = conn.execute(
+                    "SELECT id FROM nodes WHERE content LIKE ? AND id != ? "
+                    "ORDER BY importance DESC, length(content) LIMIT 1",
+                    ('%' + w + '%', self_id)).fetchone()
+                if row:
+                    return row[0]
+            except Exception:
+                continue
+        return None
+
+    def _has_causal_edge(self, source_id: str, target_id: str) -> bool:
+        """幂等：避免重复写入同一条 causal 边"""
+        try:
+            row = self.engine.store.conn.execute(
+                "SELECT id FROM edges WHERE source_id=? AND target_id=? "
+                "AND relation_type='causal'", (source_id, target_id)).fetchone()
+            return row is not None
+        except Exception:
+            return False
+
+    # ---------------- 主流程 ----------------
+    def discover(self, limit=5, persist=True):
+        """七操作对自身：识别→声明→分离/逆转→循环。
+        返回因果候选（带可验证预测），交验证回路 + 设计者终裁。
+        persist=True：候选存观测层（tags: causal_candidate + cc_key），
+        供 verify_candidates 追踪（物理基底验证闭环）。"""
+        # 1. 识别
+        anomalies = self._scan_anomalies(limit=limit)
+        if not anomalies:
+            return {"candidates": [], "note": "无异常模式（无因果候选信号）"}
+        # 2. 声明
+        candidates = [self._declare_candidate(a) for a in anomalies]
+        # 3. 分离 + 逆转
+        for c in candidates:
+            self._separate_invert(c)
+        # 4. 循环（可观测预测）
+        outputs = [self._cycle_predictions(c) for c in candidates]
+        # 5. 持久化到观测层（验证闭环追踪）
+        if persist:
+            for c in outputs:
+                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
+        return {
+            "candidates": outputs,
+            "note": ("条件论对自身的使用：七操作处理自身行为数据（被拒路径/预测未命中）"
+                     "→ 因果候选 → 可观测预测 → 验证回路（物理基底校准）→ 终裁入图"),
+        }
+
+
+# ---------------- 自测 ----------------
+if __name__ == "__main__":
+    sys.stdout.reconfigure(encoding="utf-8")
+    from aeis_core.api import Agent
+    agent = Agent(identity="灵枢",
+                  db_path=os.environ.get("LINGSHU_DB") or os.path.join(
+                      os.path.expanduser("~"), ".dsh", "profiles", "web",
+                      "data", "lingshu.db"))
+    # 注入一条被拒路径作为信号
+    try:
+        agent.engine.register_rejected_path(
+            "query", "用户问「水为什么烧开」检索不到沸点知识", "翻译表缺沸点→沸腾映射",
+            evidence="extend_test")
+        agent.engine.register_rejected_path(
+            "query", "用户问「为什么下雨前蚂蚁搬家」图谱无此常识", "常识卡缺失",
+            evidence="extend_test")
+    except Exception:
+        pass
+    discoverer = CausalDiscoverer(agent.engine, dex=agent._get_wisdom())
+    result = discoverer.discover(limit=3)
+    print("=== 因果候选生成器（条件论对自身）===")
+    for c in result.get("candidates", []):
+        print(f"\n候选 {c['candidate_id']}: {c['claim'][:50]}")
+        for s in c.get("separation_checks", []):
+            print(f"  分离/逆转: {s}")
+        for p in c.get("predictions", []):
+            print(f"  预测: {p['observable'][:40]}... ({p['verify_method']})")
+    print(f"\n{result['note']}")
+    agent.close()