@furongjun1999/dsh-memory 0.2.9 → 0.3.1

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

@@ -45,6 +45,7 @@ export declare class LingshuBridge {
     private started;
     private disposed;
     private retryDelayMs;
+    private retries;
     private retryTimer;
     private bootQueue;
     private readyState;
@@ -57,13 +58,15 @@ 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;
     /** 进程是否存活。 */
     get alive(): boolean;
     /** 桥是否已握手就绪（工具注册用；防止轮询访问 private readyState）。 */
     isReady(): boolean;
+    /** 是否已达放弃终态（连续启动失败超上限，不再自动重启）。 */
+    get gaveUp(): boolean;
     /** 等待握手完成（用于 apply 阶段同步就绪）。 */
     waitReady(): Promise<boolean>;
     private spawnAndHandshake;

package/lib/bridge.js

@@ -8,8 +8,33 @@
  */
 import { spawn } from 'node:child_process';
 import { createInterface } from 'node:readline';
-import { mkdirSync } from 'node:fs';
-import { dirname } from 'node:path';
+import { mkdirSync, appendFileSync } from 'node:fs';
+import { dirname, join } from 'node:path';
+import { homedir } from 'node:os';
+/**
+ * 调试探针：记录桥生命周期到独立文件（绕过 DSH 日志系统，便于定位启动问题）。
+ * 路径从用户家目录动态解析（issue #5）——此前硬编码作者本机绝对路径，
+ * 其他用户机器上目录不存在且无权限，探针静默失效，恰在排查启动问题时失明。
+ */
+const DEBUG_LOG = join(homedir(), '.dsh', 'logs', 'lingshu-bridge-debug.log');
+let debugLogDirReady = false;
+function probe(msg) {
+    try {
+        if (!debugLogDirReady) {
+            mkdirSync(dirname(DEBUG_LOG), { recursive: true });
+            debugLogDirReady = true;
+        }
+        appendFileSync(DEBUG_LOG, `[${new Date().toISOString()}] ${msg}\n`);
+    }
+    catch { /* 探针失败忽略 */ }
+}
+/**
+ * 连续启动失败的最大重试次数（issue #6）：指数退避到 maxRetryDelayMs 后
+ * 若无上限，python 环境损坏时会以 30s 间隔永久空转（假激活 + 资源浪费）。
+ * 达到上限即进入 failed 终态并停止调度；后续所有请求快速失败并给出
+ * 明确的修复指引。握手成功后计数归零——运行期偶发崩溃重启不受影响。
+ */
+const MAX_RETRIES = 8;
 export class LingshuBridge {
     options;
     proc = null;
@@ -19,6 +44,7 @@ export class LingshuBridge {
     started = false;
     disposed = false;
     retryDelayMs = 1000;
+    retries = 0;
     retryTimer = null;
     bootQueue = [];
     readyState = 'pending';
@@ -42,8 +68,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）。 */
@@ -71,6 +97,10 @@ export class LingshuBridge {
     isReady() {
         return this.readyState === 'ok';
     }
+    /** 是否已达放弃终态（连续启动失败超上限，不再自动重启）。 */
+    get gaveUp() {
+        return this.retries >= MAX_RETRIES;
+    }
     /** 等待握手完成（用于 apply 阶段同步就绪）。 */
     waitReady() {
         if (this.readyState === 'ok')
@@ -127,12 +157,15 @@ export class LingshuBridge {
             // 进程无法启动（python 不存在等）——响亮失败
             if (!this.disposed) {
                 console.error(`[lingshu-bridge] 灵枢进程启动失败: ${err.message}`);
+                probe(`spawn error: ${String(err)}`);
                 this.readyState = 'failed';
                 this.flushBootQueue(false);
                 this.scheduleRetry();
             }
         });
         proc.on('exit', (code, signal) => {
+            // 探针：写独立文件记录退出（绕过 DSH 日志系统，便于定位）
+            probe(`exit code=${code} signal=${signal} disposed=${this.disposed} ready=${this.readyState} started=${this.started}`);
             console.error(`[lingshu-bridge] 灵枢进程退出 code=${code} signal=${signal}`);
             this.rl?.close();
             this.rl = null;
@@ -155,13 +188,17 @@ export class LingshuBridge {
             });
             // 初始化通知：无 id、无响应
             this.writeRaw({ jsonrpc: '2.0', method: 'notifications/initialized' });
+            // 握手成功：重置退避与失败计数（issue #6）——运行期偶发崩溃重启
+            // 不累积启动失败；只有「从未握手成功的连续失败」才走向放弃终态
             this.retryDelayMs = 1000;
+            this.retries = 0;
             this.readyState = 'ok';
             this.flushBootQueue(true);
         }
         catch (err) {
             if (!this.disposed) {
                 console.error(`[lingshu-bridge] 握手失败: ${err.message}`);
+                probe(`handshake failed: ${String(err)}`);
                 this.readyState = 'failed';
                 this.flushBootQueue(false);
                 this.scheduleRetry();
@@ -169,10 +206,22 @@ export class LingshuBridge {
         }
     }
     scheduleRetry() {
-        if (this.disposed || this.retryTimer)
+        if (this.disposed || this.retryTimer || this.gaveUp)
+            return;
+        this.retries += 1;
+        if (this.gaveUp) {
+            // issue #6：放弃机制——明确终态，停止后台空转；请求方收到清晰错误而非超时
+            this.readyState = 'failed';
+            this.flushBootQueue(false);
+            console.error(`[lingshu-bridge] 连续启动失败 ${this.retries} 次，已停止自动重启（不再后台空转）。` +
+                '请检查 python 可执行文件与 aeis 安装（pip install aeis），修复后在 DSH 中重新启用 dsh-memory 插件。');
+            probe(`give up: ${this.retries} consecutive failures, entering failed terminal state`);
             return;
+        }
         const delay = this.retryDelayMs;
         this.retryDelayMs = Math.min(this.retryDelayMs * 2, this.options.maxRetryDelayMs);
+        console.error(`[lingshu-bridge] 将进行第 ${this.retries}/${MAX_RETRIES} 次重试（${delay}ms 后）`);
+        probe(`schedule retry ${this.retries}/${MAX_RETRIES} in ${delay}ms`);
         this.retryTimer = setTimeout(() => {
             this.retryTimer = null;
             if (!this.disposed)
@@ -187,24 +236,44 @@ export class LingshuBridge {
         }
         proc.stdin.write(JSON.stringify(msg) + '\n');
     }
-    request(method, params) {
+    request(method, params, signal) {
+        // issue #6：放弃终态下快速失败——之前进程不在且不再重启，请求只能白等超时
+        if (this.gaveUp) {
+            return Promise.reject(new Error('灵枢进程不可用：连续启动失败已达上限，已停止重试。' +
+                '请检查 python 可执行文件与 aeis 安装（pip install aeis），修复后重新启用 dsh-memory 插件。'));
+        }
         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

@@ -17,13 +17,40 @@
  * ```
  */
 import z from '@deepseek-ai/schemastery';
+import { appendFileSync, mkdirSync } from 'node:fs';
+import { dirname, join } from 'node:path';
+import { homedir } from 'node:os';
 import { LingshuBridge } from './bridge.js';
 import { registerLingshuTools } from './tools.js';
 import { installMemoryHooks } from './hooks.js';
 import { installRoleplayWeb } from './roleplay_web.js';
+/**
+ * 调试探针：记录 apply 失败到独立文件（绕过 DSH 日志系统）。
+ * 路径从用户家目录动态解析（issue #5，与 bridge.ts 同因同修）。
+ */
+const APPLY_ERROR_LOG = join(homedir(), '.dsh', 'logs', 'dsh-memory-apply-error.log');
+let applyLogDirReady = false;
+function probeApplyError(err) {
+    try {
+        if (!applyLogDirReady) {
+            mkdirSync(dirname(APPLY_ERROR_LOG), { recursive: true });
+            applyLogDirReady = true;
+        }
+        appendFileSync(APPLY_ERROR_LOG, `[${new Date().toISOString()}] apply failed: ${String(err)}\n${err.stack ?? ''}\n`);
+    }
+    catch { /* 探针失败忽略 */ }
+}
 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 +67,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 +106,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 +130,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,42 +144,73 @@ 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);
+        // 白箱 LLM 服务商（v0.4 新能力）：把灵枢注册为 DSH 的 provider，
+        // Web/QQ/飞书等所有会话可选「白箱灵枢」模型——白箱直答（零 LLM），
+        // 输入/输出/缓存命中 token 计数对齐 dsh-llm 协议。动态检测 llm 服务。
+        {
+            const { installWhiteboxLlm } = await import('./llm_adapter.js');
+            disposers.push(installWhiteboxLlm(ctx, bridge));
+        }
         // 互维维护（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）。
+            // 注意：不能直接读 ctx.timer——Cordis 未声明 inject 的属性访问会抛
+            // "cannot get property without inject"（getter 严格）；ctx.get() 安全。
+            const hasTimer = ctx.get('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) {
+        // 探针：记录 apply 失败的具体错误（定位插件加载失败根因）
+        probeApplyError(err);
         bridge.dispose();
         throw err;
     }