dsh-prime-memory 0.26.4 → 0.26.5

package/dist/hooks/recall.js

@@ -531,7 +531,14 @@ usage) {
                 usage?.recordAttempt(scoped.map((h) => h.id), fresh.slice(0, lines.length).map((h) => h.id));
                 // G-live:按 **sessionKey**(=agent.session?.id ?? agent.id，与 pill 的 sessionId / 投影 header.id 同源，
                 // 非 ownerId)记入本会话“活召回集”，供侧栏卡读取；压缩时同键 reset。
-                stores.recalled?.add(sessionKey, fresh.slice(0, lines.length).map((h) => h.id), injection.id);
+                // 路归因随注入透传(hybrid 融合才挂 lanes;单路策略下表空=不记,徽标无从渲染)。
+                const injectedHits = fresh.slice(0, lines.length);
+                const laneById = new Map();
+                for (const h of injectedHits) {
+                    if (h.lanes !== undefined && h.lanes.length > 0)
+                        laneById.set(h.id, h.lanes);
+                }
+                stores.recalled?.add(sessionKey, injectedHits.map((h) => h.id), injection.id, laneById);
                 // 入账在成功构造注入消息之后、返回 enter 之前——任何前置抛错路径账目零扰动
                 const led = ledgerFor(payload.agent.id);
                 recordRecallInjection(led, text.length);

package/dist/index.js

@@ -50,6 +50,7 @@ import { makeFileSyncHook } from './store/memory-md-sync.js';
 import { ObsoleteNoticeStore } from './store/obsolete-notices.js';
 import { registerSlotsProjection } from './projection/slots.js';
 import { registerRecallProjection } from './projection/recall.js';
+import { DrscClient } from './clients/drsc.js';
 import { errDetail, withFileLog } from './util/filelog.js';
 import { buildRouteChain, resolveModelRoute, invalidateEffortCache } from './llm.js';
 import { effectiveCfg } from './pipeline/runner.js';
@@ -57,6 +58,30 @@ import { pendingPathFor } from './store/pending.js';
 import { initTokenCost, resetTokenCost } from './token-cost.js';
 import { initTraceStore } from './store/trace.js';
 export const name = 'dsh-memory-plugin';
+/**
+ * webStartup(0.2.1-a.2 起更名自 webRuntime)的 best-effort 读取:trustedHosts
+ * 供 DrscClient 同源基址解析。宿主服务缺席/未声明 inject 时属性读会抛
+ * (cordis Proxy 面),双名回退链 + 两层 try,安全返回 undefined(→ 缺省 8080 口)。
+ */
+function readStartupTrustedHosts(ctx) {
+    for (const name of ['webStartup', 'webRuntime']) {
+        try {
+            const direct = ctx[name];
+            const svc = (direct !== undefined
+                ? direct
+                : typeof ctx.get === 'function'
+                    ? ctx.get(name)
+                    : undefined);
+            if (svc !== null && typeof svc === 'object' && Array.isArray(svc.trustedHosts)) {
+                return svc.trustedHosts;
+            }
+        }
+        catch {
+            /* 未声明服务的属性读抛:落下一名/缺省 */
+        }
+    }
+    return undefined;
+}
 /**
  * 硬依赖:蒸馏要用 llm,工具注册要用 tools,召回注入要用 systemPrompt。
  * 0.1.5 起 connection.rpc.handle() 把 /rpc 路由登记到 webServer 时按**调用方
@@ -170,12 +195,25 @@ export async function apply(ctx, config) {
             logger.error(`[memory] 检索库打开失败,记忆功能停用: ${err instanceof Error ? err.message : String(err)}`);
         }
     }
+    // §D 第 3 路装配(回链 + 路内向量种子 + 1-hop,见 graph-store.searchLaneRecords):
+    // embed 查询惰性接 stores.l1.embedText(嵌入源运行时活切换不被钉死在启动 service 上,
+    // 且复用其超时/失败吞并语义——未就绪/失败 = undefined = 纯词法路,与旧 searchNodes
+    // 表达式逐位一致)。图谱不可用时 searchLaneRecords 自带空返回,不影响双路。
+    // eslint-disable-next-line prefer-const -- 声明早于创建,后续单点赋值(与 embedManagerRef 同款惰性缝;TS 不允许 const 无初值)
+    let laneEmbedQuery;
+    const graphLaneProvider = async (query, limit, family) => {
+        const vec = laneEmbedQuery ? await laneEmbedQuery(query).catch(() => undefined) : undefined;
+        return db.graphStore.searchLaneRecords(query, vec, limit, family ? [family] : undefined);
+    };
     const stores = {
         usage: undefined, // 装配于下方(依赖 dataDir 就绪)
-        l0: new L0Store(dataDir, db, embed, logger),
+        // DRSC 客户端(T8.4 读切):蒸馏背景窗 + conversation_search 工具面的历史供给。
+        // 硬依赖无本地回退(l0 表退役);trustedHosts 惰性读取(webStartup 可能晚到)。
+        drsc: new DrscClient({ trustedHosts: () => readStartupTrustedHosts(ctx) }),
+        l0: new L0Store(db),
         l1: new L1Store(dataDir, db, embed, config.recall.strategy, logger, config.recall.decayHalfLifeDays, 
-        // §D 第 3 路:图谱回链。图谱不可用时 searchNodes 自带 no-op,不影响双路。
-        (query, limit, family) => db.graphStore.searchNodes(query, limit, family ? [family] : undefined), 
+        // §D 第 3 路:图谱回链(声明于 stores 之前,embed 查询在下方接线)。
+        graphLaneProvider, 
         // 投射开着才给没名字的新记录起名（“关时零动作”这条承诺不改）。
         // 传函数而不是布尔：读的是当前配置对象，不把启动那一刻的值钉进 store。
         () => config.memExport?.enabled === true),
@@ -207,10 +245,12 @@ export async function apply(ctx, config) {
         // 后台记忆后端:初始化完成后填充(worker 隔离,失败则进程内)
         backend: undefined,
     };
+    // 惰性缝接线:provider 在检索时才解引用(l1 已就绪);声明序上的"先声明后赋值"
+    // 只影响装配期,而装配期不会有检索在飞(启动未完就没有 agent 回合)。
+    laneEmbedQuery = (q) => stores.l1.embedText(q);
     if (storageOk) {
         try {
             await Promise.all([
-                stores.l0.init(),
                 stores.l1.init(),
                 stores.scenes.chat.init(),
                 stores.scenes.work.init(),
@@ -255,18 +295,18 @@ export async function apply(ctx, config) {
                         // 增量:配置变化路径向量表已被 drop,全部记录均"缺失",等效全量;
                         // 活切换发起时让路(swap 会 drop 表,并发跑只是白烧嵌入调用)
                         const shouldCancel = () => disposed || !!embedManagerRef?.isBusy();
+                        // T8.4:l0 向量腿随写停退役(表清空后无缺失,无需重建)
                         const r1 = await stores.l1.reindex({ shouldCancel });
-                        const r0 = await stores.l0.reindex({ shouldCancel });
                         // missing 复查:嵌入服务未就绪时 reindex 短路 0/0/0——那是"没跑"不是"成功",
                         // 不得标记 meta(否则启动链不再补,补齐被无限推迟到 backfill)
-                        const missingAfter = db.countL1VecMissing(db.getVecSkipSet('l1')) + db.countL0VecMissing(db.getVecSkipSet('l0'));
-                        if (r1.failed === 0 && r0.failed === 0 && missingAfter === 0) {
+                        const missingAfter = db.countL1VecMissing(db.getVecSkipSet('l1'));
+                        if (r1.failed === 0 && missingAfter === 0) {
                             db.markEmbeddingSynced(currentProviderInfo() ?? info);
-                            const skipNote = r1.skipped + r0.skipped > 0 ? `,跳过不可嵌入 ${r1.skipped + r0.skipped} 条` : '';
-                            logger.info(`[memory] 向量重建完成:L1 ${r1.written} 条,L0 ${r0.written} 条${skipNote}(原因:${dbInit.reason ?? '配置变化'})`);
+                            const skipNote = r1.skipped > 0 ? `,跳过不可嵌入 ${r1.skipped} 条` : '';
+                            logger.info(`[memory] 向量重建完成:L1 ${r1.written} 条${skipNote}(原因:${dbInit.reason ?? '配置变化'})`);
                         }
                         else {
-                            logger.warn(`[memory] 向量重建未完成(L1 失败 ${r1.failed},L0 失败 ${r0.failed},剩缺 ${Math.max(missingAfter, 0)} 条),下次启动/补齐周期重试`);
+                            logger.warn(`[memory] 向量重建未完成(L1 失败 ${r1.failed},剩缺 ${Math.max(missingAfter, 0)} 条),下次启动/补齐周期重试`);
                         }
                     }
                     catch (err) {
@@ -302,19 +342,18 @@ export async function apply(ctx, config) {
                         if (embedManagerRef?.isBusy())
                             return;
                         const l1Missing = db.countL1VecMissing(db.getVecSkipSet('l1')) > 0;
-                        const l0Missing = db.countL0VecMissing(db.getVecSkipSet('l0')) > 0;
-                        if (!l1Missing && !l0Missing)
+                        if (!l1Missing)
                             return;
                         const shouldCancel = () => disposed || !!embedManagerRef?.isBusy();
+                        // T8.4:l0 向量腿随写停退役
                         const r1 = await stores.l1.reindex({ shouldCancel });
-                        const r0 = await stores.l0.reindex({ shouldCancel });
-                        const missingAfter = db.countL1VecMissing(db.getVecSkipSet('l1')) + db.countL0VecMissing(db.getVecSkipSet('l0'));
-                        if (r1.failed === 0 && r0.failed === 0 && missingAfter === 0) {
+                        const missingAfter = db.countL1VecMissing(db.getVecSkipSet('l1'));
+                        if (r1.failed === 0 && missingAfter === 0) {
                             db.markEmbeddingSynced(infoNow);
-                            logger.info(`[memory] 向量补齐完成:L1 ${r1.written} 条,L0 ${r0.written} 条(跳过不可嵌入 ${r1.skipped + r0.skipped} 条)`);
+                            logger.info(`[memory] 向量补齐完成:L1 ${r1.written} 条(跳过不可嵌入 ${r1.skipped} 条)`);
                         }
-                        else if (r1.failed > 0 || r0.failed > 0) {
-                            logger.warn(`[memory] 向量补齐未完成(L1 失败 ${r1.failed},L0 失败 ${r0.failed}),下个周期重试`);
+                        else if (r1.failed > 0) {
+                            logger.warn(`[memory] 向量补齐未完成(L1 失败 ${r1.failed}),下个周期重试`);
                         }
                     }
                     catch (err) {
@@ -342,7 +381,6 @@ export async function apply(ctx, config) {
             dataDir,
             cfg: config,
             db,
-            l0: stores.l0,
             l1: stores.l1,
             sourceStore,
             installer,
@@ -388,7 +426,7 @@ export async function apply(ctx, config) {
         : undefined;
     let flushL0;
     if (storageOk) {
-        flushL0 = registerCapture(ctx, config, runner, stores.l0, logger, live, modes);
+        flushL0 = registerCapture(ctx, config, runner, db.l0Watermark, logger, live, modes);
     }
     // 召回使用统计(进 topN 才算 used;热路径只碰内存,去抖落盘)
     const recallUsage = new RecallUsageStore(dataDir, logger);

package/dist/pipeline/graph.d.ts

@@ -25,6 +25,15 @@ export declare const GRAPH_CONTEXT_EDGE_LIMIT = 120;
 export declare function selectContextNodes(records: readonly MemoryRecord[], nodes: readonly GraphNode[], limit?: number): GraphNode[];
 /** 选择进入上下文的边:两端都入选节点的 active 边,按更新时间新→旧,≤120。 */
 export declare function selectContextEdges(nodes: readonly GraphNode[], edges: readonly GraphEdge[], limit?: number): GraphEdge[];
+/**
+ * 瞬态失败判据(与永久错误分流,由 GraphStore.fail 选不同重试封顶)。
+ *
+ * 真机归因(2026-10-20 审计):14 个 dead 全是 `llm aborted: Request was aborted` ×13 +
+ * `llm error: terminated` ×1——零校验类失败,全部是网关负载/超时把在飞请求掉断。
+ * 这类错误与 prompt/数据无关,退避后重试即可恢复,不该和“模型真的产坏了”同封顶。
+ * 匹配串源自 callLLM/callRoute/callDirect 的实际抛出形态(小写子串包含)。
+ */
+export declare function isTransientGraphFailure(msg: string): boolean;
 /**
  * 执行一次图谱投影(claim 一个 job → LLM → 校验落库;无 job 时静默返回)。
  * 返回是否实际认领了任务(泵据此决定是否续排)。失败转 fail(退避/封顶由

package/dist/pipeline/graph.js

@@ -2,6 +2,7 @@ import { callLLM, parseJsonLogged, resolveLayerTokens } from '../llm.js';
 import { buildGraphProjectionPrompt, getGraphProjectionSystemPrompt, } from '../prompts/graph-projection.js';
 import { normalizeEntityName } from '../graph/apply.js';
 import { tokenize } from '../util/text.js';
+import { GRAPH_PROJECTION_CALL_TIMEOUT_MS } from '../graph/types.js';
 import { errDetail } from '../util/filelog.js';
 /** claim 上下文装配的节点上限(词法相关 + 最近更新,总量封顶)。 */
 export const GRAPH_CONTEXT_NODE_LIMIT = 80;
@@ -64,6 +65,27 @@ export function selectContextEdges(nodes, edges, limit = GRAPH_CONTEXT_EDGE_LIMI
         .sort((a, b) => (a.updatedAt < b.updatedAt ? 1 : a.updatedAt > b.updatedAt ? -1 : 0))
         .slice(0, limit);
 }
+/**
+ * 瞬态失败判据(与永久错误分流,由 GraphStore.fail 选不同重试封顶)。
+ *
+ * 真机归因(2026-10-20 审计):14 个 dead 全是 `llm aborted: Request was aborted` ×13 +
+ * `llm error: terminated` ×1——零校验类失败,全部是网关负载/超时把在飞请求掉断。
+ * 这类错误与 prompt/数据无关,退避后重试即可恢复,不该和“模型真的产坏了”同封顶。
+ * 匹配串源自 callLLM/callRoute/callDirect 的实际抛出形态(小写子串包含)。
+ */
+export function isTransientGraphFailure(msg) {
+    const low = msg.toLowerCase();
+    return (low.includes('aborted') ||
+        low.includes('timeout') ||
+        low.includes('timed out') ||
+        low.includes('terminated') ||
+        low.includes('empty output') ||
+        low.includes('econn') ||
+        low.includes('etimedout') ||
+        low.includes('fetch failed') ||
+        low.includes('socket hang') ||
+        low.includes('network'));
+}
 /**
  * 执行一次图谱投影(claim 一个 job → LLM → 校验落库;无 job 时静默返回)。
  * 返回是否实际认领了任务(泵据此决定是否续排)。失败转 fail(退避/封顶由
@@ -84,12 +106,17 @@ export async function runGraphProjection(ctx, cfg, graphs, logger) {
             maxTokens: resolveLayerTokens(cfg, 'graph'),
             layer: 'graph',
             logger,
+            // 自带宽超时信号:不传则沿用 cfg.llm.timeoutMs(120s)——图谱批 prompt 在本地网关上
+            // 实测 ~2min/job,正好撞线(14 dead 根因);照 backfill callTimeoutMs 先例给 240s。
+            signal: AbortSignal.timeout(GRAPH_PROJECTION_CALL_TIMEOUT_MS),
         });
         graphs.complete(job.id, parseProjection(raw, logger), { now: new Date().toISOString() });
     }
     catch (err) {
-        logger.warn(`[memory] 图谱投影失败(job=${job.id},attempts=${job.attempts}): ${errDetail(err)}`);
-        graphs.fail(job.id, errDetail(err));
+        const detail = errDetail(err);
+        logger.warn(`[memory] 图谱投影失败(job=${job.id},attempts=${job.attempts}): ${detail}`);
+        // 瞬态(网关掉断/超时/空输出)与永久(校验/解析)分档——前者多给 3 次退避重试机会。
+        graphs.fail(job.id, detail, { transient: isTransientGraphFailure(detail) });
     }
     return true;
 }

package/dist/pipeline/runner.d.ts

@@ -14,8 +14,8 @@
 import type { Context } from '@deepseek-ai/cordis';
 import { type MemoryConfig } from '../config.js';
 import type { LiveSettingsHandle } from '../settings.js';
+import type { DrscClient } from '../clients/drsc.js';
 import type { GraphStore } from '../store/graph-store.js';
-import type { L0Store } from '../store/l0.js';
 import type { L1Store } from '../store/l1.js';
 import type { PersonaStore } from '../store/persona.js';
 import type { SceneStore } from '../store/scenes.js';
@@ -23,7 +23,11 @@ import type { StateStore } from '../store/state.js';
 import type { ConversationMessage, ExtractMode, MemoryFamily, MemoryLogger } from '../types.js';
 import type { FamilyStates } from './l1.js';
 export interface MemoryStores {
-    l0: L0Store;
+    /**
+     * DRSC 客户端(T8.4 读切):蒸馏背景窗的历史供给面(op=session&tail&redact=1)。
+     * 缺席(测试缝/未装配)时背景窗为空数组;拉取失败空窗降级,不抛穿管线。
+     */
+    drsc?: DrscClient;
     l1: L1Store;
     scenes: Record<MemoryFamily, SceneStore>;
     persona: Record<MemoryFamily, PersonaStore>;
@@ -171,10 +175,19 @@ export declare class MemoryRunner {
      *  蒸馏尝试时反复整量序列化落盘(多 MB 级 IO);重建轮豁免维持。 */
     private persistPending;
     private runTurn;
+    /**
+     * 蒸馏背景窗(T8.4 读切,task_19):DRSC 会话尾窗(redact 臂)→ ConversationMessage。
+     * - 形状映射:segment 行 → 消息(drscRowToConversationMessage;非 user/assistant 段跳过);
+     * - 坐标剔除:切片自身轮次整轮剔除(尾窗在 DRS 30s interval 同步后会含刚捕获
+     *   的 turn——旧 l0 读面按消息 id 剔除,跨系统 id 不同构,按坐标等价替身);
+     * - 报错口径:collector 缺席/超时 → warn 后空窗降级,**不抛穿蒸馏管线**
+     *   (工具面 conversation_search 的显式报错口径在 tools 层分清,spec R7)。
+     */
+    private drscBackground;
     /**
      * 抽取并消费一个会话切片:成功才把切片移出桶并推进爬坡阈值;失败保留切片待重试。
-     * 调用方已保证切片达到生效阈值(或 force)。背景参考按会话从 L0 现查并剔除切片
-     * 自身(ADR-0003:会话间互不污染、重启不丢背景)。
+     * 调用方已保证切片达到生效阈值(或 force)。背景参考按会话从 DRSC 尾窗现查并
+     * 剔除切片自身轮次(ADR-0003:会话间互不污染、重启不丢背景)。
      */
     private extractSessionSlice;
 }

package/dist/pipeline/runner.js

@@ -1,10 +1,11 @@
 import { resolveDataDir } from '../config.js';
 import { GRAPH_PRIORITY_NEW } from '../graph/types.js';
+import { drscRowToConversationMessage } from '../clients/drsc.js';
 import { trace } from '../store/trace.js';
 import { emptyPending, freshWarmup, groupPendingBySession, loadPending, PENDING_MODES, pendingPathFor, savePending, } from '../store/pending.js';
 import { errDetail } from '../util/filelog.js';
 import { sessionWorkspaceIdOf } from '../workspace.js';
-import { advanceWarmupThreshold, effectiveExtractThreshold, extractionBackoffMs, idleSessionsToFlush, modeSwitchAction, pickSessionBackground, } from './trigger.js';
+import { advanceWarmupThreshold, effectiveExtractThreshold, extractionBackoffMs, idleSessionsToFlush, modeSwitchAction, } from './trigger.js';
 import { runExtraction } from './l1.js';
 import { buildAnchorMap } from './anchors.js';
 import { runGraphProjection } from './graph.js';
@@ -666,10 +667,34 @@ export class MemoryRunner {
         this.afterRun?.();
         return newRecords.length;
     }
+    /**
+     * 蒸馏背景窗(T8.4 读切,task_19):DRSC 会话尾窗(redact 臂)→ ConversationMessage。
+     * - 形状映射:segment 行 → 消息(drscRowToConversationMessage;非 user/assistant 段跳过);
+     * - 坐标剔除:切片自身轮次整轮剔除(尾窗在 DRS 30s interval 同步后会含刚捕获
+     *   的 turn——旧 l0 读面按消息 id 剔除,跨系统 id 不同构,按坐标等价替身);
+     * - 报错口径:collector 缺席/超时 → warn 后空窗降级,**不抛穿蒸馏管线**
+     *   (工具面 conversation_search 的显式报错口径在 tools 层分清,spec R7)。
+     */
+    async drscBackground(sessionId, n, sliceTurns) {
+        if (n <= 0)
+            return [];
+        try {
+            const rows = await this.stores.drsc.sessionTail(sessionId, n);
+            return rows
+                .map((r) => drscRowToConversationMessage(r, sessionId))
+                .filter((m) => m !== undefined)
+                .filter((m) => m.anchor === undefined || !sliceTurns.has(m.anchor.turn))
+                .slice(-n);
+        }
+        catch (err) {
+            this.logger.warn(`[memory] 蒸馏背景窗拉取失败(DRSC),本轮空窗降级: ${errDetail(err)}`);
+            return [];
+        }
+    }
     /**
      * 抽取并消费一个会话切片:成功才把切片移出桶并推进爬坡阈值;失败保留切片待重试。
-     * 调用方已保证切片达到生效阈值(或 force)。背景参考按会话从 L0 现查并剔除切片
-     * 自身(ADR-0003:会话间互不污染、重启不丢背景)。
+     * 调用方已保证切片达到生效阈值(或 force)。背景参考按会话从 DRSC 尾窗现查并
+     * 剔除切片自身轮次(ADR-0003:会话间互不污染、重启不丢背景)。
      */
     async extractSessionSlice(sessionId, mode, cfg, effectiveThreshold, opts) {
         const bucket = this.pending[mode];
@@ -678,9 +703,11 @@ export class MemoryRunner {
             return [];
         const rest = bucket.filter((m) => m.sessionId !== sessionId);
         try {
-            // 背景参考:该会话最近消息(多取切片条数补偿被剔除者),剔除切片自身
-            const background = this.stores.l0
-                ? pickSessionBackground(await this.stores.l0.recentBySession(sessionId, cfg.extract.backgroundMessages + slice.length), new Set(slice.map((m) => m.id)), cfg.extract.backgroundMessages)
+            // 背景参考(T8.4 读切):DRSC 会话尾窗(redact 臂)按会话现查(ADR-0003 等价),
+            // 剔除切片自身轮次(切片消息可能已进 DRS 尾窗——30s interval 同步后)。
+            // 多取切片条数补偿被剔除者,与旧 l0 读面同口径。
+            const background = this.stores.drsc
+                ? await this.drscBackground(sessionId, cfg.extract.backgroundMessages + slice.length, new Set(slice.map((m) => m.anchor?.turn).filter((t) => typeof t === 'number')))
                 : [];
             const t = Date.now();
             // R7:锚点映射同时收切片与背景——模型偶尔会引用背景消息的 id,收了它

package/dist/stats.js

@@ -107,6 +107,8 @@ export const MEMORY_ENDPOINTS = [
     'dsh-memory/conflicts-rejected',
     'dsh-memory/graph-search',
     'dsh-memory/graph-node-get',
+    'dsh-memory/graph-preview',
+    'dsh-memory/graph-cleanup-dead',
     'dsh-memory/scenes',
     'dsh-memory/persona',
     'dsh-memory/log-tail',
@@ -474,6 +476,8 @@ export async function handleEndpoint(endpoint, payload, deps) {
                 return { sessionId, records: [], typeCatalog: typeCatalogEntries() };
             // 压缩水位之上的那批：正文已被摘要取代。与 retired 正交（真实实现见 session-recalled.ts）。
             const superseded = stores.recalled?.supersededOf(sessionId);
+            // 路归因表（record id → 管道串）：不在表里 = 无从归因，不挂 lanes 字段。
+            const laneTab = stores.recalled?.lanesOf(sessionId);
             const halfLife = effectiveCfg(cfg, live).recall?.decayHalfLifeDays ?? 0;
             const byId = new Map(stores.l1.getByIds(ids).map((r) => [r.id, r]));
             const records = ids
@@ -486,7 +490,11 @@ export async function handleEndpoint(endpoint, payload, deps) {
                     userRelevance: stores.feedback?.meanOf(r.id) ?? null,
                     userMark: stores.feedback?.lastOf(r.id) ?? null,
                 });
-                return superseded?.has(r.id) === true ? { ...ui, superseded: true } : ui;
+                let out = superseded?.has(r.id) === true ? { ...ui, superseded: true } : ui;
+                const laneStr = laneTab?.get(r.id);
+                if (laneStr !== undefined && laneStr.length > 0)
+                    out = { ...out, lanes: laneStr.split('|') };
+                return out;
             });
             return { sessionId, records, typeCatalog: typeCatalogEntries() };
         }
@@ -2019,6 +2027,27 @@ export async function handleEndpoint(endpoint, payload, deps) {
                 return { node: null, edges: [] };
             return { node, edges: graph.edgesOf(id) };
         }
+        case 'dsh-memory/graph-preview': {
+            // 面板图谱预览:缺省种子推荐榜,seedId 给定展开该邻域(悬挂/不可见→空 seeds 不抛)。
+            // mode==='full' 附全图轻量块(大图星图);非 'full' 一律按缺省——无 full 键零漂移。
+            const p = (payload ?? {});
+            const seedId = typeof p.seedId === 'string' && p.seedId.length > 0 ? p.seedId.slice(0, 200) : undefined;
+            const mode = p.mode === 'full' ? 'full' : undefined;
+            const graph = stores.graph;
+            if (!graph) {
+                const zero = { seeds: [], stats: { nodes: 0, edges: 0, causalEdges: 0, pendingJobs: 0, jobsTotal: 0 } };
+                return mode === 'full' ? { ...zero, full: { nodes: [], edges: [], truncated: false } } : zero;
+            }
+            return graph.buildPreview(seedId, mode);
+        }
+        case 'dsh-memory/graph-cleanup-dead': {
+            const graph = stores.graph;
+            if (!graph)
+                return { removed: 0 };
+            const p = (payload ?? {});
+            const ms = typeof p.olderThanMs === 'number' && p.olderThanMs > 0 ? p.olderThanMs : undefined;
+            return { removed: graph.cleanupDead(ms) };
+        }
         case 'dsh-memory/scenes': {
             // 两族拼接展示(浏览器保持混合视图;路径冲突时后写入的族覆盖显示名,读取仍各自独立)
             const items = [];

package/dist/store/embedding-source.d.ts

@@ -1,7 +1,6 @@
 import type { MemoryConfig } from '../config.js';
 import type { MemoryLogger } from '../types.js';
 import type { EmbeddingProviderInfo, EmbeddingService } from './embedding.js';
-import type { L0Store } from './l0.js';
 import type { L1Store } from './l1.js';
 import { LocalEmbeddingService } from './local-embedding.js';
 import { ModelDownloadQueue } from './download-queue.js';
@@ -74,7 +73,6 @@ export interface EmbeddingManagerDeps {
      *  否则设置页里的编辑即时生效不到活切换。 */
     getEff?: () => MemoryConfig;
     db: MemoryDb;
-    l0: L0Store;
     l1: L1Store;
     sourceStore: EmbeddingSourceStore;
     installer: RuntimeInstaller;
@@ -155,7 +153,7 @@ export declare class EmbeddingManager {
      * 门槛全部前置,且**宁可拒绝也不谎报**:以下四种情况直接抛错而非"成功受理":
      *
      * - 插件已卸载 / 重嵌已在跑 / 嵌入源切换占着锁:并发语义,重复触发无意义;
-     * - 嵌入服务未就绪:`L1Store.reindex` / `L0Store.reindex` 会**静默短路**成
+     * - 嵌入服务未就绪:`L1Store.reindex` 会**静默短路**成
      *   `0/0/0`,受理了就等于告诉用户"重建成功、零条待补"——而真相是它根本没开始。
      *
      * 用抛错而不是返回 `{accepted:false, error}`:与 `embedding-model-delete` 等既有

package/dist/store/embedding-source.js

@@ -8,7 +8,7 @@
  *   embedding.allowLocalModels 上限约束;
  * - 活切换链(后台执行,RPC 立即返回 accepted,进度靠轮询):
  *   安装运行时(首次本地)→ 预热加载 → 换服务 + swapProvider(维度变化 drop 向量表)
- *   → 后台全量重嵌(L1/L0 计数进度,可取消)→ 持久化状态。
+ *   → 后台全量重嵌(L1 计数进度,可取消;l0 计数进度字段随契约保留恒 0)→ 持久化状态。
  *   失败语义:异常(安装失败/模型加载失败/db 拒绝)→ 状态不持久化,重启回到旧源;
  *   重嵌取消/部分失败 → 已切换(物理表即新维度,meta 已同步),缺失向量由周期
  *   backfill 补齐——不回滚(回滚需要再 drop 一次表,得不偿失)。
@@ -330,7 +330,7 @@ export class EmbeddingManager {
      * 门槛全部前置,且**宁可拒绝也不谎报**:以下四种情况直接抛错而非"成功受理":
      *
      * - 插件已卸载 / 重嵌已在跑 / 嵌入源切换占着锁:并发语义,重复触发无意义;
-     * - 嵌入服务未就绪:`L1Store.reindex` / `L0Store.reindex` 会**静默短路**成
+     * - 嵌入服务未就绪:`L1Store.reindex` 会**静默短路**成
      *   `0/0/0`,受理了就等于告诉用户"重建成功、零条待补"——而真相是它根本没开始。
      *
      * 用抛错而不是返回 `{accepted:false, error}`:与 `embedding-model-delete` 等既有
@@ -345,7 +345,7 @@ export class EmbeddingManager {
             throw new Error('嵌入源切换进行中，请稍后再试');
         if (!this.currentInfo)
             throw new Error('嵌入源已关闭，重建无意义（请先启用嵌入）');
-        if (!this.deps.l1.vectorsReady() || !this.deps.l0.vectorsReady()) {
+        if (!this.deps.l1.vectorsReady()) {
             throw new Error('嵌入服务未就绪（模型加载中或推理运行时未安装），请稍后再试');
         }
         void this.reindexNow()
@@ -435,7 +435,6 @@ export class EmbeddingManager {
             const oldLocal = this.localSvc;
             this.localSvc = next.source === 'local' ? svc : null;
             this.current = svc;
-            this.deps.l0.setEmbeddingService(svc);
             this.deps.l1.setEmbeddingService(svc);
             oldLocal?.close();
             let pendingNote = '';
@@ -510,15 +509,9 @@ export class EmbeddingManager {
                 shouldCancel: () => this.reindexCancel,
             });
             failedTotal += r1.failed;
-            const r0 = await this.deps.l0.reindex({
-                onProgress: (done, total) => {
-                    this.reindex.l0Done = done;
-                    this.reindex.l0Total = total;
-                },
-                shouldCancel: () => this.reindexCancel,
-            });
-            failedTotal += r0.failed;
-            const cancelled = !!(r1.cancelled || r0.cancelled);
+            // T8.4:l0 向量腿随写停退役(表清空后无缺失,无需重建);契约的
+            // l0Done/l0Total 字段保留恒 0,client 进度面零改动。
+            const cancelled = !!r1.cancelled;
             this.reindex.cancelled = cancelled;
             this.reindex.running = false;
             this.invalidateVecCache(); // 收尾:计数必须立刻反映重建结果(TTL 可能还压着 1s 旧值)

package/dist/store/graph-store.d.ts

@@ -1,4 +1,6 @@
 import type { DatabaseSync } from 'node:sqlite';
+import { buildFullView } from '../graph/preview.js';
+import type { GraphPreviewResult } from '../graph/preview.js';
 import type { GraphEdge, GraphNode, GraphNodeSearchResult, GraphProjectionJob, GraphProjectionResult } from '../graph/types.js';
 import type { MemoryFamily, MemoryLogger, MemoryRecord } from '../types.js';
 /**
@@ -99,6 +101,37 @@ export declare class GraphStore {
      * 宁可漏不可串)。降级/异常返回空数组。
      */
     searchNodes(query: string, limit: number, families?: readonly MemoryFamily[]): GraphNodeSearchResult[];
+    /**
+     * §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: string, embedding: Float32Array | undefined, limit: number, families?: readonly MemoryFamily[]): readonly string[];
+    /**
+     * 面板图谱预览存储缝(契约 `dsh-memory/graph-preview` 的数据源):
+     * loadGraph 一次 + job 计数(pending/running/failed 未定项与全量分母)传入纯函数。
+     * 降级(db 未就绪)返**全零结构**不抛——预览是展示面,永不拖垮端点。
+     * mode==='full' 时响应附 `full` 轻量块;**缺省时该键缺席**(可选键零漂移纪律,
+     * 不是 undefined 占位——消费方 `'full' in res` 与 JSON 形状双判据都干净)。
+     */
+    buildPreview(seedId?: string, mode?: 'full'): GraphPreviewResult & {
+        full?: ReturnType<typeof buildFullView>;
+    };
+    /**
+     * 清理历史 dead 作业行（纯审计痕迹删除，不影响已重入队的记录）。
+     * olderThanMs: 只删早于 now-olderThanMs 的；缺省删全部 dead。
+     */
+    cleanupDead(olderThanMs?: number): number;
     private newJobId;
     /**
      * 投影入队(按 GRAPH_JOB_BATCH 分片成多个 job;去重下推 SQL):
@@ -134,10 +167,14 @@ export declare class GraphStore {
      */
     complete(jobId: string, result: GraphProjectionResult, opts?: CompleteOptions): void;
     /**
-     * 投影失败收尾: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: string, error: string): void;
+    fail(jobId: string, error: string, opts?: {
+        transient?: boolean;
+    }): void;
     /** 启动回收:上次进程退出时卡在 running 的 job 放回 pending(dispose 缝不永久卡批)。 */
     recoverRunning(): number;
     /** 最近 job 列表(诊断/面板用;未就绪返回空)。 */