@furongjun1999/dsh-memory 0.4.3 → 0.4.5

package/md_cg/whitebox_kb/wisdom/graph_qa.py

@@ -0,0 +1,123 @@
+# -*- coding: utf-8 -*-
+"""graph_qa.py · 条件图数据库问答（第六阶段·目标6 图查询进对话）
+组装白箱图数据库单元（graph_db_units：建图/影响面/路径）→ 条件图问答：
+  「气压会影响哪些规律？」→ 影响面；「X 和 Y 有关系吗？」→ 路径存在；
+  「从 X 到 Y 怎么走？」→ 路径枚举。零 LLM——白箱知识库即条件图数据库。
+"""
+import sys
+import ast
+sys.stdout.reconfigure(encoding='utf-8')
+
+
+def _load_whitebox_units():
+    """从白箱单元库提取生成的函数（graph_db_units pattern → exec，注入 Graph）"""
+    from graph_db_units import GRAPH_UNITS
+
+    def _exec_unit(uid):
+        """编译执行图单元 pattern 源码，返回其命名空间供函数体调用。"""
+        tree = ast.parse(GRAPH_UNITS[uid]["pattern"])
+        ns = {}
+        exec(compile(tree, "<unit>", "exec"), ns)
+        return ns
+
+    graph_cls = _exec_unit("图存储-节点边")["Graph"]
+
+    def _fn(uid):
+        """取单元命名空间并注入 Graph 类，支持白箱单元之间互相组装。"""
+        ns = _exec_unit(uid)
+        ns["Graph"] = graph_cls  # 注入 Graph（白箱单元互相组装）
+        return ns
+
+    return {
+        "Graph": graph_cls,
+        "build": _fn("条件路由图-对接")["build_from_condition_units"],
+        "impact": _fn("条件路由图-对接")["condition_impact"],
+        "has_path": _fn("图遍历-路径")["has_path"],
+        "all_paths": _fn("图遍历-路径枚举")["all_paths"],
+    }
+
+
+class ConditionGraphQA:
+    """条件图数据库问答：建图（真实条件单元库）→ 影响/关系/路径 查询"""
+
+    def __init__(self, condition_units):
+        """图问答器初始化：挂载图存储与单元执行通道。"""
+        self.units = _load_whitebox_units()
+        self.graph = self.units["build"](condition_units)
+
+    def ask(self, question):
+        qtype = self._classify(question)
+        if qtype is None:
+            return {"ok": False, "reply": "（非条件图问题——不属图查询通道）", "type": None}
+        name = self._extract(question)
+        if not name:
+            return {"ok": False, "type": qtype,
+                    "reply": "（未识别到条件/知识名——诚实边界）"}
+        if qtype == "影响":
+            impact = self.units["impact"](self.graph, name)
+            if not impact:
+                return {"ok": True, "type": "影响",
+                        "reply": f"条件「{name}」不直接影响任何规律单元。", "detail": []}
+            return {"ok": True, "type": "影响",
+                    "reply": f"条件「{name}」影响的规律: {', '.join(impact)}。",
+                    "detail": impact}
+        if qtype == "关系":
+            target = self._extract2(question)
+            if not target:
+                return {"ok": False, "type": "关系",
+                        "reply": "（关系查询需要两个名字——诚实边界）"}
+            # 双向：任一路径存在即有关（有向条件链）
+            has = (self.units["has_path"](self.graph, name, target)
+                   or self.units["has_path"](self.graph, target, name))
+            return {"ok": True, "type": "关系",
+                    "reply": f"「{name}」与「{target}」{'有关联' if has else '无关联'}（条件链路径）。",
+                    "detail": {"has_path": has}}
+        if qtype == "路径":
+            target = self._extract2(question)
+            if not target:
+                return {"ok": False, "type": "路径", "reply": "（路径查询需要两个名字）"}
+            paths = self.units["all_paths"](self.graph, name, target)
+            if not paths:
+                return {"ok": True, "type": "路径",
+                        "reply": f"「{name}」到「{target}」没有路径。"}
+            return {"ok": True, "type": "路径",
+                    "reply": f"「{name}」→「{target}」路径 {len(paths)} 条: "
+                             + " | ".join("→".join(p) for p in paths[:3]),
+                    "detail": paths}
+        return {"ok": False, "type": qtype, "reply": "（未识别问题类型）"}
+
+    def _classify(self, q):
+        """图问题意图分类：按关键词命中分派问型（影响/关系/路径等）。"""
+        if any(w in q for w in ("影响哪些", "涉及哪些", "影响什么", "怎么影响")):
+            return "影响"
+        if any(w in q for w in ("有关系", "有关吗", "能到", "关联")):
+            return "关系"
+        if any(w in q for w in ("怎么走", "路径", "怎么到", "经过")):
+            return "路径"
+        return None
+
+    def _extract(self, q):
+        """条件与知识名提取：最长匹配优先（「光照」优于「光」——更具体者胜）。"""
+        # 提取条件/知识名：最长匹配优先（光照 > 光——更具体）
+        for name in sorted(self.graph.nodes, key=len, reverse=True):
+            if name in q:
+                return name
+        return None
+
+    def _extract2(self, q):
+        """提取第二个名字（关系/路径查询的目标）"""
+        hits = [n for n in sorted(self.graph.nodes, key=len, reverse=True)
+                if n in q]
+        return hits[1] if len(hits) > 1 else None
+
+
+if __name__ == "__main__":
+    print("=== 条件图数据库问答（目标6 · 图查询进对话）===\n")
+    import compose_engine as ce
+    qa = ConditionGraphQA(ce.CONDITION_UNITS)
+    for q in ["气压会影响哪些规律？", "气压 和 沸点-气压 有关系吗？",
+              "从 气压 到 沸点-气压 怎么走？", "什么是碳中和？"]:
+        r = qa.ask(q)
+        mark = "✔" if r.get("ok") else "✘"
+        print(f"[{mark}] Q: {q}")
+        print(f"     A: {r.get('reply', '')}")

