dsh-layered-memory 0.5.3

package/dist/hooks/recall.js

@@ -0,0 +1,201 @@
+import { blocksToText } from '../util/text.js';
+const PROFILE_TTL = 60_000;
+const MEMORY_TOOLS_GUIDE = `<memory-tools-guide>
+## 记忆工具调用指南
+
+当上方注入的记忆片段不足以回答用户问题时，可主动调用以下工具获取更多信息：
+
+- **memory_search**：搜索结构化记忆（L1），适用于回忆用户偏好、历史事件、项目事实、任务、规则等。
+- **conversation_search**：搜索原始对话（L0），适用于查找具体消息原文、时间线、上下文细节。
+- **memory_read_scene**：读取记忆文件详情（L2 场景块，如场景目录下的 .md 文件；也可读 persona.md）。
+
+### ⚠️ 调用次数限制
+每轮对话中，memory_search 和 conversation_search **合计最多调用 3 次**。
+- 首次搜索无结果时，可换关键词或换工具重试，但总调用次数不要超过 3 次。
+- 若 3 次搜索后仍无结果，说明该信息不在记忆中，请直接根据已有信息回复用户。
+</memory-tools-guide>`;
+export function registerRecall(ctx, cfg, stores, logger, live, modes) {
+    const l1Cache = new Map();
+    // 画像/场景导航按族缓存（分族隔离：注入时按会话档位选族）
+    const profileCache = {
+        chat: { persona: '', nav: '' },
+        work: { persona: '', nav: '' },
+    };
+    const refreshProfile = async () => {
+        try {
+            const [chat, work] = await Promise.all([
+                loadProfileParts(stores, cfg, 'chat'),
+                loadProfileParts(stores, cfg, 'work'),
+            ]);
+            profileCache.chat = chat;
+            profileCache.work = work;
+        }
+        catch (err) {
+            logger.warn(`[memory] 画像/场景缓存刷新失败: ${err instanceof Error ? err.message : String(err)}`);
+        }
+    };
+    // 初始刷新 + 定时刷新（TTL）
+    void refreshProfile();
+    ctx.effect(() => {
+        const timer = setInterval(() => void refreshProfile(), PROFILE_TTL);
+        return () => clearInterval(timer);
+    });
+    const invalidateProfile = () => {
+        void refreshProfile();
+    };
+    // agent 销毁时清掉召回缓存槽
+    ctx.on('agent/disposed', (payload) => {
+        l1Cache.delete(payload.agent.id);
+    });
+    // ── 1. pre-step：检索并缓存（按会话档位过滤族：纯档只查本族，auto 不过滤，off 跳过） ──
+    if (cfg.recall.enabled) {
+        ctx.on('agent/pre-step', async (payload, next) => {
+            try {
+                const s = live.get();
+                const mode = modes.get(payload.agent.id);
+                if (!s.enabled || !s.recall || mode === 'off') {
+                    l1Cache.set(payload.agent.id, []);
+                    return next();
+                }
+                const query = payload.messages
+                    .map((m) => blocksToText(m.content))
+                    .join(' ')
+                    .trim();
+                if (query) {
+                    const hits = await stores.l1.search(query, cfg.recall.maxResults, {
+                        scoreThreshold: cfg.recall.scoreThreshold,
+                        family: mode === 'auto' ? undefined : mode,
+                    });
+                    l1Cache.set(payload.agent.id, hits);
+                    if (hits.length > 0) {
+                        logger.info(`[memory] 召回命中 ${hits.length} 条 L1（mode=${mode}，query="${query.slice(0, 30).replace(/\n/g, ' ')}…"，agent=${payload.agent.id}）`);
+                    }
+                }
+            }
+            catch (err) {
+                logger.warn(`[memory] 召回检索失败: ${err instanceof Error ? err.message : String(err)}`);
+            }
+            return next();
+        });
+    }
+    // ── 2. agent 作用域上下文 provider ──
+    // 插件可能在默认 agent 创建之后才加载（组合顺序由依赖决定），
+    // 因此除了监听 agent/created，还要给已存在的 agent 补注册。
+    const registered = new WeakSet();
+    // context() 的 disposer 必须挂到插件自身生命周期：agent.ctx 比插件实例活得久，
+    // 不主动清理会导致热重载后旧注册泄漏、新实例撞名（"already registered"）
+    const contextDisposers = [];
+    const registerForAgent = (agent) => {
+        if (registered.has(agent))
+            return;
+        registered.add(agent);
+        try {
+            contextDisposers.push(agent.ctx.systemPrompt.context({
+                name: 'memory:recall',
+                order: 500,
+                text: () => {
+                    const s = live.get();
+                    if (!s.enabled || !s.recall)
+                        return '';
+                    const hits = l1Cache.get(agent.id) ?? [];
+                    return formatL1Memories(hits);
+                },
+            }), agent.ctx.systemPrompt.context({
+                name: 'memory:profile',
+                order: 510,
+                text: () => {
+                    const s = live.get();
+                    if (!s.enabled || !s.recall)
+                        return '';
+                    const mode = modes.get(agent.id);
+                    if (mode === 'off')
+                        return '';
+                    // auto 档：两族按类别归组（画像/导航各一个标签，域内 <domain> 分块）；纯档：单族原格式
+                    const body = mode === 'auto'
+                        ? formatProfileAuto(profileCache.chat, profileCache.work)
+                        : formatProfileSingle(profileCache[mode]);
+                    if (!body)
+                        return MEMORY_TOOLS_GUIDE;
+                    return `${body}\n\n${MEMORY_TOOLS_GUIDE}`;
+                },
+            }));
+        }
+        catch (err) {
+            logger.warn(`[memory] 召回上下文注册失败: ${err instanceof Error ? err.message : String(err)}`);
+        }
+    };
+    const agents = ctx.get('agents');
+    if (agents) {
+        for (const agent of agents.list())
+            registerForAgent(agent);
+    }
+    ctx.on('agent/created', (payload) => {
+        registerForAgent(payload.agent);
+    });
+    ctx.effect(() => () => {
+        for (const dispose of contextDisposers.splice(0)) {
+            try {
+                dispose();
+            }
+            catch {
+                /* agent 可能已先一步销毁 */
+            }
+        }
+    });
+    return { invalidateProfile };
+}
+function formatL1Memories(items) {
+    if (items.length === 0)
+        return '';
+    const lines = ['<relevant-memories>', ''];
+    for (const item of items) {
+        // [type|scene] 标签 + 内容（官方召回行格式）
+        const tag = item.scene_name ? `${item.type}|${item.scene_name}` : item.type;
+        lines.push(`- [${tag}] ${item.content}`);
+    }
+    lines.push('', '</relevant-memories>');
+    return lines.join('\n');
+}
+/** auto 档 <user-persona> 内的域说明：让模型理解分块结构与两域的独立性。 */
+const DOMAIN_HINT = '以下内容按记忆域分块：chat=用户个人画像（User Narrative Profile），work=团队工作准则（Team Operating Doctrine）。' +
+    '两域独立蒸馏与更新，请按当前对话语境参考对应域，不要把一域的内容当作另一域的事实。';
+function wrapDomain(family, content) {
+    const label = family === 'chat' ? '用户个人画像' : '团队工作准则';
+    return `<domain family="${family}" label="${label}">\n${content.trim()}\n</domain>`;
+}
+/** 纯档注入：单族画像 + 场景导航（沿用原有格式）。 */
+function formatProfileSingle(parts) {
+    const segments = [];
+    if (parts.persona)
+        segments.push(`<user-persona>\n${parts.persona}\n</user-persona>`);
+    if (parts.nav)
+        segments.push(`<scene-navigation>\n${parts.nav}\n</scene-navigation>`);
+    return segments.join('\n\n');
+}
+/** auto 档注入：两族按类别归组——画像共用一个 <user-persona>、导航共用一个 <scene-navigation>，域内 <domain> 分块。 */
+function formatProfileAuto(chat, work) {
+    const segments = [];
+    const personas = [
+        ['chat', chat.persona],
+        ['work', work.persona],
+    ];
+    const personaBlocks = personas.filter(([, p]) => p.trim()).map(([f, p]) => wrapDomain(f, p));
+    if (personaBlocks.length > 0) {
+        segments.push(`<user-persona>\n${DOMAIN_HINT}\n\n${personaBlocks.join('\n\n')}\n</user-persona>`);
+    }
+    const navs = [
+        ['chat', chat.nav],
+        ['work', work.nav],
+    ];
+    const navBlocks = navs.filter(([, n]) => n.trim()).map(([f, n]) => wrapDomain(f, n));
+    if (navBlocks.length > 0) {
+        segments.push(`<scene-navigation>\n${navBlocks.join('\n\n')}\n</scene-navigation>`);
+    }
+    // 注意：工具指南由注入侧统一附加一次（auto 档不重复）
+    return segments.join('\n\n');
+}
+async function loadProfileParts(stores, cfg, family) {
+    const persona = cfg.recall.includePersona ? ((await stores.persona[family].read()) ?? '') : '';
+    const nav = cfg.recall.includeSceneNav ? ((await stores.scenes[family].navigation()) ?? '').trim() : '';
+    return { persona, nav };
+}

