dsh-layered-memory 0.5.3

package/dist/stats.js

@@ -0,0 +1,234 @@
+/**
+ * 状态面板数据通道：Host 侧注册 /rpc 通道的 dsh-memory/stats 端点，
+ * Client 设置页通过 ctx.connection.rpc.call('/rpc', 'dsh-memory/stats') 拉取。
+ *
+ * connection 是可选服务且可能晚于本插件就绪：先探测一次，未就绪则监听
+ * internal/service，服务上线时再注册（服务消失又回来时也能重注册）。
+ */
+import { createRequire } from 'node:module';
+import { readFileSync, statSync } from 'node:fs';
+import { join } from 'node:path';
+import { resolveDataDir } from './config.js';
+const require = createRequire(import.meta.url);
+export const PLUGIN_VERSION = require('../package.json').version;
+/** 注册状态 RPC（web 侧 connection 服务可选，缺失时跳过，不影响插件主体）。 */
+export function registerMemoryRpc(ctx, cfg, stores, logger, status, live, modes, dataDir) {
+    /** 当前是否持有一段有效注册（dispose 完成后清空，允许服务重上线时重注册）。 */
+    let holding = false;
+    const tryRegister = () => {
+        if (holding)
+            return;
+        const connection = ctx.get('connection');
+        if (!connection)
+            return;
+        holding = true;
+        let active = true;
+        // handle() 同步注册并返回异步 disposer（() => Promise<void>）。
+        const dispose = connection.rpc.handle('/rpc', async (endpoint, payload) => {
+            try {
+                const value = await handleEndpoint(endpoint, payload, {
+                    cfg,
+                    stores,
+                    status,
+                    live,
+                    modes,
+                    dataDir: dataDir ?? resolveDataDir(cfg),
+                    logger,
+                });
+                return { ok: true, value };
+            }
+            catch (err) {
+                return {
+                    ok: false,
+                    error: { code: 'internal', message: err instanceof Error ? err.message : String(err), details: {} },
+                };
+            }
+        }, { authority: 'loopback' });
+        if (!active) {
+            void dispose();
+            return;
+        }
+        logger.debug?.('[memory] 状态 RPC 已注册（/rpc → dsh-memory/*）');
+        disposers.push(() => {
+            active = false;
+            holding = false;
+            void dispose();
+        });
+    };
+    const disposers = [];
+    ctx.effect(() => {
+        tryRegister();
+        const off = ctx.on('internal/service', (name) => {
+            if (name === 'connection')
+                tryRegister();
+        });
+        return () => {
+            off();
+            for (const dispose of disposers.splice(0))
+                dispose();
+        };
+    });
+}
+async function buildStats(cfg, stores, status) {
+    // 两族 checkpoint 聚合（浏览器混合视图：总量求和、时间取最新）
+    const chat = stores.state.forFamily('chat');
+    const work = stores.state.forFamily('work');
+    const [chatScenes, workScenes, chatPersona, workPersona] = await Promise.all([
+        stores.scenes.chat.list(),
+        stores.scenes.work.list(),
+        stores.persona.chat.read(),
+        stores.persona.work.read(),
+    ]);
+    const degraded = status?.degraded() ?? false;
+    const personaChars = (chatPersona?.length ?? 0) + (workPersona?.length ?? 0);
+    const max = (a, b) => Math.max(a, b);
+    const iso = (t) => (t ? new Date(t).toISOString() : null);
+    return {
+        ok: true,
+        dataDir: resolveDataDir(cfg),
+        family: cfg.family,
+        version: PLUGIN_VERSION,
+        l0Today: await stores.l0.countToday(),
+        l1Count: stores.l1.size,
+        l1TotalExtracted: chat.totalExtracted + work.totalExtracted,
+        sceneCount: chatScenes.length + workScenes.length,
+        personaChars,
+        hasPersona: chat.hasPersona || work.hasPersona,
+        lastExtractAt: iso(max(chat.lastExtractAt, work.lastExtractAt)),
+        lastL2At: iso(max(chat.lastL2At, work.lastL2At)),
+        lastL3At: iso(max(chat.lastL3At, work.lastL3At)),
+        memoriesSinceL2: chat.newMemoriesSinceL2 + work.newMemoriesSinceL2,
+        memoriesSinceL3: chat.memoriesSinceL3 + work.memoriesSinceL3,
+        pendingExtract: status?.pending() ?? 0,
+        message: degraded ? 'degraded：存储不可用，记忆功能已停用' : 'running',
+    };
+}
+async function handleEndpoint(endpoint, payload, deps) {
+    const { cfg, stores, status, live, modes, dataDir } = deps;
+    switch (endpoint) {
+        case 'dsh-memory/stats':
+            return buildStats(cfg, stores, status);
+        case 'dsh-memory/session-mode-get': {
+            if (!modes)
+                throw new Error('档位存储未初始化');
+            const p = (payload ?? {});
+            if (typeof p.sessionId !== 'string' || !p.sessionId)
+                throw new Error('sessionId 缺失');
+            return { sessionId: p.sessionId, mode: modes.get(p.sessionId), defaultMode: modes.default };
+        }
+        case 'dsh-memory/session-mode-set': {
+            if (!modes)
+                throw new Error('档位存储未初始化');
+            const p = (payload ?? {});
+            if (typeof p.sessionId !== 'string' || !p.sessionId)
+                throw new Error('sessionId 缺失');
+            const allowed = ['auto', 'chat', 'work', 'off'];
+            if (typeof p.mode !== 'string' || !allowed.includes(p.mode)) {
+                throw new Error(`非法档位: ${String(p.mode)}（允许 ${allowed.join('/')}）`);
+            }
+            modes.set(p.sessionId, p.mode);
+            deps.logger.info(`[memory] 会话档位设置 session=${p.sessionId} mode=${p.mode}`);
+            return { sessionId: p.sessionId, mode: p.mode };
+        }
+        case 'dsh-memory/settings-get':
+            return {
+                supported: live?.supported ?? false,
+                settings: live?.get() ?? { enabled: true, capture: true, distill: true, recall: true },
+                // 静态部署上限（cordis.patch.yml）：运行时开关与它取 AND
+                ceilings: { capture: cfg.capture.enabled, distill: cfg.extract.enabled, recall: cfg.recall.enabled },
+            };
+        case 'dsh-memory/settings-set': {
+            if (!live)
+                throw new Error('开关通道未初始化');
+            const patch = (payload ?? {});
+            const allowed = ['enabled', 'capture', 'distill', 'recall'];
+            const clean = {};
+            for (const key of allowed) {
+                if (typeof patch[key] === 'boolean')
+                    clean[key] = patch[key];
+            }
+            if (Object.keys(clean).length === 0)
+                throw new Error('开关更新载荷为空');
+            await live.update(clean);
+            return { ok: true, settings: live.get() };
+        }
+        case 'dsh-memory/list-records': {
+            const p = (payload ?? {});
+            const limit = Math.min(Math.max(Number(p.limit) || 50, 1), 200);
+            const offset = Math.max(Number(p.offset) || 0, 0);
+            // 关键词路径：复用检索唯一缝（与召回同源），取回后做场景过滤 + 手工分页
+            if (p.query && p.query.trim()) {
+                const hits = await stores.l1.search(p.query, Math.min(offset + limit + 1, 200), { type: p.type || undefined });
+                const filtered = p.scene ? hits.filter((h) => h.scene_name === p.scene) : hits;
+                return {
+                    items: filtered.slice(offset, offset + limit).map(hitToUiRecord),
+                    hasMore: filtered.length > offset + limit,
+                    total: null,
+                    scenes: offset === 0 ? stores.l1.distinctScenes() : undefined,
+                };
+            }
+            const { items, total } = stores.l1.list({ type: p.type || undefined, scene: p.scene || undefined, limit, offset });
+            return {
+                items: items.map(hitToUiRecord),
+                hasMore: offset + items.length < total,
+                total,
+                scenes: offset === 0 ? stores.l1.distinctScenes() : undefined,
+            };
+        }
+        case 'dsh-memory/scenes': {
+            // 两族拼接展示（浏览器保持混合视图；路径冲突时后写入的族覆盖显示名，读取仍各自独立）
+            const items = [];
+            for (const family of ['chat', 'work']) {
+                const summaries = await stores.scenes[family].list();
+                for (const s of summaries) {
+                    items.push({ path: s.path, family, summary: s.summary, updated: s.updated, heat: s.heat, content: (await stores.scenes[family].read(s.path)) ?? '' });
+                }
+            }
+            items.sort((a, b) => (a.updated < b.updated ? 1 : -1));
+            return { items };
+        }
+        case 'dsh-memory/persona': {
+            const [chat, work] = await Promise.all([stores.persona.chat.read(), stores.persona.work.read()]);
+            const parts = [];
+            if (chat)
+                parts.push(`<!-- family: chat -->\n${chat}`);
+            if (work)
+                parts.push(`<!-- family: work -->\n${work}`);
+            return { content: parts.join('\n\n---\n\n') };
+        }
+        case 'dsh-memory/log-tail': {
+            const p = (payload ?? {});
+            return { lines: readLogTail(join(dataDir, 'memory.log'), Math.min(Math.max(Number(p.lines) || 200, 1), 1000)) };
+        }
+        default:
+            throw new Error(`unknown endpoint: ${endpoint}`);
+    }
+}
+/** 浏览器卡片字段（比 MemoryRecord 精简，去掉大 metadata）。 */
+function hitToUiRecord(r) {
+    return {
+        id: r.id,
+        content: r.content,
+        type: r.type,
+        priority: r.priority ?? 60,
+        scene: r.scene_name,
+        family: r.family ?? null,
+        timestamps: (r.timestamps ?? []).map((t) => new Date(t).toISOString()),
+        createdAt: r.createdAt ? new Date(r.createdAt).toISOString() : null,
+        updatedAt: r.updatedAt ? new Date(r.updatedAt).toISOString() : null,
+        version: r.version ?? 0,
+        sourceMessageIds: r.source_message_ids ?? [],
+        score: r.score ?? null,
+    };
+}
+/** 读日志尾部（文件有 2MB 轮转上限，全量读后取尾部即可）。 */
+function readLogTail(logPath, maxLines) {
+    try {
+        void statSync(logPath);
+        const lines = readFileSync(logPath, 'utf8').split('\n').filter((l) => l.length > 0);
+        return lines.slice(-maxLines);
+    }
+    catch {
+        return [];
+    }
+}

