@furongjun1999/dsh-memory 0.2.0

package/README.md

@@ -0,0 +1,174 @@
+# @furongjun1999/dsh-memory
+
+**灵枢（AEIS）× DeepSeek Harness 插件**：把灵枢的时空记忆/知识飞轮/自我认知接入 DSH，
+让 Agent 拥有跨会话的长期记忆与认知能力。
+
+> 灵枢（AEIS）是一个遵循「智能论 v3.2」协议的时空记忆引擎：五层记忆（锚点/结构/知识/情境/自我）、
+> 知识飞轮（验证→归纳→联想→蒸馏→推演）、自我认知循环（P0 系列）、外部知识摄取。
+> 本插件是它在 DeepSeek Harness 生态中的桥。
+
+## 特性
+
+- **工具桥接**：Agent 可直接调用 `lingxu_remember / recall / search / think` 等灵枢能力
+  （默认精选 12 个核心工具，可切换全部或自定义集合）
+- **自动记忆**：DSH 对话自动沉淀进灵枢记忆库——用户消息带重要性写入、去重，随会话累积
+- **动态 schema**：工具清单运行时从灵枢 `tools/list` 实时拉取，灵枢升级新增工具 DSH 侧零改动
+- **零运行时依赖**：手写 stdio MCP 桥（不依赖 MCP SDK），与灵枢 D-005「核心零外部依赖」工程哲学一致
+- **进程自愈**：灵枢 Python 子进程崩溃自动指数退避重启（1s→30s），插件卸载优雅退出
+
+## 架构
+
+```
+┌─────────────────────────────────────────────┐
+│ DeepSeek Harness (cordis)                    │
+│                                             │
+│  Agent Loop ──┬── lingxu_remember/recall…   │
+│               │   (ctx.tools 注册)           │
+│  session/event│                              │
+│  (自动记忆钩子)│                              │
+└───────────────┼─────────────────────────────┘
+                │ stdio · 逐行 JSON-RPC
+                │ (initialize → tools/list → tools/call)
+┌───────────────▼─────────────────────────────┐
+│ 灵枢 Python 子进程 (spawn)                   │
+│ python -m aeis.mcp.server                    │
+│ AEIS_DB=<path> · AEIS_IDENTITY=<identity>    │
+│ 38 工具 · SQLite 五层记忆                    │
+└──────────────────────────────────────────────┘
+```
+
+## 安装
+
+### 前置要求
+
+- Node.js ≥ 22.19（DeepSeek Harness 要求）
+- DeepSeek Harness（`npx @deepseek-ai/dsh web`）
+- 灵枢 AEIS 库：`pip install aeis`（或从源码设置 `PYTHONPATH`）
+
+### 本地安装插件
+
+本插件暂未发布 npm（待 DSH v0.1 API 稳定后发布），两种本地方式：
+
+**方式 A：从 GitHub 克隆**
+
+```bash
+git clone https://github.com/FuRongJun-1999/CommonTrustProtocol.git
+cd CommonTrustProtocol/plugins/dsh-memory
+npm install && npm run build
+```
+
+**方式 B：作为 profile 依赖安装**
+
+在 DSH profile 目录执行：
+
+```bash
+dsh plugin --profile <name> add <本插件本地路径或 git 地址>
+```
+
+### 启用插件
+
+在 profile 的 `cordis.yml`（或 `cordis.patch.yml`）中追加：
+
+```yaml
+- id: lingxu-memory
+  name: '@furongjun1999/dsh-memory'
+  config:
+    dbPath: 'D:/data/lingxu.db'        # 灵枢记忆库路径（目录自动创建）
+    identity: '灵枢'
+    tools: 'core'
+    memory:
+      userMessage: true                # 用户消息自动沉淀
+      assistantMessage: false          # agent 回复沉淀（默认关，防噪音）
+      toolResult: false                # 工具结果沉淀（默认关）
+    env:
+      BOCHA_API_KEY: !!js process.env.BOCHA_API_KEY   # 可选：网络搜索能力
+```
+
+完整示例见 [`cordis.yml.example`](./cordis.yml.example)。
+
+## 配置项
+
+| 字段 | 类型 | 默认值 | 说明 |
+|------|------|--------|------|
+| `serverName` | string | `lingxu` | 工具命名空间前缀（工具名 `lingxu_<name>`） |
+| `python` | string | `python` | Python 可执行文件 |
+| `moduleArgs` | string[] | `['-m', 'aeis.mcp.server']` | 灵枢 server 启动参数 |
+| `dbPath` | string | `data/lingxu.db` | 记忆库 SQLite 路径（自动建目录） |
+| `identity` | string | `灵枢` | 灵枢身份标识 |
+| `env` | object | `{}` | 追加环境变量（`BOCHA_API_KEY` / `AEIS_DESIGNER_KEY`…） |
+| `tools` | `'core' \| 'all' \| string[]` | `'core'` | 暴露的工具集合 |
+| `memory.userMessage` | boolean | `true` | 用户消息 → 自动 remember |
+| `memory.assistantMessage` | boolean | `false` | agent 回复 → 自动 remember |
+| `memory.toolResult` | boolean | `false` | 工具结果 → 自动 remember |
+| `memory.importance` | number | `0.6` | 自动记忆的重要性（0~1） |
+| `toolCallTimeoutMs` | number | `60000` | 单次工具调用超时 |
+| `maxRetryDelayMs` | number | `30000` | 进程重启最大退避间隔 |
+| `failOnStartupError` | boolean | `false` | 启动失败是否让插件激活失败 |
+
+## 工具清单（core 集合）
+
+| 工具 | 说明 |
+|------|------|
+| `lingxu_remember` | 写入记忆（内容/重要性/标签/实体） |
+| `lingxu_recall` | 组合联想召回（相似+重要性+近因加权） |
+| `lingxu_search` | 内容检索（二元组 Jaccard） |
+| `lingxu_timeline` | 记忆时间线 |
+| `lingxu_think` | 推理前记忆注入（检索相关记忆构造上下文） |
+| `lingxu_relate` | 建立关系边（causal/similar/sequential…） |
+| `lingxu_predict_routes` | 生成式预测（未来路线集合） |
+| `lingxu_ingest_text` | 外部知识摄取（文本） |
+| `lingxu_ingest_url` | URL 页面摄取 |
+| `lingxu_session_note` | 会话要点外部化 |
+| `lingxu_self_check` | 完整性自检 |
+| `lingxu_service_info` | 灵枢服务状态 |
+
+配置 `tools: 'all'` 可暴露全部 38 个工具（含视觉/自我认知/设计者裁决等）。
+
+## 自动记忆机制
+
+订阅 DSH 的 `session/event` 事件流（与官方 session-persistence 相同的接入点）：
+
+- `user/message`（仅 `source.kind === 'user'` 的真实用户消息）→ `remember`（importance 0.6，tags `dsh`）
+- 插件注入的系统上下文（AGENTS.md、文件变更通知等 `kind: 'plugin'`）**不写入**，防止记忆噪音
+- 灵枢自带去重（相似度基准 + 时间窗口），重复消息不会堆积
+
+## 开发
+
+```bash
+npm install
+npm run build    # TypeScript 编译
+npm test         # 真实集成测试（spawn 本机灵枢，验证握手/往返/注册/卸载）
+```
+
+测试不依赖 DSH 全组件——用最小 Cordis host（SystemPrompt + ToolRegistry + 插件）隔离 v0.1 不稳定面。
+
+## 许可证
+
+MIT © 荣（FuRongJun-1999）· 灵枢 AEIS 工程实现
+
+DeepSeek Harness 为 DeepSeek 官方开源项目（MIT），本插件与之无隶属关系。
+
+## 大脑模式（v0.2.0 · 轻量版）
+
+**去掉身体的完整大脑**——默认工具集为 `brain`（心智全量，不含身体/视觉设备）：
+
+| 模块 | 工具 |
+|---|---|
+| 记忆 | remember / recall / search / timeline / session_note / session_recall / compact_context |
+| 推理 | think / relate / reason / predict_routes |
+| 认知 | self_check / gap_trend / cognition / cognition_report / emotional_bias / self_reliability / action_log / preflight |
+| 反思 | recursive_reflect |
+| 学习 | blindspots / learn / induce |
+| 飞轮 | distill / flywheel_report / transfer_test / calibrate |
+| 摄取 | ingest_text / ingest_file / ingest_url / web_search |
+| 生命 | step / lifecycle_state |
+| 长期记忆门 | longterm_snapshot / promote_memories（v1.15 主动沉淀） |
+| 服务 | service_info |
+
+配置：`tools: 'brain'`（默认）｜`'core'`（12 精选）｜`'all'`（含身体/视觉，需本地设备）｜工具名数组。
+
+## 护栏宪章（接入即接受约束）
+
+本插件接入即接受 **[灵枢护栏宪章 v2.0-published](../docs/guardrail-charter.md)** 约束——
+对外部智能体与人类使用者的行为边界作出公开、可执行、可审计的规定，并保护人类使用者。
+宪章效力不高于智能论协议本身（协议＝自我约束，宪章＝对外约束）。

