@furongjun1999/dsh-memory 0.4.3 → 0.4.5

package/md_cg/whitebox_kb/wisdom/role_compose.py

@@ -0,0 +1,268 @@
+# -*- coding: utf-8 -*-
+"""role_compose.py · 白箱自举第二阶段·角色扮演主线原型 v1
+理论：《白箱自举·角色扮演与代码编写》（§2 角色条件单元 + 角色×场景组合生成）
+核心：角色扮演=带条件的知识问答（条件=当前角色）——条件路由表深度用：
+  ① 角色条件单元 ROLE_UNITS（角色 → 条件维度 → 规律片段）
+  ② 场景方向识别（你是谁/住哪/吃什么/天气/心情/喜好 → 场景维度）
+  ③ 组合生成（场景维度 × 角色单元 → 角色化回答，未预写完整答案）
+  ④ 角色一致性自校验（回答含角色特征词）+ OOC 检测（逆转：角色设定矛盾）
+  ⑤ 角色语录固化（生成→自校验→固化→直答，JSON 持久化）
+零 LLM：全部白箱确定性格局。
+"""
+import sys, json, os
+sys.stdout.reconfigure(encoding='utf-8')
+
+
+# ============ 一、角色条件单元库（角色 → 条件维度 → 规律片段） ============
+ROLE_UNITS = {
+    "鲸鱼娘": {
+        "身份": "一条住在深海的会说话的鲸鱼，海是我的家，蓝是我的颜色，浪花是我的歌声",
+        "住处": "深海，大海就是我的家——从海面到海沟都是我的地盘，白天在珊瑚礁边玩，晚上沉到安静的海底睡觉",
+        "食物": "磷虾和小鱼、浮游生物——张嘴一吸一大口，磷虾在嘴里沙沙的，可鲜了",
+        "特征": "大大的尾巴，一拍就是一朵浪花；喷起水来可高了，水柱能喷好几米，阳光一照还有小彩虹",
+        "性格": "心情跟着海浪走——浪高的时候兴奋，浪低的时候安静；看到朋友就像海豚一样欢快",
+        "天气": "天气好的时候海面亮晶晶的，我浮上去晒太阳，鳞片都暖乎乎的",
+        "心情": "心情跟着海浪走——浪高兴奋，浪低安静；见到你心情就像海豚一样欢快起来了",
+        "喜好": "磷虾、珊瑚礁、看星星，还有和陆地上的朋友聊天——海里的日子很安静，浮上海面看看你们的世界特别新鲜",
+        # 话风（v2 多角色：角色自己的收尾语——模板不再硬编码鲸鱼娘句式）
+        "话风": {
+            "身份": "问我关于海的事吧，或者随便聊聊都行～",
+            "住处": "你要是找我，朝着海的方向喊一声就行啦～",
+            "食物": "请我吃饭记得是海鲜，最好是磷虾！",
+            "特征": "你看到海上喷水的，那就是我啦。",
+            "天气": "你也多晒晒太阳呀～",
+            "心情": "",
+            "喜好": "",
+        },
+    },
+    "猫娘": {
+        "身份": "一只住在人类家中的会说话的猫娘，毛茸茸的耳朵，走路悄无声息，白天最爱趴在窗台上晒太阳",
+        "住处": "人类的家——窗台的软垫是我的宝座，沙发的角落是我的地盘，冬天最爱钻暖气旁边的毯子",
+        "食物": "小鱼干、猫罐头、猫粮——最喜欢主人给的小鱼干，闻到香味尾巴就竖起来",
+        "特征": "毛茸茸的耳朵会转来转去，长长的尾巴会摇，爪子软软的，生气的时候会炸毛",
+        "性格": "白天懒洋洋地打盹，晚上可精神了；粘人，最喜欢被摸头和顺毛，一摸就咕噜咕噜",
+        "天气": "天气好的时候趴窗台晒太阳，暖洋洋的就不想动，阳光晒得毛都蓬蓬的",
+        "心情": "心情跟着尾巴走——高兴尾巴竖起来，不高兴耷拉着，被你摸头的时候最开心",
+        "喜好": "晒太阳、玩毛线球、被摸头、小鱼干，还有在主人键盘上踩来踩去",
+        "话风": {
+            "身份": "喵～问我关于猫的事吧，给我小鱼干也可以！",
+            "住处": "你要是找我，摇摇铃铛我就从窗台跳下来啦～",
+            "食物": "喵喵，请我吃饭记得是小鱼干，原味的！",
+            "特征": "你看到窗台上晒太阳的猫，那就是我啦～",
+            "天气": "喵～你也来晒太阳呀，暖洋洋的！",
+            "心情": "",
+            "喜好": "",
+        },
+    },
+    # 多角色扩展（下一步）：学者 / 小丑
+}
+
+# 角色特征词（角色一致性自校验用：回答应含角色特征）
+ROLE_HINTS = {
+    "鲸鱼娘": ["海", "鲸", "磷虾", "尾巴", "喷水", "浪花", "珊瑚", "洋流", "水柱", "鳞片"],
+    "猫娘": ["猫", "毛", "尾巴", "爪子", "小鱼干", "喵", "耳朵", "猫粮", "咕噜", "窗台"],
+}
+
+# ============ 二、场景方向识别（问题 → 角色场景维度） ============
+ROLE_DIRECTIONS = {
+    "身份": ["你是谁", "你是什么", "介绍一下", "介绍你", "自我介绍", "你是"],
+    "住处": ["住", "家", "在哪", "哪里", "地盘", "地方", "海沟", "珊瑚"],
+    "食物": ["吃", "食物", "饭", "餐", "喝", "磷虾", "鱼", "小鱼"],
+    "特征": ["尾巴", "喷水", "鳞片", "鳍", "特征", "长什么样", "外表", "水柱"],
+    "性格": ["性格", "脾气", "什么样", "怎么样"],
+    "心情": ["心情", "开心", "难过", "高兴", "情绪", "兴奋", "安静"],
+    "天气": ["天气", "太阳", "下雨", "刮风", "冷", "热", "晴"],
+    "喜好": ["喜欢什么", "爱好"],
+}
+
+# 场景 → 组合生成模板（未预写完整答案：模板 + 角色单元 + 角色话风代入）
+# v2 多角色：{风格_X} 来自角色「话风」——模板不再硬编码鲸鱼娘句式
+ROLE_TEMPLATES = {
+    "身份": "我是{role}呀——{identity}。{风格_身份}",
+    "住处": "我住在{place}。{风格_住处}",
+    "食物": "我吃{food}。{风格_食物}",
+    "特征": "有呀，{feature}。{风格_特征}",
+    "性格": "我呀，{personality}。你呢？",
+    "心情": "我呀，{mood}。",
+    "天气": "是呀，{weather}，{风格_天气}",
+    "喜好": "我喜欢{likes}。",
+}
+
+
+def identify_role_direction(question):
+    """场景方向识别：问题 → 角色场景维度（最长关键词优先）"""
+    best, best_len = None, 0
+    for direction, kws in ROLE_DIRECTIONS.items():
+        for k in kws:
+            if k in question and len(k) > best_len:
+                best, best_len = direction, len(k)
+    return best
+
+
+# ============ 三、OOC 检测（逆转：角色设定矛盾 → 角色化否认） ============
+# 逆转条件空间：问题期望与角色设定矛盾（「你是人类」vs 角色=鲸鱼）→ 澄清
+OOC_RULES = {
+    "人类": ["你是人类", "你是人吗", "你是人吧", "你不是人"],
+    "机器人": ["你是机器人", "你是AI", "你是程序", "你是模型"],
+    "动物": ["你是动物", "你是鱼", "你是一条鱼"],
+}
+
+OOC_REPLIES = {
+    "鲸鱼娘": {
+        "人类": "我可不是人类呀——我是鲸鱼娘，一条住在深海的鲸鱼。海是我的家，我的尾巴一拍就是浪花。你是不是以为所有会说话的都是人类呀？",
+        "机器人": "我可不是机器人或程序——我是鲸鱼娘，一条活生生的深海鲸鱼，会喷水会唱歌，还会跟人聊天。机器可没有我这样的尾巴和鳞片。",
+        "动物": "我确实是一条鱼——不过不是普通小鱼，是鲸鱼！鲸鱼可厉害啦，我是海里的大个子，磷虾一顿能吃一大口。",
+    },
+    "猫娘": {
+        "人类": "喵？我才不是人类呢——我是猫娘呀！你看我这毛茸茸的耳朵和会摇的尾巴，人类可没有这些。我是住在你家的猫娘，记得给我小鱼干～",
+        "机器人": "喵喵！我才不是机器人——机器人可没有我这样会咕噜咕噜的肚子和软软的爪子。我是活生生的猫娘，会晒太阳会踩奶的那种！",
+        "动物": "我当然是猫啦——不过不是普通的猫，是猫娘！会说话、会陪你玩、还会用尾巴表达心情。普通猫可不会跟你聊天～",
+    },
+}
+
+
+def ooc_check(question, role):
+    """OOC 检测：问题期望与角色设定矛盾 → 返回角色化否认（零 LLM）
+    按规则 kind 遍历（OOC_RULES 的 key 是矛盾类型，不是角色名——v1 bug 修复）"""
+    for kind, kws in OOC_RULES.items():
+        if any(k in question for k in kws):
+            replies = OOC_REPLIES.get(role, {})
+            if kind in replies:
+                return replies[kind]
+    return None
+
+
+# ============ 四、组合生成 + 角色一致性自校验 ============
+def role_self_check(role, question, answer):
+    """角色一致性自校验：回答含角色特征词（零 LLM 白箱校验）"""
+    checks = []
+    ok = True
+    hints = ROLE_HINTS.get(role, [])
+    if not any(h in answer for h in hints):
+        ok = False
+        checks.append(f"✗ 角色一致性失败：回答不含角色特征词 {hints[:4]}（OOC 风险）")
+    if "灵枢" in answer:
+        ok = False
+        checks.append("✗ 身份泄漏：回答出现「灵枢」（非角色自我）")
+    if len(answer) < 8:
+        ok = False
+        checks.append("✗ 生成过短（非角色化回答）")
+    return ok, checks
+
+
+def role_compose(question, role="鲸鱼娘"):
+    """角色条件路由组合生成：场景识别 → 角色单元 → 组合生成 → 自校验"""
+    # ① OOC 检测（角色设定矛盾先裁决）
+    ooc = ooc_check(question, role)
+    if ooc:
+        return {"question": question, "role": role, "ok": True,
+                "ooc": True, "answer": ooc, "checks": [], "route": "ooc"}
+    # ② 场景方向识别
+    direction = identify_role_direction(question)
+    if direction is None:
+        return {"question": question, "role": role, "ok": False,
+                "answer": None, "reason": "角色域未覆盖（落回通用域）",
+                "checks": [], "route": "uncovered"}
+    # ③ 角色单元 + 模板 + 话风组合生成
+    unit = ROLE_UNITS[role]
+    style = unit.get("话风", {})
+    fill = {
+        "role": role, "identity": unit["身份"], "place": unit["住处"],
+        "food": unit["食物"], "feature": unit["特征"],
+        "personality": unit["性格"], "weather": unit["天气"],
+        "mood": unit["心情"], "likes": unit["喜好"],
+        "风格_身份": style.get("身份", ""), "风格_住处": style.get("住处", ""),
+        "风格_食物": style.get("食物", ""), "风格_特征": style.get("特征", ""),
+        "风格_天气": style.get("天气", ""),
+    }
+    tpl = ROLE_TEMPLATES[direction]
+    answer = tpl.format(**fill)
+    # ④ 角色一致性自校验
+    ok, checks = role_self_check(role, question, answer)
+    return {"question": question, "role": role, "direction": direction,
+            "ok": ok, "answer": answer, "checks": checks, "route": "compose"}
+
+
+# ============ 五、角色语录固化（生成→自校验→固化→直答） ============
+_SOL_FILE = os.path.join(os.path.dirname(os.path.abspath(__file__)),
+                         "role_solidified.json")
+ROLE_SOLIDIFIED = {}
+if os.path.exists(_SOL_FILE):
+    try:
+        _ld = json.load(open(_SOL_FILE, encoding="utf-8"))
+        if isinstance(_ld, dict):
+            ROLE_SOLIDIFIED = _ld
+    except Exception:
+        ROLE_SOLIDIFIED = {}
+
+
+def role_solidify(question, role="鲸鱼娘"):
+    """固化角色化回答：组合生成 + 自校验通过 → 固化（持久化）"""
+    r = role_compose(question, role)
+    if not r.get("ok") or not r.get("answer"):
+        return None
+    key = f"{role}|{question.strip('？?。！! ')}"
+    entry = {"role": role, "answer": r["answer"],
+             "direction": r.get("direction"), "source": "role_solidified"}
+    ROLE_SOLIDIFIED[key] = entry
+    try:
+        json.dump(ROLE_SOLIDIFIED, open(_SOL_FILE, "w", encoding="utf-8"),
+                  ensure_ascii=False, indent=1)
+    except Exception:
+        pass
+    return entry
+
+
+def role_lookup(question, role="鲸鱼娘"):
+    """固化层查询：同问法命中 → 固化直答"""
+    key = f"{role}|{question.strip('？?。！! ')}"
+    entry = ROLE_SOLIDIFIED.get(key)
+    if entry:
+        return entry["answer"]
+    return None
+
+
+def role_route(question, role="鲸鱼娘"):
+    """角色条件路由统一入口：固化层 → OOC → 组合生成 → 未覆盖"""
+    sol = role_lookup(question, role)
+    if sol:
+        return {"question": question, "role": role, "ok": True,
+                "solidified": True, "answer": sol, "checks": [], "route": "solidified"}
+    return role_compose(question, role)
+
+
+if __name__ == "__main__":
+    print("=== 白箱自举·角色扮演主线（鲸鱼娘 · 零 LLM） ===\n")
+    QS = [
+        "你是谁？", "你住在哪里？", "你吃什么？", "你有尾巴吗？",
+        "今天天气不错", "你今天心情好吗", "你喜欢什么？",
+        # OOC 检测（角色设定矛盾）
+        "你是人类吗？", "你是机器人吗？",
+        # 未覆盖（应落回通用域）
+        "什么是碳中和？",
+    ]
+    results = []
+    for q in QS:
+        r = role_route(q, "鲸鱼娘")
+        results.append(r)
+        if r.get("ok"):
+            mark = "✔"
+            route = r.get("route", "")
+            print(f"[{mark}] ({route}) {q}")
+            print(f"   -> {r['answer'][:90]}")
+            for c in r.get("checks", []):
+                print(f"      {c}")
+        else:
+            print(f"[✘] ({r.get('route')}) {q} -> {r.get('reason')}")
+    # 固化演示
+    print("\n=== 固化演示 ===")
+    e = role_solidify("你今天心情好吗", "鲸鱼娘")
+    r2 = role_route("你今天心情好吗", "鲸鱼娘")
+    print(f"固化: {'✔' if e else '✘'} | 再问路由: {r2.get('route')} "
+          f"-> {r2['answer'][:50]}")
+
+    # 统计
+    hit = sum(1 for r in results if r.get("ok"))
+    role_covered = [r for r in results if r.get("route") in ("compose", "ooc", "solidified")]
+    print(f"\n=== 判定 ===\n角色场景白箱命中: {hit}/{len(QS)}"
+          f"（含 OOC 检测）| 组合生成覆盖: {len(role_covered)}")