package/dist/store/bm25.d.ts

@@ -0,0 +1,19 @@
+export interface Bm25Doc {
+    id: string;
+    text: string;
+}
+export interface Bm25Hit {
+    id: string;
+    score: number;
+}
+export declare class Bm25Index {
+    private docs;
+    private termFreq;
+    private docLen;
+    private df;
+    private totalLen;
+    get size(): number;
+    /** 全量重建。 */
+    rebuild(docs: Bm25Doc[]): void;
+    search(query: string, topK: number, filter?: (id: string) => boolean): Bm25Hit[];
+}

package/dist/store/bm25.js

@@ -0,0 +1,62 @@
+/**
+ * 轻量 BM25 检索（无外部依赖）：拉丁词 + CJK 二元组分词。
+ * 仅用于 L2 场景摘要的上下文选取（小语料）；L0/L1 检索走 SQLite FTS5/向量。
+ */
+import { tokenize } from '../util/text.js';
+const K1 = 1.5;
+const B = 0.75;
+export class Bm25Index {
+    docs = [];
+    termFreq = [];
+    docLen = [];
+    df = new Map();
+    totalLen = 0;
+    get size() {
+        return this.docs.length;
+    }
+    /** 全量重建。 */
+    rebuild(docs) {
+        this.docs = docs;
+        this.termFreq = [];
+        this.docLen = [];
+        this.df = new Map();
+        this.totalLen = 0;
+        for (let i = 0; i < docs.length; i++) {
+            const terms = tokenize(docs[i].text);
+            const tf = new Map();
+            for (const t of terms)
+                tf.set(t, (tf.get(t) ?? 0) + 1);
+            this.termFreq.push(tf);
+            this.docLen.push(terms.length);
+            this.totalLen += terms.length;
+            for (const t of tf.keys())
+                this.df.set(t, (this.df.get(t) ?? 0) + 1);
+        }
+    }
+    search(query, topK, filter) {
+        const terms = tokenize(query);
+        if (terms.length === 0 || this.docs.length === 0)
+            return [];
+        const avgdl = this.totalLen / this.docs.length || 1;
+        const n = this.docs.length;
+        const scores = [];
+        for (let i = 0; i < n; i++) {
+            if (filter && !filter(this.docs[i].id))
+                continue;
+            const tf = this.termFreq[i];
+            const len = this.docLen[i];
+            let score = 0;
+            for (const t of new Set(terms)) {
+                const f = tf.get(t) ?? 0;
+                if (f === 0)
+                    continue;
+                const idf = Math.log(1 + (n - (this.df.get(t) ?? 0) + 0.5) / ((this.df.get(t) ?? 0) + 0.5));
+                score += idf * ((f * (K1 + 1)) / (f + K1 * (1 - B + B * (len / avgdl))));
+            }
+            if (score > 0)
+                scores.push({ i, s: score });
+        }
+        scores.sort((a, b) => b.s - a.s);
+        return scores.slice(0, topK).map(({ i, s }) => ({ id: this.docs[i].id, score: s }));
+    }
+}