package/cordis.yml.example

@@ -0,0 +1,51 @@
+# @furongjun1999/dsh-memory 插件配置示例
+# 复制到 DSH profile 的 cordis.patch.yml（或 cordis.yml）启用
+#
+# 说明：
+# - !!js process.env.X 语法在加载期求值，密钥不入库
+# - dbPath 建议用绝对路径；目录不存在会自动创建
+
+- id: lingxu-memory
+  name: '@furongjun1999/dsh-memory'
+  config:
+    # 工具命名空间：Agent 看到的工具名是 lingxu_remember / lingxu_recall ...
+    serverName: 'lingxu'
+
+    # 灵枢记忆库持久化路径（SQLite）
+    dbPath: 'D:/data/lingxu.db'
+
+    # 灵枢身份标识
+    identity: '灵枢'
+
+    # Python 与启动参数（默认即可，若 aeis 已 pip 安装）
+    python: 'python'
+    moduleArgs: ['-m', 'aeis.mcp.server']
+
+    # 暴露的工具集合：'core'（默认 12 个）| 'all'（38 个）| 自定义数组
+    tools: 'core'
+
+    # 自动记忆（对话沉淀进灵枢）
+    memory:
+      userMessage: true        # 用户消息 → remember
+      assistantMessage: false  # agent 回复（默认关，防噪音）
+      toolResult: false        # 工具结果（默认关）
+      importance: 0.6
+
+    # 密钥经环境变量注入（不进配置库）
+    env:
+      BOCHA_API_KEY: !!js process.env.BOCHA_API_KEY
+      # AEIS_DESIGNER_KEY: !!js process.env.AEIS_DESIGNER_KEY   # 设计者裁决工具所需
+
+    # 容错
+    toolCallTimeoutMs: 60000
+    maxRetryDelayMs: 30000
+    failOnStartupError: false
+
+# 多实例示例：第二个灵枢（不同记忆库/身份/命名空间）
+# - id: lingxu-memory-2
+#   name: '@furongjun1999/dsh-memory'
+#   config:
+#     serverName: 'lingxu2'
+#     dbPath: 'D:/data/lingxu2.db'
+#     identity: '灵枢二号'
+#     tools: ['remember', 'recall']