package/dist/index.d.ts

@@ -0,0 +1,190 @@
+import type { Context } from '@deepseek-ai/cordis';
+import { type MemoryConfig } from './config.js';
+export declare const name = "dsh-memory-plugin";
+/** 硬依赖：蒸馏要用 llm，工具注册要用 tools，召回注入要用 systemPrompt。 */
+export declare const inject: string[];
+/**
+ * 插件配置 schema。导出名必须是 `Config`——cordis 运行时只读 plugin.Config
+ * （Standard Schema 接口）做校验与默认值填充；导出 `schema` 会被静默忽略，
+ * 导致 config 里嵌套对象为 undefined、apply 抛错、fiber FAILED 拖垮宿主启动。
+ */
+export declare const Config: import("@deepseek-ai/schemastery").default<Schemastery.ObjectS<{
+    dataDir: import("@deepseek-ai/schemastery").default<string, string>;
+    family: import("@deepseek-ai/schemastery").default<"chat" | "work" | "auto", "chat" | "work" | "auto">;
+    capture: import("@deepseek-ai/schemastery").default<Schemastery.ObjectS<{
+        enabled: import("@deepseek-ai/schemastery").default<boolean, boolean>;
+        stripCodeBlocks: import("@deepseek-ai/schemastery").default<boolean, boolean>;
+        maxMessageChars: import("@deepseek-ai/schemastery").default<number, number>;
+    }>, Schemastery.ObjectT<{
+        enabled: import("@deepseek-ai/schemastery").default<boolean, boolean>;
+        stripCodeBlocks: import("@deepseek-ai/schemastery").default<boolean, boolean>;
+        maxMessageChars: import("@deepseek-ai/schemastery").default<number, number>;
+    }>>;
+    extract: import("@deepseek-ai/schemastery").default<Schemastery.ObjectS<{
+        enabled: import("@deepseek-ai/schemastery").default<boolean, boolean>;
+        minMessages: import("@deepseek-ai/schemastery").default<number, number>;
+        backgroundMessages: import("@deepseek-ai/schemastery").default<number, number>;
+        candidatePool: import("@deepseek-ai/schemastery").default<number, number>;
+    }>, Schemastery.ObjectT<{
+        enabled: import("@deepseek-ai/schemastery").default<boolean, boolean>;
+        minMessages: import("@deepseek-ai/schemastery").default<number, number>;
+        backgroundMessages: import("@deepseek-ai/schemastery").default<number, number>;
+        candidatePool: import("@deepseek-ai/schemastery").default<number, number>;
+    }>>;
+    l2: import("@deepseek-ai/schemastery").default<Schemastery.ObjectS<{
+        enabled: import("@deepseek-ai/schemastery").default<boolean, boolean>;
+        minNewMemories: import("@deepseek-ai/schemastery").default<number, number>;
+        maxScenes: import("@deepseek-ai/schemastery").default<number, number>;
+        sceneContextLimit: import("@deepseek-ai/schemastery").default<number, number>;
+    }>, Schemastery.ObjectT<{
+        enabled: import("@deepseek-ai/schemastery").default<boolean, boolean>;
+        minNewMemories: import("@deepseek-ai/schemastery").default<number, number>;
+        maxScenes: import("@deepseek-ai/schemastery").default<number, number>;
+        sceneContextLimit: import("@deepseek-ai/schemastery").default<number, number>;
+    }>>;
+    l3: import("@deepseek-ai/schemastery").default<Schemastery.ObjectS<{
+        enabled: import("@deepseek-ai/schemastery").default<boolean, boolean>;
+        interval: import("@deepseek-ai/schemastery").default<number, number>;
+    }>, Schemastery.ObjectT<{
+        enabled: import("@deepseek-ai/schemastery").default<boolean, boolean>;
+        interval: import("@deepseek-ai/schemastery").default<number, number>;
+    }>>;
+    recall: import("@deepseek-ai/schemastery").default<Schemastery.ObjectS<{
+        enabled: import("@deepseek-ai/schemastery").default<boolean, boolean>;
+        maxResults: import("@deepseek-ai/schemastery").default<number, number>;
+        includePersona: import("@deepseek-ai/schemastery").default<boolean, boolean>;
+        includeSceneNav: import("@deepseek-ai/schemastery").default<boolean, boolean>;
+        strategy: import("@deepseek-ai/schemastery").default<"keyword" | "embedding" | "hybrid", "keyword" | "embedding" | "hybrid">;
+        scoreThreshold: import("@deepseek-ai/schemastery").default<number, number>;
+    }>, Schemastery.ObjectT<{
+        enabled: import("@deepseek-ai/schemastery").default<boolean, boolean>;
+        maxResults: import("@deepseek-ai/schemastery").default<number, number>;
+        includePersona: import("@deepseek-ai/schemastery").default<boolean, boolean>;
+        includeSceneNav: import("@deepseek-ai/schemastery").default<boolean, boolean>;
+        strategy: import("@deepseek-ai/schemastery").default<"keyword" | "embedding" | "hybrid", "keyword" | "embedding" | "hybrid">;
+        scoreThreshold: import("@deepseek-ai/schemastery").default<number, number>;
+    }>>;
+    embedding: import("@deepseek-ai/schemastery").default<Schemastery.ObjectS<{
+        enabled: import("@deepseek-ai/schemastery").default<boolean, boolean>;
+        baseUrl: import("@deepseek-ai/schemastery").default<string, string>;
+        apiKey: import("@deepseek-ai/schemastery").default<string, string>;
+        model: import("@deepseek-ai/schemastery").default<string, string>;
+        dimensions: import("@deepseek-ai/schemastery").default<number, number>;
+        maxInputChars: import("@deepseek-ai/schemastery").default<number, number>;
+        timeoutMs: import("@deepseek-ai/schemastery").default<number, number>;
+    }>, Schemastery.ObjectT<{
+        enabled: import("@deepseek-ai/schemastery").default<boolean, boolean>;
+        baseUrl: import("@deepseek-ai/schemastery").default<string, string>;
+        apiKey: import("@deepseek-ai/schemastery").default<string, string>;
+        model: import("@deepseek-ai/schemastery").default<string, string>;
+        dimensions: import("@deepseek-ai/schemastery").default<number, number>;
+        maxInputChars: import("@deepseek-ai/schemastery").default<number, number>;
+        timeoutMs: import("@deepseek-ai/schemastery").default<number, number>;
+    }>>;
+    llm: import("@deepseek-ai/schemastery").default<Schemastery.ObjectS<{
+        provider: import("@deepseek-ai/schemastery").default<string, string>;
+        model: import("@deepseek-ai/schemastery").default<string, string>;
+        maxTokens: import("@deepseek-ai/schemastery").default<number, number>;
+        temperature: import("@deepseek-ai/schemastery").default<number, number>;
+        maxInputChars: import("@deepseek-ai/schemastery").default<number, number>;
+        timeoutMs: import("@deepseek-ai/schemastery").default<number, number>;
+    }>, Schemastery.ObjectT<{
+        provider: import("@deepseek-ai/schemastery").default<string, string>;
+        model: import("@deepseek-ai/schemastery").default<string, string>;
+        maxTokens: import("@deepseek-ai/schemastery").default<number, number>;
+        temperature: import("@deepseek-ai/schemastery").default<number, number>;
+        maxInputChars: import("@deepseek-ai/schemastery").default<number, number>;
+        timeoutMs: import("@deepseek-ai/schemastery").default<number, number>;
+    }>>;
+    tools: import("@deepseek-ai/schemastery").default<boolean, boolean>;
+}>, Schemastery.ObjectT<{
+    dataDir: import("@deepseek-ai/schemastery").default<string, string>;
+    family: import("@deepseek-ai/schemastery").default<"chat" | "work" | "auto", "chat" | "work" | "auto">;
+    capture: import("@deepseek-ai/schemastery").default<Schemastery.ObjectS<{
+        enabled: import("@deepseek-ai/schemastery").default<boolean, boolean>;
+        stripCodeBlocks: import("@deepseek-ai/schemastery").default<boolean, boolean>;
+        maxMessageChars: import("@deepseek-ai/schemastery").default<number, number>;
+    }>, Schemastery.ObjectT<{
+        enabled: import("@deepseek-ai/schemastery").default<boolean, boolean>;
+        stripCodeBlocks: import("@deepseek-ai/schemastery").default<boolean, boolean>;
+        maxMessageChars: import("@deepseek-ai/schemastery").default<number, number>;
+    }>>;
+    extract: import("@deepseek-ai/schemastery").default<Schemastery.ObjectS<{
+        enabled: import("@deepseek-ai/schemastery").default<boolean, boolean>;
+        minMessages: import("@deepseek-ai/schemastery").default<number, number>;
+        backgroundMessages: import("@deepseek-ai/schemastery").default<number, number>;
+        candidatePool: import("@deepseek-ai/schemastery").default<number, number>;
+    }>, Schemastery.ObjectT<{
+        enabled: import("@deepseek-ai/schemastery").default<boolean, boolean>;
+        minMessages: import("@deepseek-ai/schemastery").default<number, number>;
+        backgroundMessages: import("@deepseek-ai/schemastery").default<number, number>;
+        candidatePool: import("@deepseek-ai/schemastery").default<number, number>;
+    }>>;
+    l2: import("@deepseek-ai/schemastery").default<Schemastery.ObjectS<{
+        enabled: import("@deepseek-ai/schemastery").default<boolean, boolean>;
+        minNewMemories: import("@deepseek-ai/schemastery").default<number, number>;
+        maxScenes: import("@deepseek-ai/schemastery").default<number, number>;
+        sceneContextLimit: import("@deepseek-ai/schemastery").default<number, number>;
+    }>, Schemastery.ObjectT<{
+        enabled: import("@deepseek-ai/schemastery").default<boolean, boolean>;
+        minNewMemories: import("@deepseek-ai/schemastery").default<number, number>;
+        maxScenes: import("@deepseek-ai/schemastery").default<number, number>;
+        sceneContextLimit: import("@deepseek-ai/schemastery").default<number, number>;
+    }>>;
+    l3: import("@deepseek-ai/schemastery").default<Schemastery.ObjectS<{
+        enabled: import("@deepseek-ai/schemastery").default<boolean, boolean>;
+        interval: import("@deepseek-ai/schemastery").default<number, number>;
+    }>, Schemastery.ObjectT<{
+        enabled: import("@deepseek-ai/schemastery").default<boolean, boolean>;
+        interval: import("@deepseek-ai/schemastery").default<number, number>;
+    }>>;
+    recall: import("@deepseek-ai/schemastery").default<Schemastery.ObjectS<{
+        enabled: import("@deepseek-ai/schemastery").default<boolean, boolean>;
+        maxResults: import("@deepseek-ai/schemastery").default<number, number>;
+        includePersona: import("@deepseek-ai/schemastery").default<boolean, boolean>;
+        includeSceneNav: import("@deepseek-ai/schemastery").default<boolean, boolean>;
+        strategy: import("@deepseek-ai/schemastery").default<"keyword" | "embedding" | "hybrid", "keyword" | "embedding" | "hybrid">;
+        scoreThreshold: import("@deepseek-ai/schemastery").default<number, number>;
+    }>, Schemastery.ObjectT<{
+        enabled: import("@deepseek-ai/schemastery").default<boolean, boolean>;
+        maxResults: import("@deepseek-ai/schemastery").default<number, number>;
+        includePersona: import("@deepseek-ai/schemastery").default<boolean, boolean>;
+        includeSceneNav: import("@deepseek-ai/schemastery").default<boolean, boolean>;
+        strategy: import("@deepseek-ai/schemastery").default<"keyword" | "embedding" | "hybrid", "keyword" | "embedding" | "hybrid">;
+        scoreThreshold: import("@deepseek-ai/schemastery").default<number, number>;
+    }>>;
+    embedding: import("@deepseek-ai/schemastery").default<Schemastery.ObjectS<{
+        enabled: import("@deepseek-ai/schemastery").default<boolean, boolean>;
+        baseUrl: import("@deepseek-ai/schemastery").default<string, string>;
+        apiKey: import("@deepseek-ai/schemastery").default<string, string>;
+        model: import("@deepseek-ai/schemastery").default<string, string>;
+        dimensions: import("@deepseek-ai/schemastery").default<number, number>;
+        maxInputChars: import("@deepseek-ai/schemastery").default<number, number>;
+        timeoutMs: import("@deepseek-ai/schemastery").default<number, number>;
+    }>, Schemastery.ObjectT<{
+        enabled: import("@deepseek-ai/schemastery").default<boolean, boolean>;
+        baseUrl: import("@deepseek-ai/schemastery").default<string, string>;
+        apiKey: import("@deepseek-ai/schemastery").default<string, string>;
+        model: import("@deepseek-ai/schemastery").default<string, string>;
+        dimensions: import("@deepseek-ai/schemastery").default<number, number>;
+        maxInputChars: import("@deepseek-ai/schemastery").default<number, number>;
+        timeoutMs: import("@deepseek-ai/schemastery").default<number, number>;
+    }>>;
+    llm: import("@deepseek-ai/schemastery").default<Schemastery.ObjectS<{
+        provider: import("@deepseek-ai/schemastery").default<string, string>;
+        model: import("@deepseek-ai/schemastery").default<string, string>;
+        maxTokens: import("@deepseek-ai/schemastery").default<number, number>;
+        temperature: import("@deepseek-ai/schemastery").default<number, number>;
+        maxInputChars: import("@deepseek-ai/schemastery").default<number, number>;
+        timeoutMs: import("@deepseek-ai/schemastery").default<number, number>;
+    }>, Schemastery.ObjectT<{
+        provider: import("@deepseek-ai/schemastery").default<string, string>;
+        model: import("@deepseek-ai/schemastery").default<string, string>;
+        maxTokens: import("@deepseek-ai/schemastery").default<number, number>;
+        temperature: import("@deepseek-ai/schemastery").default<number, number>;
+        maxInputChars: import("@deepseek-ai/schemastery").default<number, number>;
+        timeoutMs: import("@deepseek-ai/schemastery").default<number, number>;
+    }>>;
+    tools: import("@deepseek-ai/schemastery").default<boolean, boolean>;
+}>>;
+export declare function apply(ctx: Context, config: MemoryConfig): Promise<void>;