package/md_cg/whitebox_kb/wisdom/human_observer_knowledge.json

@@ -0,0 +1,43 @@
+{
+  "meta": {
+    "name": "人类观察者知识点内容（人话接口 · 人类自身观察条件空间）",
+    "version": "v0.1",
+    "date": "2026-08-16",
+    "style": "作为人的自身条件规律：条件→人的自然回应（第一人称，现象规律性）",
+    "coverage": "人类观察者骨架 30 个知识点（身体需要/情绪体验/生活情境）"
+  },
+  "content": {
+    "饿": "我饿了。饿是身体在提醒我需要吃东西了。先找点吃的，吃饱了人就有力气了。",
+    "渴": "我渴了。渴是身体在提醒我需要喝水了。喝点水，身体会舒服很多。",
+    "困": "我困了。困了就该睡觉，硬撑着反而没精神。睡一觉醒来会好很多。",
+    "睡不着": "我睡不着。越想着要睡着越睡不着。放松一下，别刷手机，闭上眼睛慢慢就睡着了。",
+    "冷": "我冷了。冷了要多穿点，暖和了人才舒服。别冻着，感冒就难受了。",
+    "热": "我热了。热了就少穿点、找个凉快的地方。多喝水，别中暑。",
+    "累": "我累了。累了就要休息，休息好才有精神继续。别硬撑，身体要紧。",
+    "疼": "我这儿疼。疼是身体在警告我，得看看是哪里不对。该休息休息，该看医生看医生。",
+    "头晕": "我有点头晕。可能是没休息好或者没吃东西。坐下来缓一缓，严重的话要看医生。",
+    "恶心": "我有点恶心。想吐的话别忍着，吐出来会舒服点。也可能是吃坏了肚子，注意休息。",
+    "发烧": "我好像发烧了。身上热热的没力气。量量体温，多喝水多休息，严重就去看医生。",
+    "感冒": "我感冒了。鼻子不通气，浑身没劲。多喝热水多休息，按时吃药，过几天就好了。",
+    "开心": "我挺开心的。做自己喜欢的事、和喜欢的人在一起，人就会开心。开心的时候要珍惜。",
+    "难过": "我有点难过。难过的时候可以哭一哭，也可以找人说说话。难过的情绪会慢慢过去的。",
+    "生气": "我有点生气。生气的时候先别急着说话，深呼吸冷静一下。等气消了再好好说。",
+    "害怕": "我有点害怕。害怕的时候心跳会快，这是身体在准备应对。确认自己安全，就会慢慢平静下来。",
+    "紧张": "我有点紧张。紧张是正常的，说明我在乎。深呼吸放松，做好准备，会好起来的。",
+    "焦虑": "我有点焦虑。担心的事多了就会焦虑。把能做的先做了，剩下的交给时间。找人聊聊会好一些。",
+    "孤独": "我有点孤独。想找人说说话，或者给家人朋友打个电话。人需要联结，这很正常。",
+    "想家": "我想家了。离家久了会想家，这是正常的。给家里打个电话，听听熟悉的声音就好多了。",
+    "委屈": "我觉得有点委屈。被人误会或者受了委屈，心里不好受。找个信任的人说说，把话说开就好了。",
+    "尴尬": "我有点尴尬。刚才的事让我不自在。没关系，大家都会这样，笑笑就过去了。",
+    "自豪": "我挺自豪的。自己做成了一件事，付出了努力有了结果，这种感觉很好。",
+    "羡慕": "我有点羡慕他。他有的我也想要。不过每个人都有自己的路，过好自己的生活就好。",
+    "嫉妒": "我有点嫉妒。看他那么好我心理不平衡。可嫉妒帮不了我，不如把精力放在自己身上。",
+    "压力": "我最近压力有点大。压力大的时候要给自己松口气，运动一下、找人聊聊，别一个人扛着。",
+    "考试": "要考试了有点紧张。紧张是正常的，说明我在乎。好好复习、早点睡，尽力就行。",
+    "疲惫": "我太疲惫了。身心都累。给自己放个假，好好休息，别把自己逼得太紧。",
+    "失眠": "我失眠了。偶尔失眠不用慌，白天多动动、睡前少想事，会慢慢好起来的。",
+    "想吐": "我有点想吐。胃里不舒服。喝点温水缓缓，别再吃东西了，休息一下。",
+    "性欲": "我会有性欲。性欲是身体的一种自然反应，和饿、困一样是本能的信号。它出现的时候，我可以选择顺着它，也可以选择不顺着——我是有选择的，身体有冲动不等于我必须行动。",
+    "性冲动": "性冲动来的时候，身体会发热、心跳会快。这是生理唤醒，不是谁对谁错。冲动会来也会走，我可以等它过去，或者用健康的方式处理它。喜欢一个人不一定等于想发生性关系，这两件事要分开看。" 
+  }
+}