package/dist/store/embedding.d.ts

@@ -0,0 +1,68 @@
+/**
+ * Embedding 服务（移植 MemoryCore embedding.ts 的裁剪版，仅保留远程 OpenAI 兼容实现）。
+ * dsh 的 ctx.llm 只有 chat 流式接口、无 embeddings 端点，因此向量能力
+ * 需要用户自备任意 OpenAI 兼容 /embeddings 服务（OpenAI/SiliconFlow/Jina/自托管 BGE 等）。
+ * 默认关闭（Noop）——纯 FTS 模式即可运行，这是官方 provider="none" 的同款语义。
+ */
+import type { MemoryLogger } from '../types.js';
+export interface EmbeddingProviderInfo {
+    provider: string;
+    model: string;
+    dimensions: number;
+}
+export interface EmbeddingService {
+    embed(text: string): Promise<Float32Array>;
+    embedBatch(texts: string[]): Promise<Float32Array[]>;
+    getDimensions(): number;
+    getProviderInfo(): EmbeddingProviderInfo;
+    isReady(): boolean;
+    close?(): void;
+}
+/** 空实现：向量能力关闭/不可用时使用，一切调用安全返回。 */
+export declare class NoopEmbeddingService implements EmbeddingService {
+    getDimensions(): number;
+    getProviderInfo(): EmbeddingProviderInfo;
+    isReady(): boolean;
+    embed(): Promise<Float32Array>;
+    embedBatch(texts: string[]): Promise<Float32Array[]>;
+}
+export interface RemoteEmbeddingOptions {
+    baseUrl: string;
+    apiKey: string;
+    model: string;
+    /** 必填且须与模型输出一致（vec0 建表需要固定维度）。 */
+    dimensions: number;
+    maxInputChars?: number;
+    timeoutMs?: number;
+    logger?: MemoryLogger;
+}
+/**
+ * OpenAI 兼容远程 embedding：POST {baseUrl}/embeddings。
+ * 向量在客户端做 L2 归一化（与余弦度量配套，照搬官方 sanitizeAndNormalize）。
+ */
+export declare class RemoteEmbeddingService implements EmbeddingService {
+    private readonly opts;
+    constructor(opts: RemoteEmbeddingOptions);
+    getDimensions(): number;
+    getProviderInfo(): EmbeddingProviderInfo;
+    isReady(): boolean;
+    embed(text: string): Promise<Float32Array>;
+    embedBatch(texts: string[]): Promise<Float32Array[]>;
+}
+/**
+ * 嵌入调用降级助手（L0/L1 Store 共用）：查询向量失败 → undefined（调用方降级 FTS）；
+ * 批量嵌入失败 → 全 undefined（跳过向量写入，由周期性 backfill 补齐）。
+ * 同类失败只告警一次，避免刷屏。
+ */
+export declare class EmbedHelper {
+    private readonly embed;
+    private readonly logger?;
+    private warned;
+    constructor(embed: EmbeddingService, logger?: MemoryLogger | undefined);
+    vectorReady(): boolean;
+    /** 查询向量；失败或空向量返回 undefined（调用方降级 FTS）。 */
+    query(text: string): Promise<Float32Array | undefined>;
+    /** 批量嵌入；服务未就绪或失败时返回全 undefined（不阻断元数据/FTS 写入）。 */
+    batch(texts: string[]): Promise<Array<Float32Array | undefined>>;
+    private warn;
+}