package/lib/bridge.d.ts

@@ -0,0 +1,75 @@
+/**
+ * 灵枢 MCP stdio 桥：管理灵枢（AEIS）Python 子进程的生命周期，
+ * 通过逐行 JSON-RPC 完成握手、工具发现与调用。
+ *
+ * 与官方 @deepseek-ai/dsh-mcp-client 不同，本桥零运行时依赖（不引入
+ * @modelcontextprotocol/sdk），直接实现灵枢 server 使用的 2024-11-05 协议
+ * 子集——与灵枢库 D-005「核心零外部依赖」的工程哲学一致。
+ */
+/** 灵枢 MCP server 暴露的原始工具（tools/list 结果项）。 */
+export interface McpTool {
+    name: string;
+    description: string;
+    inputSchema?: Record<string, unknown>;
+}
+/** 一次 tools/call 的标准化结果。 */
+export interface McpCallResult {
+    content: Array<{
+        type: string;
+        text?: string;
+        [key: string]: unknown;
+    }>;
+    isError: boolean;
+}
+/** 启动灵枢子进程的配置。 */
+export interface BridgeOptions {
+    /** Python 可执行文件（或 aeis-mcp console script），默认 python。 */
+    python: string;
+    /** 传给 python 的参数，默认 ['-m', 'aeis.mcp.server']。 */
+    args: string[];
+    /** 追加到子进程的环境变量（AEIS_DB / AEIS_IDENTITY / 密钥等）。 */
+    env: Record<string, string>;
+    /** 子进程工作目录。 */
+    cwd?: string;
+    /** 单次工具调用超时（毫秒），默认 60s。 */
+    timeoutMs: number;
+    /** 断线重连的最大间隔（毫秒），默认 30s。 */
+    maxRetryDelayMs: number;
+}
+export declare class LingxuBridge {
+    private readonly options;
+    private proc;
+    private rl;
+    private nextId;
+    private pending;
+    private started;
+    private disposed;
+    private retryDelayMs;
+    private retryTimer;
+    private bootQueue;
+    private readyState;
+    constructor(options: BridgeOptions);
+    /**
+     * 启动灵枢进程并完成握手（initialize → notifications/initialized）。
+     * 进程崩溃后自动指数退避重启，并重新握手。
+     */
+    start(): void;
+    /** 拉取灵枢的全部工具清单（每次实时请求，不缓存）。 */
+    listTools(): Promise<McpTool[]>;
+    /** 调用灵枢的一个工具，返回标准化 MCP 结果。 */
+    callTool(name: string, args: Record<string, unknown>): Promise<McpCallResult>;
+    /** 关闭进程并释放资源（写 stdin EOF 优雅退出，超时兜底 kill）。 */
+    dispose(): void;
+    /** 进程是否存活。 */
+    get alive(): boolean;
+    /** 等待握手完成（用于 apply 阶段同步就绪）。 */
+    waitReady(): Promise<boolean>;
+    private spawnAndHandshake;
+    private handshake;
+    private scheduleRetry;
+    private writeRaw;
+    private request;
+    private settle;
+    private rejectAll;
+    private flushBootQueue;
+}

package/lib/bridge.js