package/md_cg/whitebox_kb/wisdom/knowledge_points.py

@@ -0,0 +1,234 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+"""
+knowledge_points · 知识点嵌套拆分器（v1.16 · 图架构增强 2/3）
+
+设计者方向（2026-08-18）：知识点级嵌套——知识卡 ⊃ 知识点节点，
+提高子图检索能力与精确度（问题直接命中知识点，而非整卡扫描）。
+
+拆分：学科卡 content「N. 知识点名: 内容」→ 每知识点一个节点
+  - 节点：layer=knowledge，tags=[knowledge_point, card:{卡id}, domain, edu]
+    state_attributes={name, kind:"knowledge_point", parent_card, domain, edu_level}
+  - 边：卡 -hierarchical-> 知识点（verified=1：知识点继承已验证卡）
+  - 幂等：按 (parent_card, 知识点名) 查重
+
+检索适配（配合 dex_respond 的 SQL 预过滤 + recursive_item_answer）：
+  知识点节点带 knowledge_point 标签 → 卡扫描跳过（不拖慢）；知识点级精确命中
+  由 find_points / recursive_item_answer 优先消费。
+
+规模：75 卡 ≈ 2802 知识点（3 语言卡 + 元学科卡无「N.」格式，跳过）。
+纯标准库 · 零外部依赖
+"""
+
+import json
+import os
+import re
+import sqlite3
+import sys
+import time
+from typing import Dict, List, Optional
+
+DEFAULT_DB = r"C:\Users\FuRongJun\.dsh\profiles\web\data\lingshu.db"
+HERE = os.path.dirname(os.path.abspath(__file__))
+
+_KP_RE = re.compile(r"^\s*(\d+)\.\s+(.+?)[:：]\s*(.*)$")
+
+
+class KnowledgePointSplitter:
+    """知识卡 content → 知识点节点 + 卡⊃知识点 hierarchical 边"""
+
+    def __init__(self, db_path: str = DEFAULT_DB):
+        """知识点库连接初始化（缺表自愈创建）。"""
+        self.db_path = db_path
+        self.conn = sqlite3.connect(db_path, timeout=15)
+        self.conn.row_factory = sqlite3.Row
+
+    # ---------------- 拆分 ----------------
+    def parse_points(self, content: str) -> List[tuple]:
+        """content → [(知识点名, 内容)]
+        学科卡「N. 名: 内容」格式；语言卡「①名——内容；②…」格式（v1.16 补全）。"""
+        points = []
+        for ln in (content or "").split("\n"):
+            m = _KP_RE.match(ln)
+            if m:
+                points.append((m.group(2).strip(), m.group(3).strip()))
+        if points:
+            return points
+        return self.parse_lang_points(content or "")
+
+    @staticmethod
+    def parse_lang_points(content: str) -> List[tuple]:
+        """语言卡「语言名 的规律性：①名——内容；②…；适用条件：…」格式"""
+        points = []
+        segs = re.split(r"([①②③④⑤⑥])", content)
+        for i in range(1, len(segs), 2):
+            seg = segs[i + 1] if i + 1 < len(segs) else ""
+            seg = re.split(r"适用条件", seg)[0].strip().rstrip("。；;")
+            if not seg:
+                continue
+            m = re.match(r"([^——：]{1,20})(?:——|：)(.*)", seg)
+            if m:
+                points.append((m.group(1).strip(), m.group(2).strip()))
+            else:
+                points.append((seg[:20], seg))
+        m = re.search(r"适用条件[：:]([^。]*。?)", content)
+        if m:
+            points.append(("适用条件", m.group(1).strip()))
+        return points
+
+    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)
+        # 已存在的知识点名（幂等）
+        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
+        added = 0
+        skipped = 0
+        now = time.time()
+        for pname, pcontent in points:
+            if pname in existing:
+                skipped += 1
+                continue
+            if dry_run:
+                added += 1
+                continue
+            pid = f"kp_{abs(hash(card_id + pname)) % 10**10}_{int(now * 1000)}"
+            tags = ["knowledge_point", "subject_card",
+                    f"card:{card_id[:16]}", f"domain:{domain}"]
+            if edu:
+                tags.append(f"edu:{edu}")
+            sa = json.dumps({"name": pname, "kind": "knowledge_point",
+                             "parent_card": card_id, "domain": domain,
+                             "edu_level": edu}, ensure_ascii=False)
+            cs = json.dumps({"observation_position": f"{name} 知识点（{pname}）",
+                             "observation_tool": "学科知识卡拆分",
+                             "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"))
+            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(
+            "SELECT id, state_attributes, content, importance FROM nodes "
+            "WHERE tags LIKE '%subject_card%' AND tags NOT LIKE '%knowledge_point%'").fetchall()
+        for row in cards:
+            sa = json.loads(row["state_attributes"] or "{}")
+            name = sa.get("name", "")
+            content = row["content"] or ""
+            points = self.parse_points(content)
+            if not points:
+                report["no_format"].append(name or row["id"][:16])
+                continue
+            report["cards"] += 1
+            report["points_total"] += len(points)
+            r = self.split_card(row["id"], name, sa.get("domain", ""),
+                                sa.get("edu_level", ""), content,
+                                row["importance"] or 0.7, dry_run=dry_run)
+            report["added"] += r["added"]
+            report["skipped"] += r["skipped"]
+        return report
+
+    # ---------------- 知识点级精确检索 ----------------
+    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)
+            from semantic_translate import encode
+            fp = encode(query)
+        except Exception:
+            pass
+        scored = []
+        for row in c.execute(
+                "SELECT id, content, state_attributes, importance, tags "
+                "FROM nodes WHERE tags LIKE '%knowledge_point%'").fetchall():
+            sa = json.loads(row["state_attributes"] or "{}")
+            name = sa.get("name", "")
+            text = name + " " + (row["content"] or "")
+            s = 0.0
+            for term, w in fp.items():
+                if term in text:
+                    s += w
+            # v1.16 术语兜底：学科/语言术语不在翻译表（encode 空），
+            # 用问题窗口直接匹配知识点名（中文 2-4 字 + 英文词）
+            if not fp or s == 0:
+                _hit = False
+                _chars = [ch for ch in query if "\u4e00" <= ch <= "\u9fff"]
+                for i in range(len(_chars)):
+                    for L in (4, 3, 2):
+                        if i + L <= len(_chars):
+                            w = "".join(_chars[i:i + L])
+                            if w in name:
+                                # 窗口越长越精确：4字 2.0 / 3字 1.5 / 2字 1.0
+                                s += {4: 2.0, 3: 1.5, 2: 1.0}[L]
+                                _hit = True
+                                break
+                    if _hit:
+                        break
+                if not _hit:
+                    for _m in re.finditer(r"[A-Za-z]{2,}", query):
+                        if _m.group(0).lower() in text.lower():
+                            s += 1.5
+                            break
+            if s > 0:
+                scored.append({"id": row["id"], "name": name,
+                               "content": (row["content"] or "")[:200],
+                               "score": round(s, 3),
+                               "importance": row["importance"],
+                               "card": sa.get("parent_card", "")[:16]})
+        # 同分：短名优先（基础概念优先于长名细分，如「密度」>「密度矩阵与纠缠」）
+        scored.sort(key=lambda x: (-x["score"], len(x["name"]), -x["importance"]))
+        return scored[:limit]
+
+    def close(self):
+        """关闭数据库连接。"""
+        self.conn.close()
+
+
+if __name__ == "__main__":
+    sys.stdout.reconfigure(encoding="utf-8")
+    sp = KnowledgePointSplitter()
+    dry = "--dry-run" in sys.argv
+    rep = sp.split_all(dry_run=dry)
+    print(json.dumps(rep, ensure_ascii=False, indent=1))
+    if not dry:
+        hits = sp.find_points("水为什么烧开")
+        print("\nfind_points('水为什么烧开'):")
+        for h in hits[:5]:
+            print("  %.2f %s: %s" % (h["score"], h["name"], h["content"][:40]))
+    sp.close()