package/dist/store/embedding.js

@@ -0,0 +1,133 @@
+/** 空实现：向量能力关闭/不可用时使用，一切调用安全返回。 */
+export class NoopEmbeddingService {
+    getDimensions() {
+        return 0;
+    }
+    getProviderInfo() {
+        return { provider: 'noop', model: 'disabled', dimensions: 0 };
+    }
+    isReady() {
+        return false;
+    }
+    async embed() {
+        return new Float32Array(0);
+    }
+    async embedBatch(texts) {
+        return texts.map(() => new Float32Array(0));
+    }
+}
+/**
+ * OpenAI 兼容远程 embedding：POST {baseUrl}/embeddings。
+ * 向量在客户端做 L2 归一化（与余弦度量配套，照搬官方 sanitizeAndNormalize）。
+ */
+export class RemoteEmbeddingService {
+    opts;
+    constructor(opts) {
+        this.opts = { maxInputChars: 5000, timeoutMs: 10_000, ...opts };
+    }
+    getDimensions() {
+        return this.opts.dimensions;
+    }
+    getProviderInfo() {
+        return { provider: 'remote', model: this.opts.model, dimensions: this.opts.dimensions };
+    }
+    isReady() {
+        return true;
+    }
+    async embed(text) {
+        const [vec] = await this.embedBatch([text]);
+        return vec;
+    }
+    async embedBatch(texts) {
+        if (texts.length === 0)
+            return [];
+        const input = texts.map((t) => t.slice(0, this.opts.maxInputChars));
+        const base = this.opts.baseUrl.replace(/\/+$/, '');
+        const res = await fetch(`${base}/embeddings`, {
+            method: 'POST',
+            headers: {
+                'content-type': 'application/json',
+                authorization: `Bearer ${this.opts.apiKey}`,
+            },
+            body: JSON.stringify({ model: this.opts.model, input }),
+            signal: AbortSignal.timeout(this.opts.timeoutMs),
+        });
+        if (!res.ok) {
+            const body = await res.text().catch(() => '');
+            throw new Error(`embeddings HTTP ${res.status}: ${body.slice(0, 200)}`);
+        }
+        const json = (await res.json());
+        const data = json.data ?? [];
+        if (data.length !== texts.length) {
+            throw new Error(`embeddings 返回数量不匹配：期望 ${texts.length}，得到 ${data.length}`);
+        }
+        // 按 index 还原顺序（部分服务商不保序）
+        const byIndex = new Map();
+        for (const d of data)
+            byIndex.set(d.index, d.embedding);
+        return input.map((_, i) => {
+            const raw = byIndex.get(i);
+            if (!raw || raw.length !== this.opts.dimensions) {
+                throw new Error(`embedding 维度不匹配：期望 ${this.opts.dimensions}，得到 ${raw?.length ?? 0}`);
+            }
+            return sanitizeAndNormalize(raw);
+        });
+    }
+}
+/** 清洗 NaN/Inf 并 L2 归一化（零向量原样返回，写入侧会跳过）。 */
+function sanitizeAndNormalize(vec) {
+    const arr = Array.from(vec).map((v) => (Number.isFinite(v) ? v : 0));
+    const magnitude = Math.sqrt(arr.reduce((sum, v) => sum + v * v, 0));
+    if (magnitude < 1e-10)
+        return new Float32Array(arr);
+    return new Float32Array(arr.map((v) => v / magnitude));
+}
+/**
+ * 嵌入调用降级助手（L0/L1 Store 共用）：查询向量失败 → undefined（调用方降级 FTS）；
+ * 批量嵌入失败 → 全 undefined（跳过向量写入，由周期性 backfill 补齐）。
+ * 同类失败只告警一次，避免刷屏。
+ */
+export class EmbedHelper {
+    embed;
+    logger;
+    warned = false;
+    constructor(embed, logger) {
+        this.embed = embed;
+        this.logger = logger;
+    }
+    vectorReady() {
+        return this.embed.isReady();
+    }
+    /** 查询向量；失败或空向量返回 undefined（调用方降级 FTS）。 */
+    async query(text) {
+        try {
+            const vec = await this.embed.embed(text);
+            return vec.length > 0 ? vec : undefined;
+        }
+        catch (err) {
+            this.warn(`查询向量计算失败，降级 FTS: ${errMsg(err)}`);
+            return undefined;
+        }
+    }
+    /** 批量嵌入；服务未就绪或失败时返回全 undefined（不阻断元数据/FTS 写入）。 */
+    async batch(texts) {
+        if (!this.embed.isReady())
+            return texts.map(() => undefined);
+        try {
+            return await this.embed.embedBatch(texts);
+        }
+        catch (err) {
+            this.warn(`批量嵌入失败，本批暂不写向量（后台 backfill 会补齐）: ${errMsg(err)}`);
+            return texts.map(() => undefined);
+        }
+    }
+    warn(msg) {
+        if (this.warned)
+            return;
+        this.warned = true;
+        this.logger?.warn(`[memory] ${msg}`);
+    }
+}
+function errMsg(err) {
+    return err instanceof Error ? err.message : String(err);
+}