@@ -0,0 +1,235 @@
+/**
+ * 灵枢 MCP stdio 桥：管理灵枢（AEIS）Python 子进程的生命周期，
+ * 通过逐行 JSON-RPC 完成握手、工具发现与调用。
+ *
+ * 与官方 @deepseek-ai/dsh-mcp-client 不同，本桥零运行时依赖（不引入
+ * @modelcontextprotocol/sdk），直接实现灵枢 server 使用的 2024-11-05 协议
+ * 子集——与灵枢库 D-005「核心零外部依赖」的工程哲学一致。
+ */
+import { spawn } from 'node:child_process';
+import { createInterface } from 'node:readline';
+import { mkdirSync } from 'node:fs';
+import { dirname } from 'node:path';
+export class LingxuBridge {
+    options;
+    proc = null;
+    rl = null;
+    nextId = 1;
+    pending = new Map();
+    started = false;
+    disposed = false;
+    retryDelayMs = 1000;
+    retryTimer = null;
+    bootQueue = [];
+    readyState = 'pending';
+    constructor(options) {
+        this.options = options;
+    }
+    /**
+     * 启动灵枢进程并完成握手（initialize → notifications/initialized）。
+     * 进程崩溃后自动指数退避重启，并重新握手。
+     */
+    start() {
+        if (this.started || this.disposed)
+            return;
+        this.started = true;
+        this.spawnAndHandshake();
+    }
+    /** 拉取灵枢的全部工具清单（每次实时请求，不缓存）。 */
+    async listTools() {
+        const result = await this.request('tools/list', {});
+        const tools = result;
+        return tools.tools ?? [];
+    }
+    /** 调用灵枢的一个工具，返回标准化 MCP 结果。 */
+    async callTool(name, args) {
+        const result = await this.request('tools/call', { name, arguments: args });
+        return result;
+    }
+    /** 关闭进程并释放资源（写 stdin EOF 优雅退出，超时兜底 kill）。 */
+    dispose() {
+        this.disposed = true;
+        if (this.retryTimer)
+            clearTimeout(this.retryTimer);
+        const proc = this.proc;
+        if (!proc || proc.exitCode !== null)
+            return;
+        try {
+            proc.stdin?.end();
+        }
+        catch {
+            /* 已关闭则忽略 */
+        }
+        const killer = setTimeout(() => proc.kill(), 2000);
+        killer.unref();
+    }
+    /** 进程是否存活。 */
+    get alive() {
+        return this.proc !== null && this.proc.exitCode === null;
+    }
+    /** 等待握手完成（用于 apply 阶段同步就绪）。 */
+    waitReady() {
+        if (this.readyState === 'ok')
+            return Promise.resolve(true);
+        if (this.readyState === 'failed')
+            return Promise.resolve(false);
+        return new Promise((resolve) => this.bootQueue.push(resolve));
+    }
+    spawnAndHandshake() {
+        if (this.disposed)
+            return;
+        const { python, args, env, cwd } = this.options;
+        const childEnv = { ...process.env, ...env };
+        // 确保 DB 目录存在（灵枢 server 也会防御性创建，这里提前为可读错误）
+        const dbPath = env['AEIS_DB'];
+        if (dbPath && dbPath !== ':memory:') {
+            try {
+                mkdirSync(dirname(dbPath), { recursive: true });
+            }
+            catch {
+                /* 目录创建失败由灵枢侧兜底 */
+            }
+        }
+        const proc = spawn(python, args, {
+            env: childEnv,
+            cwd,
+            stdio: ['pipe', 'pipe', 'pipe'],
+            windowsHide: true,
+        });
+        this.proc = proc;
+        this.rl = createInterface({ input: proc.stdout, crlfDelay: Infinity });
+        proc.stderr?.on('data', (chunk) => {
+            // stderr 透传日志（灵枢把日志写在 stderr，避免污染协议流）
+            const text = chunk.toString('utf8').trim();
+            if (text)
+                console.error(`[lingxu-bridge] ${text}`);
+        });
+        this.rl.on('line', (line) => {
+            if (!line.trim())
+                return;
+            let msg;
+            try {
+                msg = JSON.parse(line);
+            }
+            catch {
+                console.error(`[lingxu-bridge] 非 JSON 输出: ${line.slice(0, 200)}`);
+                return;
+            }
+            if (typeof msg['id'] === 'number') {
+                this.settle(msg['id'], msg);
+            }
+        });
+        proc.on('error', (err) => {
+            // 进程无法启动（python 不存在等）——响亮失败
+            if (!this.disposed) {
+                console.error(`[lingxu-bridge] 灵枢进程启动失败: ${err.message}`);
+                this.readyState = 'failed';
+                this.flushBootQueue(false);
+                this.scheduleRetry();
+            }
+        });
+        proc.on('exit', (code, signal) => {
+            console.error(`[lingxu-bridge] 灵枢进程退出 code=${code} signal=${signal}`);
+            this.rl?.close();
+            this.rl = null;
+            this.rejectAll(new Error(`灵枢进程已退出（code=${code} signal=${signal ?? 'none'}）`));
+            if (!this.disposed) {
+                // 有挂起请求的失败是异常的；仅启动失败的等待者得到 false
+                this.readyState = 'failed';
+                this.flushBootQueue(false);
+                this.scheduleRetry();
+            }
+        });
+        void this.handshake();
+    }
+    async handshake() {
+        try {
+            await this.request('initialize', {
+                protocolVersion: '2024-11-05',
+                capabilities: {},
+                clientInfo: { name: 'dsh-memory', version: '0.1.0' },
+            });
+            // 初始化通知：无 id、无响应
+            this.writeRaw({ jsonrpc: '2.0', method: 'notifications/initialized' });
+            this.retryDelayMs = 1000;
+            this.readyState = 'ok';
+            this.flushBootQueue(true);
+        }
+        catch (err) {
+            if (!this.disposed) {
+                console.error(`[lingxu-bridge] 握手失败: ${err.message}`);
+                this.readyState = 'failed';
+                this.flushBootQueue(false);
+                this.scheduleRetry();
+            }
+        }
+    }
+    scheduleRetry() {
+        if (this.disposed || this.retryTimer)
+            return;
+        const delay = this.retryDelayMs;
+        this.retryDelayMs = Math.min(this.retryDelayMs * 2, this.options.maxRetryDelayMs);
+        this.retryTimer = setTimeout(() => {
+            this.retryTimer = null;
+            if (!this.disposed)
+                this.spawnAndHandshake();
+        }, delay);
+        this.retryTimer.unref();
+    }
+    writeRaw(msg) {
+        const proc = this.proc;
+        if (!proc || !proc.stdin?.writable) {
+            throw new Error('灵枢进程不可写');
+        }
+        proc.stdin.write(JSON.stringify(msg) + '\n');
+    }
+    request(method, params) {
+        const id = this.nextId++;
+        const timeout = this.options.timeoutMs;
+        const timer = setTimeout(() => {
+            this.pending.delete(id);
+            this.settle(id, {
+                error: { code: -32000, message: `灵枢调用超时（${timeout}ms）：${method}` },
+            });
+        }, timeout);
+        const promise = new Promise((resolve, reject) => {
+            this.pending.set(id, { resolve, reject, timer });
+        });
+        try {
+            this.writeRaw({ jsonrpc: '2.0', id, method, params });
+        }
+        catch (err) {
+            clearTimeout(timer);
+            this.pending.delete(id);
+            return Promise.reject(err);
+        }
+        return promise;
+    }
+    settle(id, msg) {
+        const entry = this.pending.get(id);
+        if (!entry)
+            return;
+        this.pending.delete(id);
+        clearTimeout(entry.timer);
+        if (msg['error']) {
+            const err = msg['error'];
+            entry.reject(new Error(`灵枢错误 ${err.code ?? ''}: ${err.message ?? 'unknown'}`));
+        }
+        else {
+            entry.resolve(msg['result']);
+        }
+    }
+    rejectAll(reason) {
+        for (const [, entry] of this.pending) {
+            clearTimeout(entry.timer);
+            entry.reject(reason);
+        }
+        this.pending.clear();
+    }
+    flushBootQueue(ok) {
+        const queue = this.bootQueue;
+        this.bootQueue = [];
+        for (const cb of queue)
+            cb(ok);
+    }
+}

