dsh-layered-memory 0.5.3

package/dist/config.d.ts

@@ -0,0 +1,263 @@
+/**
+ * 插件配置：Schemastery schema + 类型。
+ *
+ * 默认数据目录：$DSH_HOME/memory（用官方 dshHomePath 解析，DSH_HOME 缺省 ~/.dsh）。
+ */
+import Schema from '@deepseek-ai/schemastery';
+import type { ExtractMode } from './types.js';
+export interface MemoryConfig {
+    /** 数据目录；留空则用 $DSH_HOME/memory。 */
+    dataDir: string;
+    /** 新会话的默认记忆档位：auto（双族自动）| chat（个人）| work（工作）。 */
+    family: ExtractMode;
+    capture: {
+        enabled: boolean;
+        /** 助手消息是否剥离代码块（减少嵌入噪声）。 */
+        stripCodeBlocks: boolean;
+        /** 单条消息内容最大字符数。 */
+        maxMessageChars: number;
+    };
+    extract: {
+        enabled: boolean;
+        /** 至少攒够多少条新消息才跑一次 L1 抽取（省 token）。 */
+        minMessages: number;
+        /** L1 抽取时的背景消息条数（供上下文推断，不参与提取）。 */
+        backgroundMessages: number;
+        /** 去重候选池大小（每条新记忆的相似候选数）。 */
+        candidatePool: number;
+    };
+    l2: {
+        enabled: boolean;
+        /** 距上次 L2 整合的新记忆达到该数量才触发。 */
+        minNewMemories: number;
+        /** 场景块数量上限。 */
+        maxScenes: number;
+        /** L2 prompt 里附带的相似场景全文数量上限。 */
+        sceneContextLimit: number;
+    };
+    l3: {
+        enabled: boolean;
+        /** 距上次 L3 蒸馏的新记忆数量阈值。 */
+        interval: number;
+    };
+    recall: {
+        enabled: boolean;
+        /** 每步自动召回注入的 L1 条数。 */
+        maxResults: number;
+        includePersona: boolean;
+        includeSceneNav: boolean;
+        /** 检索策略：keyword（FTS5 BM25）| embedding（向量）| hybrid（双路 + RRF 融合）。 */
+        strategy: 'keyword' | 'embedding' | 'hybrid';
+        /** 召回路径分数阈值（0~1，低于该分不注入；工具路径不过滤）。 */
+        scoreThreshold: number;
+    };
+    embedding: {
+        /** 向量检索总开关；关闭时纯 FTS 运行（官方 provider="none" 同款）。 */
+        enabled: boolean;
+        /** OpenAI 兼容 /embeddings 服务地址，如 https://api.siliconflow.cn/v1。 */
+        baseUrl: string;
+        apiKey: string;
+        model: string;
+        /** 向量维度（启用时必填，须与模型输出一致；vec0 建表需要固定维度）。 */
+        dimensions: number;
+        /** 单条文本最大字符数（超长截断）。 */
+        maxInputChars: number;
+        /** 单次调用超时（ms）。 */
+        timeoutMs: number;
+    };
+    llm: {
+        /** 蒸馏用的 provider 路由；留空用当前默认选择。 */
+        provider: string;
+        /** 蒸馏用的模型；留空用当前默认选择。 */
+        model: string;
+        /** 单次蒸馏调用的输出 token 上限（推理模型的 reasoning 与正文共享该预算）。 */
+        maxTokens: number;
+        temperature: number;
+        /** 单次蒸馏调用的用户 prompt 字符预算（≈token 数，按中文 1 字≈1 token 保守估算）。 */
+        maxInputChars: number;
+        /** 单次蒸馏调用超时（ms）。 */
+        timeoutMs: number;
+    };
+    /** 是否注册模型可调用的记忆工具。 */
+    tools: boolean;
+}
+export declare const memorySchema: Schema<Schemastery.ObjectS<{
+    dataDir: Schema<string, string>;
+    family: Schema<"chat" | "work" | "auto", "chat" | "work" | "auto">;
+    capture: Schema<Schemastery.ObjectS<{
+        enabled: Schema<boolean, boolean>;
+        stripCodeBlocks: Schema<boolean, boolean>;
+        maxMessageChars: Schema<number, number>;
+    }>, Schemastery.ObjectT<{
+        enabled: Schema<boolean, boolean>;
+        stripCodeBlocks: Schema<boolean, boolean>;
+        maxMessageChars: Schema<number, number>;
+    }>>;
+    extract: Schema<Schemastery.ObjectS<{
+        enabled: Schema<boolean, boolean>;
+        minMessages: Schema<number, number>;
+        backgroundMessages: Schema<number, number>;
+        candidatePool: Schema<number, number>;
+    }>, Schemastery.ObjectT<{
+        enabled: Schema<boolean, boolean>;
+        minMessages: Schema<number, number>;
+        backgroundMessages: Schema<number, number>;
+        candidatePool: Schema<number, number>;
+    }>>;
+    l2: Schema<Schemastery.ObjectS<{
+        enabled: Schema<boolean, boolean>;
+        minNewMemories: Schema<number, number>;
+        maxScenes: Schema<number, number>;
+        sceneContextLimit: Schema<number, number>;
+    }>, Schemastery.ObjectT<{
+        enabled: Schema<boolean, boolean>;
+        minNewMemories: Schema<number, number>;
+        maxScenes: Schema<number, number>;
+        sceneContextLimit: Schema<number, number>;
+    }>>;
+    l3: Schema<Schemastery.ObjectS<{
+        enabled: Schema<boolean, boolean>;
+        interval: Schema<number, number>;
+    }>, Schemastery.ObjectT<{
+        enabled: Schema<boolean, boolean>;
+        interval: Schema<number, number>;
+    }>>;
+    recall: Schema<Schemastery.ObjectS<{
+        enabled: Schema<boolean, boolean>;
+        maxResults: Schema<number, number>;
+        includePersona: Schema<boolean, boolean>;
+        includeSceneNav: Schema<boolean, boolean>;
+        strategy: Schema<"keyword" | "embedding" | "hybrid", "keyword" | "embedding" | "hybrid">;
+        scoreThreshold: Schema<number, number>;
+    }>, Schemastery.ObjectT<{
+        enabled: Schema<boolean, boolean>;
+        maxResults: Schema<number, number>;
+        includePersona: Schema<boolean, boolean>;
+        includeSceneNav: Schema<boolean, boolean>;
+        strategy: Schema<"keyword" | "embedding" | "hybrid", "keyword" | "embedding" | "hybrid">;
+        scoreThreshold: Schema<number, number>;
+    }>>;
+    embedding: Schema<Schemastery.ObjectS<{
+        enabled: Schema<boolean, boolean>;
+        baseUrl: Schema<string, string>;
+        apiKey: Schema<string, string>;
+        model: Schema<string, string>;
+        dimensions: Schema<number, number>;
+        maxInputChars: Schema<number, number>;
+        timeoutMs: Schema<number, number>;
+    }>, Schemastery.ObjectT<{
+        enabled: Schema<boolean, boolean>;
+        baseUrl: Schema<string, string>;
+        apiKey: Schema<string, string>;
+        model: Schema<string, string>;
+        dimensions: Schema<number, number>;
+        maxInputChars: Schema<number, number>;
+        timeoutMs: Schema<number, number>;
+    }>>;
+    llm: Schema<Schemastery.ObjectS<{
+        provider: Schema<string, string>;
+        model: Schema<string, string>;
+        maxTokens: Schema<number, number>;
+        temperature: Schema<number, number>;
+        maxInputChars: Schema<number, number>;
+        timeoutMs: Schema<number, number>;
+    }>, Schemastery.ObjectT<{
+        provider: Schema<string, string>;
+        model: Schema<string, string>;
+        maxTokens: Schema<number, number>;
+        temperature: Schema<number, number>;
+        maxInputChars: Schema<number, number>;
+        timeoutMs: Schema<number, number>;
+    }>>;
+    tools: Schema<boolean, boolean>;
+}>, Schemastery.ObjectT<{
+    dataDir: Schema<string, string>;
+    family: Schema<"chat" | "work" | "auto", "chat" | "work" | "auto">;
+    capture: Schema<Schemastery.ObjectS<{
+        enabled: Schema<boolean, boolean>;
+        stripCodeBlocks: Schema<boolean, boolean>;
+        maxMessageChars: Schema<number, number>;
+    }>, Schemastery.ObjectT<{
+        enabled: Schema<boolean, boolean>;
+        stripCodeBlocks: Schema<boolean, boolean>;
+        maxMessageChars: Schema<number, number>;
+    }>>;
+    extract: Schema<Schemastery.ObjectS<{
+        enabled: Schema<boolean, boolean>;
+        minMessages: Schema<number, number>;
+        backgroundMessages: Schema<number, number>;
+        candidatePool: Schema<number, number>;
+    }>, Schemastery.ObjectT<{
+        enabled: Schema<boolean, boolean>;
+        minMessages: Schema<number, number>;
+        backgroundMessages: Schema<number, number>;
+        candidatePool: Schema<number, number>;
+    }>>;
+    l2: Schema<Schemastery.ObjectS<{
+        enabled: Schema<boolean, boolean>;
+        minNewMemories: Schema<number, number>;
+        maxScenes: Schema<number, number>;
+        sceneContextLimit: Schema<number, number>;
+    }>, Schemastery.ObjectT<{
+        enabled: Schema<boolean, boolean>;
+        minNewMemories: Schema<number, number>;
+        maxScenes: Schema<number, number>;
+        sceneContextLimit: Schema<number, number>;
+    }>>;
+    l3: Schema<Schemastery.ObjectS<{
+        enabled: Schema<boolean, boolean>;
+        interval: Schema<number, number>;
+    }>, Schemastery.ObjectT<{
+        enabled: Schema<boolean, boolean>;
+        interval: Schema<number, number>;
+    }>>;
+    recall: Schema<Schemastery.ObjectS<{
+        enabled: Schema<boolean, boolean>;
+        maxResults: Schema<number, number>;
+        includePersona: Schema<boolean, boolean>;
+        includeSceneNav: Schema<boolean, boolean>;
+        strategy: Schema<"keyword" | "embedding" | "hybrid", "keyword" | "embedding" | "hybrid">;
+        scoreThreshold: Schema<number, number>;
+    }>, Schemastery.ObjectT<{
+        enabled: Schema<boolean, boolean>;
+        maxResults: Schema<number, number>;
+        includePersona: Schema<boolean, boolean>;
+        includeSceneNav: Schema<boolean, boolean>;
+        strategy: Schema<"keyword" | "embedding" | "hybrid", "keyword" | "embedding" | "hybrid">;
+        scoreThreshold: Schema<number, number>;
+    }>>;
+    embedding: Schema<Schemastery.ObjectS<{
+        enabled: Schema<boolean, boolean>;
+        baseUrl: Schema<string, string>;
+        apiKey: Schema<string, string>;
+        model: Schema<string, string>;
+        dimensions: Schema<number, number>;
+        maxInputChars: Schema<number, number>;
+        timeoutMs: Schema<number, number>;
+    }>, Schemastery.ObjectT<{
+        enabled: Schema<boolean, boolean>;
+        baseUrl: Schema<string, string>;
+        apiKey: Schema<string, string>;
+        model: Schema<string, string>;
+        dimensions: Schema<number, number>;
+        maxInputChars: Schema<number, number>;
+        timeoutMs: Schema<number, number>;
+    }>>;
+    llm: Schema<Schemastery.ObjectS<{
+        provider: Schema<string, string>;
+        model: Schema<string, string>;
+        maxTokens: Schema<number, number>;
+        temperature: Schema<number, number>;
+        maxInputChars: Schema<number, number>;
+        timeoutMs: Schema<number, number>;
+    }>, Schemastery.ObjectT<{
+        provider: Schema<string, string>;
+        model: Schema<string, string>;
+        maxTokens: Schema<number, number>;
+        temperature: Schema<number, number>;
+        maxInputChars: Schema<number, number>;
+        timeoutMs: Schema<number, number>;
+    }>>;
+    tools: Schema<boolean, boolean>;
+}>>;
+export declare function resolveDataDir(cfg: MemoryConfig): string;

