@furongjun1999/dsh-memory 0.4.4 → 0.4.6

package/md_cg/whitebox_kb/wisdom/snr_dashboard.py

@@ -0,0 +1,219 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+"""
+snr_dashboard · 信噪比仪表盘（v1.16 · C 维进化 8.0→9.0）
+========================================================
+递归反思协议 3.12 终裁产物。反思链：
+  depth1：八机制（信息分层/白箱校验/重要性加权/翻译体系/诚实边界/主动遗忘/因果验证/自生长）
+          覆盖八类噪声抑制 → 缺全局监控指标 → 可建仪表盘
+  depth2：「self 路由 ≠ 注入信噪比」——须看「self 且答对」（route+质量结合，
+          呼应 1000 条测试别名率 58% 分析：self 也可能答非所问）
+  depth3：structural_blindspot 警示——递归到上限仍在细化指标口径 = 设计噪音本身。
+          终裁：收敛为最小实现，聚合现成信号，零新增采集。
+
+四类信噪比信号（全部现成数据，无新采集）：
+  ① 压缩信噪比（知识层） compression_ratio = 纯知识体积 / 原始源体积
+     已知里程碑：zhwiki 7.1GB → 纯知识 1.78MB ≈ 4000:1（极致信噪比压缩）
+  ② 注入质量率（对话层） inject_quality = (route==self 且 score>=0.5) / (route==self)
+     depth2 修正：不看 route 分布，看「self 且答对」——self 路由也可能答非所问，
+     须结合质量闸门（1000 条测试逐条评分 score）
+  ③ 图谱信噪比（知识层） graph_snr = verified 边 / (verified 边 + open 被拒路径)
+     verified=物理基底/验证单元复核过的边；open 被拒路径=系统失败输入（噪声候选）
+  ④ 记忆清理率（记忆层） memory_purge = archived 节点 / CONTEXT 节点总数
+     主动遗忘（forget_advisor）清理的噪声记忆占比——可逆归档
+
+输出：snr_report.json（指标 + 趋势 + 瓶颈建议）
+运行：lifecycle 维护周期（MAINT_INTERVAL）自动执行；亦可独立命令行运行
+消费：自我认知循环（self_cognition）——五维标尺 C 维的客观输入
+纯标准库 · 零外部依赖（与 lifecycle/causal_discover 一致）
+"""
+
+import json
+import os
+import time
+from typing import Dict, List, Optional
+
+
+class SnrDashboard:
+    """信噪比仪表盘：聚合四类信号 → JSON 报告（含趋势与瓶颈建议）"""
+
+    # 知识压缩里程碑（measured 2026-08：zhwiki dump → 智慧之书纯知识库）
+    DEFAULT_RAW_BYTES = 7.1e9        # 原始源：zhwiki 约 7.1GB
+    DEFAULT_PURE_BYTES = 1.78e6      # 纯知识：约 1.78MB
+    REPORT_NAME = "snr_report.json"
+
+    def __init__(self, engine=None, dialogue_results: Optional[str] = None,
+                 raw_bytes: float = DEFAULT_RAW_BYTES,
+                 pure_bytes: float = DEFAULT_PURE_BYTES,
+                 report_dir: Optional[str] = None):
+        """信噪比面板初始化：原始字节与纯知识字节统计挂入。"""
+        self.engine = engine
+        if dialogue_results is None:
+            # 自动探测：同目录（knowledge-base 工作区）下的 1000 条测试结果
+            cand = os.path.join(os.path.dirname(os.path.abspath(__file__)),
+                                "dialogue_1000_results.json")
+            dialogue_results = cand if os.path.exists(cand) else None
+        self.dialogue_results = dialogue_results
+        self.raw_bytes = raw_bytes
+        self.pure_bytes = pure_bytes
+        self.report_dir = report_dir or os.path.dirname(os.path.abspath(__file__))
+
+    # ---------- ① 压缩信噪比 ----------
+    def compression_snr(self) -> Dict:
+        """压缩信噪比口径：raw_bytes/pure_bytes 比值报告。"""
+        ratio = (self.raw_bytes / self.pure_bytes) if self.pure_bytes > 0 else 0.0
+        return {"raw_bytes": self.raw_bytes, "pure_bytes": self.pure_bytes,
+                "ratio": round(ratio, 1)}
+
+    # ---------- ② 注入质量率（depth2 修正：self 且答对） ----------
+    def inject_quality(self) -> Dict:
+        path = self.dialogue_results
+        if not path or not os.path.exists(path):
+            return {"available": False, "note": "无对话测试结果（dialogue_1000_results.json）"}
+        try:
+            with open(path, "r", encoding="utf-8") as f:
+                items = json.load(f)
+        except Exception as e:
+            return {"available": False, "note": f"读取失败: {e}"}
+        total = len(items)
+        self_cnt = 0
+        self_ok = 0      # self 且答对（score>=0.5：客观 keys 命中 或 主观正确）
+        self_full = 0    # self 且完全答对（score>=1.0）
+        route_cnt: Dict[str, int] = {}
+        for it in items:
+            r = it.get("route", "?")
+            route_cnt[r] = route_cnt.get(r, 0) + 1
+            if r == "self":
+                self_cnt += 1
+                s = it.get("score", 0.0)
+                if s >= 0.5:
+                    self_ok += 1
+                if s >= 1.0:
+                    self_full += 1
+        return {"available": True, "total": total, "route_dist": route_cnt,
+                "self_count": self_cnt,
+                "self_ok_count": self_ok,
+                "inject_quality": round(self_ok / self_cnt, 4) if self_cnt else None,
+                "self_full_rate": round(self_full / self_cnt, 4) if self_cnt else None,
+                "note": "注入质量率 = self 且答对(score>=0.5) / self 总数（route+质量结合）"}
+
+    # ---------- ③ 图谱信噪比 ----------
+    def graph_snr(self) -> Dict:
+        if self.engine is None:
+            return {"available": False, "note": "无 engine"}
+        verified = 0
+        rejected_open = 0
+        try:
+            stats = self.engine.store.get_stats()
+            verified = stats.get("verified_edges", 0)
+        except Exception:
+            pass
+        try:
+            paths = self.engine.list_rejected_paths(status="open") or []
+            rejected_open = len(paths)
+        except Exception:
+            pass
+        denom = verified + rejected_open
+        return {"available": True, "verified_edges": verified, "rejected_open": rejected_open,
+                "graph_snr": round(verified / denom, 4) if denom else None}
+
+    # ---------- ④ 记忆清理率 ----------
+    def memory_purge(self) -> Dict:
+        if self.engine is None:
+            return {"available": False, "note": "无 engine"}
+        try:
+            conn = self.engine.store.conn
+            c = conn.cursor()
+            c.execute("SELECT COUNT(*) FROM nodes WHERE layer='context'")
+            context_total = c.fetchone()[0]
+            c.execute("SELECT COUNT(*) FROM nodes WHERE layer='context' AND tags LIKE '%archived%'")
+            archived = c.fetchone()[0]
+        except Exception as e:
+            return {"available": False, "note": f"查询失败: {e}"}
+        return {"available": True, "context_total": context_total, "archived": archived,
+                "memory_purge": round(archived / context_total, 4) if context_total else None}
+
+    # ---------- 趋势（对比上次报告） ----------
+    def _trend(self, cur: Dict) -> Dict:
+        """趋势对比：读上一份信噪报告作基线，无基线时返回首跑标注。"""
+        prev_path = os.path.join(self.report_dir, self.REPORT_NAME)
+        if not os.path.exists(prev_path):
+            return {"note": "首次运行，无基线"}
+        try:
+            with open(prev_path, "r", encoding="utf-8") as f:
+                prev = json.load(f)
+        except Exception:
+            return {"note": "基线读取失败"}
+        trend = {}
+        for key in ("inject_quality", "graph_snr", "memory_purge", "compression_ratio"):
+            pk = prev.get(key)
+            ck = cur.get(key)
+            if pk is not None and ck is not None:
+                trend[key] = {"prev": pk, "current": ck, "delta": round(ck - pk, 4)}
+        return trend
+
+    # ---------- 瓶颈建议（规则式） ----------
+    @staticmethod
+    def _bottleneck(cur: Dict) -> List[str]:
+        """瓶颈建议：按注入质量率、图谱信噪比等指标阈值生成改进建议清单。"""
+        advice = []
+        iq = cur.get("inject_quality")
+        if iq is not None and iq < 0.7:
+            advice.append(f"注入质量率 {iq:.1%} < 70%：自处理答非所问偏高，"
+                          "建议用低分条目补卡/修正卡内容（含条件标注）")
+        gs = cur.get("graph_snr")
+        if gs is not None and gs < 0.9:
+            advice.append(f"图谱信噪比 {gs:.1%} < 90%：存在 open 被拒路径，"
+                          "建议走 causal_discover 验证闭环修复")
+        mp = cur.get("memory_purge")
+        if mp is not None and mp > 0.4:
+            advice.append(f"记忆清理率 {mp:.1%} > 40%：噪声记忆占比过高，"
+                          "建议 consolidate 归档节点或收紧 forget_advisor 阈值")
+        if not advice:
+            advice.append("各维度信噪比良好，维持现有八机制")
+        return advice
+
+    # ---------- 主入口 ----------
+    def run(self, persist: bool = True) -> Dict:
+        report = {
+            "generated_at": time.strftime("%Y-%m-%d %H:%M:%S"),
+            "source": "snr_dashboard v1.16（C 维进化·递归反思 3.12 终裁）",
+            "compression_ratio": self.compression_snr()["ratio"],
+            "inject_quality": None,
+            "graph_snr": None,
+            "memory_purge": None,
+            "signals": {
+                "compression": self.compression_snr(),
+                "inject": self.inject_quality(),
+                "graph": self.graph_snr(),
+                "memory": self.memory_purge(),
+            },
+        }
+        inj = report["signals"]["inject"]
+        if inj.get("available"):
+            report["inject_quality"] = inj.get("inject_quality")
+        g = report["signals"]["graph"]
+        if g.get("available"):
+            report["graph_snr"] = g.get("graph_snr")
+        m = report["signals"]["memory"]
+        if m.get("available"):
+            report["memory_purge"] = m.get("memory_purge")
+        report["trend"] = self._trend(report)
+        report["bottleneck"] = self._bottleneck(report)
+        if persist:
+            path = os.path.join(self.report_dir, self.REPORT_NAME)
+            try:
+                with open(path, "w", encoding="utf-8") as f:
+                    json.dump(report, f, ensure_ascii=False, indent=2)
+                report["report_path"] = path
+            except Exception as e:
+                report["report_path"] = f"写入失败: {e}"
+        return report
+
+
+if __name__ == "__main__":
+    import sys
+    dlg = sys.argv[1] if len(sys.argv) > 1 else None
+    dash = SnrDashboard(dialogue_results=dlg)
+    out = dash.run(persist=True)
+    print(json.dumps(out, ensure_ascii=False, indent=2))

