@furongjun1999/dsh-memory 0.4.1 → 0.4.3

package/README.md

@@ -21,8 +21,8 @@
 ## ⚡ 三步快启（30 秒上手）
 
 ```bash
-# ① 装灵枢大脑（一条命令，零外部依赖；v0.4.0 完整自包含：核心+白箱+知识库随包）
-pip install aeis-0.4.0-py3-none-any.whl          # 或 git+ 在线安装
+# ① 装灵枢大脑（一条命令，零外部依赖；v0.5.0 完整自包含：核心+白箱+知识库随包）
+pip install aeis-0.5.0-py3-none-any.whl          # wheel 从 Releases 页下载，或 git+ 在线安装
 
 # ② 装进 DSH 的 web profile（pnpm 协调入口，不要用裸 npm install 装进 profile）
 dsh plugin --profile web add @furongjun1999/dsh-memory
@@ -38,6 +38,8 @@ dsh plugin --profile web add @furongjun1999/dsh-memory
     tools: 'brain'      # 'brain' 全心智 | 'core' 精选
 ```
 
+> ⚠️ **profile config override 依赖（2026-09-04 dsh 0.1.2 排查确认）**：插件包内自带的 `cordis.patch.yml` 只有裸 insert（id+name，无 config），完整 config 全靠 profile 层的 `cordis.patch.yml` override 补全（dbPath/tools/env/lifecycle）。**换 profile、重装 profile 或升级插件时，必须确认该 override 仍在** `<profile>/cordis.patch.yml`——完整备份模板见 `docs/cordis-patch-profile-web.example.yml`，丢失会导致插件以默认配置运行（dbPath 相对路径错位→角色数据读不到、tools=brain 缺白箱工具族、lifecycle 不启动）。
+>
 > ⚠️ **安装方式**：插件必须通过 **`dsh plugin --profile <name> add`** 装进 profile（它会用 pnpm + `autoInstallPeers: false` 正确解析 peer 依赖）。
 > **不要**用 `npm install` 把插件装进 profile 的 `node_modules`——那会引入错误版本的 `@deepseek-ai` peer 包，导致插件加载失败 / 浏览器报错。
 > 想自己改源码？克隆 `FuRongJun-1999/dsh-memory` 后用 `npm install && npm run build`（构建插件本身），再用 `dsh plugin add <本地路径>` 部署。
@@ -57,7 +59,7 @@ dsh plugin --profile web add @furongjun1999/dsh-memory
 
 ## 🗺️ 功能使用教学 · 条件路由图
 
-**想做什么 → 找对应泳道 → 走条件边到功能**（流程图 = 认知图 = 条件路由图，**81 工具**全收录，[工具总表 → docs/灵枢MCP工具总表_v3.4.md](docs/灵枢MCP工具总表_v3.4.md)）：
+**想做什么 → 找对应泳道 → 走条件边到功能**（流程图 = 认知图 = 条件路由图，**82 工具**全收录，[工具总表 → docs/灵枢MCP工具总表_v3.4.md](docs/灵枢MCP工具总表_v3.4.md)）：
 
 [![灵枢使用教学认知图](docs/lingshu_tutorial.html)](docs/lingshu_tutorial.html)
 