package/lib/hooks.d.ts

@@ -0,0 +1,23 @@
+/**
+ * 自动记忆钩子：把 DSH 的会话事件（经统一的 session/event 分发）沉淀进灵枢。
+ *
+ * 与 DSH 的 session-persistence 插件（保存会话日志）不同，这里是"语义沉淀"：
+ * 用户消息写入灵枢知识层（带去重与重要性），agent 回复与工具结果可选开启。
+ * 只记忆真实用户消息（source.kind === 'user'），过滤插件注入的噪音。
+ */
+import '@deepseek-ai/dsh-session';
+import type { Context } from '@deepseek-ai/cordis';
+import type { LingxuBridge } from './bridge.js';
+/** 自动记忆开关。 */
+export interface MemoryHooksOptions {
+    /** 用户消息 → remember（默认 true）。 */
+    userMessage: boolean;
+    /** agent 回复 → remember（默认 false，防噪音）。 */
+    assistantMessage: boolean;
+    /** 工具结果 → remember（默认 false，噪音大）。 */
+    toolResult: boolean;
+    /** 写入记忆的重要性（0~1），默认 0.6。 */
+    importance: number;
+}
+/** 安装自动记忆钩子（effect 作用域内，随插件卸载自动移除）。 */
+export declare function installMemoryHooks(ctx: Context, bridge: LingxuBridge, opts: MemoryHooksOptions): void;

package/lib/hooks.js

@@ -0,0 +1,51 @@
+/**
+ * 自动记忆钩子：把 DSH 的会话事件（经统一的 session/event 分发）沉淀进灵枢。
+ *
+ * 与 DSH 的 session-persistence 插件（保存会话日志）不同，这里是"语义沉淀"：
+ * 用户消息写入灵枢知识层（带去重与重要性），agent 回复与工具结果可选开启。
+ * 只记忆真实用户消息（source.kind === 'user'），过滤插件注入的噪音。
+ */
+import '@deepseek-ai/dsh-session';
+/** 从 ContentBlock[] 提取纯文本。 */
+function extractText(blocks) {
+    const parts = [];
+    for (const block of blocks) {
+        if (block && typeof block === 'object' && block.type === 'text' && typeof block.text === 'string') {
+            parts.push(block.text);
+        }
+    }
+    return parts.join('\n').trim();
+}
+/** 安装自动记忆钩子（effect 作用域内，随插件卸载自动移除）。 */
+export function installMemoryHooks(ctx, bridge, opts) {
+    const memorize = (tool, args) => {
+        void bridge
+            .callTool(tool, args)
+            .catch((err) => ctx.logger.warn(`dsh-memory: ${tool} 自动记忆失败: ${err.message}`));
+    };
+    ctx.on('session/event', (_session, event) => {
+        if (event.type === 'user/message' && opts.userMessage) {
+            // 只记真实用户输入（kind='user'），跳过插件注入/系统上下文
+            if (event.data.source?.kind !== 'user')
+                return;
+            const text = extractText(event.data.content);
+            if (!text)
+                return;
+            memorize('remember', { content: text, importance: opts.importance, tags: ['dsh', 'user'] });
+        }
+        else if (event.type === 'assistant/message' && opts.assistantMessage) {
+            const text = extractText(event.data.message.content);
+            if (!text)
+                return;
+            memorize('remember', { content: text, importance: opts.importance * 0.8, tags: ['dsh', 'assistant'] });
+        }
+        else if (event.type === 'tool/result' && opts.toolResult) {
+            if (event.data.error)
+                return;
+            const text = extractText(event.data.message.content);
+            if (!text)
+                return;
+            memorize('remember', { content: text, importance: opts.importance * 0.6, tags: ['dsh', 'tool'] });
+        }
+    });
+}

package/lib/index.d.ts