package/dist/index.js

@@ -0,0 +1,234 @@
+/**
+ * dsh-memory-plugin — L0~L3 分层蒸馏记忆插件（持久组合插件）。
+ *
+ * 功能：
+ * - L0：订阅 session/event，按轮次捕获原始对话，双写 JSONL 事实源 + SQLite 检索库；
+ * - L1：LLM 抽取原子记忆（情境切分 + 记忆提取）+ 冲突检测去重 + FTS/向量/混合检索；
+ * - L2：LLM 把新记忆整合为场景块（Markdown，META 块 + 热度管理 + 场景导航）；
+ * - L3：LLM 从变化场景蒸馏 persona.md（chat=用户画像 / work=Team Operating Doctrine）；
+ * - 召回：agent/pre-step 检索 L1，agent 作用域上下文注入画像/场景导航/工具指南；
+ * - 工具：memory_search / conversation_search / memory_read_scene。
+ *
+ * 存储架构（对齐 MemoryCore 官方双写设计）：
+ * - JSONL 追加文件（conversations/、records/ 按天分片）= 备份/恢复事实源；
+ * - memory.db（node:sqlite + WAL + FTS5 BM25 + sqlite-vec 余弦向量）= 主检索引擎。
+ *
+ * 移植自 MemoryCore（TencentDB Agent Memory）的 L0~L3 设计，Prompt 原样保留，
+ * 仅把"LLM 操作文件"的 L2/L3 流程适配为"LLM 输出、工程侧执行"。
+ */
+import * as path from 'node:path';
+import { memorySchema, resolveDataDir } from './config.js';
+import { registerCapture } from './hooks/capture.js';
+import { registerRecall } from './hooks/recall.js';
+import { MemoryRunner } from './pipeline/runner.js';
+import { registerMemoryRpc, PLUGIN_VERSION } from './stats.js';
+import { registerLiveSettings } from './settings.js';
+import { NoopEmbeddingService, RemoteEmbeddingService, } from './store/embedding.js';
+import { ensureDir } from './store/io.js';
+import { L0Store } from './store/l0.js';
+import { L1Store } from './store/l1.js';
+import { PersonaStore } from './store/persona.js';
+import { MemoryDb } from './store/sqlite.js';
+import { SceneStore } from './store/scenes.js';
+import { SessionModeStore } from './store/session-modes.js';
+import { StateStore } from './store/state.js';
+import { registerMemoryTools } from './tools/index.js';
+import { errDetail, withFileLog } from './util/filelog.js';
+import { resolveModelRoute } from './llm.js';
+export const name = 'dsh-memory-plugin';
+/** 硬依赖：蒸馏要用 llm，工具注册要用 tools，召回注入要用 systemPrompt。 */
+export const inject = ['llm', 'tools', 'systemPrompt'];
+/**
+ * 插件配置 schema。导出名必须是 `Config`——cordis 运行时只读 plugin.Config
+ * （Standard Schema 接口）做校验与默认值填充；导出 `schema` 会被静默忽略，
+ * 导致 config 里嵌套对象为 undefined、apply 抛错、fiber FAILED 拖垮宿主启动。
+ */
+export const Config = memorySchema;
+/** 按配置构造 embedding 服务：未启用或配置不完整 → Noop（纯 FTS 运行）。 */
+function createEmbeddingService(cfg, logger) {
+    if (!cfg.embedding.enabled)
+        return new NoopEmbeddingService();
+    const { baseUrl, apiKey, model, dimensions } = cfg.embedding;
+    if (!baseUrl || !apiKey || !model || dimensions <= 0) {
+        logger.error('[memory] embedding.enabled=true 但 baseUrl/apiKey/model/dimensions 未配置完整，向量检索停用（纯 FTS 运行）');
+        return new NoopEmbeddingService();
+    }
+    return new RemoteEmbeddingService({
+        baseUrl,
+        apiKey,
+        model,
+        dimensions,
+        maxInputChars: cfg.embedding.maxInputChars,
+        timeoutMs: cfg.embedding.timeoutMs,
+        logger,
+    });
+}
+export async function apply(ctx, config) {
+    let logger = {
+        debug: (m) => ctx.logger.debug(m),
+        info: (m) => ctx.logger.info(m),
+        warn: (m) => ctx.logger.warn(m),
+        error: (m) => ctx.logger.error(m),
+    };
+    const dataDir = resolveDataDir(config);
+    // dsh 宿主无持久化日志，镜像 info+ 到数据目录 memory.log 供蒸馏问题诊断
+    const fileLogger = withFileLog(dataDir, logger);
+    logger = fileLogger;
+    // 存储初始化失败只降级（禁用捕获/蒸馏），绝不拖垮宿主——
+    // 记忆是增强能力，数据目录不可写时 dsh 本体必须照常启动。
+    let storageOk = true;
+    try {
+        await ensureDir(dataDir);
+    }
+    catch (err) {
+        storageOk = false;
+        logger.error(`[memory] 数据目录不可写，记忆功能停用: ${dataDir} (${err instanceof Error ? err.message : String(err)})`);
+    }
+    // ── 记忆模式运行时开关（官方 settings 服务，live 生效；缺失时恒开） ──
+    const live = registerLiveSettings(ctx, logger);
+    // ── 会话档位存储（sessionId → auto/chat/work/off；默认档 = config.family） ──
+    const modes = new SessionModeStore(dataDir, config.family, logger);
+    if (storageOk) {
+        try {
+            await modes.init();
+        }
+        catch (err) {
+            logger.warn(`[memory] 会话档位载入失败（降级为默认档内存态）: ${err instanceof Error ? err.message : String(err)}`);
+        }
+    }
+    // ── 检索引擎（memory.db）与向量服务 ──
+    const embed = createEmbeddingService(config, logger);
+    const db = new MemoryDb(path.join(dataDir, 'memory.db'), embed.getDimensions(), logger);
+    // 插件卸载时关闭连接（WAL 落盘），注册一次即可
+    ctx.effect(() => () => db.close());
+    let dbInit = { needsReindex: false };
+    if (storageOk) {
+        try {
+            dbInit = db.init(embed.isReady() ? embed.getProviderInfo() : undefined);
+            if (db.isDegraded()) {
+                storageOk = false;
+                logger.error('[memory] 检索库初始化失败（schema/FTS 不可用），记忆功能停用');
+            }
+        }
+        catch (err) {
+            storageOk = false;
+            logger.error(`[memory] 检索库打开失败，记忆功能停用: ${err instanceof Error ? err.message : String(err)}`);
+        }
+    }
+    const stores = {
+        l0: new L0Store(dataDir, db, embed, logger),
+        l1: new L1Store(dataDir, db, embed, config.recall.strategy, logger),
+        // L2/L3 分族隔离：各自目录与文件（scenes/chat|work、persona-chat|work.md）
+        scenes: {
+            chat: new SceneStore(dataDir, 'chat', logger),
+            work: new SceneStore(dataDir, 'work', logger),
+        },
+        persona: {
+            chat: new PersonaStore(dataDir, 'chat', logger),
+            work: new PersonaStore(dataDir, 'work', logger),
+        },
+        state: new StateStore(StateStore.pathFor(dataDir)),
+    };
+    if (storageOk) {
+        try {
+            await Promise.all([
+                stores.l0.init(),
+                stores.l1.init(),
+                stores.scenes.chat.init(),
+                stores.scenes.work.init(),
+                stores.persona.chat.init(),
+                stores.persona.work.init(),
+            ]);
+        }
+        catch (err) {
+            storageOk = false;
+            logger.error(`[memory] 存储初始化失败，记忆功能停用: ${err instanceof Error ? err.message : String(err)}`);
+        }
+    }
+    // 检索能力与策略说明（能力位由降级结果决定）
+    const caps = db.getCapabilities();
+    if (storageOk && config.recall.strategy !== 'keyword' && !caps.vectorSearch) {
+        logger.warn(`[memory] 检索策略 ${config.recall.strategy} 需要向量能力（embedding 未启用/不可用），本次运行按 keyword（FTS5 BM25）检索`);
+    }
+    logger.info(`[memory] 数据目录: ${dataDir}（v${PLUGIN_VERSION}，默认档=${config.family}，检索: FTS=${caps.ftsSearch} 向量=${caps.vectorSearch}${storageOk ? '' : '，存储不可用已停用捕获/蒸馏'}）`);
+    // 蒸馏模型路由：启动期解析一次并记录（路由错误是最难事后排查的问题之一）
+    try {
+        const route = await resolveModelRoute(ctx, config);
+        logger.info(`[memory] 蒸馏模型路由: ${route.provider}/${route.model}`);
+    }
+    catch (err) {
+        logger.warn(`[memory] 蒸馏模型路由解析失败: ${errDetail(err)}`);
+    }
+    // embedding 配置变化 → 后台全量重嵌入（不阻塞启动）。
+    // meta 只在重嵌入完全成功后写入（review P7）：过早写入会让下次启动比对通过而跳过补齐。
+    if (storageOk && embed.isReady() && !db.isDegraded()) {
+        const info = embed.getProviderInfo();
+        if (dbInit.needsReindex) {
+            if (caps.vectorSearch) {
+                void (async () => {
+                    try {
+                        const r1 = await stores.l1.reindex();
+                        const r0 = await stores.l0.reindex();
+                        if (r1.failed === 0 && r0.failed === 0) {
+                            db.markEmbeddingSynced(info);
+                            logger.info(`[memory] 向量重建完成：L1 ${r1.written} 条，L0 ${r0.written} 条（原因：${dbInit.reason ?? '配置变化'}）`);
+                        }
+                        else {
+                            logger.warn(`[memory] 向量重建未完成（L1 失败 ${r1.failed}，L0 失败 ${r0.failed}），下次启动/补齐周期重试`);
+                        }
+                    }
+                    catch (err) {
+                        logger.warn(`[memory] 向量重建失败: ${err instanceof Error ? err.message : String(err)}`);
+                    }
+                })();
+            }
+        }
+        else {
+            // meta 已匹配或空库（initSchema 已写入），幂等重写一次
+            db.markEmbeddingSynced(info);
+        }
+        // 周期性向量补齐：嵌入失败的批次/漏网记录自动补上（30 分钟一次，缺量判定幂等）
+        if (caps.vectorSearch) {
+            const backfill = () => {
+                void (async () => {
+                    try {
+                        const l1Missing = db.countL1Vec() >= 0 && db.countL1Vec() < db.countL1();
+                        const l0Missing = db.countL0Vec() >= 0 && db.countL0Vec() < db.countL0();
+                        if (!l1Missing && !l0Missing)
+                            return;
+                        const r1 = await stores.l1.reindex();
+                        const r0 = await stores.l0.reindex();
+                        if (r1.failed === 0 && r0.failed === 0) {
+                            db.markEmbeddingSynced(info);
+                            logger.info(`[memory] 向量补齐完成：L1 ${r1.written} 条，L0 ${r0.written} 条`);
+                        }
+                    }
+                    catch (err) {
+                        logger.warn(`[memory] 向量补齐失败: ${err instanceof Error ? err.message : String(err)}`);
+                    }
+                })();
+            };
+            ctx.effect(() => {
+                const timer = setInterval(backfill, 30 * 60_000);
+                const first = setTimeout(backfill, 60_000);
+                return () => {
+                    clearInterval(timer);
+                    clearTimeout(first);
+                };
+            });
+        }
+    }
+    const runner = new MemoryRunner(ctx, config, stores, logger, live);
+    await runner.init();
+    if (storageOk) {
+        registerCapture(ctx, config, runner, stores.l0, logger, live, modes);
+    }
+    const recall = registerRecall(ctx, config, stores, logger, live, modes);
+    runner.setAfterRun(recall.invalidateProfile);
+    registerMemoryTools(ctx, config, stores, logger, modes);
+    registerMemoryRpc(ctx, config, stores, logger, {
+        degraded: () => !storageOk || db.isDegraded(),
+        pending: () => runner.pendingCount,
+    }, live, modes, dataDir);
+    logger.info(`[memory] L0~L3 分层蒸馏记忆插件就绪（L1 记忆 ${storageOk ? stores.l1.size : 0} 条 | 捕获=${storageOk && config.capture.enabled} | 蒸馏=${storageOk && config.extract.enabled} | 召回=${config.recall.enabled}）`);
+}