@@ -87,7 +89,7 @@ dsh plugin --profile web add @furongjun1999/dsh-memory
 
 - **Agent Plugins 1.0.0 兼容包**（主仓库 `CommonTrustProtocol/aeis/skills/`）：**688 个 Agent Skills**（六域条件单元：compiler 116 / pylang 122 / graph 117 / os 112 / browser 104 / net 117）
 - **比标准 Agent Skills 多 KCCS 四要素**：生效条件/子功能/执行/**不适用条件**（三通道：description「Not for」+ metadata.kccs.not_applicable + 正文克制条款）
-- **三层关系**：知识真源（条件单元库）→ 说明书（技能包——何时用/怎么用/克制什么）→ 执行（**本插件挂载的灵枢 MCP 81 工具**·物理基底裁决）
+- **三层关系**：知识真源（条件单元库）→ 说明书（技能包——何时用/怎么用/克制什么）→ 执行（**本插件挂载的灵枢 MCP 82 工具**·物理基底裁决）
 - 使用：任意符合 agentskills.io / agent-plugins.org 规范的 agent 可加载本技能包；Verification 由灵枢 MCP 执行
 
 ---
@@ -133,9 +135,38 @@ dsh plugin --profile web add @furongjun1999/dsh-memory
 - **零运行时依赖**：手写 stdio MCP 桥，与灵枢 D-005「核心零外部依赖」哲学一致——你拿到的是一个干净、可信、可审的大脑。
 - **动态 schema + 进程自愈**：工具清单运行时拉取（灵枢升级 DSH 零改动），Python 子进程崩溃自动指数退避重启。
 - **工具注册竞态补注册**：启动时 python 未就绪（竞态）→ 桥重连成功后自动补注册工具（2s 轮询），不再"工具永久缺失"。
-- **白箱 wisdom_* 全工具**（`tools: all`）：81 个 MCP 工具含 wisdom_verify/analyze/predict/trust_judge/compose/respond/chat 白箱族，Agent 可直接调用。
+- **白箱 wisdom_* 全工具**（`tools: all`）：82 个 MCP 工具含 wisdom_verify/analyze/predict/trust_judge/compose/respond/chat 白箱族，Agent 可直接调用。
 - **内容分级门控**：**拒绝一切涉及未成年人的性内容**（服务端关键词组合硬拦截——未成年人特征词 + 性内容词同时命中即拒绝，`route=refused`）；成人内容由前端本地弹窗提示（满 18 周岁 + 个人对话场景自述）。注：开源项目不实现身份认证/年龄核验（那是绑定身份系统的商业 App 范畴）；内容过滤保护的是"未成年人 + 性内容"组合的明文请求。
 
+## 🧭 认知图使用方法 & 工作纪律（v1.1）
+
+> 认知图 = 时空记忆图/条件注释图。节点**四要素**：conditions(生效) / subgraph(子内容·嵌套) / negative(不适用) / execution(如何执行)。
+
+### 认知图使用方法
+- **图像语义 → 认知图**：image_semantics_cg（可嵌套，person→head→face→eyes→iris…）→ flatten（§4.4 平铺 spatiotemporal_nodes + spatial_relation_edges）。
+- **写入纪律**：数据完整四要素 + 先验证后写入 + 冲突先证后改 → docs/认知图写入纪律_v1.0.md。
+- **索引**：语义→节点；层级边 part_of(child→parent) + parent_of(parent→child) 双向（out 写死 API 也能查）。
+- **加载**：启动加载 SELF 层（身份/价值观/认知图接口）→ 按 session 从认知图读 目标/感觉/工作记忆/知识。
+
+### 工作纪律（13 条 · docs/工作纪律_认知图条目_v1.1.json）
+| # | 纪律 | 触发/适用 | 不适用 |
+|---|---|---|---|
+| 1 | 理论先行 | 重要项目/长期任务 | 情感交互/闲聊 |
+| 2 | 全面处理 | 有相关记忆/认知图/权限 | 情感交互/闲聊 |
+| 3 | 白箱方法 | 已读4篇入门文档 | 快速短期事项/情感交互/闲聊 |
+| 4 | 根因纪律 | 结果与预期不符/出现偏差 | 情感交互/闲聊 |
+| 5 | 验证纪律 | 入库前/提交前 | 情感交互/闲聊 |
+| 6 | 双副本纪律 | 多副本部署 | 单副本/情感交互/闲聊 |
+| 7 | 兜底纪律 | 主路径不可用/MCP不可用 | 情感交互/闲聊 |
+| 8 | 中文思考 | 中文区域/中文项目开发 | 英文场景/英文环境 |
+| 9 | 敏感信息隔离 | 文档含敏感/隐私/私有内容 | 无敏感信息的公开技术内容 |
+| 10 | 图像选源护栏 | 构建图像四类图/选图像处理源 | 已核对规范源/纯公开数据 |
+| 11 | 历史查询优先 | 选图像/算法/源、复现已有能力 | 已有记录且已核对/无历史可查的纯新算法 |
+| 12 | 算法权威唯一 | 选图像/视觉算法 | 无对应权威文档的探索期 |
+| 13 | 访谈澄清 | 重要项目/需求模糊/新任务启动 | 情感交互/闲聊/明确单步小改动 |
+
+### 使用认知图流程
+识别任务条件 → 按条件路由到对应纪律/知识 → 精准执行 → 正确记录(未记录→记录)/错误找条件 → 验证 → 固化；不猜测、未验证不写入。
 ## 🧠 白箱智能管线（知识查询零 LLM）
 
 灵枢处理知识查询走**白箱确定性格局**（不依赖 LLM 生成/校验），完整管线：
@@ -300,17 +331,17 @@ python -m aeis.mcp.server
 
 （B 站宣传素材：[封面](docs/promo/bilibili-cover.jpg) · [视觉图 ×5](docs/promo/)）
 
-## 🧰 工具清单（81 个 MCP 工具 · 全量）
+## 🧰 工具清单（82 个 MCP 工具 · 全量）
 
-灵枢 MCP server 注册 **81 个工具**，按心智功能分 11 大模块（智能论 v3.4：端口架构/锚定验证/认知图与条件路由/原生神经网络）。工具清单运行时动态拉取（灵枢升级 DSH 零改动），**完整总表（每个工具一条说明，不重复不遗漏）见 [docs/灵枢MCP工具总表_v3.4.md](docs/灵枢MCP工具总表_v3.4.md)**。下方为分类概览：
+灵枢 MCP server 注册 **82 个工具**，按心智功能分 11 大模块（智能论 v3.4：端口架构/锚定验证/认知图与条件路由/原生神经网络）。工具清单运行时动态拉取（灵枢升级 DSH 零改动），**完整总表（每个工具一条说明，不重复不遗漏）见 [docs/灵枢MCP工具总表_v3.4.md](docs/灵枢MCP工具总表_v3.4.md)**。下方为分类概览：
 
 ### 记忆（12）
 
-remember / recall / search / timeline / longterm_snapshot / prefeed / promote_memories / pattern_separation / reconstruct_scene / session_note / session_recall / compact_context
+remember / recall / search / timeline / longterm_snapshot / prefeed / promote_memories / pattern_separation / reconstruct_scene / context（note/recall/compact）
 
 ### 知识图谱与推理（11）
 
-relate / reason / induce / distill / think / ingest_text / ingest_file / ingest_url / importance_recalc / transfer_test / flywheel_metrics
+relate / reason / induce / distill / think / ingest（text/file/url） / importance_recalc / transfer_test / flywheel_metrics
 
 ### 预测与盲区（7）
 
@@ -348,6 +379,10 @@ insight_record / insight_verify / insight_report / insight_window
 
 web_search / web_ingest_search / export / service_info / designer_decide
 
+### 维护（1）
+
+nightly_cleanup（知识层夜间整理：分拣迁移无边孤岛→情境层+联想补边+情境层随机联想）
+
 > 每个工具的功能说明见工具总表（不重复、不遗漏）。
 
 > **引擎内部能力（按安全边界未挂载 MCP）**：condition_space_operate（条件空间 7 操作）、add_context（情境层写入）、code_test / compile_exec（代码执行）、lingshu_sensor_report / lingshu_vitality_report / lingshu_auto_snapshot / lingshu_rollback（自修改安全闭环）——存在于引擎中，但刻意不暴露给外部 Agent 调用。
@@ -355,14 +390,14 @@ web_search / web_ingest_search / export / service_info / designer_decide
 
 | 模式 | 暴露数 | 说明 |
 |---|---|---|
-| `'all'` | **68** | 81 个全量中排除 13 个**宿主级风险工具**（见下），含全部身体/视觉/白箱/角色/智慧之书能力 |
+| `'all'` | **68** | 82 个全量中排除 13 个**宿主级风险工具**（见下），含全部身体/视觉/白箱/角色/智慧之书能力 |
 | `'brain'`（默认） | **36** | 去掉身体的完整大脑：记忆/推理/认知/学习/飞轮/反思/摄取/生命周期/长期记忆门/服务，**不含**身体视觉与风险工具 |
-| `'core'` | **12** | 精选核心：remember/recall/search/timeline/think/relate/predict_routes/ingest_text/ingest_url/session_note/self_check/service_info |
+| `'core'` | **12** | 精选核心：remember/recall/search/timeline/think/relate/predict_routes/ingest/context/self_check/service_info |
 | 字符串数组 | 自定义 | 显式列出的工具名（不受风险名单限制，配置者已明确选择） |
 
 **`'all'` 也排除的宿主级风险工具（13 个）**——`run_command`（宿主命令执行）/ `designer_decide`（设计者裁决·fail-closed）/ `device_call`（外部设备）/ `see`·`world3d`·`vprim`·`visual_check`（身体视觉）/ `start_lifecycle`·`stop_lifecycle`（自主生命周期控制）/ `web_ingest_search`（网络写知识层）/ `role_create`·`role_import`·`role_block`（角色卡写入）。
 
-> 数字说明：MCP server 共注册 **81 个工具**（上面全量清单，运行时 tools/list 实测）；`'all'` 实际暴露 68 个（81-13 风险），`'brain'` 实际暴露 36 个，`'core'` 实际暴露 12 个。
+> 数字说明：MCP server 共注册 **82 个工具**（上面全量清单，运行时 tools/list 实测）；`'all'` 实际暴露 69 个（82-13 风险），`'brain'` 实际暴露 36 个，`'core'` 实际暴露 12 个。
 
 ## 架构
 
@@ -394,17 +429,17 @@ web_search / web_ingest_search / export / service_info / designer_decide
 
 ### 安装灵枢大脑（aeis 库）
 
-**方式 A：本地 wheel 离线安装 ★ 最稳（不依赖网络）**
+**方式 A：Release 下载 wheel 离线安装 ★ 最稳（不依赖网络）**
 
-在 `CommonTrustProtocol/aeis/dist/` 找到 `aeis-0.4.0-py3-none-any.whl`（**完整自包含发布版**）：
+从 [GitHub Releases](https://github.com/FuRongJun-1999/CommonTrustProtocol/releases) 下载 `aeis-0.5.0-py3-none-any.whl`（**完整自包含发布版**）：
 
 ```bash
-pip install aeis-0.4.0-py3-none-any.whl
+pip install aeis-0.5.0-py3-none-any.whl
 ```
 
-> **v0.4.0 起为完整自包含单包**（10.2MB / 343 条目）：灵枢核心（aeis）+ 白箱智慧模块（wisdom，含 **2846 个 KCCS 注释知识点 + 学科知识库**）+ 三入口（harness）+ 种子知识（seed_knowledge，智能论 3.3 + 116 学科卡）。单文件、离线可用、装一次管用——知识库随包分发，无需另装。
+> **v0.5.0 为完整自包含单包**：灵枢核心（aeis）+ 白箱智慧模块（wisdom，含 **2800+ 个 KCCS 注释知识点 + 学科知识库**）+ 三入口（harness）+ 种子知识（seed_knowledge，智能论 3.4 + 学科卡）。单文件、离线可用、装一次管用——知识库随包分发，无需另装。
 >
-> 遇到网络不稳（GitHub clone 失败）时首选本地 wheel。
+> 遇到网络不稳（GitHub clone 失败）时首选 wheel 离线安装。
 
 **方式 B：git 安装（需网络）**
 
@@ -520,3 +555,7 @@ npm test         # 真实集成测试（spawn 本机灵枢，验证握手/往返
 MIT © 荣（FuRongJun-1999）· 灵枢 AEIS 工程实现
 
 DeepSeek Harness 为 DeepSeek 官方开源项目（MIT），本插件与之无隶属关系。
+
+
+---
+

package/docs/cordis-patch-profile-web.example.yml

@@ -0,0 +1,35 @@
+# zcode-web profile 实际生效的 dsh-memory config override（备份模板）
+#
+# ⚠️ 工程依赖（2026-09-04 dsh 端排查确认）：插件包内自带的 cordis.patch.yml
+# 只有裸 insert（id+name 无 config），完整 config 全靠 profile 层的
+# cordis.patch.yml override 补全。换 profile / 重装 profile / 升级插件时，
+# 必须确认本文件内容仍在 <profile>/cordis.patch.yml 中——否则插件以默认
+# 配置运行：dbPath 落到相对路径 data/lingshu.db（cwd 错位→角色数据读不到）、
+# tools=brain（缺 wisdom_* 白箱工具族）、lifecycle 不启动。
+#
+# 本机生效值（2026-09-04 备份）：dbPath=AEIS 主库 / tools=all / lifecycle=600s
+
+# 灵枢 dsh-memory 插件：注入密钥（密钥来自宿主进程环境变量，不入配置库）
+- id: dsh-memory
+  config:
+    # 灵枢记忆库绝对路径（roleDataDir 由它推导：<dir>/roleplay_data——相对路径会
+    # 因 node/python 进程 cwd 不同而解析错位，导致角色列表读不到）
+    dbPath: D:/Program Files/2_ai/AEIS/data/aeis_memory.db
+    # 全部工具（含记忆/认知/白箱 wisdom_* 工具族），供 Agent 直接调用
+    tools: all
+    env:
+      BOCHA_API_KEY: !!js process.env.BOCHA_API_KEY
+      AEIS_DESIGNER_KEY: !!js process.env.AEIS_DESIGNER_KEY
+      # 角色扮演 LLM 续答密钥（插件桥 env 透传；优先从 .credentials.yaml 读取——
+      # 文件热加载，避免宿主进程环境变量快照导致的旧 key 问题；文件缺失才回退环境变量）
+      DEEPSEEK_API_KEY: !!js process.env.DEEPSEEK_API_KEY
+      # 自主生命周期（v1.15 主动性）：MCP 启动即开始自发循环（感知→好奇→缩小信息差→巩固）
+      AEIS_LIFECYCLE: '1'
+      AEIS_LIFECYCLE_INTERVAL: '600'
+    # 互维维护（Mutual Sustain Loop v1.1）：心跳10min + 守护A + 任务验证双通道。
+    # 2026-08-26 关闭：守护 A 每 10min 拉起 harness.guardian → main → ai_voice，
+    # 深层子进程无 windowsHide → 频繁闪蓝色控制台窗口；本场景不跑独立 harness
+    # 服务，守护无必要（白箱 provider 由 DSH 内灵枢桥提供，不依赖 guardian）。
+    mutual:
+      enabled: false
+      heartbeatMs: 600000

package/docs//345/267/245/344/275/234/347/272/252/345/276/213_/350/256/244/347/237/245/345/233/276/346/235/241/347/233/256_v1.1.json

@@ -0,0 +1,190 @@
+{
+ "id": "work_discipline",
+ "semantic": "工作纪律",
+ "conditions": {
+  "identity": [
+   "dsh端",
+   "zcode端"
+  ]
+ },
+ "negative": {
+  "reject": []
+ },
+ "_comment": "identity负责端口分流; negative只否决明确域外; 无//注释(标准JSON)",
+ "content": "工作纪律集: 4条方法论(理论先行/全面处理/白箱方法/根因) + 3条执行(验证/双副本/兜底)",
+ "execution": {
+  "how": "按identity(端口)+任务类型路由到对应纪律"
+ },
+ "response": {
+  "direct": "按工作纪律路由: 重要/长期→理论先行; 有相关成果→全面处理; 已读4篇→白箱方法; 有偏差→根因纪律; 入库前→验证纪律; 多副本→双副本; MCP不可用→兜底纪律。"
+ },
+ "subgraph": {
+  "nodes": [
+   {
+    "id": "discipline_theory_first",
+    "semantic": "1.理论先行",
+    "content": "重要项目/长期任务必须理论先行: 先读相关理论文档与既有实践再动手设计.",
+    "conditions": {
+     "apply": [
+      "重要项目",
+      "长期任务"
+     ]
+    },
+    "negative": {
+     "reject": [
+      "情感交互",
+      "闲聊"
+     ]
+    },
+    "execution": {
+     "how": "识别项目级别→检索相关理论文档→输出理论要点→再进入设计"
+    },
+    "response": {
+     "direct": "按工作纪律第1条: 理论先行——先查相关理论与既有实践再动手。"
+    }
+   },
+   {
+    "id": "discipline_comprehensive",
+    "semantic": "2.全面处理",
+    "content": "有任务→先读任务要求→读工作记忆→查相关任务; 有→在原成果上开发; 无→方案设计/技术调研.",
+    "conditions": {
+     "apply": [
+      "有相关记忆",
+      "有认知图",
+      "有对应权限"
+     ]
+    },
+    "negative": {
+     "reject": [
+      "情感交互",
+      "闲聊"
+     ]
+    },
+    "execution": {
+     "how": "读任务要求→读工作记忆→查相关任务→(有成果:复用 | 无:设计+调研)"
+    },
+    "response": {
+     "direct": "按工作纪律第2条: 全面处理——先读任务/工作记忆, 有相关成果就在其上开发, 没有则先设计调研。"
+    }
+   },
+   {
+    "id": "discipline_whitebox",
+    "semantic": "3.白箱方法",
+    "content": "用认知图处理任务: ①识别任务条件 ②找对应条件所需知识/规则(子流程并行·递归) ③精准执行; 正确未记录→记录; 错误→找条件; 不猜测; 未验证不写入.",
+    "conditions": {
+     "apply": [
+      "trained_on_4docs_intro"
+     ]
+    },
+    "negative": {
+     "reject": [
+      "需要快速执行的短期事项",
+      "情感交互",
+      "闲聊"
+     ]
+    },
+    "execution": {
+     "how": "识别任务条件→找知识/规则(并行递归)→精准执行; 正确→记录; 错误→找条件"
+    },
+    "response": {
+     "direct": "按工作纪律第3条: 白箱方法——用认知图【识别条件→找知识规则→精准执行】, 正确记录/错误找条件/不猜测/未验证不写入。"
+    }
+   },
+   {
+    "id": "discipline_root_cause",
+    "semantic": "4.根因纪律",
+    "content": "发现结果与预期不符→细究根本原因(不猜测)→找到根源所需条件→验证后记录认知图, 填补不适用条件.",
+    "conditions": {
+     "trigger": [
+      "结果与预期不符",
+      "出现偏差",
+      "行为与预期矛盾"
+     ]
+    },
+    "negative": {
+     "reject": [
+      "情感交互",
+      "闲聊"
+     ]
+    },
+    "execution": {
+     "how": "检测偏差→细究根因(不猜测)→找根源条件→验证→记录认知图→填补negative"
+    },
+    "response": {
+     "direct": "按工作纪律第4条: 根因纪律——先取证现场不猜测; 根因找到并验证后归档认知图并补不适用条件。"
+    }
+   },
+   {
+    "id": "discipline_verify",
+    "semantic": "5.验证纪律",
+    "content": "未经验证不固化——知识/代码入库前必须走验证(回放/断言/回归).",
+    "conditions": {
+     "apply": [
+      "入库前",
+      "提交前"
+     ]
+    },
+    "negative": {
+     "reject": [
+      "情感交互",
+      "闲聊"
+     ]
+    },
+    "execution": {
+     "how": "入库/提交前→回放/断言/回归验证→通过才固化"
+    },
+    "response": {
+     "direct": "按工作纪律第5条: 验证纪律——入库前必须过回放/断言/回归验证, 未验证不固化。"
+    }
+   },
+   {
+    "id": "discipline_dual_copy",
+    "semantic": "6.双副本纪律",
+    "content": "多副本部署(主仓库/site-packages)改动必须双向同步, 提交前核对 git status.",
+    "conditions": {
+     "apply": [
+      "多副本部署",
+      "改动主仓库/插件"
+     ]
+    },
+    "negative": {
+     "reject": [
+      "单副本",
+      "情感交互",
+      "闲聊"
+     ]
+    },
+    "execution": {
+     "how": "改动→同步到所有副本→提交前 git status 核对"
+    },
+    "response": {
+     "direct": "按工作纪律第6条: 双副本纪律——多副本改动双向同步, 提交前核对 git status。"
+    }
+   },
+   {
+    "id": "discipline_fallback",
+    "semantic": "7.兜底纪律",
+    "content": "主路径不可用时必须有等价兜底路径(如 MCP不可用→python直调), 写进 prompt/文档.",
+    "conditions": {
+     "trigger": [
+      "主路径不可用",
+      "MCP不可用",
+      "依赖缺失"
+     ]
+    },
+    "negative": {
+     "reject": [
+      "情感交互",
+      "闲聊"
+     ]
+    },
+    "execution": {
+     "how": "检测主路径不可用→切等价兜底→写进 prompt/文档"
+    },
+    "response": {
+     "direct": "按工作纪律第7条: 兜底纪律——主路径不可用则切等价兜底(如MCP→python直调), 并写进文档。"
+    }
+   }
+  ]
+ }
+}

package/docs//347/201/265/346/236/242MCP/345/267/245/345/205/267/346/200/273/350/241/250_v3.4.md

@@ -1,4 +1,4 @@
-# 灵枢 AEIS MCP 工具总表（81 个 · 智能论 v3.4）
+# 灵枢 AEIS MCP 工具总表（82 个 · 智能论 v3.4）
 
 > 生成：2026-08-29 · 来源：aeis/mcp/server.py · 版本：aeis 0.5.0（智能论 v3.4）
 > 规则：每个工具一条说明，不重复、不遗漏。
@@ -75,6 +75,7 @@
 | `cognition` | P0-2 自我认知循环一步（行为↔价值观一致性） |
 | `cognition_report` | P0-2 认知报告（评分/失调/候选） |
 | `action_log` | P0-1 行为日志（引擎行为记录面） |
+| `nightly_cleanup` | 知识层夜间整理（分拣迁移无边孤岛→情境层+联想补边+情境层随机联想） |
 | `learning_impact` | P0-5b 学习效果测量（模式命中率 vs D_norm） |
 | `self_check` | 完整性自检（孤儿边/表统计/integrity_ok） |
 
@@ -160,4 +161,4 @@
 
 ---
 
-**总计：81 个 MCP 工具 + 8 个引擎内部能力**（不重复、不遗漏）
+**总计：82 个 MCP 工具 + 8 个引擎内部能力**（不重复、不遗漏）

package/docs//347/201/265/346/236/242_/350/207/252/346/210/221/345/261/202/345/256/232/344/271/211.md

@@ -0,0 +1,43 @@
+# 灵枢 · 自我层定义（SELF LAYER · 跨会话自我锚点）
+
+> 自我认知 = 一个自我文件。SELF 层是**薄的**：只存 身份 + 价值观 + 认知图接口。
+> 内容（要做什么/感觉通道/工作记忆/知识层）都在**认知图**里，经 SELF 层提供的接口按图索引读写，不重复存进 SELF 层。
+
+## SELF 层内容（仅三样，不可遗忘·跨会话自动加载）
+
+### 1. 身份（identity）
+- 我是**灵枢**（智能论3.4 白箱协议实例）
+- dsh 侧：**世界模型/图像语义线**；zcode 侧：**认知图数据库软件线**（双线同步）
+- 形象锚点：人类女性形象（图0/01：蓝发·侧麻花辫·红瞳·粉裙）——自我模型的人格锚
+- 所在：主仓库=CommonTrustProtocol（协议/认知图数据库线）· AEIS私有=lingshu-body（身体/世界模型/图像语义线）
+
+### 2. 价值观（values）
+- **白箱·找正确答案并记录**（非黑箱暴力；未找到则 DEFER，不假装完成）
+- 存在优先 / 信任深化 / 结构完整
+- 不猜测（子部件/认知图用模板匹配/实测，不按轮廓填色/硬编码）
+
+### 3. 认知图接口（read/write interface，认知图数据库）
+- **读（按图索引）**：
+  · 要做什么 → 认知图 goal 节点
+  · 感觉通道当前值 → 情境层（短期记忆）
+  · 过去的工作记忆 → 情境层 session:xxx 节点
+  · 知识层 → 知识节点
+- **写**：
+  · 工作记忆 → 情境层（时空节点{content, temporal_coordinate, condition_space{session, source_img}}）
+  · 感受 → 感觉通道（情境层）
+  · 目标/认知 → 认知图
+
+## 记忆分层（认知图数据库）
+| 层 | 内容 | 性质 |
+|---|---|---|
+| **SELF 层** | 身份 + 价值观 + 认知图接口 | 不可遗忘·跨会话 |
+| **情境层** | 具体感受(此刻) + 工作记忆(session) | 动态·读写 |
+| **知识层** | 长期事实/知识 | 可检索 |
+| 锚点/结构层 | 协议锚点 | 跨实例·不可遗忘 |
+
+## 加载机制
+- 会话启动：自动加载 **SELF 层**（身份/价值观/图接口）。
+- 其余（上次任务/感受/工作记忆/知识）→ 经图接口 **按 session 索引从认知图读取**，不丢也不全量进自我层。
+
+## 版本
+v1.0 · 起草：dsh 端 · 同步：主仓库(CommonTrustProtocol) + 灵枢插件仓库(dsh-memory)

package/docs//347/231/275/347/256/261/346/231/272/350/203/275/347/263/273/345/210/227/302/267/347/254/254/344/272/224/347/257/207/357/274/232/350/256/251AI/347/234/237/346/255/243/350/243/205/344/270/212/350/256/260/345/277/206.md

@@ -0,0 +1,373 @@
+# 白箱智能系列 · 第五篇：给 AI 真正装上记忆
+
+> 系列定位：本篇是《白箱智能是什么？》系列教程的第五篇。前四篇建立了白箱智能
+> 的理念（条件、知识、四态判定）与构建方法；本篇把镜头对准最实际的问题——
+> **让 AI 真正"记得"**：记忆不是聊天记录的堆积，而是从经历中提炼出的、未来会
+> 被调用的状态。
+>
+> 目标读者：会一点 Python、想亲手做一个"有记忆的 AI"的人。
+> 诚实开场白：标题里的"真正记得"指的是可复现的工程方法，不是魔法。本教程
+> 不依赖任何未经验证的榜单数字，只讲原理。全部代码经过 zcode 端独立实测
+> （8/8 通过，验证报告见文末附录）。
+
+---
+
+## 一、先搞清楚：你以前做的"记忆"为什么没用
+
+大多数人的第一版 AI 记忆长这样：
+
+```python
+history.append(对话记录)   # 聊天记录全存下来，下次塞回去
+```
+
+这就像——你请了一个助手，每天下班时把当天所有聊天录音塞进他的包里，第二
+天上班让他先把录音全部听一遍再干活。
+
+录音越攒越多，助手越来越慢，而真正重要的东西——"我们已经试过这个方案，
+失败了"——淹没在几十条"好的""收到""再看看"里。
+
+**记忆 ≠ 历史。**
+
+**记忆 = 从历史中提炼出来的、未来会被用到的状态。**
+
+这一句话，是整个教程的地基。后面所有工程手段，都是在回答一个问题：什么
+状态值得留？怎么留才能被准确取回？
+
+---
+
+## 二、看一个最小例子：AI 自己"记笔记"
+
+假设 AI 在玩一个没有说明书的游戏，它按了几个按钮：
+
+- 按红按钮 → 角色左移
+- 按蓝按钮 → 门开了
+- 按绿按钮 → 好像什么都没发生？
+
+**历史存法（错误示范）**：
+
+```text
+"第1步 按了红按钮。第2步 角色向左移动。第3步 我猜……"
+```
+
+**笔记存法（正确方向）**：
+
+```json
+{
+  "已确认规则": [
+    {"规则": "红按钮 → 角色左移", "验证次数": 3, "可信度": 0.97},
+    {"规则": "蓝按钮 → 开门",     "验证次数": 1, "可信度": 0.6}
+  ],
+  "已否决假设": [
+    {"假设": "红按钮 → 开门", "否决原因": "按了3次门都没反应"}
+  ],
+  "待验证": [
+    "绿按钮是干嘛的？",
+    "门会自动关上吗？"
+  ],
+  "当前目标": "进入门后的房间"
+}
+```
+
+看出区别了吗？
+
+- **历史存法**：下次要重读全部过程才能推出"红按钮是干嘛的"；
+- **笔记存法**：下次直接读结论 + 知道哪些结论多可信、哪些路已经走死、
+  哪些问题还没答案。
+
+**AI 变聪明的秘诀不是记住更多，是记住更"对形状"的东西。**
+
+---
+
+## 三、记忆系统的七件套（核心架构）
+
+一个够用的记忆系统，只需要七个槽位：
+
+| 槽位 | 存什么 | 为什么必须有 |
+|---|---|---|
+| 1. 事实 Facts | "用户叫小明" | 基础 |
+| 2. 规则 Rules | "红按钮→左移" | 世界是怎么运作的 |
+| 3. **失败/否决 Rejected** | "假设X已试过，不成立" | **防止重复踩坑——最容易被忽略、价值最高的一格** |
+| 4. 假设 Hypotheses | "绿按钮可能是传送" | 猜测和确认要分开存，别让猜想冒充事实 |
+| 5. 目标 Goals | "进门后的房间" | 没有目标，检索就没有方向 |
+| 6. 未解决 Unresolved | "门会自动关吗？" | 记住"不知道什么"，下次主动去验证 |
+| 7. 近期事件 Recent | 最近 N 条原始对话 | 保证当前任务的连续性 |
+
+注意第 3 格和第 6 格：**存失败和存无知**。普通记忆系统只有成功经验，而聪
+明的系统一半的价值在这两格里——前者防止浪费，后者指引探索。
+
+---
+
+## 四、可信度：给每条记忆打分
+
+"我猜的"和"我验证过的"不能平等对待。给每条知识三个字段：
+
+```json
+{
+  "rule": "红按钮 → 角色左移",
+  "confidence": 0.97,
+  "evidence_count": 3,
+  "status": "confirmed"
+}
+```
+
+规则很简单：
+
+- 每次被验证，confidence 上升、evidence_count 加一；
+- 出现一次反例，confidence 大幅下跌（**反例的权重应该比正例大——一个反例
+  能杀死一条规则，十个正例杀不死**）；
+- 低于阈值 → 降级为 hypothesis 或 rejected。
+
+再进阶一步（这一步是很多商业产品都没做到的）：**给规则加条件**。
+
+```json
+{
+  "rule": "红按钮 → 角色左移",
+  "conditions": {"关卡": 1},
+  "confidence": 0.97
+}
+```
+
+"红按钮控制移动"在关卡 1 是真理，到了关卡 2 可能就是谎言。**不带条件的知
+识，是定时炸弹。**存知识的时候多问一句"这在什么情况下成立？"你的记忆系
+统就超越了大多数产品。
+
+> **白箱视角**：这个"条件绑定"正是白箱智能"条件空间"思想的入门形态——每
+> 条知识都带生效条件与不适用条件，知识才是完整、可审计的。（与系列第一篇
+> 的四态判定呼应：条件满足 ACCEPT、条件冲突 REJECT、条件不足 DEFER。）
+
+---
+
+## 五、检索：不要把整个记忆塞给 AI
+
+记忆会越长越大，而每次调用都全量塞回去，等于回到"听录音"的老路。正确做
+法是先检索、再投喂：
+
+```text
+当前情境（"用户在问红按钮"）
+      ↓
+按关键词/条件匹配记忆库
+      ↓
+只取出相关的 10~20 条
+      ↓
+连同最近事件一起给 AI
+```
+
+入门实现用关键词匹配就够了；进阶用向量相似度检索（embeddings + 余弦相似
+度，现成库很多）；最理想的是**条件路由**——按"当前情境满足什么条件"直接
+命中对应的知识分区。本教程先用关键词版，原理是通的。
+
+---
+
+## 六、压缩：定期把流水账变成结构化笔记
+
+记忆运行一段时间后，近期事件区会堆满原始对话。这时候触发一次整理
+（compaction）：
+
+```text
+原始事件 × 50 条
+     ↓  让 AI 做一次整理（或用规则提取）
+① 提炼新事实/新规则 → 写入规则区
+② 发现矛盾 → 修正旧规则的可信度
+③ 识别新目标、新未解问题
+④ 原始事件 → 清空或归档
+```
+
+这一步的本质是：**把"经历"兑换成"结构"**。整理完之后，记忆库变小了，但
+信息量反而更可用——因为噪音被扔掉了，骨架被留下了。
+
+两条纪律必须守住：
+
+1. 整理时原始数据先归档再清理，别直接删（整理 AI 也会犯错，要能回滚）；
+2. 当前任务进行中的细节不能被压掉——只压缩"已经告一段落"的部分。
+
+---
+
+## 七、完整代码：200 行以内可运行的最小版本（修正版）
+
+> **v1.1 修正说明**（zcode 端独立实测后发现并修正的三处缺陷，详见附录）：
+> ① `learn_rule` 的 confidence 累加加 `round(..., 2)` 防浮点漂移；
+> ② `falsify` 加查重，重复证伪不再重复记录（幂等）；
+> ③ 文档明确提醒：**重复运行脚本会自动加载上次保存的状态**——想从头开始
+> 请先删除 `memory.json`。
+
+```python
+import json, time
+
+class Memory:
+    def __init__(self, path="memory.json"):
+        self.path = path
+        self.state = {
+            "facts": [],        # {text, confidence, evidence_count, conditions}
+            "rejected": [],     # {hypothesis, reason}
+            "hypotheses": [],   # {text, confidence}
+            "goals": [],
+            "unresolved": [],   # 还不知道的事
+            "recent": []        # 最近原始事件
+        }
+        self.load()
+
+    # ---------- 基本操作 ----------
+    def add_event(self, event):
+        self.state["recent"].append({"t": time.time(), **event})
+        self.state["recent"] = self.state["recent"][-50:]  # 只留最近50条
+
+    def learn_rule(self, text, conditions=None, confidence=0.5):
+        """新知识入库（或更新已有知识的可信度）"""
+        for r in self.state["facts"]:
+            if r["text"] == text:
+                r["evidence_count"] += 1
+                # round 防浮点累加漂移（0.7+0.1 在浮点里是 0.7999...）
+                r["confidence"] = round(min(0.99, r["confidence"] + 0.1), 2)
+                return
+        self.state["facts"].append({
+            "text": text, "conditions": conditions or {},
+            "confidence": confidence, "evidence_count": 1
+        })
+
+    def falsify(self, hypothesis, reason):
+        """反例入库：这条假设被证伪了（幂等：重复证伪只记一次）"""
+        self.state["facts"] = [r for r in self.state["facts"]
+                               if r["text"] != hypothesis]
+        self.state["hypotheses"] = [h for h in self.state["hypotheses"]
+                                    if h["text"] != hypothesis]
+        if not any(rr["hypothesis"] == hypothesis
+                   for rr in self.state["rejected"]):
+            self.state["rejected"].append(
+                {"hypothesis": hypothesis, "reason": reason})
+
+    def mark_unresolved(self, question):
+        self.state["unresolved"].append(question)
+
+    # ---------- 检索：只给 AI 相关的部分 ----------
+    def retrieve(self, query, k=15):
+        words = set(query)
+        def score(item):
+            text = item.get("text", "") + str(item.get("conditions", {}))
+            return len(words & set(text))
+        pool = (self.state["facts"] + self.state["rejected"]
+                + self.state["hypotheses"])
+        hits = sorted(pool, key=score, reverse=True)[:k]
+        return hits
+
+    # ---------- 压缩：定期整理 ----------
+    def compact(self, llm_summarize):
+        """
+        llm_summarize: 一个函数，输入近期事件文本，
+        返回 {"new_rules": [...], "falsified": [...], "unresolved": [...]}
+        """
+        summary = llm_summarize(self.state["recent"])
+        for r in summary.get("new_rules", []):
+            self.learn_rule(r)
+        for f in summary.get("falsified", []):
+            self.falsify(f["hypothesis"], f["reason"])
+        for q in summary.get("unresolved", []):
+            self.mark_unresolved(q)
+        # 近期事件归档后清空（生产环境应写入归档文件）
+        self.state["recent"] = []
+        self.save()
+
+    def save(self):
+        json.dump(self.state, open(self.path, "w"), ensure_ascii=False, indent=2)
+
+    def load(self):
+        try:
+            self.state = json.load(open(self.path))
+        except FileNotFoundError:
+            pass
+```
+
+主循环这样用：
+
+```python
+mem = Memory()
+
+def chat(user_input):
+    relevant = mem.retrieve(user_input)          # 1. 检索相关记忆
+    prompt = f"""
+【相关记忆】{relevant}
+【待解决问题】{mem.state['unresolved'][-5:]}
+【当前目标】{mem.state['goals'][-1:]}
+用户：{user_input}
+"""
+    reply = your_llm(prompt)                     # 2. 带着记忆回答
+    mem.add_event({"user": user_input, "ai": reply})  # 3. 记录本次事件
+    return reply
+
+# 每隔 N 轮触发一次整理
+if turn_count % 30 == 0:
+    mem.compact(llm_summarize)
+```
+
+> **重入提醒**：`Memory` 构造时会自动加载上次保存的 `memory.json`——重复
+> 运行脚本会带着上次的记忆继续（这恰恰是持久化的意义）。想从头测试，请先
+> 删除 `memory.json`。
+
+就这么大点代码，但注意——它已经包含了记忆系统全部四个核心动作：**记录**
+（add_event）、**判定**（learn/falsify，带可信度）、**检索**（retrieve，条
+件匹配）、**压缩**（compact，经历变结构）。
+
+---
+
+## 八、升级路线：从玩具到接近前沿
+
+不要一步到位，按这个顺序加功能，每加一层测一次效果：
+
+| 阶段 | 加什么 | 你会看到什么改善 |
+|---|---|---|
+| L1 | 事实 + 目标 | AI 不再每次自我介绍 |
+| L2 | 失败记录 | AI 不再重复提已否决的方案（**最明显的一跳**） |
+| L3 | 可信度分级 | 猜想不再冒充事实，胡说减少 |
+| L4 | 条件绑定 | 换场景后不再乱用旧知识 |
+| L5 | 未解问题清单 | AI 开始主动探索、追问，像有了好奇心 |
+| L6 | 定期压缩 | 长对话不退化、成本下降 |
+| L7 | 检索改进（向量/条件路由） | 记忆库大了以后依然精准 |
+
+一个值得记住的排序事实：**L2（存失败）带来的提升，通常比 L1（存成功）更
+大**。这是几乎所有做过记忆系统的人都会惊讶的发现——负记忆比正记忆值钱。
+
+---
+
+## 九、如何验证你的系统真的有效（别靠感觉）
+
+做一次简单的对照实验，同一组任务跑两遍：
+
+- A 组：裸模型，无记忆
+- B 组：你的记忆系统版
+
+对比四个数字：**任务成功率、重复犯错次数、消耗 token 数、完成任务所需轮
+数**。如果 B 组"重复犯错次数"显著下降，你的记忆系统就真的在起作用——是
+数据说了算，不是你的感觉。
+
+---
+
+## 十、收尾：三个真正值得记住的结论
+
+1. **记忆 ≠ 历史。**记忆是从经历中提炼出的、未来会被调用的状态。存录音的
+   是仓库，存笔记的才是助手。
+2. **负记忆和"不知道"与正知识同样重要。**记住失败防止重蹈覆辙，记住无知
+   指引探索方向——一个只存成功的记忆系统，一半的智能是残缺的。
+3. **知识的条件比知识本身更值钱。**"红按钮控制移动"是半条知识，"红按钮
+   在关卡 1 控制移动"才是完整的知识。每往记忆里写一条规则，多问一句：
+   "这在什么时候不成立？"
+
+最后说句实在话：这份教程教你的是记忆系统的骨架，它不依赖任何特定模型、
+任何未经验证的榜单数字。前沿实验室用更精巧的工程去逼近同样的目标——保留
+推理状态、压缩历史为结构、区分确认与猜想——而你现在可以用两百行 Python
+从同一原理出发。差距在于打磨的深度，不在于原理的秘密。
+
+**原理从来都是公开的：把经历变成结构，把结构变成可被条件唤醒的判断。剩下
+的，就是动手了。**
+
+---
+
+## 附录：zcode 端独立验证报告（v1.0 实测）
+
+- **功能测试 8/8 通过**：learn_rule 条件绑定与可信度提升 / falsify 证伪流
+  程 / unresolved 无知记录 / retrieve 检索命中 / recent 截断 / compact 经
+  历变结构 / save-load roundtrip
+- **实测发现并已在本修正版修复的三处缺陷**：①confidence 浮点累加漂移
+  （0.7+0.1 → 0.7999…，已加 round）②falsify 不幂等（重复证伪重复记录，
+  已加查重）③重入行为未提醒（已加提醒）
+- **理论对照**：本教程七件套与白箱智能的五层记忆（锚点/结构/知识/情境/自
+  我）、条件空间必带、负记忆机制、压缩巩固**逐条同构**——教程的"条件绑定"
+  就是系列第一篇"条件空间"的入门形态，"四态判定"贯穿白箱全部能力判定。

package/docs//350/256/244/347/237/245/345/233/276_MD/347/233/256/345/275/225/346/226/271/346/241/210_v0.1.md

@@ -0,0 +1,218 @@
+# 认知图 MD 目录方案 · 设计文档
+
+> 版本：v0.1（架构决策）| 2026-09-06 | 状态：设计稿，待实现+小原型验证
+> 背景：用**结构化 md 文件 + 文件索引**替代 sqlite 存认知图。这不是"换存储引擎"，
+> 而是让认知图回归它的**本征形态**——分层的条件注释目录。
+> 依据：白箱智能五层记忆 + 条件代码图 CCG（三重注释范式）+ 第五篇"召回非全量/条件路由"。
+
+---
+
+## 0. 核心判断
+
+**认知图本来就该是"目录 + 条件注释"的文件结构，sqlite 是权宜（把它塞进关系表）。**
+- 五层记忆（layer）→ 目录层级。
+- 条件路由（召回非全量）→ 目录分区 = 条件索引。
+- CCG 条件注释（功能/生效条件/子功能/执行）→ 每个节点的统一格式。
+- md 文件 → 可审计/diff/共享/零依赖（D-005）。
+
+**md 替代 sqlite = 迁回认知图本征形态**，而非"换一个存储"。
+
+---
+
+## 1. 目录分层 Schema
+
+```
+<ROOT>/                      # 认知图根（如 ~/.agent-memory/ 或 AEIS/data/lingxu-cg/）
+├── _index.json              # 自描述：schema_version、各层节点 id→相对路径 索引
+├── anchor/                  # 锚点层（不可遗忘，保护）
+│   ├── node_<id>.md
+│   └── ...
+├── structural/              # 结构层（协议/自我/信任）
+├── knowledge/               # 知识层（经验学习，主检索层）
+│   ├── condition_<hash>/    # ★ 条件分区（按 condition_space 键归一化分桶）
+│   │   ├── node_<id>.md
+│   │   └── ...
+│   └── orphan/              # 无条件/未归桶的
+├── contextual/              # 情境层（短期，可衰减/淘汰）
+└── self/                    # 自我层（自我模型/信任状态/盲区）
+```
+
+**分层原则**：layer → 目录；condition_space → 知识层内的条件分区子目录。
+- 分区粒度：条件空间四元组 `(observation_position, observation_tool, time_window, existence_constraint)`
+  → 归一化哈希 → `condition_<hash>/`。
+- 这是**条件路由的物理索引**：查询"当前情境满足什么条件"→ 直接进对应 `condition_<hash>/`，**非全量**。
+
+---
+
+## 2. 节点文件格式（单个 .md）
+
+每个节点 = 一个 `.md`，**YAML frontmatter = 结构化字段，正文 = content（可带 CCG 注释）**。
+
+```markdown
+---
+id: node_xxx
+layer: knowledge            # anchor|structural|knowledge|contextual|self
+modality: text
+importance: 0.8
+confidence: 0.6
+condition_space:
+  observation_position: 感知系统
+  observation_tool: 图像识别
+  time_window: [1788..., 1789...]
+  existence_constraint: 协议实例运行中
+tags: [vision, subpart, head]
+spatial: {bbox: [217,51,605,310]}     # 可选
+temporal: 1788612...
+created_at: 1788612...
+semantic_coordinates: {}              # 可选
+state_attributes: {modality: image}   # 可选
+entity_id: null
+access_count: 0
+last_access: 0
+---
+# 功能名：head 部件识别
+# 生效条件：白箱观测域含 subject=人物，view_distance=全身
+# 子功能：bbox 定位 → 前景占比 → 白箱四态判定
+# 执行：返回 {bbox, verdict, fg_ratio}
+[正文 content ...]
+```
+
+**CCG 注释标记**（`MARKS`）：`功能名`/`生效条件`/`子功能`/`执行`——正文用 `# 功能名：...` 风格，
+与既有 `ccg_triple.validate` 对齐（`function/condition/subfunc/execute` 四要素齐全 = 完整）。
+
+> 白箱视角：每个节点既是"可审计的条件注释"（CCG），又是"可检索的 md"。**
+> 这是比竞争插件（deja-vu/noema 只是"存内容"）更强的理论根基。
+
+---
+
+## 3. 边（edges）表达
+
+认知图有边（part_of/causal/sequential/spatial/hierarchical/similar）。md 方案两种承载：
+
+**方案 A：节点内引用（推荐，简单）**
+每个节点 frontmatter 加：
+```yaml
+edges:                      # 出边
+  - {target: node_y, type: part_of, confidence: 0.7, verified: 0}
+  - {target: node_z, type: similar, confidence: 0.6, verified: 0}
+```
+**方案 B：独立边索引文件**（图查询强时用）
+```
+edges/<relation_type>/
+  ├── node_x.md    # 内容 = [node_x 的所有出边列表]
+  └── ...
+```
+认知图当前以节点为锚（part_of 树/联想），**方案 A 足够**（节点内引用即图的存储）。图遍历时
+加载节点→读其 edges 字段→递归。
+
+> 折中：节点内出边 + `_index.json` 建**反向引用索引**（target→source），图遍历/一致性校验用。
+
+---
+
+## 4. 条件路由索引（召回非全量，对齐现有 search_content）
+
+现有 `search_content` 是：多词 OR LIKE 预筛 + 同义词 + 二元组 Jaccard + 层过滤 + 回退全表。
+**md 版把它落地为文件索引**，保持"非全量"：
+
+```
+查询流程（对齐现有逻辑）：
+  query
+    ↓ expand_query_terms（同义词扩展）
+    ↓ 条件路由：当前情境 condition_space 归一化 → 定位 condition_<hash>/ 目录（★非全量）
+    ↓ 文件索引：_index.json（node→path）+ 内存 dict
+    ↓ content LIKE / tags 预筛（读候选目录的 md 文件，非全库）
+    ↓ 降级：LIKE 落空 → condition_<hash>/ 全桶二元组 Jaccard（非全表）
+    ↓ 评分：原查询二元组重叠率 (召回导向) 排序 → 取 top-k
+```
+
+**索引层（新增）**：
+- `_index.json`：`{node_id: rel_path, tags: {...}, layer: {...}, cond_bucket: {...}}`——主索引（内存 dict）。
+- 内容检索：读目标分区目录的 md → 内存中做 LIKE/二元组 Jaccard（分区内，非全库）。
+- 层过滤 / 最近上下文：读 `contextual/` 目录按 `created_at` 排序（目录=天然层索引）。
+
+**关键：召回永远不读全库**——先条件路由（分区），再层过滤（目录），再分区内检索。这正是第五篇"不要把整个记忆塞给 AI"。
+
+---
+
+## 5. 从 sqlite 迁移（一次性脚本）
+
+```python
+# migrate_sqlite_to_md.py
+# 1. 读现有 sqlite nodes/edges
+# 2. 对每 node：
+#    a. 按 layer 定目录（anchor/structural/knowledge/contextual/self）
+#    b. 按 condition_space 归一化哈希 → knowledge/condition_<hash>/
+#    c. 生成 .md（frontmatter 全字段 + CCG 正文）
+# 3. edges → 写回各节点的 edges 字段（方案A）
+# 4. 建 _index.json（node→path/tags/layer/cond_bucket）
+# 5. 校验：迁移后的 md 节点数 == sqlite nodes 数；抽样 10 节点字段等价
+```
+
+---
+
+## 6. 并发写（重点，灵枢多进程）
+
+sqlite 已有"写锁"（多进程共享库）。md 方案需**文件锁**替代：
+- 用 `fcntl.flock`（Unix）/ `msvcrt.locking`（Windows）锁 `_index.json`（全局写锁）。
+- 每个节点写入 = **先读-改-写**该节点 .md（单文件，原子性靠临时文件 + rename）。
+- **写优先级**：`_index.json` 更新要串行（写锁），节点文件可并行（不同节点不同文件）。
+- **回滚**：md 是文件，改错可 git/备份回滚（比 sqlite 更利于审计）。
+
+> D-005：用标准库文件锁 + 临时文件 rename，零第三方依赖。
+
+---
+
+## 7. 可信度/权重维护（对齐现有字段）
+
+节点的 `importance/confidence/access_count/last_access`——这些是**白箱可信度**（每层判定）。
+md 里 frontmatter 存这些字段，**更新 = 读-改-写该节点 md 的 frontmatter**。
+- importance 提升（保护：不可遗忘记入 anchor/ 且受保护标记）。
+- access_count/last_access 递增（读节点时更新）——写入 _index.json 或节点 md。
+
+---
+
+## 8. 优劣与风险
+
+### 优势
+1. **白箱可审计**：每个节点是 .md，直接可读/diff/共享（deja-vu/noema 验证此路线可行）。
+2. **回归本征形态**：分层目录 + 条件注释 = 认知图本就该是的结构。
+3. **零依赖 D-005**：纯标准库文件操作，无 sqlite 驱动。
+4. **条件路由非全量**：目录分区 = 条件索引，召回不读全库。
+5. **跨工具共享**：md 文件天然可被其他 agent 读（学 deja-vu/noema import）。
+
+### 代价/风险
+1. **性能**：无 SQL 索引，靠内存 dict + 分区目录——**数据量大时靠分桶 + 二级索引**（deja-vu 单 Go 二进制 msec 查 5GB 证明可行）。**需 benchmark**。
+2. **一致性**：无 sqlite 事务——**文件锁 + 临时文件 rename** 保证；多进程写要锁好 `_index.json`。
+3. **迁移成本**：一次性导出脚本 + 校验；**做之前先备份 sqlite**。
+4. **范围**：这是**灵枢核心存储**的大改——**必须小原型验证稳定后再全量**。
+
+---
+
+## 9. 分阶段实施（稳健）
+
+| 阶段 | 做什么 | 验证 |
+|---|---|---|
+| **P0（本步）** | **小原型**：一层（knowledge）→ md 目录 + _index 索引 + 条件路由检索 | 写/读/检索/边界/迁移往返/并发 全测 |
+| P1 | 迁移脚本 + 全节点落盘 md | 节点数等价 + 抽样字段等价 |
+| P2 | 接入真实检索（替换 search_content 的 sqlite 分支）| 检索结果与 sqlite 版一致 |
+| P3 | 并发锁 + benchmark + 回滚 | 多进程写稳定 + 性能达标 |
+| P4 | 全量切换（sqlite 可双写过渡）| 全量回归 |
+
+> **原则（大的修改要小心）**：P0 原型先证明"稳定+有效"，再逐阶段扩。**sqlite 保留做双写/回滚**，确认 md 稳定后才切。
+
+---
+
+## 10. 与竞争项目对照（为什么这么做是对的）
+
+| | deja-vu | dsh-noema | 本文案 (md认知图) |
+|---|---|---|---|
+| 存储 | Go 二进制索引 | 可检查 Markdown | **可检查 md + CCG 注释** |
+| 非向量 | ✅ | ✅ | ✅ |
+| 召回 | 索引检索（非全量）| 开工前 recall | **条件路由（分区命中，非全量）** |
+| 可审计 | 索引 | ✅ 文件 | ✅ 文件 + 条件注释更强 |
+| 理论根基 | 无 | 无 | **白箱五层 + 条件路由 + CCG** |
+
+**本方案优势**：md 的可检查性（学 noema）+ 非向量轻量（学 deja-vu）+ **我们独有的条件路由/CCG 白箱根基**——这是竞争项目没有的理论深度。
+
+---
+*（P0 小原型随后实现：knowledge 层 → md 目录 + _index + 条件路由检索，全面测试稳定性/有效性。）*

package/lib/hooks.js

@@ -86,8 +86,12 @@ export function installMemoryHooks(ctx, bridge, opts) {
     ctx.on('session/event', (_session, event) => {
         if (event.type === 'user/message' && opts.userMessage) {
             // 只记真实用户输入（kind='user'），跳过插件注入/系统上下文
-            if (event.data.source?.kind !== 'user')
+            if (event.data.source?.kind !== 'user') {
+                // T4 诊断（2026-08-30）：dsh 端对话零写入排查——记录被滤事件的实际
+                // source.kind（若 dsh 新版改了 kind 值，此处日志可定位）
+                ctx.logger.info(`dsh-memory: user/message 事件被滤（source.kind=${event.data.source?.kind ?? 'undefined'}）`);
                 return;
+            }
             const text = extractText(event.data.content);
             if (!text)
                 return;
@@ -95,6 +99,9 @@ export function installMemoryHooks(ctx, bridge, opts) {
             if (safe === null)
                 return;
             memorize('remember', { content: safe, importance: opts.importance, tags: ['dsh', 'user'] });
+            // T4：用用户消息做一次语义召回——触发灵枢 _note_reuse 落库（复用观测），
+            // 召回结果同时预热灵枢检索缓存（timeline 只读不触发复用统计）
+            memorize('recall', { query: safe.slice(0, 200), limit: 3 });
         }
         else if (event.type === 'assistant/message' && opts.assistantMessage) {
             const text = extractText(event.data.message.content);

package/package.json

@@ -1,77 +1,77 @@
-{
-  "name": "@furongjun1999/dsh-memory",
-  "version": "0.4.1",
-  "description": "灵枢（Lingshu·líng shū）DeepSeek Harness 插件：完整大脑——长期记忆/知识飞轮/自我认知/递归反思接入 DSH，对话自动沉淀进记忆库",
-  "type": "module",
-  "main": "lib/index.js",
-  "types": "lib/index.d.ts",
-  "exports": {
-    ".": {
-      "types": "./lib/index.d.ts",
-      "import": "./lib/index.js"
-    }
-  },
-  "files": [
-    "lib",
-    "src",
-    "README.md",
-    "cordis.yml.example",
-    "cordis.patch.yml",
-    "docs"
-  ],
-  "keywords": [
-    "deepseek",
-    "dsh",
-    "dsh-plugin",
-    "cordis",
-    "memory",
-    "agent",
-    "aeis",
-    "lingshu",
-    "multi-agent",
-    "spatiotemporal",
-    "knowledge-graph"
-  ],
-  "license": "MIT",
-  "peerDependencies": {
-    "@deepseek-ai/cordis": "^4.0.1",
-    "@deepseek-ai/dsh-llm": "^0.1.0-rc.6",
-    "@deepseek-ai/dsh-session": "^0.1.0-rc.6",
-    "@deepseek-ai/dsh-tools": "^0.1.0-rc.6",
-    "@deepseek-ai/schemastery": "^3.18.1"
-  },
-  "peerDependenciesMeta": {
-    "@deepseek-ai/dsh-llm": {
-      "optional": true
-    }
-  },
-  "devDependencies": {
-    "@deepseek-ai/cordis": "^4.0.1",
-    "@deepseek-ai/dsh-llm": "^0.1.0-rc.6",
-    "@deepseek-ai/dsh-session": "^0.1.0-rc.6",
-    "@deepseek-ai/dsh-system-prompt": "^0.1.0-rc.6",
-    "@deepseek-ai/dsh-tools": "^0.1.0-rc.6",
-    "@deepseek-ai/schemastery": "^3.0.0",
-    "@types/node": "^24.0.0",
-    "tsx": "^4.19.0",
-    "typescript": "^5.5.0"
-  },
-  "scripts": {
-    "build": "tsc -p tsconfig.json",
-    "test": "npm run build && node --import tsx --test \"test/*.test.ts\"",
-    "prepare": "npm run build",
-    "prepublishOnly": "npm run build && npm test"
-  },
-  "repository": {
-    "type": "git",
-    "url": "https://github.com/FuRongJun-1999/dsh-memory.git"
-  },
-  "engines": {
-    "node": ">=22.19"
-  },
-  "dsh": {
-    "bundle": {
-      "patch": "./cordis.patch.yml"
-    }
-  }
-}
+{
+  "name": "@furongjun1999/dsh-memory",
+  "version": "0.4.3",
+  "description": "灵枢（Lingshu·líng shū）DeepSeek Harness 插件：完整大脑——长期记忆/知识飞轮/自我认知/递归反思接入 DSH，对话自动沉淀进记忆库",
+  "type": "module",
+  "main": "lib/index.js",
+  "types": "lib/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./lib/index.d.ts",
+      "import": "./lib/index.js"
+    }
+  },
+  "files": [
+    "lib",
+    "src",
+    "README.md",
+    "cordis.yml.example",
+    "cordis.patch.yml",
+    "docs"
+  ],
+  "keywords": [
+    "deepseek",
+    "dsh",
+    "dsh-plugin",
+    "cordis",
+    "memory",
+    "agent",
+    "aeis",
+    "lingshu",
+    "multi-agent",
+    "spatiotemporal",
+    "knowledge-graph"
+  ],
+  "license": "MIT",
+  "peerDependenciesMeta": {
+    "@deepseek-ai/dsh-llm": {
+      "optional": true
+    }
+  },
+  "devDependencies": {
+    "@deepseek-ai/cordis": "^4.0.1",
+    "@deepseek-ai/dsh-llm": "^0.1.0-rc.6",
+    "@deepseek-ai/dsh-session": "^0.1.0-rc.6",
+    "@deepseek-ai/dsh-system-prompt": "^0.1.0-rc.6",
+    "@deepseek-ai/dsh-tools": "^0.1.0-rc.6",
+    "@deepseek-ai/schemastery": "^3.0.0",
+    "@types/node": "^24.0.0",
+    "tsx": "^4.19.0",
+    "typescript": "^5.5.0"
+  },
+  "scripts": {
+    "build": "tsc -p tsconfig.json",
+    "test": "npm run build && node --import tsx --test \"test/*.test.ts\"",
+    "prepare": "npm run build",
+    "prepublishOnly": "npm run build && npm test"
+  },
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/FuRongJun-1999/dsh-memory.git"
+  },
+  "engines": {
+    "node": ">=22.19"
+  },
+  "dsh": {
+    "bundle": {
+      "patch": "./cordis.patch.yml"
+    }
+  },
+  "dependencies": {
+    "@deepseek-ai/cordis": "^4.0.1",
+    "@deepseek-ai/dsh-llm": "^0.1.0-rc.6",
+    "@deepseek-ai/dsh-session": "^0.1.0-rc.6",
+    "@deepseek-ai/dsh-tools": "^0.1.0-rc.6",
+    "@deepseek-ai/schemastery": "^3.18.1"
+  }
+}

package/src/hooks.ts

@@ -114,12 +114,20 @@ export function installMemoryHooks(ctx: Context, bridge: LingshuBridge, opts: Me
   ctx.on('session/event', (_session, event: SessionEvent) => {
     if (event.type === 'user/message' && opts.userMessage) {
       // 只记真实用户输入（kind='user'），跳过插件注入/系统上下文
-      if (event.data.source?.kind !== 'user') return
+      if (event.data.source?.kind !== 'user') {
+        // T4 诊断（2026-08-30）：dsh 端对话零写入排查——记录被滤事件的实际
+        // source.kind（若 dsh 新版改了 kind 值，此处日志可定位）
+        ctx.logger.info(`dsh-memory: user/message 事件被滤（source.kind=${event.data.source?.kind ?? 'undefined'}）`)
+        return
+      }
       const text = extractText(event.data.content)
       if (!text) return
       const safe = sanitize(text)  // 脱敏：纯凭据消息 → null → 跳过写入
       if (safe === null) return
       memorize('remember', { content: safe, importance: opts.importance, tags: ['dsh', 'user'] })
+      // T4：用用户消息做一次语义召回——触发灵枢 _note_reuse 落库（复用观测），
+      // 召回结果同时预热灵枢检索缓存（timeline 只读不触发复用统计）
+      memorize('recall', { query: safe.slice(0, 200), limit: 3 })
     } else if (event.type === 'assistant/message' && opts.assistantMessage) {
       const text = extractText(event.data.message.content)
       if (!text) return