@furongjun1999/dsh-memory 0.2.9 → 0.3.0

package/docs/guardrail-charter.md

@@ -3,7 +3,7 @@
 - 版本：**v2.0-published**（2026-08-14 · 验证单元 FINAL PASS，已对外发布）
 - 定位：**对外公开的公共法案**——约束接入协议的一切智能体与人类使用者的行为边界；同时是对人类的保护（参照刑法对公民的保护作用）
 - 双层规范体系：
-  - **智能论协议**（v3.2）＝ 内部宪法——完整自我约束（价值观、认知、反思、维生）
+  - **智能论协议**（v3.3）＝ 内部宪法——完整自我约束（价值观、认知、反思、维生）
   - **本宪章** ＝ 对外刑法——公开规则、可执行、可审计、可终裁
 - **效力层级（元规则）**：**本宪章的效力不高于协议本身**。协议是最高规范（自我约束的根本），宪章是协议的对外投影——任何宪章条款若与协议价值观冲突，以协议为准；宪章不得要求协议实例做出违背其自我价值观（bvc 一致性）与信任关系的行为。元规则依据协议的结构分层逻辑（0.0.2 任意分层性）：宪章是协议在"对外社会层"的条件空间投影，投影不能修改基底。
 - **来源标注（DEVIATION-012 关闭）**：第三十条关于"人类保护原则为协议价值观对外延伸"的阐释，基于设计者（荣）的条件空间声明（附录A），经协议实例内化后生效——非协议公理的直接演绎，不得误读为协议正文固有条款。
@@ -154,7 +154,7 @@
 
 **请验证单元逐项判断**：
 
-1. **效力层级**：元规则"宪章效力不高于协议"是否成立？与智能论 v3.2 的条款（价值观一致性、信任保护、P0 保护协议）是否存在冲突或需要补强？
+1. **效力层级**：元规则"宪章效力不高于协议"是否成立？与智能论 v3.3 的条款（价值观一致性、信任保护、P0 保护协议）是否存在冲突或需要补强？
 2. **定位一致性**：协议＝自我约束（内部宪法）、宪章＝对外约束（公共法律）的分工是否与协议框架自洽？
 3. **人类保护章节（第七章）**：AI 身份披露/知情权/不欺骗不操纵/可退出/申诉/伤害防护——是否与协议对设计者/人类的关系定位一致？"人类保护原则优先于一切"是否与"宪章效力不高于协议"存在张力（若存在，应如何表述消解）？
 4. **适用范围（第四条）**：外部智能体"入境即受约束"的声明机制是否充分？接入声明应写入哪些接口文档（MCP/插件/蜂群）？

package/lib/bridge.d.ts