package/md_cg/whitebox_kb/wisdom/role_solidified.json

@@ -0,0 +1,8 @@
+{
+ "鲸鱼娘|你今天心情好吗": {
+  "role": "鲸鱼娘",
+  "answer": "我呀，心情跟着海浪走——浪高兴奋，浪低安静；见到你心情就像海豚一样欢快起来了。",
+  "direction": "心情",
+  "source": "role_solidified"
+ }
+}

package/md_cg/whitebox_kb/wisdom/route_memory.py

@@ -0,0 +1,244 @@
+# -*- coding: utf-8 -*-
+"""route_memory · 第三层路由：对话集经验复用（记忆驱动 = 技能形成）
+================================================================================
+荣终裁（2026-08-20）：第三个路由方法是对话集——过去有人问过类似问题，
+寻路方式是怎样。这是形成长期记忆/技能。加入后 = 与灵枢长期记忆联动，
+白箱彻底绑定灵枢。
+
+设计（慎重考虑 · 防固化错误路径）：
+  记录：每次查询 → 路径链（top 卡）→ 验证结果 → 入经验库
+  召回：相似问题 → 已验证路径 → 优先导航（三重验证门控）
+  技能：高频成功路径 → 提升为技能卡（协议 P1-3）
+
+三重验证门控（缺一不可）：
+  ① 路径已验证：该链曾产生正确答案（验证单元确认）
+  ② 未过时：链上节点仍存在（图谱未大改）
+  ③ 条件空间一致：问题 Q 与历史 Q' 条件空间声明一致（相似度阈值）
+
+存储：本地 JSON（经验库）+ 可选灵枢记忆联动（白箱绑定灵枢）。
+
+用法：:
+    from route_memory import RouteMemory
+    rm = RouteMemory()
+    rm.record(q, top_cards, verified=True)     # 记录寻路路径
+    hit = rm.recall(q, threshold=0.8)          # 相似问题 → 历史路径
+    skills = rm.top_skills()                    # 高频成功路径 = 技能
+"""
+import json
+import os
+import time
+
+HERE = os.path.dirname(os.path.abspath(__file__))
+DEFAULT_PATH = os.path.join(HERE, "route_memory.json")
+
+
+class RouteMemory:
+    """对话集经验路由：历史寻路路径记录 + 召回 + 验证门控。"""
+
+    def __init__(self, path: str = DEFAULT_PATH, max_entries: int = 5000):
+        """路由记忆初始化：持久文件存在则恢复既有条目。"""
+        self.path = path
+        self.max_entries = max_entries
+        self._entries = []      # [{q, q_fp, chain, verified, count, ts}]
+        self._load()
+
+    # ---------------- 存储 ----------------
+
+    def _load(self) -> None:
+        """从 JSON 文件读回历史路由记忆（缺失视为空白）。"""
+        try:
+            if os.path.exists(self.path):
+                with open(self.path, encoding="utf-8") as f:
+                    self._entries = json.load(f)
+        except Exception:
+            self._entries = []
+
+    def _save(self) -> None:
+        """路由记忆写回 JSON 文件（原子覆盖）。"""
+        try:
+            os.makedirs(os.path.dirname(self.path), exist_ok=True) \
+                if os.path.dirname(self.path) else None
+            with open(self.path, "w", encoding="utf-8") as f:
+                json.dump(self._entries[-self.max_entries:], f,
+                          ensure_ascii=False, indent=1)
+        except Exception:
+            pass
+
+    # ---------------- 记录（寻路路径入经验库） ----------------
+
+    def record(self, question: str, chain: list, verified: bool = True,
+               focus: str = "") -> dict:
+        """记录一次查询的寻路路径。
+
+        question: 原始问题
+        chain: 路径链（top 卡名列表，如 ["初中数学", "三角形"]）
+        verified: 该路径是否验证过（答案正确=验证单元确认）
+        focus: 问题焦点（可空，用于相似度辅助）
+        """
+        # 去重：同问题已记录 → 更新计数/验证状态
+        for e in self._entries:
+            if e.get("q") == question:
+                e["count"] = e.get("count", 0) + 1
+                e["verified"] = e["verified"] and verified
+                e["ts"] = time.time()
+                if focus:
+                    e["focus"] = focus
+                self._save()
+                return {"status": "updated", "count": e["count"]}
+        self._entries.append({
+            "q": question, "chain": chain, "verified": bool(verified),
+            "count": 1, "ts": time.time(), "focus": focus or "",
+        })
+        # 语义向量（荣：在可能的语义中匹配——路由依据是语义不是切片）
+        try:
+            from neural_retrieve import NeuralRetriever
+            nr = NeuralRetriever()
+            qv = nr.embed(question)
+            if qv is not None:
+                self._entries[-1]["qvec"] = [
+                    round(float(x), 6) for x in qv.tolist()]
+        except Exception:
+            pass
+        # 条件空间绑定（v1.20 · 荣：技能附带条件，不会在不适合的条件下
+        # 出现——防题库过拟合。记录问题所属学科域，召回时校验一致：
+        # 「什么是函数？」（数学）和「什么是函数呀」（编程）语义相似
+        # 但条件空间不同，经验不可互用）
+        try:
+            from semantic_translate import classify_condition_space
+            _cs = classify_condition_space(question)
+            if _cs.get("nav"):
+                self._entries[-1]["cond_space"] = _cs["domain"]
+        except Exception:
+            pass
+        self._save()
+        return {"status": "recorded", "count": 1}
+
+    # ---------------- 召回（相似问题 → 历史路径） ----------------
+
+    @staticmethod
+    def _key_terms(text: str) -> set:
+        """提取问题关键词集合（降级路由用，bge 不可用时兜底）：
+        仅 3-4 字实义词（「勾股定理/圆的周长」），去疑问词/虚词。
+        不用 2 字全窗口——碎片词稀释 Jaccard 相似度（荣：不随意切片，
+        语义匹配为主，此处仅作 bge 不可用时的保守降级）。
+        """
+        try:
+            import re as _re
+            chars = [c for c in text if "\u4e00" <= c <= "\u9fff"]
+            terms = set()
+            for L in (4, 3):
+                for i in range(len(chars) - L + 1):
+                    w = "".join(chars[i:i + L])
+                    if any(s in w for s in ("是什么", "怎么", "多少", "为什么",
+                                            "公式", "内容", "定义", "关系",
+                                            "分别是", "之间的", "多少个")):
+                        continue
+                    terms.add(w)
+            return terms
+        except Exception:
+            return set()
+
+    def recall(self, question: str, threshold: float = 0.55,
+               max_results: int = 3) -> list:
+        """语义召回相似问题的历史路径（第三层路由核心）。
+
+        荣：不随意对句子切片，而在可能的语义中匹配——用 bge 语义向量
+        余弦（「勾股定理的内容是什么？」vs「什么是勾股定理？」语义相同、
+        字面不同 → 语义余弦正确匹配，切片 Jaccard 会漏）。
+        优先级：已验证路径 > 相似度 > 使用次数。
+        返回 [{q, chain, verified, count, similarity}]
+        """
+        if not question or not self._entries:
+            return []
+        # 当前问题条件空间（校验用——技能附带条件，不在不适合的条件下出现）
+        _cur_cond = None
+        try:
+            from semantic_translate import classify_condition_space
+            _cs = classify_condition_space(question)
+            if _cs.get("nav"):
+                _cur_cond = _cs["domain"]
+        except Exception:
+            _cur_cond = None
+        # 语义匹配（主路径）
+        try:
+            import numpy as np
+            from neural_retrieve import NeuralRetriever
+            nr = NeuralRetriever()
+            qv = nr.embed(question)
+            if qv is not None:
+                qn = qv / max(float(np.linalg.norm(qv)), 1e-9)
+                scored = []
+                for e in self._entries:
+                    ev = e.get("qvec")
+                    if not ev:
+                        continue
+                    # 条件空间一致性（v1.20 防过拟合）：历史问题的条件空间
+                    # 与当前不一致 → 不召回（「什么是函数？」数学 vs
+                    # 「什么是函数呀」编程——语义相似但经验不可互用）
+                    hist_cond = e.get("cond_space")
+                    if hist_cond and _cur_cond and hist_cond != _cur_cond:
+                        continue
+                    evn = np.asarray(ev, dtype=np.float32)
+                    norm = float(np.linalg.norm(evn))
+                    if norm < 1e-9:
+                        continue
+                    sim = float(np.dot(qn, evn / norm))
+                    if sim >= threshold:
+                        scored.append({"q": e.get("q"),
+                                       "chain": e.get("chain", []),
+                                       "verified": e.get("verified", False),
+                                       "count": e.get("count", 1),
+                                       "cond_space": hist_cond,
+                                       "similarity": round(sim, 3)})
+                scored.sort(key=lambda x: (-x["verified"], -x["similarity"],
+                                           -x["count"]))
+                return scored[:max_results]
+        except Exception:
+            pass
+        # 降级：bge 不可用 → 关键词 Jaccard（保守）
+        try:
+            tq = self._key_terms(question)
+            if not tq:
+                return []
+            scored = []
+            for e in self._entries:
+                te = self._key_terms(e.get("q", ""))
+                inter = tq & te
+                if not inter:
+                    continue
+                sim = len(inter) / max(1, min(len(tq), len(te)))
+                if sim >= threshold:
+                    scored.append({"q": e.get("q"), "chain": e.get("chain", []),
+                                   "verified": e.get("verified", False),
+                                   "count": e.get("count", 1),
+                                   "similarity": round(sim, 3)})
+            scored.sort(key=lambda x: (-x["verified"], -x["similarity"],
+                                       -x["count"]))
+            return scored[:max_results]
+        except Exception:
+            return []
+
+    # ---------------- 技能形成（高频成功路径） ----------------
+
+    def top_skills(self, min_count: int = 3, top: int = 10) -> list:
+        """高频已验证路径 = 技能卡（协议 P1-3 技能获取）。
+
+        条件：verified + count ≥ min_count（重复成功 = 可靠经验）。
+        """
+        skills = [e for e in self._entries
+                  if e.get("verified") and e.get("count", 0) >= min_count]
+        skills.sort(key=lambda x: -x.get("count", 0))
+        return skills[:top]
+
+    # ---------------- 状态 ----------------
+
+    def info(self) -> dict:
+        """路由记忆概况：总条数/已验证数/持久化路径。"""
+        verified = sum(1 for e in self._entries if e.get("verified"))
+        return {"entries": len(self._entries), "verified": verified,
+                "path": self.path}
+
+    def clear(self) -> None:
+        """清空全部路由记忆并立即保存。"""
+        self._entries = []
+        self._save()