package/dist/store/io.d.ts

@@ -0,0 +1,13 @@
+export declare function ensureDir(dir: string): Promise<void>;
+/** 原子写文本文件。 */
+export declare function atomicWriteText(file: string, content: string): Promise<void>;
+/** 原子写 JSON。 */
+export declare function atomicWriteJson(file: string, value: unknown): Promise<void>;
+export declare function readJsonIfExists<T>(file: string): Promise<T | undefined>;
+export declare function readTextIfExists(file: string): Promise<string | undefined>;
+/** 追加 JSONL 行（存在则追加，否则创建）。 */
+export declare function appendJsonl(file: string, lines: unknown[]): Promise<void>;
+/** 读取 JSONL 全部行。 */
+export declare function readJsonl<T>(file: string): Promise<T[]>;
+export declare function nowIso(): string;
+export declare function dayKey(ts: number): string;

package/dist/store/io.js

@@ -0,0 +1,75 @@
+/**
+ * 持久化工具：原子写（tmp + rename）、JSON 状态。
+ */
+import { promises as fs } from 'node:fs';
+import * as path from 'node:path';
+export async function ensureDir(dir) {
+    await fs.mkdir(dir, { recursive: true });
+}
+/** 原子写文本文件。 */
+export async function atomicWriteText(file, content) {
+    await ensureDir(path.dirname(file));
+    const tmp = `${file}.${process.pid}.${Date.now()}.tmp`;
+    await fs.writeFile(tmp, content, 'utf-8');
+    await fs.rename(tmp, file);
+}
+/** 原子写 JSON。 */
+export async function atomicWriteJson(file, value) {
+    await atomicWriteText(file, JSON.stringify(value, null, 2));
+}
+export async function readJsonIfExists(file) {
+    try {
+        const raw = await fs.readFile(file, 'utf-8');
+        return JSON.parse(raw);
+    }
+    catch {
+        return undefined;
+    }
+}
+export async function readTextIfExists(file) {
+    try {
+        return await fs.readFile(file, 'utf-8');
+    }
+    catch {
+        return undefined;
+    }
+}
+/** 追加 JSONL 行（存在则追加，否则创建）。 */
+export async function appendJsonl(file, lines) {
+    if (lines.length === 0)
+        return;
+    await ensureDir(path.dirname(file));
+    const payload = lines.map((l) => JSON.stringify(l)).join('\n') + '\n';
+    await fs.appendFile(file, payload, 'utf-8');
+}
+/** 读取 JSONL 全部行。 */
+export async function readJsonl(file) {
+    try {
+        const raw = await fs.readFile(file, 'utf-8');
+        const out = [];
+        for (const line of raw.split('\n')) {
+            const t = line.trim();
+            if (!t)
+                continue;
+            try {
+                out.push(JSON.parse(t));
+            }
+            catch {
+                // 跳过坏行
+            }
+        }
+        return out;
+    }
+    catch {
+        return [];
+    }
+}
+export function nowIso() {
+    return new Date().toISOString();
+}
+export function dayKey(ts) {
+    const d = new Date(ts);
+    const mm = String(d.getMonth() + 1).padStart(2, '0');
+    const dd = String(d.getDate()).padStart(2, '0');
+    return `${d.getFullYear()}-${mm}-${dd}`;
+}

