dsh-prime-memory 0.26.5-beta.0 → 0.26.5

package/dist/index.js

@@ -195,6 +195,16 @@ 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 就绪)
         // DRSC 客户端(T8.4 读切):蒸馏背景窗 + conversation_search 工具面的历史供给。
@@ -202,8 +212,8 @@ export async function apply(ctx, config) {
         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),
@@ -235,6 +245,9 @@ export async function apply(ctx, config) {
         // 后台记忆后端:初始化完成后填充(worker 隔离,失败则进程内)
         backend: undefined,
     };
+    // 惰性缝接线:provider 在检索时才解引用(l1 已就绪);声明序上的"先声明后赋值"
+    // 只影响装配期,而装配期不会有检索在飞(启动未完就没有 agent 回合)。
+    laneEmbedQuery = (q) => stores.l1.embedText(q);
     if (storageOk) {
         try {
             await Promise.all([

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/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/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 列表(诊断/面板用;未就绪返回空)。 */

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/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 里凭空加分)。
      */

package/dist/store/l1.js

@@ -9,7 +9,6 @@
 import { existsSync, mkdirSync, promises as fs, writeFileSync } from 'node:fs';
 import * as path from 'node:path';
 import { familyForType, isScopeVisible } from '../types.js';
-import { graphHitRecordIds } from '../graph/search.js';
 import { isRetired } from './supersede.js';
 import { exportThenPurge, readSnapshotManifest, readSnapshotRecords, restoreL1Snapshot, selectSnapshotTargets, snapshotDirFor, listSnapshots as listSnapshotsIn } from './l1-snapshot.js';
 import { EmbedHelper, NoopEmbeddingService } from './embedding.js';
@@ -735,14 +734,35 @@ export class L1Store {
         const vecList = vecRaw ? this.db.searchL1Vector(vecRaw, candidateK, opts?.family, opts?.workspaceId) : [];
         // 第 3 路(图谱)仅在接线时**结构性存在**:未接线不占路数名额,故既有调用方
         // 仍走 2 路、得分与改动前逐位一致(见 findings.md §12.1 的路数语义)
-        const lanes = [ftsList, vecList];
+        const lanes = [['fts', ftsList], ['vec', vecList]];
         if (this.graphLaneProvider)
-            lanes.push(this.graphLane(query, candidateK, opts?.family, opts?.workspaceId));
+            lanes.push(['graph', await this.graphLane(query, candidateK, opts?.family, opts?.workspaceId)]);
         // 第 4 路(时效)在衰减开启时**结构性存在**;关掉衰减 = 该路不存在
         if (this.decayHalfLifeDays > 0)
-            lanes.push(this.recencyLane([...ftsList, ...vecList]));
-        const merged = rrfMerge(lanes, (h) => h.id);
-        return this.postProcess(this.applyDecay(merged.map(({ rrfScore, ...h }) => ({ ...h, score: normalizeRrf(rrfScore, lanes.length) }))), opts?.type, limit);
+            lanes.push(['recency', this.recencyLane([...ftsList, ...vecList])]);
+        const laneLists = lanes.map(([, list]) => list);
+        // 路归因(与融合并行,不改 rrfMerge 本体):id → 命中路集合,按路构造序
+        // 去重追加(fts→vec→graph→recency,确定性输出)。命中对象在下方 map 里
+        // 新建(不往变回路的列表元素上写),挂 lanes 后随 postProcess/applyDecay 透传。
+        const lanesById = new Map();
+        for (const [name, list] of lanes) {
+            for (const h of list) {
+                const arr = lanesById.get(h.id);
+                if (arr) {
+                    if (!arr.includes(name))
+                        arr.push(name);
+                }
+                else {
+                    lanesById.set(h.id, [name]);
+                }
+            }
+        }
+        const merged = rrfMerge(laneLists, (h) => h.id);
+        return this.postProcess(this.applyDecay(merged.map(({ rrfScore, ...h }) => ({
+            ...h,
+            lanes: lanesById.get(h.id),
+            score: normalizeRrf(rrfScore, laneLists.length),
+        }))), opts?.type, limit);
     }
     /**
      * §D 第 4 路(时效路,hybrid 专用):把候选池按 `applyDecayWeight` 加权后的
@@ -770,36 +790,37 @@ export class L1Store {
         return this.applyDecay(deduped);
     }
     /**
-     * §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 里凭空加分)。
      */
-    graphLane(query, limit, family, workspaceId) {
+    async graphLane(query, limit, family, workspaceId) {
         const provider = this.graphLaneProvider;
         if (!provider)
             return [];
-        let hits;
+        let ids;
         try {
-            hits = provider(query, limit, family);
+            ids = await provider(query, limit, family);
         }
         catch (err) {
             this.logger?.warn(`[memory] 图谱路检索失败,本轮退回双路: ${err instanceof Error ? err.message : String(err)}`);
             return [];
         }
-        const ids = graphHitRecordIds(hits);
         if (ids.length === 0)
             return [];
-        const byId = new Map(this.db.getL1ByIds(ids).map((r) => [r.id, r]));
+        const byId = new Map(this.db.getL1ByIds([...ids]).map((r) => [r.id, r]));
         const out = [];
         for (const id of ids) {
             const r = byId.get(id);

package/dist/store/session-recalled.d.ts

@@ -1,4 +1,4 @@
-import type { MemoryLogger } from '../types.js';
+import type { MemoryLogger, RecallLane } from '../types.js';
 export declare class SessionRecalledStore {
     private readonly logger?;
     private readonly file;
@@ -12,8 +12,9 @@ export declare class SessionRecalledStore {
     constructor(dataDir: string, logger?: MemoryLogger | undefined);
     revision(): number;
     private init;
-    /** 记入本 sessionKey 本轮实际注入的记录 id（写穿；插入序淘汰最旧）。 */
-    add(sessionKey: string, recordIds: readonly string[], injectionId?: string): void;
+    /** 记入本 sessionKey 本轮实际注入的记录 id（写穿；插入序淘汰最旧）。
+     *  laneById 只带真正有归因的条目（hybrid 融合才挂 lanes；单路/旧路不传）。 */
+    add(sessionKey: string, recordIds: readonly string[], injectionId?: string, laneById?: ReadonlyMap<string, readonly RecallLane[]>): void;
     /**
      * 标为受保护（判过时/软退场）：条目留在列表里，且不受上限淘汰与压缩清理影响。
      * id 不在本会话列表里时忽略（不凭这个调用新建条目）。
@@ -34,6 +35,11 @@ export declare class SessionRecalledStore {
      * 未出现过取代的会话返回共享空集，不每次新建）。
      */
     supersededOf(sessionKey: string): ReadonlySet<string>;
+    /**
+     * 本会话的路归因表（record id → 管道串；只读共享，投影/端点用）。
+     * 不在表里 = 无从归因（单路检索/旧文件条目），展示层不渲染徽标。
+     */
+    lanesOf(sessionKey: string): ReadonlyMap<string, string>;
     /**
      * 用会话日志的可见性事实**对账**取代标记（Phase 0B）。
      *

package/dist/store/session-recalled.js

@@ -23,9 +23,12 @@ import { SESSION_RECALLED_FILE_VERSION } from './file-versions.js';
 import { RECALL_DEDUPE_IDS_CAP, RECALL_DEDUPE_SESSION_CAP } from './recall-dedupe.js';
 /** 共享空集（未出现过取代的会话重复取用，不必每次新建）。 */
 const EMPTY_SET = new Set();
+/** 共享空归因表（同 EMPTY_SET 口径）。 */
+const EMPTY_LANES = new Map();
 /**
- * 读 `injectedBy` 的宽容解析：非对象/值非字符串一律丢弃。
- * 宁可让那条记录“无从判”（对账不动它），也不把脏值喂给可见性判定——
+ * 读 `Record<string, string>` 型字段的宽容解析（injectedBy/lanes 共用）：
+ * 非对象/值非字符串一律丢弃。
+ * 宁可让那条记录“无从判”（对账不动它/徽标不渲染），也不把脏值喂给下游判定——
  * 一个错的 message id 会把仍在本上下文里的正文误标成“已被摘要取代”。
  */
 function toIdMap(raw) {
@@ -93,17 +96,19 @@ export class SessionRecalledStore {
                 protectedIds: new Set(Array.isArray(entry.protectedIds) ? entry.protectedIds : []),
                 supersededIds: new Set(Array.isArray(entry.supersededIds) ? entry.supersededIds : []),
                 injectedBy: toIdMap(entry.injectedBy),
+                laneOf: toIdMap(entry.lanes),
                 updatedAt: entry.updatedAt ?? now,
             });
         }
     }
-    /** 记入本 sessionKey 本轮实际注入的记录 id（写穿；插入序淘汰最旧）。 */
-    add(sessionKey, recordIds, injectionId) {
+    /** 记入本 sessionKey 本轮实际注入的记录 id（写穿；插入序淘汰最旧）。
+     *  laneById 只带真正有归因的条目（hybrid 融合才挂 lanes；单路/旧路不传）。 */
+    add(sessionKey, recordIds, injectionId, laneById) {
         if (!sessionKey || recordIds.length === 0)
             return;
         let entry = this.entries.get(sessionKey);
         if (!entry) {
-            entry = { ids: new Set(), protectedIds: new Set(), supersededIds: new Set(), injectedBy: new Map(), updatedAt: 0 };
+            entry = { ids: new Set(), protectedIds: new Set(), supersededIds: new Set(), injectedBy: new Map(), laneOf: new Map(), updatedAt: 0 };
             this.entries.set(sessionKey, entry);
         }
         const stamp = typeof injectionId === 'string' && injectionId.length > 0 ? injectionId : undefined;
@@ -114,6 +119,11 @@ export class SessionRecalledStore {
             // 记下这次注入落在哪条消息上：没有它，对账就无从判“这条正文还在不在”。
             if (stamp !== undefined)
                 entry.injectedBy.set(id, stamp);
+            // 路归因：最后一次注入赢；本轮无归因时**不清旧值**（徽标宁可残留一轮
+            // 也不要闪无——真实路集在下一次带归因注入时自然覆盖）。
+            const laneArr = laneById?.get(id);
+            if (laneArr !== undefined && laneArr.length > 0)
+                entry.laneOf.set(id, laneArr.join('|'));
             // 淘汰只能淘汰**没被判过时的**：受保护条目数本身超顶时宁可超顶，也不能把人的裁决
             // 凭证挤掉（那等于“因为后面又召回了几条，所以之前那条的判定历史丢了”）。
             while (entry.ids.size > RECALL_DEDUPE_IDS_CAP) {
@@ -124,6 +134,7 @@ export class SessionRecalledStore {
                 entry.protectedIds.delete(oldest);
                 entry.supersededIds.delete(oldest);
                 entry.injectedBy.delete(oldest);
+                entry.laneOf.delete(oldest);
             }
         }
         entry.updatedAt = Date.now();
@@ -197,6 +208,13 @@ export class SessionRecalledStore {
     supersededOf(sessionKey) {
         return this.entries.get(sessionKey)?.supersededIds ?? EMPTY_SET;
     }
+    /**
+     * 本会话的路归因表（record id → 管道串；只读共享，投影/端点用）。
+     * 不在表里 = 无从归因（单路检索/旧文件条目），展示层不渲染徽标。
+     */
+    lanesOf(sessionKey) {
+        return this.entries.get(sessionKey)?.laneOf ?? EMPTY_LANES;
+    }
     /**
      * 用会话日志的可见性事实**对账**取代标记（Phase 0B）。
      *
@@ -302,6 +320,7 @@ export class SessionRecalledStore {
                 ...(e.protectedIds.size > 0 ? { protectedIds: [...e.protectedIds] } : {}),
                 ...(e.supersededIds.size > 0 ? { supersededIds: [...e.supersededIds] } : {}),
                 ...(e.injectedBy.size > 0 ? { injectedBy: Object.fromEntries(e.injectedBy) } : {}),
+                ...(e.laneOf.size > 0 ? { lanes: Object.fromEntries(e.laneOf) } : {}),
                 updatedAt: e.updatedAt,
             };
         }