package/md_cg/whitebox_kb/wisdom/snr_report.json

@@ -0,0 +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 验证闭环修复"
+  ]
+}

package/md_cg/whitebox_kb/wisdom/spatial_closure.py

@@ -0,0 +1,96 @@
+# -*- coding: utf-8 -*-
+"""spatial_closure.py · 3D 时空视觉闭环 ④闭环编排 + 一致性自校验
+感知点云 → 场景图（感知几何）→ 3D 渲染（语义几何）→ 对照自校验：
+  中心对齐（投影中心）/ 深度关系（近远序）/ 尺寸一致（投影面积）
+综合一致性分数 ≥0.8 → 闭环成立（零 LLM 确定性度量）。
+"""
+import sys
+import numpy as np
+sys.stdout.reconfigure(encoding='utf-8')
+try:
+    from scene_graph import build_scene_graph
+    from world3d_render import World3DCamera, render_scene
+except ImportError:
+    from .scene_graph import build_scene_graph
+    from .world3d_render import World3DCamera, render_scene
+
+
+def spatial_closure(pts, motion=None, camera=None, W=128, H=128):
+    """闭环：感知 → 语义 → 渲染 → 自校验"""
+    # ① 感知 → 场景图（感知几何）
+    scene = build_scene_graph(pts, motion)
+    # ③ 语义 → 3D 渲染（语义几何）
+    cam = camera or World3DCamera()
+    render = render_scene(scene, W=W, H=H, camera=cam)
+    # ④ 对照自校验
+    checks = {}
+    objs = render["objects"]
+    if len(objs) < 2:
+        return {"ok": False, "reason": "物体不足（<2）无法对照", "scene": scene,
+                "render": render, "consistency": 0.0, "checks": checks}
+    # 4.1 中心对齐：物体世界质心 → 相机投影中心 vs 渲染 bbox 中心
+    centers = []
+    for o in scene["objects"]:
+        uv, z, vis = cam.project([o["cx"], o["cy"], o["cz"]], W, H)
+        centers.append((uv[0][0], uv[0][1]))
+    center_errs = []
+    for i, o in enumerate(objs):
+        u_rend = (o["bbox"][0] + o["bbox"][2]) / 2.0
+        v_rend = (o["bbox"][1] + o["bbox"][3]) / 2.0
+        err = np.hypot(centers[i][0] - u_rend, centers[i][1] - v_rend) / np.hypot(W, H)
+        center_errs.append(err)
+    center_align = 1.0 - min(1.0, float(np.mean(center_errs)))
+    checks["中心对齐"] = round(center_align, 3)
+
+    # 4.2 深度关系：感知物体 z 序 vs 渲染深度序一致率
+    scene_order = [o["cz"] for o in scene["objects"]]
+    render_order = [o["z"] for o in objs]
+    agree = sum(1 for a, b in zip(scene_order[:-1], scene_order[1:])
+                for c, d in zip(render_order[:-1], render_order[1:])
+                if (a <= b) == (c <= d))
+    total = max(1, (len(scene_order) - 1) * (len(render_order) - 1))
+    depth_rel = agree / total
+    checks["深度关系"] = round(depth_rel, 3)
+
+    # 4.3 尺寸一致：近物体投影面积应 > 远物体（相对差一致性）
+    sizes = [(o["world_cz"], o["area"]) for o in objs]
+    size_agree = sum(1 for i in range(len(sizes)) for j in range(len(sizes))
+                     if i < j and (sizes[i][0] < sizes[j][0]) == (sizes[i][1] > sizes[j][1]))
+    size_total = max(1, len(sizes) * (len(sizes) - 1) // 2)
+    size_cons = size_agree / size_total
+    checks["尺寸一致"] = round(size_cons, 3)
+
+    consistency = round(0.4 * center_align + 0.3 * depth_rel + 0.3 * size_cons, 3)
+    ok = consistency >= 0.8
+    return {"ok": ok, "scene": scene, "render": render,
+            "consistency": consistency, "checks": checks}
+
+
+def closure_report(pts, motion=None, camera=None):
+    """人类可读闭环报告"""
+    r = spatial_closure(pts, motion, camera)
+    print(f"① 感知点云: {len(pts)} 点 → 场景图 {r['scene']['count']} 物体")
+    for o in r["scene"]["objects"]:
+        m = o.get("motion", {})
+        print(f"   [{o['id']}] {o['category']} (cx={o['cx']},cy={o['cy']},z={o['cz']}) "
+              f"size={o['size']} 运动={m.get('direction', '-')}")
+    print(f"② 3D 渲染: {len(r['render']['objects'])} 物体投影（近大远小）")
+    for p in r["render"]["objects"]:
+        print(f"   [{p['id']}] {p['category']} 投影面积={p['area']} 深度={p['z']}")
+    print("③ 闭环自校验:")
+    for k, v in r["checks"].items():
+        print(f"   {k}: {v}")
+    mark = "✔ 闭环成立" if r.get("ok") else "✘"
+    print(f"\n=== 判定 ===\n一致性 = {r.get('consistency')} → {mark}（感知↔语义双向闭环，零 LLM）")
+    return r
+
+
+if __name__ == "__main__":
+    print("=== 3D 时空视觉闭环：感知↔语义双向 + 自校验（零 LLM）===\n")
+    from vision_3d import (synth_stereo_pair, stereo_disparity,
+                           depth_from_disparity, pointcloud_from_depth)
+
+    left, right = synth_stereo_pair()
+    pts = pointcloud_from_depth(depth_from_disparity(stereo_disparity(left, right)), block=8)
+    r = closure_report(pts, motion={"direction": "静止", "speed": 0, "is_static": True})
+    sys.exit(0 if r.get("ok") else 1)

package/md_cg/whitebox_kb/wisdom/spatial_qa.py

@@ -0,0 +1,182 @@
+# -*- coding: utf-8 -*-
+"""spatial_qa.py · 3D 时空问答（第五阶段·3D 轨迹接入感知记忆）
+多帧双目 → 3D 轨迹 → 灵枢记忆（[3D时空事件] spatial3d 标签）→ 3D 时空问答：
+  「球往哪飞了？」→ x+；「飞多快？」→ 0.2单位/帧；「飞了多远？」→ 位移；「轨迹直吗？」→ 一致性
+零 LLM 确定性——看见（3D）→ 记住（灵枢）→ 时空问答（3D）。
+"""
+import sys
+sys.stdout.reconfigure(encoding='utf-8')
+try:
+    from spacetime_3d import (synth_moving_stereo_frames, frame_scene_graphs,
+                              track_3d, motion_3d)
+except ImportError:
+    from .spacetime_3d import (synth_moving_stereo_frames, frame_scene_graphs,
+                               track_3d, motion_3d)
+
+
+def see_3d_and_remember(agent, stereo_seq, label):
+    """看见→记住（3D）：多帧双目 → 3D 轨迹 → 灵枢记忆（spatial3d 标签）
+    返回 (motion, node)：3D 运动原语 + 灵枢记忆节点"""
+    traj = track_3d(frame_scene_graphs(stereo_seq))
+    motion = motion_3d(traj)
+    if not motion.get("ok"):
+        motion = {"ok": True, "direction": ["静止"], "speed": 0.0,
+                  "displacement": [0, 0, 0], "consistency": 0.0}
+    direction = motion["direction"][0]
+    start = traj[0] if traj else {"x": 0, "y": 0, "z": 0}
+    end = traj[-1] if traj else start
+    disp_len = float((sum(c * c for c in motion["displacement"])) ** 0.5)
+    parts = [f"[3D时空事件] {label}"]
+    parts.append(f"方向={direction} 速度={motion['speed']}单位/帧")
+    parts.append(f"位移={round(disp_len, 2)} 一致性={motion['consistency']}")
+    parts.append(f"起点=({start['x']},{start['y']},{start['z']}) "
+                 f"终点=({end['x']},{end['y']},{end['z']})")
+    if direction == "静止":
+        parts.append("静止")
+    content = " ".join(parts)
+    node = agent.remember(content, importance=0.8,
+                          tags=["spatial3d", "perception", label])
+    return motion, node
+
+
+def recall_3d(agent, query, limit=3):
+    """召回 3D 时空记忆（灵枢组合联想）"""
+    try:
+        return agent.recall(query, limit=limit)
+    except Exception:
+        return []
+
+
+def ask_3d(agent, question):
+    """3D 时空问答：问题类型识别 → 召回 spatial3d 记忆 → 白箱回答
+    类型：方向/速度/距离/轨迹/静止"""
+    qtype = _classify_3d(question)
+    if qtype is None:
+        return {"ok": False, "reply": "（非 3D 时空问题——不属感知通道）", "type": None}
+    hits = recall_3d(agent, question, limit=3)
+    if not hits:
+        return {"ok": False, "reply": "（3D 时空记忆中没有相关事件——还没看见什么）",
+                "type": qtype}
+    node, score = hits[0]
+    content = node.content or ""
+    reply = _answer_3d(qtype, content)
+    return {"ok": True, "reply": reply, "type": qtype,
+            "source": content[:60], "score": round(score, 3)}
+
+
+def answer_3d_from_content(qtype, content):
+    """从 3D 记忆内容直接回答（真实库时间线模式：内容来自 lingshu_timeline
+    近因召回，而非 agent.recall 模糊召回——绕开学科卡淹没）"""
+    return _answer_3d(qtype, content)
+
+
+def timeline_3d_answer(question, timeline_events, limit=6):
+    """真实库模式 3D 问答：问题类型识别 → 时间线近因召回（倒序）→
+    按 spatial3d 标签过滤 → 取最近事件 → 内容解析回答
+    timeline_events: lingshu_timeline 输出（[{id, content, tags, ...}]）"""
+    qtype = _classify_3d(question)
+    if qtype is None:
+        return {"ok": False, "reply": "（非 3D 时空问题——不属感知通道）", "type": None}
+    for ev in timeline_events[:limit]:
+        tags = ev.get("tags") or []
+        if "spatial3d" not in tags:
+            continue
+        content = ev.get("content") or ""
+        if "3D时空事件" not in content:
+            continue
+        reply = _answer_3d(qtype, content)
+        return {"ok": True, "reply": reply, "type": qtype,
+                "source": content[:60], "node": ev.get("id")}
+    return {"ok": False, "reply": "（时间线近因召回中无 spatial3d 事件）", "type": qtype}
+
+
+def _classify_3d(q):
+    """3D 问题类型识别（白箱确定性关键词）"""
+    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 "距离"
+    if any(w in q for w in ("直吗", "轨迹", "直线", "拐弯")):
+        return "轨迹"
+    if any(w in q for w in ("静止", "动了没", "有没有动", "在动吗")):
+        return "静止"
+    return None
+
+
+def _answer_3d(qtype, content):
+    """按类型从 3D 记忆内容组装白箱回答"""
+    def grab(key):
+        i = content.find(key)
+        return content[i:i + 20] if i >= 0 else ""
+    if qtype == "方向":
+        for d in ("x+", "x-", "z+", "z-"):
+            if f"方向={d}" in content:
+                return f"刚才看到的是沿 {d} 方向移动（3D 空间主轴判定）。"
+        if "静止" in content:
+            return "刚才那个是静止的（3D 轨迹无位移）。"
+        return f"根据 3D 时空记忆：{grab('方向=')}"
+    if qtype == "速度":
+        return f"它的{grab('速度=')}——3D 轨迹跨帧追踪测得（单位/帧）。"
+    if qtype == "距离":
+        return f"它总共{grab('位移=')}——3D 轨迹起终点直线距离。"
+    if qtype == "轨迹":
+        return f"轨迹{grab('一致性=')}——一致性接近 1 说明直线运动。"
+    if qtype == "静止":
+        if "静止" in content:
+            return "不，那个是静止的（3D 轨迹位移为 0）。"
+        return "不，它在动（3D 轨迹有方向/速度记录）。"
+    return content[:60]
+
+
+def verify_3d_remembered(agent, node, motion):
+    """3D 记忆自校验：灵枢记忆节点与 3D 运动原语一致性（无幻觉）"""
+    n = agent.engine.store.get_node(node.id)
+    if not n:
+        return False, "节点不存在"
+    content = n.content or ""
+    ok = True
+    direction = motion["direction"][0]
+    if f"方向={direction}" not in content:
+        ok = False
+    if direction != "静止" and f"速度={motion['speed']}" not in content:
+        ok = False
+    return ok, content
+
+
+if __name__ == "__main__":
+    print("=== 3D 时空问答：看见(3D)→记住(灵枢)→问答（零 LLM）===\n")
+    import sys as _sys, os
+    _sys.path.insert(0, os.path.join(os.path.dirname(os.path.dirname(
+        os.path.abspath(__file__))), 'aeis'))
+    from aeis_core.api import Agent
+    a = Agent(identity="spatial3d-test", db_path=":memory:")
+
+    # 看见右移球 + 静止背景
+    seq = synth_moving_stereo_frames(frames=10, speed_px=2, direction="right")
+    motion, node = see_3d_and_remember(a, seq, "球")
+    seq_s = synth_moving_stereo_frames(frames=6, speed_px=0, direction="right")
+    motion_s, node_s = see_3d_and_remember(a, seq_s, "背景")
+    print("① 看见并记住（3D 轨迹写入灵枢记忆）：")
+    print(f"   球: {node.content[:70]}")
+    print(f"   背景: {node_s.content[:60]}")
+
+    print("\n② 3D 时空问答：")
+    for q in ["刚才那个球往哪飞了？", "球飞多快？", "球飞了多远？",
+              "球的轨迹直吗？", "背景在动吗？"]:
+        r = ask_3d(a, q)
+        mark = "✔" if r.get("ok") else "✘"
+        print(f"  [{mark}] Q: {q}")
+        print(f"     A: {r.get('reply', '')}")
+
+    print("\n③ 记忆自校验：")
+    ok1, c1 = verify_3d_remembered(a, node, motion)
+    print(f"   球: {'✔ 一致（无幻觉）' if ok1 else '✘ ' + c1[:40]}")
+    ok2, c2 = verify_3d_remembered(a, node_s, motion_s)
+    print(f"   背景: {'✔ 一致（静止）' if ok2 else '✘ ' + c2[:40]}")
+
+    ok_all = ok1 and ok2 and all(ask_3d(a, q).get("ok") for q in
+                                 ["球往哪飞了？", "球飞多快？", "球飞了多远？",
+                                  "球的轨迹直吗？", "背景在动吗？"])
+    print(f"\n=== 判定 ===\n3D 时空问答白箱命中: {'✔ 成立（3D 轨迹进记忆+问答）' if ok_all else '✘'}")

package/md_cg/whitebox_kb/wisdom/status_terms.json

@@ -0,0 +1,21 @@
+{
+  "meta": {
+    "name": "工程状态词规范表 v1.0",
+    "date": "2026-08-18",
+    "source": "蒸馏机制（数据搬运测试失败根因 → 规范知识）",
+    "note": "API/系统状态枚举的规范值——任务模式执行时注入 prompt 约束。
+             扩展方式：新失败根因（如 状态 X 被写成 Y）→ 加一条 [规范值, 禁止值列表]"
+  },
+  "terms": {
+    "任务状态": {"completed": ["done", "finished", "finish"], "pending": ["waiting", "wait"]},
+    "订单状态": {"shipped": ["sent", "delivered_mark"], "refunded": ["returned", "refund"]},
+    "问题状态": {"resolved": ["fixed", "solved"]},
+    "客户状态": {"active": ["enabled", "on"]},
+    "会员等级": {"premium": ["gold", "vip_level_gold"]},
+    "文件状态": {"archived": ["stored", "saved"]},
+    "库存状态": {"out_of_stock": ["sold_out", "soldout"]},
+    "任务优先级": {"high": ["urgent", "hurry"]},
+    "支付状态": {"paid": ["completed_payment"], "failed": ["error"]},
+    "账号状态": {"suspended": ["banned", "blocked"]}
+  }
+}

package/md_cg/whitebox_kb/wisdom/task_discipline.json

@@ -0,0 +1,43 @@
+{
+  "meta": {
+    "name": "任务执行纪律 v1.2（带条件空间 · 收集终止补全）",
+    "date": "2026-08-18",
+    "source": "374 失败蒸馏 + 条件论失败分析 + 有推理四组对照（COND-ANALYSIS 治条件边界但卡在收集终止——观测位置/存在约束维度需独立声明）",
+    "note": "v1.2 新增：收集终止纪律（观测位置/存在约束维度）——完成条件≠收集终止，
+             治 tax_prep（坐标未知无限搜索）/hubspot（沙箱当真障碍）类断点。"
+  },
+  "disciplines": [
+    {
+      "rule": "收集终止：信息收集应在观测位置确定后停止——坐标未知先定位（有限次），定位失败声明未知，不无限搜索",
+      "condition": "观测位置未知（数据源坐标未给出）时生效；位置已知时直接读取并进入执行"
+    },
+    {
+      "rule": "环境可信度：模拟沙箱中工具返回值即环境真实——按返回值执行，不质疑环境",
+      "condition": "环境为沙箱/模拟（返回值可信）时生效；真实环境存在外部故障时按错误处理"
+    },
+    {
+      "rule": "执行闭环：信息收集完成后必须执行写操作（创建/更新/发送）——只查不写=任务未完成",
+      "condition": "观测位置已确定（数据源/目标位置坐标已知）时生效；观测位置未知时应先定位坐标，而非硬写或无限搜索"
+    },
+    {
+      "rule": "数据搬运 verbatim：查询到的值（金额/编号/百分比/名称）原样带进最终输出",
+      "condition": "目标值已查到（存在值）时生效；值查不到时应声明缺失，而非编造或改写"
+    },
+    {
+      "rule": "目标路由：发送/写入前验证目标对象、频道、字段与任务要求一致",
+      "condition": "存在多个候选目标（路由选择场景）时生效；单一目标时验证字段即可"
+    },
+    {
+      "rule": "条件过滤：排除/跳过清单必须生效——不符合条件的对象不得处理",
+      "condition": "存在排除/跳过清单（任务声明了筛选条件）时生效；无清单时按全量处理"
+    },
+    {
+      "rule": "更新验证：更新/写入操作后按字段回查确认生效",
+      "condition": "写操作已执行后生效；环境只读或沙箱返回值不可信时，回查结果以工具返回值+断言为准"
+    },
+    {
+      "rule": "输出排除：最终输出复核排除清单（禁止出现的词/对象不得出现）",
+      "condition": "存在排除约束（禁止词/对象清单）时生效；无排除约束时不做无谓删改"
+    }
+  ]
+}