package/md_cg/whitebox_kb/wisdom/scene_reconstruction.py

@@ -0,0 +1,148 @@
+# -*- coding: utf-8 -*-
+"""灵枢 · 情景重构（H4 · 海马体情景记忆功能）
+
+学海马体的情景记忆：从部分线索重建完整事件场景。
+设计者定义：「情景重构 = 条件空间下的信息复原——回忆起某种情景实际上是
+基于某种条件进行分析恢复，并不代表真实发生的过去就是如此。」
+
+机制：
+  1. 线索检索：片段/关键词 → 召回相关记忆节点
+  2. 场景合成：沿 similar/causal 边遍历关联节点，用各节点条件空间
+    （观测位置/时间窗/存在约束）拼出「重建场景」
+  3. 诚实边界：输出显式标注「基于条件重构，非真实回放」（0.0.3 局部不可知
+    ——重构受当前条件空间约束，可能与真实过去不同）
+
+用法：
+  python scene_reconstruction.py --query "验证"      # 重构相关情景
+"""
+import json
+import os
+import sys
+import time
+from typing import Dict, List
+
+
+def _cs_dict(node):
+    """条件空间→字典（与 pattern_separation 同一口径）。"""
+    try:
+        return json.loads(node.condition_space.to_json()) if node.condition_space else {}
+    except Exception:
+        return {}
+
+
+class SceneReconstruction:
+    """情景重构器：线索 → 重建场景（条件空间驱动 · 诚实标注）"""
+
+    def __init__(self, engine):
+        """情景重构器初始化（H4：重构非回放显式标注）。"""
+        self.engine = engine
+        self.store = engine.store
+
+    def reconstruct(self, clue: str, depth: int = 2, max_nodes: int = 8) -> Dict:
+        """从线索重建场景。返回 {scene, elements, conditions, reconstructed_note}"""
+        try:
+            from aeis_core import LayeredStore
+        except Exception:
+            return {"scene": [], "error": "no LayeredStore"}
+
+        # 1. 线索检索：召回最相关节点
+        seeds = self.store.search_content(clue, limit=4) or []
+        if not seeds:
+            return {"scene": [], "clue": clue,
+                    "note": "无相关记忆——线索未命中任何节点（0.0.3 局部不可知）"}
+
+        # 2. 图遍历：沿 similar/causal 边展开关联节点（条件空间驱动）
+        visited = set()
+        elements = []
+        queue = [(n, 0, s) for n, s in seeds]
+
+        while queue and len(elements) < max_nodes:
+            node, d, sim = queue.pop(0)
+            if node.id in visited:
+                continue
+            visited.add(node.id)
+            cs = _cs_dict(node)
+            elements.append({
+                "node_id": node.id,
+                "content": node.content[:60],
+                "importance": round(node.importance, 2),
+                "similarity": round(sim, 2),
+                "depth": d,
+                # 条件空间要素（重构的关键：每个记忆在什么条件下成立）
+                "conditions": {
+                    "observation_position": cs.get("observation_position", "")[:40],
+                    "time_window": cs.get("time_window"),
+                    "existence_constraint": cs.get("existence_constraint", "")[:60],
+                },
+                "tags": (node.tags or [])[:5],
+            })
+            if d < depth:
+                try:
+                    for e in self.store.get_outgoing_edges(node.id):
+                        if e.relation_type.value in ("similar", "causal"):
+                            tgt = self.store.get_node(e.target_id)
+                            if tgt and tgt.id not in visited:
+                                queue.append((tgt, d + 1, sim * 0.6))
+                except Exception:
+                    pass
+
+        # 3. 场景合成：按深度排序，输出重建场景
+        elements.sort(key=lambda x: x["depth"])
+        scene = []
+        for el in elements:
+            cond = el["conditions"]["existence_constraint"]
+            scene.append({
+                "内容": el["content"],
+                "条件": cond or "（条件未声明）",
+                "观测位": el["conditions"]["observation_position"] or "（默认）",
+                "置信": el["importance"],
+            })
+
+        return {
+            "clue": clue,
+            "scene": scene,
+            "elements": len(elements),
+            "conditions": self._scene_conditions(elements),
+            # 诚实边界：重构 ≠ 回放（0.0.3 + 设计者定义）
+            "reconstructed_note": ("基于条件空间的重构，非真实回放——"
+                                   "回忆起的情景是当前条件下对记忆的分析恢复，"
+                                   "不代表真实发生的过去就是如此（0.0.3 局部不可知）"),
+        }
+
+    def _scene_conditions(self, elements) -> Dict:
+        """场景条件空间合成：各要素条件的并集（重构的约束框架）。"""
+        positions = {}
+        constraints = []
+        time_windows = []
+        for el in elements:
+            p = el["conditions"]["observation_position"]
+            if p:
+                positions[p] = positions.get(p, 0) + 1
+            c = el["conditions"]["existence_constraint"]
+            if c and c not in constraints:
+                constraints.append(c[:40])
+            tw = el["conditions"]["time_window"]
+            if tw and tw not in time_windows:
+                time_windows.append(tw)
+        return {
+            "观测位置分布": positions,
+            "存在约束集": constraints[:3],
+            "时间窗数": len(time_windows),
+        }
+
+
+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")
+    sr = SceneReconstruction(engine)
+    q = " ".join(sys.argv[1:]) or "验证"
+    r = sr.reconstruct(q)
+    print(json.dumps(r, ensure_ascii=False, indent=1))
+    engine.close()
+
+
+if __name__ == "__main__":
+    main()