@furongjun1999/dsh-memory 0.4.11 → 0.5.1

package/md_cg/whitebox_kb/wisdom/scene_reconstruction.py

@@ -1,148 +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()
+# -*- 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()

package/md_cg/whitebox_kb/wisdom/snr_report.json

@@ -1,41 +1,41 @@
-{
-  "generated_at": "2026-09-05 23:17:21",
-  "source": "snr_dashboard v1.16（C 维进化·递归反思 3.12 终裁）",
-  "compression_ratio": 3988.8,
-  "inject_quality": null,
-  "graph_snr": 0.0,
-  "memory_purge": null,
-  "signals": {
-    "compression": {
-      "raw_bytes": 7100000000.0,
-      "pure_bytes": 1780000.0,
-      "ratio": 3988.8
-    },
-    "inject": {
-      "available": false,
-      "note": "无对话测试结果（dialogue_1000_results.json）"
-    },
-    "graph": {
-      "available": true,
-      "verified_edges": 0,
-      "rejected_open": 10,
-      "graph_snr": 0.0
-    },
-    "memory": {
-      "available": true,
-      "context_total": 0,
-      "archived": 0,
-      "memory_purge": null
-    }
-  },
-  "trend": {
-    "compression_ratio": {
-      "prev": 3988.8,
-      "current": 3988.8,
-      "delta": 0.0
-    }
-  },
-  "bottleneck": [
-    "图谱信噪比 0.0% < 90%：存在 open 被拒路径，建议走 causal_discover 验证闭环修复"
-  ]
+{
+  "generated_at": "2026-09-05 23:17:21",
+  "source": "snr_dashboard v1.16（C 维进化·递归反思 3.12 终裁）",
+  "compression_ratio": 3988.8,
+  "inject_quality": null,
+  "graph_snr": 0.0,
+  "memory_purge": null,
+  "signals": {
+    "compression": {
+      "raw_bytes": 7100000000.0,
+      "pure_bytes": 1780000.0,
+      "ratio": 3988.8
+    },
+    "inject": {
+      "available": false,
+      "note": "无对话测试结果（dialogue_1000_results.json）"
+    },
+    "graph": {
+      "available": true,
+      "verified_edges": 0,
+      "rejected_open": 10,
+      "graph_snr": 0.0
+    },
+    "memory": {
+      "available": true,
+      "context_total": 0,
+      "archived": 0,
+      "memory_purge": null
+    }
+  },
+  "trend": {
+    "compression_ratio": {
+      "prev": 3988.8,
+      "current": 3988.8,
+      "delta": 0.0
+    }
+  },
+  "bottleneck": [
+    "图谱信噪比 0.0% < 90%：存在 open 被拒路径，建议走 causal_discover 验证闭环修复"
+  ]
 }