dsh-prime-memory 0.26.4 → 0.26.5

package/dist/store/graph-store.js

@@ -19,8 +19,9 @@
  */
 import { randomBytes } from 'node:crypto';
 import { applyGraphProjection } from '../graph/apply.js';
-import { searchGraphNodes } from '../graph/search.js';
-import { GRAPH_JOB_BACKOFF_BASE_MS, GRAPH_JOB_BATCH, GRAPH_JOB_MAX_ATTEMPTS, GRAPH_PRIORITY_BACKFILL, GRAPH_PROJECTOR_VERSION, } from '../graph/types.js';
+import { expandHitRecordIds, searchGraphNodes } from '../graph/search.js';
+import { buildFullView, buildGraphPreview } from '../graph/preview.js';
+import { GRAPH_JOB_BACKOFF_BASE_MS, GRAPH_JOB_BATCH, GRAPH_JOB_MAX_ATTEMPTS, GRAPH_JOB_TRANSIENT_MAX_ATTEMPTS, GRAPH_PRIORITY_BACKFILL, GRAPH_PROJECTOR_VERSION, GRAPH_VEC_SEED_CAP, } from '../graph/types.js';
 import { normPersistence } from '../types.js';
 import { isZeroVector, vecToBuffer } from './vec-utils.js';
 const TAG = '[memory][graph]';
@@ -460,6 +461,98 @@ export class GraphStore {
             : nodes;
         return searchGraphNodes(filtered, edges, query, limit);
     }
+    /**
+     * §D 第 3 路存储缝(回链记录 id 序;graphLane 直接消费):词法命中 ∪ 路内向量种子
+     * → 1-hop 边扩展 → 保序去重的 L1 记录 id 序列。
+     *
+     * - **向量种子是路内并集、不是新路**:embedding 由调用方传入(装配层惰性查
+     *   l1.embedText;未就绪/失败传 undefined = 纯词法路,与旧 searchNodes+直连回链
+     *   逐位一致);并集不占 RRF 路数名额,"未接线 = 恰为 2 路"不变量不动;
+     * - **种子序**:词法命中在前、向量种子追加在后(RRF 用 rank,顺序即权重),
+     *   同节点去重;向量种子同样过 visible 族集与 active|disputed 状态闸(宁可漏不可串);
+     * - **1-hop 邻居不按族预筛**:来源记录的跨族由 graphLane 尾部记录级 family/scope
+     *   双闸兜底(与本路既有纪律同源);
+     * - 降级(db 未就绪/空图)返回空数组,不抛。
+     *
+     * 返回记录 id 而非 hits 是刻意的:回链/扩展属于读路径细节,路侧只需排名序列。
+     */
+    searchLaneRecords(query, embedding, limit, families) {
+        if (!this.db)
+            return [];
+        const { nodes, edges } = this.loadGraph();
+        const visible = families && families.length > 0
+            ? nodes.filter((n) => n.families.some((f) => families.includes(f)))
+            : nodes;
+        const lexical = searchGraphNodes(visible, edges, query, limit);
+        let hits = lexical;
+        if (embedding && embedding.length > 0) {
+            const visibleIds = new Set(visible.map((n) => n.id));
+            const seenNodes = new Set(lexical.map((h) => h.node.id));
+            const extra = [];
+            for (const v of this.searchNodesByVector(embedding, GRAPH_VEC_SEED_CAP)) {
+                if (seenNodes.has(v.node.id) || !visibleIds.has(v.node.id))
+                    continue;
+                if (v.node.status !== 'active' && v.node.status !== 'disputed')
+                    continue;
+                seenNodes.add(v.node.id);
+                extra.push({ node: v.node, score: v.score, matchedFields: ['name'], matchReason: '向量种子命中' });
+            }
+            if (extra.length > 0)
+                hits = [...lexical, ...extra];
+        }
+        return expandHitRecordIds(hits, nodes, edges);
+    }
+    /**
+     * 面板图谱预览存储缝(契约 `dsh-memory/graph-preview` 的数据源):
+     * loadGraph 一次 + job 计数(pending/running/failed 未定项与全量分母)传入纯函数。
+     * 降级(db 未就绪)返**全零结构**不抛——预览是展示面,永不拖垮端点。
+     * mode==='full' 时响应附 `full` 轻量块;**缺省时该键缺席**(可选键零漂移纪律,
+     * 不是 undefined 占位——消费方 `'full' in res` 与 JSON 形状双判据都干净)。
+     */
+    buildPreview(seedId, mode) {
+        const zero = { seeds: [], stats: { nodes: 0, edges: 0, causalEdges: 0, pendingJobs: 0, jobsTotal: 0 } };
+        if (!this.db)
+            return mode === 'full' ? { ...zero, full: { nodes: [], edges: [], truncated: false } } : zero;
+        const { nodes, edges } = this.loadGraph();
+        let pendingJobs = 0;
+        let jobsTotal = 0;
+        let deadJobs = 0;
+        try {
+            pendingJobs = this.db
+                .prepare("SELECT COUNT(1) AS c FROM graph_projection_jobs WHERE status IN ('pending','running','failed')")
+                .get().c;
+            jobsTotal = this.db.prepare('SELECT COUNT(1) AS c FROM graph_projection_jobs').get().c;
+            deadJobs = this.db.prepare("SELECT COUNT(1) AS c FROM graph_projection_jobs WHERE status = 'dead'").get().c;
+        }
+        catch (err) {
+            this.logger?.warn(`${TAG} 预览 job 计数失败(计数回零): ${err instanceof Error ? err.message : String(err)}`);
+        }
+        const r = buildGraphPreview(nodes, edges, { seedId, pendingJobs, jobsTotal, deadJobs });
+        if (mode === 'full')
+            return { ...r, full: buildFullView(nodes, edges) };
+        return r;
+    }
+    /**
+     * 清理历史 dead 作业行（纯审计痕迹删除，不影响已重入队的记录）。
+     * olderThanMs: 只删早于 now-olderThanMs 的；缺省删全部 dead。
+     */
+    cleanupDead(olderThanMs) {
+        if (!this.db)
+            return 0;
+        try {
+            const cutoff = olderThanMs != null && olderThanMs > 0
+                ? new Date(Date.now() - olderThanMs).toISOString()
+                : undefined;
+            const result = cutoff
+                ? this.db.prepare("DELETE FROM graph_projection_jobs WHERE status = 'dead' AND updated_time < ?").run(cutoff)
+                : this.db.prepare("DELETE FROM graph_projection_jobs WHERE status = 'dead'").run();
+            return Number(result.changes ?? 0);
+        }
+        catch (err) {
+            this.logger?.warn(`${TAG} cleanupDead 失败(忽略): ${err instanceof Error ? err.message : String(err)}`);
+            return 0;
+        }
+    }
     // ============================
     // 投影 job 队列
     // ============================