package/dist/config.js

@@ -0,0 +1,65 @@
+/**
+ * 插件配置：Schemastery schema + 类型。
+ *
+ * 默认数据目录：$DSH_HOME/memory（用官方 dshHomePath 解析，DSH_HOME 缺省 ~/.dsh）。
+ */
+import Schema from '@deepseek-ai/schemastery';
+import { dshHomePath } from '@deepseek-ai/dsh-home-paths';
+export const memorySchema = Schema.object({
+    dataDir: Schema.string().default(''),
+    family: Schema.union(['auto', 'chat', 'work']).default('auto'),
+    capture: Schema.object({
+        enabled: Schema.boolean().default(true),
+        stripCodeBlocks: Schema.boolean().default(true),
+        maxMessageChars: Schema.number().default(4000),
+    }),
+    extract: Schema.object({
+        enabled: Schema.boolean().default(true),
+        minMessages: Schema.number().default(1),
+        backgroundMessages: Schema.number().default(10),
+        candidatePool: Schema.number().default(5),
+    }),
+    l2: Schema.object({
+        enabled: Schema.boolean().default(true),
+        minNewMemories: Schema.number().default(5),
+        maxScenes: Schema.number().default(12),
+        sceneContextLimit: Schema.number().default(3),
+    }),
+    l3: Schema.object({
+        enabled: Schema.boolean().default(true),
+        interval: Schema.number().default(20),
+    }),
+    recall: Schema.object({
+        enabled: Schema.boolean().default(true),
+        maxResults: Schema.number().default(5),
+        includePersona: Schema.boolean().default(true),
+        includeSceneNav: Schema.boolean().default(true),
+        strategy: Schema.union(['keyword', 'embedding', 'hybrid']).default('hybrid'),
+        scoreThreshold: Schema.number().default(0.3),
+    }),
+    embedding: Schema.object({
+        enabled: Schema.boolean().default(false),
+        baseUrl: Schema.string().default(''),
+        apiKey: Schema.string().default(''),
+        model: Schema.string().default(''),
+        dimensions: Schema.number().default(0),
+        maxInputChars: Schema.number().default(5000),
+        timeoutMs: Schema.number().default(10_000),
+    }),
+    llm: Schema.object({
+        provider: Schema.string().default(''),
+        model: Schema.string().default(''),
+        // 推理模型（如 v4-flash）的 reasoning 计入输出预算：预算不足会被思考吃光导致正文 0 字符
+        maxTokens: Schema.number().default(20_000),
+        temperature: Schema.number().default(0.3),
+        // 模型上下文 1M token，日常压到 ~700k 使用（中文按 1 字≈1 token 保守折算）
+        maxInputChars: Schema.number().default(700_000),
+        timeoutMs: Schema.number().default(120_000),
+    }),
+    tools: Schema.boolean().default(true),
+});
+export function resolveDataDir(cfg) {
+    if (cfg.dataDir)
+        return cfg.dataDir;
+    return dshHomePath('memory');
+}