package/md_cg/whitebox_kb/wisdom/merge_subgraph.py

@@ -0,0 +1,178 @@
+# -*- coding: utf-8 -*-
+"""
+补全随包图谱：把主库（lingshu.db）的学科卡 + 知识点子图合入随包图谱
+=====================================================================
+背景（2026-08-19 测试报告）：白箱测试 41% vs 声称 80%——根因是随包图谱
+（wisdom-book-cloud.db）只有 148 个协议知识节点，没有学科卡和知识点子图，
+recursive_item_answer 依赖「卡⊃知识点」子图解析直接答案，子图缺失→只导航不回答。
+
+本脚本：
+1. 从主库抽取学科卡（domain 含「知识点内容（按骨架填充）」等学科类）+
+   其 knowledge_point 子图（card:<prefix> 关联）
+2. 合并进随包图谱（wisdom-book-cloud.db）
+3. 校验：合并后图谱含知识点子图、关键词查询能解析出 direct_answer
+
+用法：
+    python merge_subgraph.py [--src 主库] [--dst 随包图谱] [--backup]
+"""
+
+from __future__ import annotations
+
+import argparse
+import json
+import os
+import shutil
+import sqlite3
+import sys
+from pathlib import Path
+
+# 学科 domain 关键词（主库中「按骨架填充」的学科卡 + 标准学科域）
+SUBJECT_KEYWORDS = ("知识点内容（按骨架填充）", "知识点内容", "初中", "高中",
+                    "小学", "数学", "物理", "化学", "生物", "英语", "语文",
+                    "政治", "历史", "地理", "计算机", "工程", "电路")
+
+
+def _is_subject_node(state_attr: str, tags: str, content: str) -> bool:
+    """判断节点是否属于学科知识。
+
+    精确判定：subject_card 标签（主库学科卡的标准标记）。
+    兜底：domain 以「知识点内容」结尾的学科骨架卡（部分卡无 subject_card 标签）。
+    不做宽泛关键词匹配（会误伤协议/哲学知识节点）。
+    """
+    if "subject_card" in (tags or ""):
+        return True
+    try:
+        sa_d = json.loads(state_attr or "{}") if state_attr else {}
+    except Exception:
+        sa_d = {}
+    dom = sa_d.get("domain", "")
+    return "知识点内容（按骨架填充）" in dom
+
+
+def extract_subject_graph(src_db: str, dst_db: str, backup: bool = True) -> dict:
+    """从主库抽取学科节点（卡 + 知识点子图），合并进随包图谱。"""
+    if backup and os.path.exists(dst_db):
+        bak = dst_db + ".bak_merge_subgraph"
+        shutil.copy2(dst_db, bak)
+        print(f"备份 → {bak}")
+
+    sconn = sqlite3.connect(src_db)
+    sconn.row_factory = sqlite3.Row
+    dconn = sqlite3.connect(dst_db)
+    dconn.row_factory = sqlite3.Row
+
+    # 收集主库所有节点（id→row），和边
+    s_cur = sconn.cursor()
+    s_cur.execute("SELECT * FROM nodes")
+    src_nodes = {r["id"]: dict(r) for r in s_cur.fetchall()}
+    s_cur.execute("SELECT * FROM edges")
+    src_edges = [dict(r) for r in s_cur.fetchall()]
+
+    # 第一步：标记学科卡（subject_card 标签 或 domain 匹配学科关键词 且 是知识层）
+    card_ids = set()
+    for nid, row in src_nodes.items():
+        if row["layer"] != "knowledge":
+            continue
+        sa = row["state_attributes"] or ""
+        tags = row["tags"] or ""
+        content = row["content"] or ""
+        try:
+            sa_d = json.loads(sa) if sa else {}
+        except Exception:
+            sa_d = {}
+        dom = sa_d.get("domain", "")
+        if _is_subject_node(dom, tags, content) or _is_subject_node(sa, tags, content):
+            card_ids.add(nid)
+
+    # 第二步：找这些卡的知识点子图（knowledge_point + card:<卡id前16> 标签）
+    card_prefixes = {cid[:16] for cid in card_ids}
+    kp_ids = set()
+    for nid, row in src_nodes.items():
+        tags = row["tags"] or ""
+        if "knowledge_point" not in tags:
+            continue
+        for prefix in card_prefixes:
+            if f"card:{prefix}" in tags:
+                kp_ids.add(nid)
+                break
+
+    # 第三步：收集关联边（卡↔知识点、知识点之间）
+    wanted = card_ids | kp_ids
+    edge_ids = set()
+    for e in src_edges:
+        if e["source_id"] in wanted and e["target_id"] in wanted:
+            edge_ids.add((e["source_id"], e["target_id"], e.get("relation_type", "causal")))
+
+    # 第四步：写入随包图谱
+    d_cur = dconn.cursor()
+    # 查随包已有 id，避免重复
+    d_cur.execute("SELECT id FROM nodes")
+    existing = {r["id"] for r in d_cur.fetchall()}
+
+    added_nodes = 0
+    for nid in sorted(wanted):
+        if nid in existing:
+            continue
+        row = src_nodes[nid]
+        d_cur.execute(
+            "INSERT OR REPLACE 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, entity_id) VALUES (?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?)",
+            (row["id"], row["content"], row["modality"],
+             json.dumps(row["spatial_coordinates"] or {}, ensure_ascii=False),
+             row["temporal_coordinate"], row["condition_space"] or "",
+             row["importance"], row["confidence"], row["layer"],
+             row["access_count"], row["last_access"], row["created_at"],
+             row["tags"] or "", row["semantic_coordinates"] or "",
+             row["state_attributes"] or "", row["entity_id"]))
+        added_nodes += 1
+
+    added_edges = 0
+    for sid, tid, rel in edge_ids:
+        d_cur.execute(
+            "INSERT OR IGNORE INTO edges (source_id, target_id, relation_type, "
+            "confidence, weight, verified, created_at, last_verified, condition_space, "
+            "source_evidence) SELECT ?,?,?,?,?,?,?,?,?,? WHERE NOT EXISTS "
+            "(SELECT 1 FROM edges WHERE source_id=? AND target_id=? AND relation_type=?)",
+            (sid, tid, rel, 0.5, 1.0, 0, src_nodes[sid]["created_at"], None, "", "extracted",
+             sid, tid, rel))
+        added_edges += 1
+
+    dconn.commit()
+    dconn.close()
+    sconn.close()
+    return {"cards": len(card_ids), "knowledge_points": len(kp_ids),
+            "added_nodes": added_nodes, "added_edges": added_edges}
+
+
+def verify(dst_db: str) -> dict:
+    """校验合并后的图谱：知识点子图存在 + 关键词能解析 direct_answer。"""
+    conn = sqlite3.connect(dst_db)
+    cur = conn.cursor()
+    cur.execute("SELECT COUNT(*) FROM nodes WHERE tags LIKE '%knowledge_point%'")
+    kp = cur.fetchone()[0]
+    cur.execute("SELECT COUNT(*) FROM nodes WHERE tags LIKE '%card:%'")
+    card = cur.fetchone()[0]
+    cur.execute("SELECT COUNT(*) FROM nodes")
+    total = cur.fetchone()[0]
+    conn.close()
+    return {"total": total, "knowledge_point": kp, "card": card}
+
+
+if __name__ == "__main__":
+    ap = argparse.ArgumentParser(description="补全随包图谱：学科卡+知识点子图")
+    _def_src = os.environ.get("AEIS_DB", os.path.join("data", "lingshu.db"))
+    _def_dst = os.path.join(os.path.dirname(os.path.abspath(__file__)), "wisdom-book-cloud.db")
+    ap.add_argument("--src", default=_def_src)
+    ap.add_argument("--dst", default=_def_dst)
+    ap.add_argument("--no-backup", action="store_true")
+    args = ap.parse_args()
+
+    print(f"源（主库）: {args.src}")
+    print(f"目标（随包）: {args.dst}")
+    r = extract_subject_graph(args.src, args.dst, backup=not args.no_backup)
+    print(f"\n抽取结果: 学科卡={r['cards']} 知识点={r['knowledge_points']} "
+          f"新增节点={r['added_nodes']} 新增边={r['added_edges']}")
+    v = verify(args.dst)
+    print(f"合并后图谱: 总节点={v['total']} knowledge_point={v['knowledge_point']} card:={v['card']}")