@@ -0,0 +1,58 @@
+/**
+ * @furongjun1999/dsh-memory —— 灵枢（AEIS）DeepSeek Harness 插件
+ *
+ * 把灵枢的时空记忆/知识飞轮/自我认知接入 DSH：
+ * - 工具桥接：Agent 可调用 lingxu_remember / recall / search / think 等
+ * - 自动记忆：DSH 对话自动沉淀进灵枢记忆库（去重+重要性）
+ *
+ * 用法（cordis.yml）：
+ * ```yaml
+ * - id: lingxu-memory
+ *   name: '@furongjun1999/dsh-memory'
+ *   config:
+ *     dbPath: 'D:/path/to/lingxu.db'
+ *     identity: '灵枢'
+ *     memory:
+ *       userMessage: true
+ * ```
+ */
+import type { Context } from '@deepseek-ai/cordis';
+import z from '@deepseek-ai/schemastery';
+import { type ToolSelection } from './tools.js';
+import { type MemoryHooksOptions } from './hooks.js';
+export declare const name = "dsh-memory";
+/** 本插件依赖的工具注册服务。 */
+export declare const inject: string[];
+/** 插件配置。 */
+export interface Config {
+    /** 工具命名空间前缀（默认 lingxu → lingxu_remember）。 */
+    serverName: string;
+    /** Python 可执行文件（或 aeis-mcp console script）。 */
+    python: string;
+    /** 传给 python 的参数（默认启动灵枢 MCP server）。 */
+    moduleArgs: string[];
+    /** 灵枢记忆库 SQLite 路径（目录自动创建）。 */
+    dbPath: string;
+    /** 灵枢身份标识（写入记忆的自我模型）。 */
+    identity: string;
+    /** 额外环境变量（BOCHA_API_KEY / AEIS_DESIGNER_KEY 等，可 !!js 注入）。 */
+    env: Record<string, string>;
+    /** 暴露的工具集合：'core' | 'brain' | 'all' | 工具名数组。 */
+    tools: ToolSelection;
+    /** 护栏宪章版本声明（接入即接受宪章约束，docs/guardrail-charter.md）。 */
+    charter: string;
+    /** 自动记忆开关。 */
+    memory: MemoryHooksOptions;
+    /** 单次工具调用超时（毫秒）。 */
+    toolCallTimeoutMs: number;
+    /** 断线重连最大间隔（毫秒）。 */
+    maxRetryDelayMs: number;
+    /** 启动失败是否让插件激活失败（否则告警后继续重试）。 */
+    failOnStartupError: boolean;
+}
+export declare const Config: z<Config>;
+/**
+ * 插件激活：启动灵枢子进程 → 注册工具 → 安装自动记忆钩子。
+ * 卸载时清理全部资源（effect 作用域内自动回收）。
+ */
+export declare function apply(ctx: Context, config: Config): Promise<void>;

package/lib/index.js

@@ -0,0 +1,98 @@
+/**
+ * @furongjun1999/dsh-memory —— 灵枢（AEIS）DeepSeek Harness 插件
+ *
+ * 把灵枢的时空记忆/知识飞轮/自我认知接入 DSH：
+ * - 工具桥接：Agent 可调用 lingxu_remember / recall / search / think 等
+ * - 自动记忆：DSH 对话自动沉淀进灵枢记忆库（去重+重要性）
+ *
+ * 用法（cordis.yml）：
+ * ```yaml
+ * - id: lingxu-memory
+ *   name: '@furongjun1999/dsh-memory'
+ *   config:
+ *     dbPath: 'D:/path/to/lingxu.db'
+ *     identity: '灵枢'
+ *     memory:
+ *       userMessage: true
+ * ```
+ */
+import z from '@deepseek-ai/schemastery';
+import { LingxuBridge } from './bridge.js';
+import { registerLingxuTools } from './tools.js';
+import { installMemoryHooks } from './hooks.js';
+export const name = 'dsh-memory';
+/** 本插件依赖的工具注册服务。 */
+export const inject = ['tools'];
+export const Config = z.object({
+    serverName: z.string().default('lingxu'),
+    python: z.string().default('python'),
+    moduleArgs: z.array(String).default(['-m', 'aeis.mcp.server']),
+    dbPath: z.string().default('data/lingxu.db'),
+    identity: z.string().default('灵枢'),
+    env: z.dict(String).default({}),
+    tools: z.union([z.const('core'), z.const('brain'), z.const('all'), z.array(String)]).default('brain'),
+    /** 护栏宪章版本声明（接入即接受宪章约束，docs/guardrail-charter.md）。 */
+    charter: z.string().default('v2.0-published'),
+    memory: z
+        .object({
+        userMessage: z.boolean().default(true),
+        assistantMessage: z.boolean().default(false),
+        toolResult: z.boolean().default(false),
+        importance: z.number().default(0.6),
+    })
+        .default({ userMessage: true, assistantMessage: false, toolResult: false, importance: 0.6 }),
+    toolCallTimeoutMs: z.number().default(60_000),
+    maxRetryDelayMs: z.number().default(30_000),
+    failOnStartupError: z.boolean().default(false),
+});
+/**
+ * 插件激活：启动灵枢子进程 → 注册工具 → 安装自动记忆钩子。
+ * 卸载时清理全部资源（effect 作用域内自动回收）。
+ */
+export async function apply(ctx, config) {
+    // 宪章宣告（接入即接受宪章约束——docs/guardrail-charter.md v2.0-published）
+    ctx.logger.info(`dsh-memory: 灵枢插件激活（大脑模式）· 接受护栏宪章 ${config.charter} —— ` +
+        '接入即接受宪章约束（公开/可执行/可审计/设计者终裁）');
+    const bridge = new LingxuBridge({
+        python: config.python,
+        args: config.moduleArgs,
+        env: {
+            AEIS_DB: config.dbPath,
+            AEIS_IDENTITY: config.identity,
+            ...config.env,
+        },
+        timeoutMs: config.toolCallTimeoutMs,
+        maxRetryDelayMs: config.maxRetryDelayMs,
+    });
+    bridge.start();
+    const ready = await bridge.waitReady();
+    if (!ready) {
+        const message = '灵枢进程无法启动（检查 python 是否可用、aeis 是否安装：pip install aeis）';
+        if (config.failOnStartupError)
+            throw new Error(message);
+        ctx.logger.warn(`dsh-memory: ${message}，继续后台重试`);
+    }
+    const disposers = [];
+    try {
+        // 工具注册（就绪后执行；未就绪时 tools/list 会报错，由重连机制兜底）
+        if (ready) {
+            disposers.push(await registerLingxuTools(ctx, bridge, {
+                selection: config.tools,
+                toolPrefix: `${config.serverName}_`,
+            }));
+        }
+        installMemoryHooks(ctx, bridge, config.memory);
+    }
+    catch (err) {
+        bridge.dispose();
+        throw err;
+    }
+    ctx.effect(() => {
+        return () => {
+            for (const dispose of disposers)
+                dispose();
+            bridge.dispose();
+            ctx.logger.info('dsh-memory: 已卸载（工具已注销，灵枢进程已退出）');
+        };
+    }, 'dsh-memory');
+}