package/dist/hooks/capture.d.ts

@@ -0,0 +1,16 @@
+import type { Context } from '@deepseek-ai/cordis';
+import type { SessionEvent } from '@deepseek-ai/dsh-session';
+import type { MemoryConfig } from '../config.js';
+import type { MemoryRunner } from '../pipeline/runner.js';
+import type { SessionModeStore } from '../store/session-modes.js';
+import type { L0Store } from '../store/l0.js';
+import type { LiveSettingsHandle } from '../settings.js';
+import type { MemoryLogger } from '../types.js';
+export declare function isCaptureRelevant(type: string): boolean;
+export declare function registerCapture(ctx: Context, cfg: MemoryConfig, runner: MemoryRunner, l0: L0Store, logger: MemoryLogger, live: LiveSettingsHandle, modes: SessionModeStore): void;
+/**
+ * 缓冲上限裁剪（防御性；RELEVANT_TYPES 过滤后基本不可达）。
+ * 铁律：进行中轮次（turn/start 之后、turn/end 之前）的事件绝不裁——
+ * 只裁最早一个未闭合 turn/start 之前的已完成前缀。
+ */
+export declare function trimBuffer(buf: SessionEvent[]): void;

package/dist/hooks/capture.js

@@ -0,0 +1,160 @@
+/**
+ * L0 捕获 Hook：订阅 session/event，按轮次缓冲 user/assistant 消息，
+ * turn/end 时清洗并交给 Runner 落盘 + 触发蒸馏。
+ *
+ * 冷启动保护：插件激活时间之前的事件不捕获（防止恢复会话时倾倒全部历史）。
+ */
+import { randomBytes } from 'node:crypto';
+import { blocksToText } from '../util/text.js';
+import { sanitizeText, shouldCaptureL0, stripCodeBlocks } from '../util/sanitize.js';
+/**
+ * 需要进缓冲的事件类型。流式 chunk（text-delta/reasoning 等）一秒钟可达数百条，
+ * 缓冲它们会把 MAX_BUFFER 撑爆、把轮次头部（turn/start + user 消息）裁掉——
+ * 2026-08-16 真实事故：长回复轮次丢失 user 消息。
+ */
+const RELEVANT_TYPES = new Set(['user/message', 'assistant/message', 'turn/start', 'turn/end']);
+export function isCaptureRelevant(type) {
+    return RELEVANT_TYPES.has(type);
+}
+const MAX_BUFFER = 500;
+export function registerCapture(ctx, cfg, runner, l0, logger, live, modes) {
+    if (!cfg.capture.enabled)
+        return;
+    const startFloor = Date.now();
+    const buffers = new Map();
+    // L0 即时落盘链：turn/end 立刻写，不被蒸馏队列（慢 LLM 调用）阻塞；
+    // 串行化保证同轮次顺序与单次写入（进程退出时排队中的 L0 不再依赖蒸馏完成）
+    let l0Queue = Promise.resolve();
+    ctx.on('session/event', (session, event) => {
+        try {
+            const s = live.get();
+            if (!s.enabled || !s.capture)
+                return;
+            const sid = String(session.id ?? session);
+            // off 档：本会话对记忆系统完全隐身（不缓冲、不写 L0、不蒸馏）
+            if (modes.get(sid) === 'off')
+                return;
+            if (!isCaptureRelevant(event.type))
+                return;
+            if (event.time < startFloor) {
+                // 冷启动保护拦截的 user 消息记 info（罕见，但正是"整轮只剩 assistant"现象的线索）
+                if (event.type === 'user/message') {
+                    logger.info(`[memory] L0 跳过早于插件启动的 user 消息（冷启动保护，早 ${startFloor - event.time}ms）`);
+                }
+                return;
+            }
+            let buf = buffers.get(sid);
+            if (!buf) {
+                buf = [];
+                buffers.set(sid, buf);
+            }
+            buf.push(event);
+            trimBuffer(buf);
+            if (event.type === 'turn/end') {
+                const turn = event.data.turn;
+                const startIdx = findTurnStart(buf, turn);
+                const turnEvents = startIdx === -1 ? buf : buf.slice(startIdx + 1);
+                buffers.set(sid, startIdx === -1 ? [] : buf.slice(0, startIdx));
+                const messages = turnEventsToMessages(turnEvents, cfg, logger);
+                if (messages.length > 0) {
+                    const roles = messages.reduce((acc, m) => {
+                        acc[m.role] = (acc[m.role] ?? 0) + 1;
+                        return acc;
+                    }, {});
+                    // 轮末档位生效（中途切档：本轮按 turn/end 时的档位蒸馏）
+                    const mode = modes.get(sid);
+                    if (mode === 'off') {
+                        logger.info(`[memory] turn=${turn} 结束时档位为关闭，本轮不落盘不蒸馏（session=${sid}）`);
+                        return;
+                    }
+                    logger.info(`[memory] L0 捕获 turn=${turn} ${messages.length} 条（${Object.entries(roles)
+                        .map(([k, v]) => `${k}=${v}`)
+                        .join('/')}，session=${sid}，mode=${mode}）`);
+                    // L0 立刻落盘（不等蒸馏）
+                    const n = messages.length;
+                    l0Queue = l0Queue
+                        .then(() => l0.append(sid, messages))
+                        .then(() => logger.info(`[memory] L0 落盘 ${n} 条`))
+                        .catch((err) => logger.warn(`[memory] L0 落盘失败: ${err instanceof Error ? err.message : String(err)}`));
+                    runner.enqueue(sid, messages, mode);
+                }
+            }
+        }
+        catch (err) {
+            logger.warn(`[memory] session/event 处理失败: ${err instanceof Error ? err.message : String(err)}`);
+        }
+    });
+}
+/**
+ * 缓冲上限裁剪（防御性；RELEVANT_TYPES 过滤后基本不可达）。
+ * 铁律：进行中轮次（turn/start 之后、turn/end 之前）的事件绝不裁——
+ * 只裁最早一个未闭合 turn/start 之前的已完成前缀。
+ */
+export function trimBuffer(buf) {
+    if (buf.length <= MAX_BUFFER)
+        return;
+    let openStart = -1;
+    let closed = true;
+    for (let i = 0; i < buf.length; i++) {
+        const t = buf[i].type;
+        if (t === 'turn/start' && closed) {
+            openStart = i;
+            closed = false;
+        }
+        else if (t === 'turn/end') {
+            closed = true;
+            openStart = -1;
+        }
+    }
+    const floorIdx = openStart === -1 ? Math.max(0, buf.length - MAX_BUFFER) : openStart;
+    if (floorIdx > 0)
+        buf.splice(0, floorIdx);
+}
+/** 找到与 turn/end 同 turn 的最后一个 turn/start 的索引（含自身）。 */
+function findTurnStart(buf, turn) {
+    for (let i = buf.length - 1; i >= 0; i--) {
+        const e = buf[i];
+        if (e.type === 'turn/start' && e.data.turn === turn)
+            return i;
+    }
+    return -1;
+}
+/** 把轮次事件转成 L0 消息（仅真实 user 消息 + assistant 消息，清洗过滤）。 */
+function turnEventsToMessages(events, cfg, logger) {
+    const out = [];
+    for (const event of events) {
+        if (event.type === 'user/message') {
+            const msg = event.data;
+            // 只捕获真实用户输入（source.kind === 'user'），跳过插件注入上下文
+            if (msg.source?.kind !== 'user') {
+                logger.info(`[memory] L0 跳过非用户来源消息（source.kind=${msg.source?.kind ?? 'none'}）`);
+                continue;
+            }
+            const content = sanitizeText(blocksToText(msg.content));
+            if (shouldCaptureL0(content)) {
+                out.push(makeMessage('user', content, event.time, cfg.capture.maxMessageChars));
+            }
+        }
+        else if (event.type === 'assistant/message') {
+            const data = event.data;
+            let content = sanitizeText(blocksToText(data.message?.content));
+            if (cfg.capture.stripCodeBlocks)
+                content = stripCodeBlocks(content);
+            if (shouldCaptureL0(content)) {
+                out.push(makeMessage('assistant', content, event.time, cfg.capture.maxMessageChars));
+            }
+        }
+    }
+    if (out.length > 0) {
+        logger.debug?.(`[memory] 轮次消息 ${events.length} 事件 → ${out.length} 条（清洗过滤后）`);
+    }
+    return out;
+}
+function makeMessage(role, content, timestamp, maxChars) {
+    return {
+        id: `msg_${Date.now()}_${randomBytes(3).toString('hex')}`,
+        role,
+        content: content.slice(0, maxChars),
+        timestamp,
+    };
+}