package/dist/llm.d.ts

@@ -0,0 +1,32 @@
+/**
+ * LLM 桥：用 DSH 自身的 llm 服务跑蒸馏调用。
+ */
+import type { Context } from '@deepseek-ai/cordis';
+import type { MemoryConfig } from './config.js';
+import type { MemoryLogger } from './types.js';
+export interface LlmCallOptions {
+    system: string;
+    user: string;
+    maxTokens?: number;
+    temperature?: number;
+    signal?: AbortSignal;
+    /** 诊断日志（缺失时静默，不影响调用） */
+    logger?: MemoryLogger;
+}
+/** 解析蒸馏用的 provider/model：配置优先，其次当前默认选择。 */
+export declare function resolveModelRoute(ctx: Context, cfg: MemoryConfig): Promise<{
+    provider: string;
+    model: string;
+}>;
+/**
+ * 一次完整蒸馏调用：流式收集文本，返回最终字符串。
+ * 失败（error/aborted finish）抛错，由调用方兜底。
+ *
+ * 文本只从 block-end（协议保证携带**组装完成的整块**）取；text-delta 仅在
+ * 适配器异常地没有发 block-end 时兜底。两者都累计会把输出翻倍。
+ */
+export declare function callLLM(ctx: Context, cfg: MemoryConfig, opts: LlmCallOptions): Promise<string>;
+/** 带诊断日志的 parseJson：解析失败时记录原始输出摘录（模型输出异常排查的关键信息）。 */
+export declare function parseJsonLogged<T>(raw: string, what: string, logger?: MemoryLogger): T;
+/** 容错地解析 LLM 输出的 JSON（剥掉可能的 ```json 围栏）。 */
+export declare function parseJson<T>(raw: string): T;