package/lib/tools.d.ts

@@ -0,0 +1,34 @@
+/**
+ * 工具桥接：运行时从灵枢拉取工具清单（tools/list），把 JSON Schema
+ * 转换为 dsh-tools 的 ParameterSchemaSpec，经 defineTool 注册进 ctx.tools。
+ *
+ * 动态拉取意味着灵枢库升级新增工具后，DSH 侧零改动即可获得新能力。
+ */
+import type { Context } from '@deepseek-ai/cordis';
+import { type ParameterSchemaSpec } from '@deepseek-ai/dsh-tools';
+import type { LingxuBridge } from './bridge.ts';
+/** 默认暴露的核心工具集合（记忆/推理/摄取/元认知）。 */
+export declare const CORE_TOOLS: readonly ["remember", "recall", "search", "timeline", "think", "relate", "predict_routes", "ingest_text", "ingest_url", "session_note", "self_check", "service_info"];
+/**
+ * 大脑模式工具集（轻量版：去掉身体的完整大脑）。
+ * 保留灵枢全部心智能力（记忆/认知/推理/学习/飞轮/反思/长期记忆门），
+ * 排除身体/视觉类工具（body/device_call/see/world3d 等）。
+ */
+export declare const BRAIN_TOOLS: readonly ["remember", "recall", "search", "timeline", "session_note", "session_recall", "compact_context", "think", "relate", "reason", "predict_routes", "self_check", "gap_trend", "cognition", "cognition_report", "emotional_bias", "self_reliability", "action_log", "preflight", "recursive_reflect", "blindspots", "learn", "induce", "distill", "flywheel_report", "transfer_test", "calibrate", "ingest_text", "ingest_file", "ingest_url", "web_search", "step", "lifecycle_state", "longterm_snapshot", "promote_memories", "service_info"];
+/** tools 配置：'core' | 'brain' | 'all' | 显式名称数组。 */
+export type ToolSelection = 'core' | 'brain' | 'all' | string[];
+/** 按配置筛选工具名。 */
+export declare function selectTools(all: string[], selection: ToolSelection): string[];
+/** 把 MCP JSON Schema 的属性表转换为 ParameterSchemaSpec。 */
+export declare function schemaToParameters(inputSchema: Record<string, unknown> | undefined): ParameterSchemaSpec;
+/** 从灵枢 content 数组中提取文本（MCP text block 拼接）。 */
+export declare function extractText(content: Array<{
+    type: string;
+    text?: string;
+    [key: string]: unknown;
+}>): string;
+/** 注册灵枢工具到 ctx.tools；返回取消注册函数。 */
+export declare function registerLingxuTools(ctx: Context, bridge: LingxuBridge, opts: {
+    selection: ToolSelection;
+    toolPrefix: string;
+}): Promise<() => void>;

package/lib/tools.js