package/dist/hooks/recall.d.ts

@@ -0,0 +1,31 @@
+/**
+ * 召回 Hook：
+ * 1. agent/pre-step（waterfall）：用进入步骤的用户消息做 L1 BM25 检索，缓存到该 agent 的槽位；
+ *    必须调用并返回 next()（只观察，不改写步骤）。
+ * 2. agent/created：在 agent 作用域注册动态上下文 provider（L1 召回 + L3 画像 + L2 场景导航 + 工具指南）。
+ *
+ * 注入内容使用 <relevant-memories> / <user-persona> / <scene-navigation> / <memory-tools-guide>
+ * 标签包裹——capture 侧 sanitize 会剥离这些标签，防止反馈循环。
+ * auto 档两族合并时在 <user-persona>/<scene-navigation> 内部用 <domain family="..."> 子块
+ * 分域（子块只出现在外层标签内部，随外层一起被 sanitize 剥离，无泄漏风险）。
+ *
+ * 注意：PromptContext.text 是**同步**函数，画像/场景导航这类异步文件读取必须走内存缓存，
+ * 由定时刷新 + 管线更新后的主动失效来更新。
+ */
+import type { Context } from '@deepseek-ai/cordis';
+import type { MemoryConfig } from '../config.js';
+import type { LiveSettingsHandle } from '../settings.js';
+import type { L1Store } from '../store/l1.js';
+import type { PersonaStore } from '../store/persona.js';
+import type { SceneStore } from '../store/scenes.js';
+import type { SessionModeStore } from '../store/session-modes.js';
+import type { MemoryLogger } from '../types.js';
+export interface RecallHooks {
+    /** 管线更新后调用：画像/场景缓存立即失效并异步刷新。 */
+    invalidateProfile(): void;
+}
+export declare function registerRecall(ctx: Context, cfg: MemoryConfig, stores: {
+    l1: L1Store;
+    scenes: Record<'chat' | 'work', SceneStore>;
+    persona: Record<'chat' | 'work', PersonaStore>;
+}, logger: MemoryLogger, live: LiveSettingsHandle, modes: SessionModeStore): RecallHooks;