@furongjun1999/dsh-memory 0.3.0 → 0.3.1

package/lib/llm_adapter.js

@@ -0,0 +1,243 @@
+/**
+ * llm_adapter.ts —— 白箱 LLM 服务商（WhiteboxLlmAdapter）
+ *
+ * 设计哲学：白箱本身就是 LLM 模型（对外完全对齐 dsh-llm 协议），内部白箱化。
+ *  - provider: 'lingshu-whitebox'（设置页「模型」可见，可被 agent 默认选用）
+ *  - stream(): 调灵枢 wisdom_chat（白箱 CCG 条件路由/组合生成/自校验）
+ *  - token 计数：输入/输出/缓存命中（白箱直答 = 全部 cacheRead，零推理成本）
+ *  - 降级：白箱无把握（route=llm / 桥未就绪）→ 可选 fallback（后续接 deepseek）
+ *
+ * 结构仿官方 @deepseek-ai/dsh-llm-deepseek adapter。
+ */
+// ---- token 估算（确定性启发式：CJK 0.6/字符，其余 /4）----
+export function estimateTokens(text) {
+    if (!text)
+        return 0;
+    let cjk = 0;
+    let other = 0;
+    for (const ch of text) {
+        const code = ch.codePointAt(0);
+        if ((code >= 0x4e00 && code <= 0x9fff) || (code >= 0x3040 && code <= 0x30ff))
+            cjk++;
+        else
+            other++;
+    }
+    return Math.ceil(cjk * 0.6 + other / 4);
+}
+/** 从 GenerateOptions 汇总输入 token（system + messages 全部文本）。 */
+export function countInputTokens(options) {
+    let total = 0;
+    if (options.system)
+        total += estimateTokens(options.system);
+    for (const msg of options.messages ?? []) {
+        for (const block of msg.content ?? []) {
+            if (typeof block?.text === 'string')
+                total += estimateTokens(block.text);
+            if (typeof block?.arguments === 'string')
+                total += estimateTokens(block.arguments);
+        }
+    }
+    return total;
+}
+/** 把 DSH 会话消息折叠成白箱可读的对话文本。 */
+export function serializeMessages(options) {
+    const parts = [];
+    if (options.system)
+        parts.push(`[系统] ${options.system}`);
+    for (const msg of options.messages ?? []) {
+        const text = (msg.content ?? [])
+            .filter((b) => b?.type === 'text' && typeof b.text === 'string')
+            .map((b) => b.text)
+            .join('');
+        if (!text)
+            continue;
+        const role = msg.role === 'assistant' ? '灵枢' : msg.role === 'user' ? '用户' : msg.role;
+        parts.push(`[${role}] ${text}`);
+    }
+    return parts.join('\n');
+}
+/** 把一段完整文本包装成协议流（确定性整段生成 → 单次流）。 */
+export async function* wrapTextStream(text, inputTokens, outputTokens, cacheReadTokens) {
+    yield { type: 'block-start', index: 0, blockType: 'text' };
+    yield { type: 'text-delta', index: 0, text };
+    yield { type: 'block-end', index: 0, block: { type: 'text', text } };
+    yield {
+        type: 'usage',
+        usage: {
+            inputTokens,
+            outputTokens,
+            ...(cacheReadTokens > 0 ? { cacheReadTokens } : {}),
+        },
+    };
+    yield { type: 'finish', reason: 'stop' };
+}
+/**
+ * 白箱知识卡片格式检测：REVERSE_DAILY 直答是知识库内部格式——
+ * 「X是什么…，是『A』vs『B』的矛盾——X（是…（…（…）…）…真相：①…」
+ * 特征（任一强信号命中即判定）：
+ * ① 卡片开头句式：内容含「，是『X』vs『Y』的矛盾——」（矛盾标记+破折号）
+ * ② 「真相：」结构化标记（卡片分段标题）+ 括号密集（>8）
+ * ③ 长文本（>300）+ 高括号密度（>20）+ 无自然语言标点分隔（顿号密集）
+ */
+export function isCardFormat(text) {
+    if (!text)
+        return false;
+    // ① 强信号：矛盾标记句式（「，是『A』vs『B』的矛盾——」）——卡片开头的
+    //    标志性结构，不受长度门槛限制（短卡片也判定）
+    if (/，是『[^』]{1,12}』vs『[^』]{1,12}』的矛盾[——\-]/.test(text))
+        return true;
+    // 短文本（<150）无矛盾标记 → 正常文本
+    if (text.length < 150)
+        return false;
+    // ② 「真相：」+ 括号密集（卡片的分段结构）
+    if (text.includes('真相：')) {
+        const parens = (text.match(/（/g) ?? []).length;
+        if (parens >= 8)
+            return true;
+    }
+    // ③ 超长 + 极高括号密度（卡片展开体）
+    const parens2 = (text.match(/（/g) ?? []).length;
+    if (text.length > 300 && parens2 > 20)
+        return true;
+    return false;
+}
+/** 白箱 LLM adapter —— 注册为 DSH 的 provider。 */
+export class WhiteboxLlmAdapter {
+    bridge;
+    fallback;
+    constructor(deps = {}) {
+        this.bridge = deps.bridge;
+        this.fallback = deps.fallback;
+    }
+    providerInfo(provider) {
+        return { id: provider, name: '白箱灵枢 (lingshu-whitebox)' };
+    }
+    providerRetryPolicy() {
+        return undefined;
+    }
+    async listModels() {
+        return [
+            { provider: 'lingshu-whitebox', id: 'whitebox-v1', name: '白箱引擎 v1 (CCG 条件路由)' },
+            { provider: 'lingshu-whitebox', id: 'whitebox-wisdom', name: '白箱智慧之书' },
+        ];
+    }
+    async resolveModel(provider, model) {
+        return { provider, id: model, name: model };
+    }
+    /**
+     * 核心：一次模型调用。白箱优先，无把握降级。
+     * @param options 完全装配的请求（必须 honor options.signal）
+     */
+    async *stream(options) {
+        const inputTokens = countInputTokens(options);
+        const conversation = serializeMessages(options);
+        // 取最后一条用户文本作为白箱输入（完整对话太长时截尾）
+        const lastUserText = [...(options.messages ?? [])]
+            .reverse()
+            .flatMap((m) => m.content ?? [])
+            .filter((b) => b?.type === 'text')
+            .map((b) => b.text)
+            .join('')
+            .slice(-2000);
+        // ---- 白箱主路径：调灵枢 wisdom_chat ----
+        let whitebox = null;
+        if (this.bridge?.isReady?.()) {
+            try {
+                const r = await this.bridge.callTool('wisdom_chat', {
+                    message: lastUserText || conversation.slice(-4000),
+                    session_id: options.sessionId ?? 'default',
+                }, options.signal);
+                const raw = (r?.content ?? []).map((c) => c.text ?? '').join('\n');
+                // 白箱返回结构：{"reply": "...", "route": "self|llm", "hits": [...], "honest": bool}
+                let text = raw;
+                let route = 'self';
+                try {
+                    const parsed = JSON.parse(raw);
+                    if (parsed.route)
+                        route = parsed.route;
+                    if (typeof parsed.reply === 'string')
+                        text = parsed.reply;
+                    else if (parsed.reply !== undefined)
+                        text = JSON.stringify(parsed.reply);
+                }
+                catch { /* 非 JSON = 纯文本回复 */ }
+                // 质量门槛（v0.4.1）：REVERSE_DAILY 卡片直答是知识库内部格式——
+                // 「X是什么…是『A』vs『B』的矛盾——X（是…（…）」重复+括号嵌套，
+                // 直接当 LLM 输出喂给用户=「重复回答」。检测到卡片特征 → 视为
+                // 未命中，走降级 LLM（白箱不输出内部格式垃圾）。
+                if (route !== 'llm' && text && text.trim() && !isCardFormat(text)) {
+                    whitebox = { text: text.trim(), route };
+                }
+                else if (text && isCardFormat(text)) {
+                    console.warn('[whitebox-llm] 白箱返回知识卡片格式，降级 LLM（内部格式不直出）');
+                }
+            }
+            catch (err) {
+                // 白箱异常不阻塞——记日志后走降级
+                console.warn('[whitebox-llm] 白箱调用失败，降级:', String(err));
+            }
+        }
+        if (whitebox) {
+            const outputTokens = estimateTokens(whitebox.text);
+            // 白箱直答 = 全缓存命中（条件路由固化命中，零推理成本）
+            yield* wrapTextStream(whitebox.text, inputTokens, outputTokens, inputTokens);
+            return;
+        }
+        // ---- 降级路径：白箱无把握 / 桥未就绪 ----
+        if (this.fallback) {
+            console.warn('[whitebox-llm] 白箱未命中，转降级 LLM');
+            yield* this.fallback.stream(options);
+            return;
+        }
+        // 无降级可用：诚实声明（盲区 28：未来承诺不可检验——不假装回答）
+        const honest = '（白箱引擎未命中且降级 LLM 未配置——按白箱纪律，我诚实声明不知道，不编造答案。）';
+        yield* wrapTextStream(honest, inputTokens, estimateTokens(honest), 0);
+    }
+}
+/** provider 路由名（设置页「模型」下拉可见）。 */
+export const WHITEBOX_PROVIDER = 'lingshu-whitebox';
+/**
+ * 注册白箱 provider 到 DSH llm 服务（动态检测，不强依赖 llm 服务——
+ * 最小 host 无 llm 时跳过，插件其余功能不受影响）。
+ * @returns 注销函数；未注册返回 noop。
+ */
+export function installWhiteboxLlm(ctx, bridge) {
+    // 动态检测 llm 服务（P1 模式：timer/webServer 同理）。
+    // 注意：不能直接读 ctx.llm——Cordis 未声明 inject 的属性访问会抛
+    // "cannot get property without inject"；ctx.get('llm') 安全返回 undefined。
+    const llm = ctx.get('llm');
+    if (!llm?.registerAdapter) {
+        ctx.logger?.info?.('dsh-memory: llm 服务不可用，跳过白箱 provider 注册（最小 host）');
+        return () => { };
+    }
+    // 降级 LLM：白箱未命中时转发给 fallbackProvider 路由（默认 deepseek-official，
+    // 可在 settings.yaml 的 llm-whitebox.fallbackProvider 覆盖）。通过 llm.stream
+    // 重路由——保持 DSH 的全链路（重试/瀑布流/用量计量）。
+    const fallbackProvider = 'deepseek-official';
+    const fallback = llm.stream
+        ? {
+            stream(options) {
+                return llm.stream({ ...options, provider: fallbackProvider });
+            },
+        }
+        : undefined;
+    const adapter = new WhiteboxLlmAdapter({ bridge, fallback });
+    try {
+        llm.registerConfigurableProviders?.([{
+                provider: WHITEBOX_PROVIDER,
+                displayName: '白箱灵枢 (Whitebox)',
+                settingsNs: 'llm-whitebox',
+                settingsPath: [],
+            }]);
+        const registration = llm.registerAdapter([WHITEBOX_PROVIDER], adapter);
+        ctx.logger?.info?.('dsh-memory: 白箱 LLM provider 已注册: %s（降级→%s）', WHITEBOX_PROVIDER, fallbackProvider);
+        return () => { try {
+            registration?.replace?.([]);
+        }
+        catch { /* 忽略注销异常 */ } };
+    }
+    catch (err) {
+        ctx.logger?.warn?.('dsh-memory: 白箱 provider 注册失败: %s', String(err));
+        return () => { };
+    }
+}