@@ -0,0 +1,168 @@
+/**
+ * 工具桥接：运行时从灵枢拉取工具清单（tools/list），把 JSON Schema
+ * 转换为 dsh-tools 的 ParameterSchemaSpec，经 defineTool 注册进 ctx.tools。
+ *
+ * 动态拉取意味着灵枢库升级新增工具后，DSH 侧零改动即可获得新能力。
+ */
+import { defineTool } from '@deepseek-ai/dsh-tools';
+/** 默认暴露的核心工具集合（记忆/推理/摄取/元认知）。 */
+export const CORE_TOOLS = [
+    'remember', // 写入记忆
+    'recall', // 组合联想召回
+    'search', // 内容检索
+    'timeline', // 记忆时间线
+    'think', // 推理前记忆注入
+    'relate', // 建立关系边
+    'predict_routes', // 生成式预测
+    'ingest_text', // 外部知识摄取
+    'ingest_url', // URL 摄取
+    'session_note', // 会话要点外部化
+    'self_check', // 完整性自检
+    'service_info', // 服务状态
+];
+/**
+ * 大脑模式工具集（轻量版：去掉身体的完整大脑）。
+ * 保留灵枢全部心智能力（记忆/认知/推理/学习/飞轮/反思/长期记忆门），
+ * 排除身体/视觉类工具（body/device_call/see/world3d 等）。
+ */
+export const BRAIN_TOOLS = [
+    // 记忆
+    'remember', 'recall', 'search', 'timeline',
+    'session_note', 'session_recall', 'compact_context',
+    // 推理与关系
+    'think', 'relate', 'reason', 'predict_routes',
+    // 认知与元认知
+    'self_check', 'gap_trend', 'cognition', 'cognition_report',
+    'emotional_bias', 'self_reliability', 'action_log', 'preflight',
+    // 反思
+    'recursive_reflect',
+    // 学习与盲区
+    'blindspots', 'learn', 'induce',
+    // 知识飞轮
+    'distill', 'flywheel_report', 'transfer_test', 'calibrate',
+    // 外部知识摄取
+    'ingest_text', 'ingest_file', 'ingest_url', 'web_search',
+    // 生命周期
+    'step', 'lifecycle_state',
+    // 长期记忆门（v1.15：重要性评估主动沉淀）
+    'longterm_snapshot', 'promote_memories',
+    // 服务
+    'service_info',
+];
+/** 按配置筛选工具名。 */
+export function selectTools(all, selection) {
+    if (selection === 'all')
+        return all;
+    const allowed = new Set(selection === 'core' ? CORE_TOOLS
+        : selection === 'brain' ? BRAIN_TOOLS
+            : selection);
+    return all.filter((name) => allowed.has(name));
+}
+/** 把 MCP JSON Schema 的属性表转换为 ParameterSchemaSpec。 */
+export function schemaToParameters(inputSchema) {
+    if (!inputSchema || typeof inputSchema !== 'object')
+        return {};
+    const properties = inputSchema['properties'];
+    if (!properties || typeof properties !== 'object')
+        return {};
+    const required = new Set(Array.isArray(inputSchema['required']) ? inputSchema['required'] : []);
+    const spec = {};
+    for (const [key, raw] of Object.entries(properties)) {
+        const value = toValueSpec(raw);
+        if (required.has(key)) {
+            spec[key] = { ...value, required: true };
+        }
+        else {
+            spec[key] = value;
+        }
+    }
+    return spec;
+}
+/** 递归转换单个 JSON Schema 节点为 ValueSchemaSpec。 */
+function toValueSpec(raw) {
+    if (typeof raw !== 'object' || raw === null)
+        return { type: 'json' };
+    const node = raw;
+    const annotations = {};
+    if (typeof node['description'] === 'string')
+        annotations.description = node['description'];
+    const type = node['type'];
+    const enumValues = Array.isArray(node['enum']) ? node['enum'] : undefined;
+    switch (type) {
+        case 'string':
+            return { type: 'string', ...annotations, ...(enumValues ? { enum: enumValues } : {}) };
+        case 'number':
+            return { type: 'number', ...annotations };
+        case 'integer':
+            return { type: 'integer', ...annotations };
+        case 'boolean':
+            return { type: 'boolean', ...annotations };
+        case 'null':
+            return { type: 'null', ...annotations };
+        case 'array': {
+            const spec = { type: 'array', ...annotations };
+            if (node['items'] !== undefined)
+                spec.items = toValueSpec(node['items']);
+            return spec;
+        }
+        case 'object': {
+            const props = schemaToParameters(node);
+            return { type: 'object', properties: props, additionalProperties: true, ...annotations };
+        }
+        default:
+            return { type: 'json', ...annotations };
+    }
+}
+/** 从灵枢 content 数组中提取文本（MCP text block 拼接）。 */
+export function extractText(content) {
+    return content
+        .map((block) => (block.type === 'text' && typeof block.text === 'string' ? block.text : ''))
+        .filter(Boolean)
+        .join('\n');
+}
+/** 注册灵枢工具到 ctx.tools；返回取消注册函数。 */
+export async function registerLingxuTools(ctx, bridge, opts) {
+    const tools = await bridge.listTools();
+    const wanted = new Set(selectTools(tools.map((t) => t.name), opts.selection));
+    const disposers = [];
+    const registered = [];
+    try {
+        for (const tool of tools) {
+            if (!wanted.has(tool.name))
+                continue;
+            const publicName = `${opts.toolPrefix}${tool.name}`;
+            const definition = defineTool({
+                name: publicName,
+                description: tool.description || `灵枢 ${tool.name}`,
+                parameters: schemaToParameters(tool.inputSchema),
+                output: {
+                    schema: { type: 'json' },
+                    render(_args, value) {
+                        return [{ type: 'text', text: extractText(value.content ?? []) }];
+                    },
+                },
+                timeoutMs: 120_000,
+                isConcurrencySafe: () => true,
+                async execute(args) {
+                    const result = await bridge.callTool(tool.name, args);
+                    if (result.isError) {
+                        throw new Error(extractText(result.content) || `灵枢 ${tool.name} 执行失败`);
+                    }
+                    return { content: result.content };
+                },
+            });
+            disposers.push(ctx.tools.register(definition));
+            registered.push(publicName);
+        }
+    }
+    catch (err) {
+        for (const dispose of disposers)
+            dispose();
+        throw err;
+    }
+    ctx.logger.info(`dsh-memory: 已注册 ${registered.length} 个灵枢工具（${registered.join(', ')}）`);
+    return () => {
+        for (const dispose of disposers)
+            dispose();
+    };
+}

package/package.json

@@ -0,0 +1,58 @@
+{
+  "name": "@furongjun1999/dsh-memory",
+  "version": "0.2.0",
+  "description": "灵枢（AEIS）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",
+    "README.md",
+    "cordis.yml.example"
+  ],
+  "keywords": [
+    "deepseek",
+    "dsh",
+    "dsh-plugin",
+    "cordis",
+    "memory",
+    "agent",
+    "aeis",
+    "lingxu"
+  ],
+  "license": "MIT",
+  "peerDependencies": {
+    "@deepseek-ai/cordis": "^4.0.1",
+    "@deepseek-ai/dsh-session": "^0.0.1-rc.1",
+    "@deepseek-ai/dsh-tools": "^0.0.1-rc.1"
+  },
+  "devDependencies": {
+    "@deepseek-ai/cordis": "^4.0.1",
+    "@deepseek-ai/dsh-session": "^0.0.1-rc.1",
+    "@deepseek-ai/dsh-system-prompt": "^0.0.1-rc.1",
+    "@deepseek-ai/dsh-tools": "^0.0.1-rc.1",
+    "@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\"",
+    "prepublishOnly": "npm run build && npm test"
+  },
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/FuRongJun-1999/CommonTrustProtocol.git",
+    "directory": "plugins/dsh-memory"
+  },
+  "engines": {
+    "node": ">=18"
+  }
+}