@@ -568,7 +661,7 @@ export class GraphStore {
                AND status IN ('pending', 'failed')
                AND (next_attempt_at IS NULL OR next_attempt_at <= ?)
              ORDER BY priority DESC, created_time ASC LIMIT 1`)
-                    .get(GRAPH_PROJECTOR_VERSION, GRAPH_JOB_MAX_ATTEMPTS, nowMs);
+                    .get(GRAPH_PROJECTOR_VERSION, GRAPH_JOB_TRANSIENT_MAX_ATTEMPTS, nowMs);
                 if (!row)
                     return null;
                 db.prepare(`UPDATE graph_projection_jobs SET status = 'running', attempts = attempts + 1, error = NULL, updated_time = ? WHERE job_id = ?`).run(nowIso, row.job_id);
@@ -645,24 +738,27 @@ export class GraphStore {
         }
     }
     /**
-     * 投影失败收尾:attempts 已在 claim 时 +1——封顶转 dead(放掉 mapping,允许
-     * 重新入队);未封顶转 failed + 指数退避 nextAttemptAt(mapping 保留防重复入队)。
+     * 投影失败收尾:attempts 已在 claim 时 +1——根据错误分类选不同封顶:
+     * - 永久错误(校验/解析):attempts >= GRAPH_JOB_MAX_ATTEMPTS(3) → dead
+     * - 瞬态错误(aborted/timeout/网络):attempts >= GRAPH_JOB_TRANSIENT_MAX_ATTEMPTS(6) → dead
+     * dead 放掉 mapping(允许下次 backfill 重新入队);未封顶转 failed + 指数退避。
      */
-    fail(jobId, error) {
+    fail(jobId, error, opts) {
         if (!this.db)
             return;
         try {
             const db = this.db;
             const nowMs = Date.now();
             const nowIso = new Date(nowMs).toISOString();
+            const cap = opts?.transient ? GRAPH_JOB_TRANSIENT_MAX_ATTEMPTS : GRAPH_JOB_MAX_ATTEMPTS;
             this.tx(() => {
                 const row = db.prepare('SELECT attempts FROM graph_projection_jobs WHERE job_id = ?').get(jobId);
                 if (!row)
                     return;
-                if (row.attempts >= GRAPH_JOB_MAX_ATTEMPTS) {
+                if (row.attempts >= cap) {
                     db.prepare(`UPDATE graph_projection_jobs SET status = 'dead', error = ?, updated_time = ? WHERE job_id = ?`).run(error.slice(0, 500), nowIso, jobId);
                     db.prepare('DELETE FROM graph_job_records WHERE job_id = ?').run(jobId);
-                    this.logger?.warn(`${TAG} 投影任务达重试上限,标记 dead(job=${jobId}): ${error.slice(0, 200)}`);
+                    this.logger?.warn(`${TAG} 投影任务达重试上限(${opts?.transient ? '瞬态' : '永久'}cap=${cap}),标记 dead(job=${jobId}): ${error.slice(0, 200)}`);
                 }
                 else {
                     const backoffMs = GRAPH_JOB_BACKOFF_BASE_MS * 2 ** (row.attempts - 1);

package/dist/store/l0-watermark.d.ts

@@ -0,0 +1,46 @@
+/**
+ * L0 水位表(T8.4 l0 写停,drsc-redact-memory-wiring task_16)。
+ *
+ * capture 停写 l0_conversations/l0_fts/l0_vec 三表后,§A 崩溃恢复的幂等判据
+ * (maxCapturedTurn / hasAnyL0Message)失去数据源——本小表接住:每会话一行,
+ * 只存 (max_turn, last_step),几十 KB 量级。正文改由 DRSC 投影供读(历史面),
+ * 水位只服务「重启不重放旧 turn」的自检,不再承载任何文本。
+ *
+ * 语义对齐被退役的 SQL 口径:
+ * - `maxTurn(sid)`  ≡ 退役前 `MAX(turn)`;只前进不回退(重放/乱序登记无害);
+ * - `hasAny(sid, t)` ≡ 退役前 `t <= MAX(turn)` 的存在性判定——恢复窗口
+ *   (foldRecoverableTurns 只产出 turn > 水位 的括号)内恒 false,行为与
+ *   MAX 口径等价;写停后正文无「部分写残行」,逐 turn 点查的原始动机消失。
+ *
+ * 基线物化:写停生效前已存在的 l0_conversations 行由 {@link ensureBaseline}
+ * 一次性灌入(INSERT OR IGNORE,存量水位行不覆盖)——没有它,升级后的首次
+ * resume 会把水位当空、重放旧 turn 重复蒸馏。每次 init 幂等重跑(空表扫描
+ * 零成本;task_22 存量清退删表后同样安静)。
+ *
+ * 与 CostLedger/GraphStore 同款纪律:独立职责类,唯一耦合是共享 node:sqlite
+ * 连接;未 init / 降级时全部方法安全 no-op。
+ */
+import type { DatabaseSync } from 'node:sqlite';
+import type { MemoryLogger } from '../types.js';
+export declare const L0_WATERMARK_DDL = "\nCREATE TABLE IF NOT EXISTS l0_watermark (\n  session_id TEXT PRIMARY KEY,\n  max_turn INTEGER NOT NULL DEFAULT 0,\n  last_step INTEGER,\n  updated_at TEXT DEFAULT (datetime('now'))\n)\n";
+export declare class L0WatermarkStore {
+    private db;
+    private logger;
+    init(db: DatabaseSync, logger?: MemoryLogger): void;
+    close(): void;
+    /**
+     * 基线物化:从现存 l0_conversations 把每会话最大 turn 灌进水位表。
+     * INSERT OR IGNORE = 已有水位行(活捕获已推进)一律不覆盖;旧行文与
+     * 水位并存期两侧取大者由 record 的单调语义兜底。
+     */
+    ensureBaseline(): void;
+    /**
+     * 登记一个已捕获轮次(写停后 capture 的唯一落盘点)。单调:turn 更小/相等的
+     * 登记不回退水位(恢复对账与乱序事件都安全);step 取该轮已知最大 step。
+     */
+    record(sessionId: string, turn: number, step?: number): void;
+    /** §A 水位线:该会话已捕获的最大 turn(空会话/未 init 返回 undefined)。 */
+    maxTurn(sessionId: string): number | undefined;
+    /** §A 幂等检查:该 (session, turn) 是否已捕获(≡ 退役前 hasAnyL0Message)。 */
+    hasAny(sessionId: string, turn: number): boolean;
+}

package/dist/store/l0-watermark.js

@@ -0,0 +1,93 @@
+export const L0_WATERMARK_DDL = `
+CREATE TABLE IF NOT EXISTS l0_watermark (
+  session_id TEXT PRIMARY KEY,
+  max_turn INTEGER NOT NULL DEFAULT 0,
+  last_step INTEGER,
+  updated_at TEXT DEFAULT (datetime('now'))
+)
+`;
+export class L0WatermarkStore {
+    db = null;
+    logger;
+    init(db, logger) {
+        this.db = db;
+        this.logger = logger;
+        db.exec(L0_WATERMARK_DDL);
+        this.ensureBaseline();
+    }
+    close() {
+        this.db = null;
+    }
+    /**
+     * 基线物化:从现存 l0_conversations 把每会话最大 turn 灌进水位表。
+     * INSERT OR IGNORE = 已有水位行(活捕获已推进)一律不覆盖;旧行文与
+     * 水位并存期两侧取大者由 record 的单调语义兜底。
+     */
+    ensureBaseline() {
+        if (!this.db)
+            return;
+        try {
+            this.db.exec(`
+        INSERT OR IGNORE INTO l0_watermark (session_id, max_turn, last_step)
+        SELECT session_id, MAX(turn), NULL
+        FROM l0_conversations
+        WHERE turn IS NOT NULL
+        GROUP BY session_id
+      `);
+        }
+        catch (err) {
+            // l0_conversations 可能已被存量清退(task_22)删除:表缺 = 无基线可灌,安静跳过
+            this.logger?.debug?.(`[memory] L0 水位基线物化跳过: ${err instanceof Error ? err.message : String(err)}`);
+        }
+    }
+    /**
+     * 登记一个已捕获轮次(写停后 capture 的唯一落盘点)。单调:turn 更小/相等的
+     * 登记不回退水位(恢复对账与乱序事件都安全);step 取该轮已知最大 step。
+     */
+    record(sessionId, turn, step) {
+        if (!this.db || !sessionId || !Number.isFinite(turn))
+            return;
+        try {
+            this.db
+                .prepare(`INSERT INTO l0_watermark (session_id, max_turn, last_step, updated_at)
+           VALUES (?, ?, ?, datetime('now'))
+           ON CONFLICT(session_id) DO UPDATE SET
+             max_turn = MAX(l0_watermark.max_turn, excluded.max_turn),
+             last_step = CASE WHEN excluded.max_turn > l0_watermark.max_turn
+                              THEN excluded.last_step ELSE l0_watermark.last_step END,
+             updated_at = excluded.updated_at`)
+                .run(sessionId, turn, typeof step === 'number' && Number.isFinite(step) ? step : null);
+        }
+        catch (err) {
+            this.logger?.warn(`[memory] L0 水位登记失败(幂等自检可能重放): ${err instanceof Error ? err.message : String(err)}`);
+        }
+    }
+    /** §A 水位线:该会话已捕获的最大 turn(空会话/未 init 返回 undefined)。 */
+    maxTurn(sessionId) {
+        if (!this.db || !sessionId)
+            return undefined;
+        try {
+            const row = this.db
+                .prepare('SELECT max_turn FROM l0_watermark WHERE session_id = ?')
+                .get(sessionId);
+            return typeof row?.max_turn === 'number' ? row.max_turn : undefined;
+        }
+        catch {
+            return undefined;
+        }
+    }
+    /** §A 幂等检查:该 (session, turn) 是否已捕获(≡ 退役前 hasAnyL0Message)。 */
+    hasAny(sessionId, turn) {
+        if (!this.db || !sessionId || !Number.isFinite(turn))
+            return false;
+        try {
+            const row = this.db
+                .prepare('SELECT 1 FROM l0_watermark WHERE session_id = ? AND max_turn >= ? LIMIT 1')
+                .get(sessionId, turn);
+            return row !== undefined;
+        }
+        catch {
+            return false;
+        }
+    }
+}

package/dist/store/l0.d.ts

@@ -1,48 +1,18 @@
-import type { ConversationMessage, L0MessageRecord, MemoryLogger } from '../types.js';
-import { type EmbeddingService } from './embedding.js';
-import { type MemoryDb } from './sqlite.js';
+/**
+ * L0 存量计数门面(T8.4 l0 写路径退役后)。
+ *
+ * capture 已停写 l0 正文三表与 JSONL 事实源(见 hooks/capture.ts 与
+ * store/l0-watermark.ts),历史读面(recentBySession / search)改经
+ * `clients/drsc.ts` 的 DrscClient(硬依赖,无本地回退)——本类只剩状态
+ * 面板的两个只读计数(今日捕获 / 按会话累计)。task_22 存量清退后表为
+ * 空壳,计数自然归零,读路径无需判空。
+ */
+import type { MemoryDb } from './sqlite.js';
 export declare class L0Store {
     private readonly db;
-    private readonly dir;
-    private readonly legacyDir;
-    private readonly helper;
-    private 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 计数,不再读整文件)。 */
+    constructor(db: MemoryDb);
+    /** 今日已捕获消息数(SQL 计数,不再读整文件;写停后归零,面板口径保留)。 */
     countToday(): Promise<number>;
     /** 该会话累计已捕获消息数(session-stats 数据源;索引 COUNT)。 */
     countBySession(sessionId: string): Promise<number>;
-    /** 该会话最近 n 条消息(时间升序;蒸馏背景参考用,按会话现查——ADR-0003)。 */
-    recentBySession(sessionId: string, limit: number): Promise<ConversationMessage[]>;
-    /** §A 水位线:该会话 L0 已落盘的最大 turn(空会话 undefined;委托 MemoryDb)。 */
-    maxCapturedTurn(sessionId: string): number | undefined;
-    /** §A 幂等检查:该 (session, turn) 是否已有任意 L0 行(委托 MemoryDb)。 */
-    hasAnyL0Message(sessionId: string, turn: number): boolean;
-    /** 检索:FTS + 向量 hybrid(RRF 融合),返回按相关性排序的消息。 */
-    search(query: string, limit: number): Promise<L0MessageRecord[]>;
-    /** 活切换嵌入源:同步换底层服务(嵌入源三态切换用)。 */
-    setEmbeddingService(svc: EmbeddingService): void;
-    /** 向量写入能力是否就绪。`reindex` 在未就绪时**静默短路**成 0/0/0
-     *  (见本文件 `reindex` 首行),调用方必须自己问这里——否则"根本没跑"
-     *  会长得和"跑完了、零条待补"一模一样。 */
-    vectorsReady(): boolean;
-    /**
-     * 增量重嵌入(同 L1Store.reindex:只补缺失向量,零向量记 skipped 并入 skip 集,
-     * 不算失败、不阻塞同步标记——保证补齐判据收敛)。onProgress/shouldCancel
-     * 供活切换的进度展示与取消。
-     */
-    reindex(opts?: {
-        onProgress?: (done: number, total: number) => void;
-        shouldCancel?: () => boolean;
-    }): Promise<{
-        written: number;
-        failed: number;
-        skipped: number;
-        cancelled?: boolean;
-    }>;
 }

package/dist/store/l0.js

@@ -1,121 +1,9 @@
-/**
- * L0 原始对话存储(双写架构):
- * - conversations/YYYY-MM-DD.jsonl:追加式事实源;
- * - MemoryDb(SQLite):主检索引擎——检索不再按天扫文件、现建内存索引。
- */
-import { existsSync, promises as fs } from 'node:fs';
-import * as path from 'node:path';
-import { EmbedHelper, NoopEmbeddingService } from './embedding.js';
-import { appendJsonl, dayKey, ensureDir, nowIso, readJsonl } from '../util/io.js';
-import { rrfMerge } from './search-utils.js';
-import { isZeroVector } from './sqlite.js';
-/** 官方过度召回倍数(conversation-search:limit × 3)。 */
-const CANDIDATE_MULTIPLIER = 3;
 export class L0Store {
     db;
-    dir;
-    legacyDir;
-    helper;
-    embedSvc;
-    logger;
-    constructor(dataDir, db, embed = new NoopEmbeddingService(), logger) {
+    constructor(db) {
         this.db = db;
-        this.dir = path.join(dataDir, 'conversations');
-        this.legacyDir = path.join(dataDir, 'l0');
-        this.embedSvc = embed;
-        this.helper = new EmbedHelper(embed, logger);
-        this.logger = logger;
     }
-    async init() {
-        await ensureDir(this.dir);
-        await this.importLegacy();
-    }
-    /** 旧版 l0/*.jsonl 一次性导入检索库,成功后目录改名 l0.imported/。 */
-    async importLegacy() {
-        if (!existsSync(this.legacyDir))
-            return;
-        try {
-            const files = await fs.readdir(this.legacyDir).catch(() => []);
-            let imported = 0;
-            let total = 0;
-            for (const f of files.sort()) {
-                if (!f.endsWith('.jsonl'))
-                    continue;
-                const records = await readJsonl(path.join(this.legacyDir, f));
-                // 最小有效性门(同 L1 的 importLegacy):坏行读取时丢弃,按 valid 数判迁移完成
-                const valid = records.filter((r) => r && typeof r.id === 'string' && r.content);
-                const badCount = records.length - valid.length;
-                if (badCount > 0) {
-                    this.logger?.warn(`[memory] 旧版 L0 文件 ${f} 丢弃 ${badCount} 条坏行(缺 id/content)`);
-                }
-                if (valid.length > 0) {
-                    total += valid.length;
-                    if (this.db.upsertL0Batch(valid))
-                        imported += valid.length;
-                }
-            }
-            // 只有全部批次入库成功(或目录为空)才改名,避免数据被改名带走
-            if (imported === total) {
-                const renamed = await fs
-                    .rename(this.legacyDir, `${this.legacyDir}.imported`)
-                    .then(() => true, () => false);
-                if (renamed) {
-                    this.logger?.info(`[memory] 旧版 L0 数据已导入检索库 ${imported} 条(l0/ → l0.imported/)`);
-                }
-                else {
-                    this.logger?.warn('[memory] 旧版 L0 导入完成但改名失败(l0.imported/ 已存在?),下次启动会重复导入(幂等,无害)');
-                }
-            }
-            else {
-                this.logger?.warn(`[memory] 旧版 L0 导入不完整(${imported}/${total}),保留原目录下次重试`);
-            }
-        }
-        catch (err) {
-            this.logger?.warn(`[memory] 旧版 L0 数据导入失败: ${err instanceof Error ? err.message : String(err)}`);
-        }
-    }
-    async append(sessionId, messages) {
-        if (messages.length === 0)
-            return;
-        const records = messages.map((m) => {
-            const rec = {
-                sessionId,
-                recordedAt: nowIso(),
-                id: m.id,
-                role: m.role,
-                content: m.content,
-                timestamp: m.timestamp,
-            };
-            // R7:锚点摊平到事实源与 DB 两处(事实源可跨进程重建,DB 供按坐标查询)。
-            // 无锚点时**不写键**——旧行与新增的无坐标消息保持同形。
-            if (m.anchor !== undefined) {
-                rec.turn = m.anchor.turn;
-                if (m.anchor.step !== undefined)
-                    rec.step = m.anchor.step;
-            }
-            return rec;
-        });
-        // 事实源:按天追加
-        const byDay = new Map();
-        for (const r of records) {
-            const k = dayKey(r.timestamp);
-            const arr = byDay.get(k) ?? [];
-            arr.push(r);
-            byDay.set(k, arr);
-        }
-        for (const [day, list] of byDay) {
-            await appendJsonl(path.join(this.dir, `${day}.jsonl`), list);
-        }
-        // 检索引擎:DB + 向量(嵌入失败只跳过向量,不影响元数据/FTS,backfill 补齐)。
-        // 双写失败闭环:JSONL 事实源已先行追加,DB 缺行 = 这些消息检索不可见
-        // (conversation_search / 蒸馏背景参考都查不到)——升 error 并给自愈指引。
-        const vecs = await this.helper.batch(records.map((r) => r.content));
-        if (!this.db.upsertL0Batch(records, vecs)) {
-            this.logger?.error(`[memory] L0 检索库批量写入失败(${records.length} 条,JSONL 事实源完好),` +
-                '这些消息暂不可检索;可在设置页运行「重建记忆」修复');
-        }
-    }
-    /** 今日已捕获消息数(SQL 计数,不再读整文件)。 */
+    /** 今日已捕获消息数(SQL 计数,不再读整文件;写停后归零,面板口径保留)。 */
     async countToday() {
         const d = new Date();
         return this.db.countL0Since(new Date(d.getFullYear(), d.getMonth(), d.getDate()).toISOString());
@@ -124,98 +12,4 @@ export class L0Store {
     async countBySession(sessionId) {
         return this.db.countL0BySession(sessionId);
     }
-    /** 该会话最近 n 条消息(时间升序;蒸馏背景参考用,按会话现查——ADR-0003)。 */
-    async recentBySession(sessionId, limit) {
-        return this.db.recentL0BySession(sessionId, limit);
-    }
-    /** §A 水位线:该会话 L0 已落盘的最大 turn(空会话 undefined;委托 MemoryDb)。 */
-    maxCapturedTurn(sessionId) {
-        return this.db.maxCapturedTurn(sessionId);
-    }
-    /** §A 幂等检查:该 (session, turn) 是否已有任意 L0 行(委托 MemoryDb)。 */
-    hasAnyL0Message(sessionId, turn) {
-        return this.db.hasAnyL0Message(sessionId, turn);
-    }
-    /** 检索:FTS + 向量 hybrid(RRF 融合),返回按相关性排序的消息。 */
-    async search(query, limit) {
-        const caps = this.db.getCapabilities();
-        if (!caps.ftsSearch && !caps.vectorSearch)
-            return [];
-        const candidateK = limit * CANDIDATE_MULTIPLIER;
-        if (caps.vectorSearch && this.helper.vectorReady()) {
-            const [ftsRaw, vec] = await Promise.all([
-                Promise.resolve(this.db.searchL0Fts(query, candidateK)),
-                this.helper.query(query),
-            ]);
-            const vecList = vec ? this.db.searchL0Vector(vec, candidateK) : [];
-            const merged = rrfMerge([ftsRaw, vecList], (h) => h.id);
-            return merged.map(({ rrfScore: _rrf, ...r }) => r).slice(0, limit);
-        }
-        return this.db.searchL0Fts(query, limit).map(({ score: _score, ...r }) => r);
-    }
-    /** 活切换嵌入源:同步换底层服务(嵌入源三态切换用)。 */
-    setEmbeddingService(svc) {
-        this.embedSvc = svc;
-        this.helper.setService(svc);
-    }
-    /** 向量写入能力是否就绪。`reindex` 在未就绪时**静默短路**成 0/0/0
-     *  (见本文件 `reindex` 首行),调用方必须自己问这里——否则"根本没跑"
-     *  会长得和"跑完了、零条待补"一模一样。 */
-    vectorsReady() {
-        return this.helper.vectorReady();
-    }
-    /**
-     * 增量重嵌入(同 L1Store.reindex:只补缺失向量,零向量记 skipped 并入 skip 集,
-     * 不算失败、不阻塞同步标记——保证补齐判据收敛)。onProgress/shouldCancel
-     * 供活切换的进度展示与取消。
-     */
-    async reindex(opts) {
-        if (!this.helper.vectorReady())
-            return { written: 0, failed: 0, skipped: 0 };
-        const items = this.db.getL0ForReindex(this.db.getVecSkipSet('l0'));
-        const total = items.length;
-        let done = 0;
-        let written = 0;
-        let failed = 0;
-        let skipped = 0;
-        let cancelled = false;
-        const skippedNow = [];
-        const CHUNK = 32;
-        for (let i = 0; i < items.length; i += CHUNK) {
-            if (opts?.shouldCancel?.()) {
-                cancelled = true;
-                break;
-            }
-            const chunk = items.slice(i, i + CHUNK);
-            let vecs;
-            try {
-                vecs = await this.embedSvc.embedBatch(chunk.map((c) => c.text));
-            }
-            catch {
-                failed += chunk.length;
-                done += chunk.length;
-                opts?.onProgress?.(done, total);
-                continue;
-            }
-            const pending = [];
-            chunk.forEach((c, j) => {
-                if (isZeroVector(vecs[j])) {
-                    skipped++;
-                    skippedNow.push(c.id);
-                    return;
-                }
-                pending.push({ id: c.id, embedding: vecs[j] });
-            });
-            if (pending.length > 0) {
-                const ok = this.db.updateL0VecBatch(pending, '');
-                written += ok;
-                failed += pending.length - ok;
-            }
-            done += chunk.length;
-            opts?.onProgress?.(done, total);
-        }
-        if (skippedNow.length > 0)
-            this.db.addVecSkippedIds('l0', skippedNow);
-        return { written, failed, skipped, cancelled };
-    }
 }

package/dist/store/l1.d.ts

@@ -1,5 +1,4 @@
 import type { L1Hit, MemoryFamily, MemoryLogger, MemoryRecord, RoomCount } from '../types.js';
-import type { GraphNodeSearchResult } from '../graph/types.js';
 import type { L1Receipt, ReceiptQuery } from './receipts.js';
 import type { ConflictClaimGroup, ConflictPair, ConflictRejected, ConflictResolution, ConflictType } from './conflicts.js';
 import { type SupersedeInfo } from './supersede.js';
@@ -9,11 +8,13 @@ import { type L1MetaLite, type MemoryDb } from './sqlite.js';
 import type { L1FileSyncHook } from './memory-md-sync.js';
 export type RecallStrategy = 'keyword' | 'embedding' | 'hybrid';
 /**
- * 图谱路提供者(§D 第 3 路):按查询返回图谱命中(已按 score 降序)。
+ * 图谱路提供者(§D 第 3 路):按查询返回图谱回链的 L1 记录 id 有序列
+ * (向量种子并集与 1-hop 边扩展在 provider 内完成,见 graph-store.searchLaneRecords)。
  * 抽成注入式而非直接读 `db.graphStore`,是为了给 hybrid 融合留一个可替换的测试缝,
- * 并让「未接线 = 恰为 2 路」成为默认行为(既有调用方零行为变化)。
+ * 并让「未接线 = 恰为 2 路」成为默认行为(既有调用方零行为变化)。允许返回 Promise
+ * 是给向量种子的 embed 查询(装配层惰性取嵌入源);异常由 graphLane 吞并降级。
  */
-export type GraphLaneProvider = (query: string, limit: number, family?: MemoryFamily) => readonly GraphNodeSearchResult[];
+export type GraphLaneProvider = (query: string, limit: number, family?: MemoryFamily) => readonly string[] | Promise<readonly string[]>;
 export interface L1SearchOptions {
     /** 按记忆类型精确过滤(后置过滤,官方做法)。 */
     type?: string;
@@ -424,17 +425,19 @@ export declare class L1Store {
      */
     private recencyLane;
     /**
-     * §D 第 3 路(图谱路径,hybrid 专用):图谱命中 → `sourceRecordIds` 回链 →
-     * L1 记录,作为第 3 条**已排序**列表参与 RRF。
+     * §D 第 3 路(图谱路径,hybrid 专用):provider 给出回链记录 id 序(路内向量种子
+     * 并集 + 1-hop 边扩展在 provider 内完成),本缝只做点查回形 + family/scope 双闸,
+     * 作为第 3 条**已排序**列表参与 RRF。
      *
      * 为什么值得:图谱是按实体/关系组织的**可重建派生投影**,能召回词法与向量
      * 都命不中的记录(同义表述、关系可达)——这正是本路相对双路的增量。
      *
      * 三条边界:
      * - **异常降级**:图谱是派生投影,不得因它失败而拖垮主检索 → 记 warn、返回空路,
-     *   融合退回双路(路数随之降为 2,分数回到既有量纲);
-     * - **族隔离**:图谱节点已按族过滤,但其来源记录可能跨族 → 这里再按 `family`
-     *   过滤一次。宁可漏不可串(与档位隔离同源,§A 的 P0 关注点);
+     *   融合退回双路(路数随之降为 2,分数回到既有量纲);await 在 try 内——
+     *   provider 的 Promise reject 与同步 throw 同路径降级;
+     * - **族隔离**:图谱节点已按族过滤(含向量种子),但 1-hop 邻居与来源记录可能跨族
+     *   → 这里再按 `family` 过滤一次。宁可漏不可串(与档位隔离同源,§A 的 P0 关注点);
      * - **墓碑边界**:图谱行可能回链到已被删除的 L1 记录 → 取不到就跳过,
      *   不补空占位(占位会在 RRF 里凭空加分)。
      */