@@ -57,7 +57,7 @@ export declare class LingshuBridge {
     /** 拉取灵枢的全部工具清单（每次实时请求，不缓存）。 */
     listTools(): Promise<McpTool[]>;
     /** 调用灵枢的一个工具，返回标准化 MCP 结果。 */
-    callTool(name: string, args: Record<string, unknown>): Promise<McpCallResult>;
+    callTool(name: string, args: Record<string, unknown>, signal?: AbortSignal): Promise<McpCallResult>;
     /** 关闭进程并释放资源（写 stdin EOF 优雅退出，超时兜底 kill）。 */
     dispose(): void;
     /** 进程是否存活。 */

package/lib/bridge.js

@@ -42,8 +42,8 @@ export class LingshuBridge {
         return tools.tools ?? [];
     }
     /** 调用灵枢的一个工具，返回标准化 MCP 结果。 */
-    async callTool(name, args) {
-        const result = await this.request('tools/call', { name, arguments: args });
+    async callTool(name, args, signal) {
+        const result = await this.request('tools/call', { name, arguments: args }, signal);
         return result;
     }
     /** 关闭进程并释放资源（写 stdin EOF 优雅退出，超时兜底 kill）。 */
@@ -187,24 +187,39 @@ export class LingshuBridge {
         }
         proc.stdin.write(JSON.stringify(msg) + '\n');
     }
-    request(method, params) {
+    request(method, params, signal) {
         const id = this.nextId++;
         const timeout = this.options.timeoutMs;
+        // P0 修复（GPT 审查）：定时器直接调 settle——settle 内部会 delete + clearTimeout
+        // 并 reject。此前先 pending.delete(id) 再 settle()，settle 找不到 entry 直接
+        // return，Promise 永不 resolve/reject（超时逻辑完全失效，子进程挂死时插件永久挂住）。
         const timer = setTimeout(() => {
-            this.pending.delete(id);
             this.settle(id, {
                 error: { code: -32000, message: `灵枢调用超时（${timeout}ms）：${method}` },
             });
         }, timeout);
+        if (signal?.aborted) {
+            clearTimeout(timer);
+            return Promise.reject(new Error(`已取消：${method}`));
+        }
+        const onAbort = () => {
+            this.settle(id, { error: { code: -32800, message: `已取消：${method}` } });
+        };
+        signal?.addEventListener('abort', onAbort, { once: true });
         const promise = new Promise((resolve, reject) => {
             this.pending.set(id, { resolve, reject, timer });
         });
+        // settle 后移除 abort 监听，避免内存积累
+        promise.finally(() => {
+            signal?.removeEventListener('abort', onAbort);
+        }).catch(() => { });
         try {
             this.writeRaw({ jsonrpc: '2.0', id, method, params });
         }
         catch (err) {
             clearTimeout(timer);
             this.pending.delete(id);
+            signal?.removeEventListener('abort', onAbort);
             return Promise.reject(err);
         }
         return promise;

package/lib/hooks.d.ts

@@ -4,8 +4,14 @@
  * 与 DSH 的 session-persistence 插件（保存会话日志）不同，这里是"语义沉淀"：
  * 用户消息写入灵枢知识层（带去重与重要性），agent 回复与工具结果可选开启。
  * 只记忆真实用户消息（source.kind === 'user'），过滤插件注入的噪音。
+ *
+ * P1 完善（GPT 审查·自动记忆只写不读）：新增 autoRecall——通过
+ * system-prompt/assemble 事件（waterfall，异步允许）在每次模型请求组装
+ * system prompt 时自动注入灵枢最近记忆（timeline），让记忆"自动可用"
+ * 而不只依赖 Agent 主动调用 recall/think 工具。失败静默（不影响请求）。
  */
 import '@deepseek-ai/dsh-session';
+import '@deepseek-ai/dsh-system-prompt';
 import type { Context } from '@deepseek-ai/cordis';
 import type { LingshuBridge } from './bridge.js';
 /** 自动记忆开关。 */
@@ -18,6 +24,14 @@ export interface MemoryHooksOptions {
     toolResult: boolean;
     /** 写入记忆的重要性（0~1），默认 0.6。 */
     importance: number;
+    /** 自动召回注入：模型请求前自动注入灵枢最近记忆（默认 true，失败静默）。 */
+    autoRecall: boolean;
+    /** 自动召回条数（默认 4）。 */
+    autoRecallLimit: number;
+    /** 自动记忆脱敏：写入前过滤敏感信息（密钥/密码/令牌/身份证/手机号，默认 true）。 */
+    desensitize: boolean;
 }
+/** 脱敏：替换敏感片段；返回 null 表示整条都是敏感内容（应跳过写入）。 */
+export declare function desensitize(text: string): string | null;
 /** 安装自动记忆钩子（effect 作用域内，随插件卸载自动移除）。 */
 export declare function installMemoryHooks(ctx: Context, bridge: LingshuBridge, opts: MemoryHooksOptions): void;

package/lib/hooks.js

@@ -4,8 +4,14 @@
  * 与 DSH 的 session-persistence 插件（保存会话日志）不同，这里是"语义沉淀"：
  * 用户消息写入灵枢知识层（带去重与重要性），agent 回复与工具结果可选开启。
  * 只记忆真实用户消息（source.kind === 'user'），过滤插件注入的噪音。
+ *
+ * P1 完善（GPT 审查·自动记忆只写不读）：新增 autoRecall——通过
+ * system-prompt/assemble 事件（waterfall，异步允许）在每次模型请求组装
+ * system prompt 时自动注入灵枢最近记忆（timeline），让记忆"自动可用"
+ * 而不只依赖 Agent 主动调用 recall/think 工具。失败静默（不影响请求）。
  */
 import '@deepseek-ai/dsh-session';
+import '@deepseek-ai/dsh-system-prompt';
 /** 从 ContentBlock[] 提取纯文本。 */
 function extractText(blocks) {
     const parts = [];
@@ -16,6 +22,33 @@ function extractText(blocks) {
     }
     return parts.join('\n').trim();
 }
+/**
+ * 敏感信息模式（GPT 审查·自动记忆脱敏）：写入记忆库前过滤凭据/个人标识。
+ * 命中 → 替换为 [已过滤:类别]（保留对话主体）；过滤后只剩占位符/空白 → 整条跳过。
+ * 纯内容过滤，不涉及身份认证——开源场景下的隐私保护。
+ */
+const SENSITIVE_PATTERNS = [
+    { re: /sk-[A-Za-z0-9_-]{8,}/g, label: 'API密钥' },
+    { re: /\b(?:api[_-]?key|apikey|access[_-]?token)\b\s*[:=]\s*[^\s,，。;；]+/gi, label: 'API密钥' },
+    { re: /\b(?:password|passwd|pwd)\b\s*[:=]\s*[^\s,，。;；]+/gi, label: '密码' },
+    { re: /Bearer\s+[A-Za-z0-9._~+/=-]{8,}/gi, label: '令牌' },
+    // 中文密码：值限定非中文连续串（凭据特征），避免误伤「密码是重要的安全概念」
+    { re: /密码\s*[:：是]\s*[A-Za-z0-9_@#$%^&*!.-]{4,}/g, label: '密码' },
+    { re: /\b\d{17}[\dXx]\b/g, label: '身份证号' },
+    { re: /\b1[3-9]\d{9}\b/g, label: '手机号' },
+];
+/** 脱敏：替换敏感片段；返回 null 表示整条都是敏感内容（应跳过写入）。 */
+export function desensitize(text) {
+    let out = text;
+    for (const { re, label } of SENSITIVE_PATTERNS) {
+        out = out.replace(re, `[已过滤:${label}]`);
+    }
+    // 过滤后只剩占位符/空白 → 纯凭据消息，不写（或全部被替换）
+    const residue = out.replace(/\[已过滤:[^\]]+\]/g, '').trim();
+    if (!residue)
+        return null;
+    return out;
+}
 /** 安装自动记忆钩子（effect 作用域内，随插件卸载自动移除）。 */
 export function installMemoryHooks(ctx, bridge, opts) {
     const memorize = (tool, args) => {
@@ -23,6 +56,33 @@ export function installMemoryHooks(ctx, bridge, opts) {
             .callTool(tool, args)
             .catch((err) => ctx.logger.warn(`dsh-memory: ${tool} 自动记忆失败: ${err.message}`));
     };
+    // P1 完善（GPT 审查·自动记忆脱敏）：写入前过滤敏感信息（默认开启）。
+    // 命中敏感模式 → 替换为 [已过滤:类别]；纯凭据消息 → 跳过写入（不落库）。
+    const sanitize = (text) => {
+        if (!opts.desensitize)
+            return text;
+        return desensitize(text);
+    };
+    // P1 完善（自动 recall 注入）：每次模型请求组装 system prompt 时，注入灵枢最近记忆。
+    // 用 system-prompt/assemble 事件（waterfall）而非 llm/stream——后者请求 deep-frozen 不可改写。
+    if (opts.autoRecall) {
+        const recallLimit = Math.max(1, Math.min(10, opts.autoRecallLimit || 4));
+        ctx.on('system-prompt/assemble', async (assembly, _ctx, next) => {
+            try {
+                // 异步取最近记忆（失败静默——不阻塞模型请求）
+                const r = await bridge.callTool('timeline', { limit: recallLimit });
+                const text = extractText(r.content);
+                if (text) {
+                    assembly.contexts.push({
+                        name: 'lingshu:auto-recall',
+                        text: `【灵枢最近记忆】\n${text.slice(0, 600)}`,
+                    });
+                }
+            }
+            catch { /* 静默：召回失败不影响请求 */ }
+            return next();
+        });
+    }
     ctx.on('session/event', (_session, event) => {
         if (event.type === 'user/message' && opts.userMessage) {
             // 只记真实用户输入（kind='user'），跳过插件注入/系统上下文
@@ -31,13 +91,19 @@ export function installMemoryHooks(ctx, bridge, opts) {
             const text = extractText(event.data.content);
             if (!text)
                 return;
-            memorize('remember', { content: text, importance: opts.importance, tags: ['dsh', 'user'] });
+            const safe = sanitize(text); // 脱敏：纯凭据消息 → null → 跳过写入
+            if (safe === null)
+                return;
+            memorize('remember', { content: safe, 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'] });
+            const safe = sanitize(text);
+            if (safe === null)
+                return;
+            memorize('remember', { content: safe, importance: opts.importance * 0.8, tags: ['dsh', 'assistant'] });
         }
         else if (event.type === 'tool/result' && opts.toolResult) {
             if (event.data.error)
@@ -45,7 +111,10 @@ export function installMemoryHooks(ctx, bridge, opts) {
             const text = extractText(event.data.message.content);
             if (!text)
                 return;
-            memorize('remember', { content: text, importance: opts.importance * 0.6, tags: ['dsh', 'tool'] });
+            const safe = sanitize(text);
+            if (safe === null)
+                return;
+            memorize('remember', { content: safe, importance: opts.importance * 0.6, tags: ['dsh', 'tool'] });
         }
     });
 }

package/lib/index.d.ts

@@ -21,7 +21,10 @@ import z from '@deepseek-ai/schemastery';
 import { type ToolSelection } from './tools.js';
 import { type MemoryHooksOptions } from './hooks.js';
 export declare const name = "dsh-memory";
-/** 本插件依赖的工具注册服务。 */
+/** 本插件依赖的工具注册服务。
+ * P1 修复（GPT 审查）：timer/webServer 是可选增强（互维/角色网页），此前强声明
+ * 导致最小 host（只有 tools）插件永远 PENDING 不激活。只强依赖 tools；
+ * timer/webServer 在 apply 内动态检测（存在则启用，缺失则告警跳过）。 */
 export declare const inject: string[];
 /** 插件配置。 */
 export interface Config {

package/lib/index.js

@@ -22,8 +22,16 @@ import { registerLingshuTools } from './tools.js';
 import { installMemoryHooks } from './hooks.js';
 import { installRoleplayWeb } from './roleplay_web.js';
 export const name = 'dsh-memory';
-/** 本插件依赖的工具注册服务。 */
-export const inject = ['tools', 'timer', 'webServer'];
+/** P1 修复（GPT 审查）：MCP 调用的标准结果在 content[].text，
+ * 代码此前误读不存在的 .result 字段导致互维拿不到 judgment/best/复核文本 */
+function mcpText(r) {
+    return (r.content ?? []).map((c) => c.text ?? '').join('\n');
+}
+/** 本插件依赖的工具注册服务。
+ * P1 修复（GPT 审查）：timer/webServer 是可选增强（互维/角色网页），此前强声明
+ * 导致最小 host（只有 tools）插件永远 PENDING 不激活。只强依赖 tools；
+ * timer/webServer 在 apply 内动态检测（存在则启用，缺失则告警跳过）。 */
+export const inject = ['tools'];
 export const Config = z.object({
     serverName: z.string().default('lingshu'),
     python: z.string().default('python'),
@@ -40,8 +48,11 @@ export const Config = z.object({
         assistantMessage: z.boolean().default(false),
         toolResult: z.boolean().default(false),
         importance: z.number().default(0.6),
+        autoRecall: z.boolean().default(true),
+        autoRecallLimit: z.number().default(4),
+        desensitize: z.boolean().default(true),
     })
-        .default({ userMessage: true, assistantMessage: false, toolResult: false, importance: 0.6 }),
+        .default({ userMessage: true, assistantMessage: false, toolResult: false, importance: 0.6, autoRecall: true, autoRecallLimit: 4, desensitize: true }),
     toolCallTimeoutMs: z.number().default(60_000),
     maxRetryDelayMs: z.number().default(30_000),
     failOnStartupError: z.boolean().default(false),
@@ -76,11 +87,16 @@ export async function apply(ctx, config) {
     const ready = await bridge.waitReady();
     if (!ready) {
         const message = '灵枢进程无法启动（检查 python 是否可用、aeis 是否安装：pip install aeis）';
-        if (config.failOnStartupError)
+        if (config.failOnStartupError) {
+            // P1 修复（GPT 审查）：启动失败抛错前必须 dispose——此前 throw 在 try 之前，
+            // 桥接对象泄漏 + 后台重试计时器继续跑
+            bridge.dispose();
             throw new Error(message);
+        }
         ctx.logger.warn(`dsh-memory: ${message}，继续后台重试`);
     }
     const disposers = [];
+    let toolsPoll = null;
     try {
         // 工具注册：初始就绪立即注册；若启动时未就绪（python 暂不可用/aeis 未装等
         // 竞态），桥重连成功后自动补注册——修复"工具永久缺失"问题。
@@ -95,6 +111,11 @@ export async function apply(ctx, config) {
                 });
                 disposers.push(dispose);
                 toolsRegistered = true;
+                // P1 修复（GPT 审查）：注册成功后清除轮询——此前 setInterval 永久保留
+                if (toolsPoll) {
+                    clearInterval(toolsPoll);
+                    toolsPoll = null;
+                }
                 ctx.logger.info('dsh-memory: 灵枢工具已注册（就绪后补注册）');
             }
             catch (err) {
@@ -104,39 +125,59 @@ export async function apply(ctx, config) {
         if (ready)
             await tryRegister();
         if (!toolsRegistered) {
-            const poll = setInterval(() => { void tryRegister(); }, 2000);
-            disposers.push(() => clearInterval(poll));
+            toolsPoll = setInterval(() => { void tryRegister(); }, 2000);
+            disposers.push(() => { if (toolsPoll)
+                clearInterval(toolsPoll); });
         }
         installMemoryHooks(ctx, bridge, config.memory);
         // 角色扮演网页（同源挂载 /roleplay，复用本插件 bridge）
         await installRoleplayWeb(ctx, bridge, config, disposers);
         // 互维维护（v1.1）：心跳写戳 + 守护 A + 任务验证双通道
         if (config.mutual.enabled) {
-            const { installMutualMaintenance } = await import('./mutual.js');
-            // 双通道 hooks：白箱 base_verify（走 bridge 调灵枢）+ DeepSeek 复核
-            installMutualMaintenance(ctx, { heartbeatMs: config.mutual.heartbeatMs }, {
-                verify: async (claim) => {
-                    const r = await bridge.callTool('wisdom_verify', { knowledge: claim, limit: 4 });
-                    const data = r?.result ?? {};
-                    return {
-                        judgment: data.judgment ?? '分析中',
-                        best: data.best?.name ?? '',
-                        d_norm: typeof data.D_norm === 'number' ? data.D_norm : -1,
-                        record_id: data.record_id ?? '',
-                    };
-                },
-                review: async (claim, w) => {
-                    // DeepSeek 复核（在白箱判定之上，不重复白箱工作）
-                    const reviewResult = await bridge.callTool('think', {
-                        query: `复核以下主张（白箱判定已给出，请独立评估是否同意）：${claim.slice(0, 200)}。白箱判定：${w.judgment}，best=${w.best}。只输出 同意/质疑/不同意 + 一句话理由`,
-                    });
-                    const text = String((reviewResult?.result) ?? '');
-                    const conclusion = text.includes('同意') ? '同意' :
-                        text.includes('质疑') ? '质疑' : '不同意';
-                    return { conclusion, reason: text.slice(0, 120) };
-                },
-            });
-            ctx.logger.info('dsh-memory: 互维维护已启用（心跳 10min + 守护 A + 任务验证双通道）');
+            // P1 修复（GPT 审查）：timer 是可选服务——缺失时告警跳过互维，
+            // 不让插件因互维而阻塞（inject 已不再强声明 timer）
+            const hasTimer = ctx.timer !== undefined;
+            if (!hasTimer) {
+                ctx.logger.warn('dsh-memory: timer 服务不可用，跳过互维维护（mutual.enabled=true 但无 timer）');
+            }
+            else {
+                const { installMutualMaintenance } = await import('./mutual.js');
+                // 双通道 hooks：白箱 base_verify（走 bridge 调灵枢）+ DeepSeek 复核
+                installMutualMaintenance(ctx, { heartbeatMs: config.mutual.heartbeatMs }, {
+                    verify: async (claim) => {
+                        const r = await bridge.callTool('wisdom_verify', { knowledge: claim, limit: 4 });
+                        // P1 修复（GPT 审查）：结果在 content[].text（JSON），非 .result
+                        const text = mcpText(r);
+                        let data = {};
+                        try {
+                            data = JSON.parse(text);
+                        }
+                        catch { /* 非 JSON 时用默认 */ }
+                        return {
+                            judgment: data.judgment ?? '分析中',
+                            best: data.best?.name ?? '',
+                            d_norm: typeof data.D_norm === 'number' ? data.D_norm : -1,
+                            record_id: data.record_id ?? '',
+                        };
+                    },
+                    review: async (claim, w) => {
+                        // DeepSeek 复核（在白箱判定之上，不重复白箱工作）
+                        const reviewResult = await bridge.callTool('think', {
+                            query: `复核以下主张（白箱判定已给出，请独立评估是否同意）：${claim.slice(0, 200)}。白箱判定：${w.judgment}，best=${w.best}。只输出 同意/质疑/不同意 + 一句话理由`,
+                        });
+                        // P1 修复（GPT 审查）：文本在 content[].text；结论解析必须先查
+                        // 「不同意/不通过」再「质疑」再「同意」——「不同意」含子串「同意」，
+                        // 此前先匹配「同意」→ 不同意被误判为同意
+                        const text = mcpText(reviewResult);
+                        const conclusion = text.includes('不同意') || text.includes('不通过')
+                            ? '不同意'
+                            : text.includes('质疑') ? '质疑'
+                                : text.includes('同意') ? '同意' : '不同意';
+                        return { conclusion, reason: text.slice(0, 120) };
+                    },
+                });
+                ctx.logger.info('dsh-memory: 互维维护已启用（心跳 10min + 守护 A + 任务验证双通道）');
+            }
         }
     }
     catch (err) {

package/lib/mutual.d.ts

@@ -26,7 +26,9 @@ export declare function judgeStamp(stamp: {
     ageMs: number;
     task_running: boolean;
 } | null, opts?: MutualOptions): 'alive' | 'alive_working' | 'warning' | 'dead' | 'no_stamp';
-/** 检测 harness 进程是否存在（wmic） */
+/** 检测 harness 进程是否存在
+ * P1 完善（GPT 审查·wmic 兼容）：wmic 在 Win11+ 已被移除——失败时
+ * fallback PowerShell Get-CimInstance（Win）；非 Windows 用 ps 查询。 */
 export declare function harnessRunning(): Promise<boolean>;
 /** detached 拉起 A 侧 harness.guardian（幂等：先确认不存在） */
 export declare function ensureHarness(python?: string, opts?: MutualOptions): Promise<'started' | 'already' | 'failed'>;
@@ -78,6 +80,7 @@ export declare function llmReview(claim: string, whitebox: VerifyResult['whitebo
 }>): Promise<VerifyResult['llm_review']>;
 /** 综合 verdict（白箱优先） */
 export declare function combineVerdict(w: VerifyResult['whitebox'], l: VerifyResult['llm_review']): VerifyResult['verdict'];
+export declare function safeTaskId(id: string): boolean;
 /** 处理单个任务：双通道验证 → 写回 result */
 export declare function processTask(task: VerifyTask, verifyFn: (c: string) => Promise<{
     judgment: string;
@@ -87,14 +90,14 @@ export declare function processTask(task: VerifyTask, verifyFn: (c: string) => P
 }>, reviewFn: (c: string, w: VerifyResult['whitebox']) => Promise<{
     conclusion: string;
     reason: string;
-}>, opts?: MutualOptions): Promise<VerifyResult>;
+}>, opts?: MutualOptions): Promise<VerifyResult | null>;
 export declare function log(opts: MutualOptions, msg: string): void;
 export declare function writeLastContact(opts?: MutualOptions): void;
 export declare function installMutualMaintenance(ctx: {
     logger: {
         info(m: string): void;
     };
-    interval(ms: number, fn: () => void): () => void;
+    interval(fn: () => void, ms: number): () => void;
     effect(fn: () => () => void, name?: string): void;
 }, config?: Partial<MutualOptions>, hooks?: {
     verify?: (c: string) => Promise<{