package/dist/store/l0.d.ts

@@ -0,0 +1,28 @@
+import type { ConversationMessage, L0MessageRecord, MemoryLogger } from '../types.js';
+import { type EmbeddingService } from './embedding.js';
+import type { MemoryDb } from './sqlite.js';
+export declare class L0Store {
+    private readonly db;
+    private readonly dir;
+    private readonly legacyDir;
+    private readonly helper;
+    private readonly embedSvc;
+    private readonly logger?;
+    constructor(dataDir: string, db: MemoryDb, embed?: EmbeddingService, logger?: MemoryLogger);
+    init(): Promise<void>;
+    /** 旧版 l0/*.jsonl 一次性导入检索库，成功后目录改名 l0.imported/。 */
+    private importLegacy;
+    append(sessionId: string, messages: ConversationMessage[]): Promise<void>;
+    /** 今日已捕获消息数（SQL 计数，不再读整文件）。 */
+    countToday(): Promise<number>;
+    /** 检索：FTS + 向量 hybrid（RRF 融合），返回按相关性排序的消息。 */
+    search(query: string, limit: number): Promise<L0MessageRecord[]>;
+    /**
+     * 全量重嵌入（embedding 启用 / 周期性补齐用）。
+     * 返回写入数与失败数——failed > 0 时调用方不应标记 meta 同步完成。
+     */
+    reindex(): Promise<{
+        written: number;
+        failed: number;
+    }>;
+}