package/lib/mutual.d.ts

@@ -97,7 +97,6 @@ export declare function installMutualMaintenance(ctx: {
     logger: {
         info(m: string): void;
     };
-    interval(fn: () => void, ms: number): () => void;
     effect(fn: () => () => void, name?: string): void;
 }, config?: Partial<MutualOptions>, hooks?: {
     verify?: (c: string) => Promise<{

package/lib/mutual.js

@@ -296,7 +296,10 @@ export function installMutualMaintenance(ctx, config = {}, hooks = {}) {
     // P1 修复（GPT 审查）：cordis-plugin-timer 签名是 interval(callback, delay)
     // ——此前 (ms, fn) 写反：数字被当 callback、函数被当 delay，回调永不执行，
     // 互维心跳/任务扫描实际不工作。
-    const heartbeatDispose = ctx.interval(() => {
+    // P2 修复：不能用 ctx.interval——那是 cordis-plugin-timer 注入的快捷属性，
+    // 未声明 `timer` inject 时访问抛 "cannot get property without inject"。
+    // 改用 Node 原生 setInterval（互维不需要 Cordis effect 生命周期管理）。
+    const heartbeatTimer = setInterval(() => {
         try {
             writeHeartbeat(opts);
             // 守护 A：harness 不在 → 拉起
@@ -315,8 +318,9 @@ export function installMutualMaintenance(ctx, config = {}, hooks = {}) {
         }
         catch (e) { /* 单次失败不中断 */ }
     }, opts.heartbeatMs);
+    heartbeatTimer.unref?.();
     // 2. 任务轮询（30s 周期，检查 A→B 任务）
-    const taskDispose = ctx.interval(() => {
+    const taskTimer = setInterval(() => {
         try {
             const tasks = scanTasks(opts);
             for (const t of tasks) {
@@ -329,12 +333,13 @@ export function installMutualMaintenance(ctx, config = {}, hooks = {}) {
         }
         catch (e) { /* 单次失败不中断 */ }
     }, 30_000);
+    taskTimer.unref?.();
     // 3. effect 作用域清理
     ctx.effect(() => {
         return () => {
             try {
-                heartbeatDispose();
-                taskDispose();
+                clearInterval(heartbeatTimer);
+                clearInterval(taskTimer);
             }
             catch { /* 清理失败不阻塞 */ }
         };

package/lib/roleplay_web.js

@@ -438,7 +438,9 @@ window.addEventListener('resize', function () { if (chat) chat.scrollTop = chat.
 /** 在 webServer 上挂载 /roleplay 前缀路由（页面 + API）。失败不影响插件主体。 */
 export async function installRoleplayWeb(ctx, bridge, config, disposers) {
     try {
-        const webServer = ctx.webServer;
+        // 注意：不能直接读 ctx.webServer——Cordis 未声明 inject 的属性访问会抛
+        // "cannot get property without inject"；ctx.get() 安全返回 undefined。
+        const webServer = ctx.get('webServer');
         if (!webServer) {
             ctx.logger.warn('dsh-memory: webServer 服务不可用，跳过角色扮演网页挂载');
             return;

package/lib/tools.d.ts

@@ -14,7 +14,7 @@ export declare const CORE_TOOLS: readonly ["remember", "recall", "search", "time
  * 保留灵枢全部心智能力（记忆/认知/推理/学习/飞轮/反思/长期记忆门），
  * 排除身体/视觉类工具（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"];
+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_metrics", "transfer_test", "calibrate", "ingest_text", "ingest_file", "ingest_url", "web_search", "lifecycle_step", "lifecycle_state", "longterm_snapshot", "promote_memories", "service_info"];
 /** tools 配置：'core' | 'brain' | 'all' | 显式名称数组。 */
 export type ToolSelection = 'core' | 'brain' | 'all' | string[];
 /** 按工具名判定并发安全（只读查询 true；写操作 false） */

package/lib/tools.js

@@ -39,11 +39,11 @@ export const BRAIN_TOOLS = [
     // 学习与盲区
     'blindspots', 'learn', 'induce',
     // 知识飞轮
-    'distill', 'flywheel_report', 'transfer_test', 'calibrate',
+    'distill', 'flywheel_metrics', 'transfer_test', 'calibrate',
     // 外部知识摄取
     'ingest_text', 'ingest_file', 'ingest_url', 'web_search',
     // 生命周期
-    'step', 'lifecycle_state',
+    'lifecycle_step', 'lifecycle_state',
     // 长期记忆门（v1.15：重要性评估主动沉淀）
     'longterm_snapshot', 'promote_memories',
     // 服务
@@ -55,7 +55,7 @@ export const BRAIN_TOOLS = [
 const READ_TOOLS = new Set([
     'recall', 'search', 'timeline', 'think', 'reason', 'predict_routes',
     'self_check', 'service_info', 'session_recall', 'gap_trend', 'transfer_test',
-    'cognition_report', 'self_reliability', 'emotional_bias', 'flywheel_report',
+    'cognition_report', 'self_reliability', 'emotional_bias', 'flywheel_metrics',
     'distill', 'insight_report', 'prediction_stats', 'blindspots', 'pattern_separation',
 ]);
 /** 按工具名判定并发安全（只读查询 true；写操作 false） */

package/package.json

@@ -1,6 +1,6 @@
-{
+{
   "name": "@furongjun1999/dsh-memory",
-  "version": "0.3.0",
+  "version": "0.3.1",
   "description": "灵枢（Lingshu·líng shū）DeepSeek Harness 插件：完整大脑——长期记忆/知识飞轮/自我认知/递归反思接入 DSH，对话自动沉淀进记忆库",
   "type": "module",
   "main": "lib/index.js",
@@ -35,12 +35,19 @@
   "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",

package/src/bridge.ts

@@ -9,8 +9,26 @@
 
 import { spawn, type ChildProcess } 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: string): void {
+  try {
+    if (!debugLogDirReady) {
+      mkdirSync(dirname(DEBUG_LOG), { recursive: true })
+      debugLogDirReady = true
+    }
+    appendFileSync(DEBUG_LOG, `[${new Date().toISOString()}] ${msg}\n`)
+  } catch { /* 探针失败忽略 */ }
+}
 
 /** 灵枢 MCP server 暴露的原始工具（tools/list 结果项）。 */
 export interface McpTool {
@@ -47,6 +65,14 @@ interface PendingCall {
   timer: NodeJS.Timeout
 }
 
+/**
+ * 连续启动失败的最大重试次数（issue #6）：指数退避到 maxRetryDelayMs 后
+ * 若无上限，python 环境损坏时会以 30s 间隔永久空转（假激活 + 资源浪费）。
+ * 达到上限即进入 failed 终态并停止调度；后续所有请求快速失败并给出
+ * 明确的修复指引。握手成功后计数归零——运行期偶发崩溃重启不受影响。
+ */
+const MAX_RETRIES = 8
+
 export class LingshuBridge {
   private readonly options: BridgeOptions
   private proc: ChildProcess | null = null
@@ -56,6 +82,7 @@ export class LingshuBridge {
   private started = false
   private disposed = false
   private retryDelayMs = 1000
+  private retries = 0
   private retryTimer: NodeJS.Timeout | null = null
   private bootQueue: Array<(ok: boolean) => void> = []
   private readyState: 'pending' | 'ok' | 'failed' = 'pending'
@@ -113,6 +140,11 @@ export class LingshuBridge {
     return this.readyState === 'ok'
   }
 
+  /** 是否已达放弃终态（连续启动失败超上限，不再自动重启）。 */
+  get gaveUp(): boolean {
+    return this.retries >= MAX_RETRIES
+  }
+
   /** 等待握手完成（用于 apply 阶段同步就绪）。 */
   waitReady(): Promise<boolean> {
     if (this.readyState === 'ok') return Promise.resolve(true)
@@ -166,6 +198,7 @@ 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()
@@ -173,6 +206,8 @@ export class LingshuBridge {
     })
 
     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
@@ -197,12 +232,16 @@ 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 as Error).message}`)
+        probe(`handshake failed: ${String(err)}`)
         this.readyState = 'failed'
         this.flushBootQueue(false)
         this.scheduleRetry()
@@ -211,9 +250,22 @@ export class LingshuBridge {
   }
 
   private scheduleRetry(): void {
-    if (this.disposed || this.retryTimer) return
+    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) this.spawnAndHandshake()
@@ -231,6 +283,12 @@ export class LingshuBridge {
 
   private request(method: string, params: Record<string, unknown>,
                   signal?: AbortSignal): Promise<unknown> {
+    // 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

package/src/index.ts

@@ -19,11 +19,30 @@
 
 import type { Context } from '@deepseek-ai/cordis'
 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, type McpCallResult } from './bridge.js'
 import { registerLingshuTools, type ToolSelection } from './tools.js'
 import { installMemoryHooks, type MemoryHooksOptions } 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: unknown): void {
+  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 as Error).stack ?? ''}\n`)
+  } catch { /* 探针失败忽略 */ }
+}
+
 export const name = 'dsh-memory'
 
 /** P1 修复（GPT 审查）：MCP 调用的标准结果在 content[].text，
@@ -173,11 +192,21 @@ export async function apply(ctx: Context, config: Config): Promise<void> {
     // 角色扮演网页（同源挂载 /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) {
       // P1 修复（GPT 审查）：timer 是可选服务——缺失时告警跳过互维，
-      // 不让插件因互维而阻塞（inject 已不再强声明 timer）
-      const hasTimer = (ctx as { timer?: unknown }).timer !== undefined
+      // 不让插件因互维而阻塞（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 {
@@ -223,6 +252,8 @@ export async function apply(ctx: Context, config: Config): Promise<void> {
       }
     }
   } catch (err) {
+    // 探针：记录 apply 失败的具体错误（定位插件加载失败根因）
+    probeApplyError(err)
     bridge.dispose()
     throw err
   }