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

package/dist/graph/preview.js

@@ -0,0 +1,186 @@
+/**
+ * 面板图谱预览(读路径纯函数):种子推荐榜 + 指定节点邻域展开。
+ *
+ * 定位:图谱投影三表的"值得画哪些片"视图筛选,不查库、不落库、无 I/O——
+ * job 计数(pendingJobs/jobsTotal)由存储缝(graph-store.buildPreview)传入。
+ * 起点推荐有实证底座(2026-10-20 装机审计):关系全落规范词表、因果边 ~24%,
+ * 故 score 以 active 度数为主键、因果边加权——纯 top 度会漏"因→果"链。
+ *
+ * 判据与检索同源(search.ts):候选 = active|disputed 节点 × active 边;
+ * 确定性 = 同输入两次调用逐位一致(同分裁决链落到 id 升序兜底)。
+ */
+import { GRAPH_CAUSAL_RELATIONS } from './constraints.js';
+import { GRAPH_PREVIEW_CAUSAL_WEIGHT, GRAPH_PREVIEW_FULL_EDGES, GRAPH_PREVIEW_FULL_NODES, GRAPH_PREVIEW_NEIGHBORS, GRAPH_PREVIEW_SEEDS, } from './types.js';
+const CAUSAL_SET = new Set(GRAPH_CAUSAL_RELATIONS);
+/** 预览唯一判定的节点可见性(与 searchGraphNodes 候选集同式)。 */
+function visible(n) {
+    return n.status === 'active' || n.status === 'disputed';
+}
+export function degreeMaps(nodes, edges) {
+    const candidate = new Set(nodes.filter(visible).map((n) => n.id));
+    const degree = new Map();
+    const causal = new Map();
+    for (const e of edges) {
+        if (e.status !== 'active')
+            continue;
+        if (!candidate.has(e.fromNodeId) || !candidate.has(e.toNodeId))
+            continue;
+        const isCausal = CAUSAL_SET.has(e.relation);
+        for (const id of [e.fromNodeId, e.toNodeId]) {
+            degree.set(id, (degree.get(id) ?? 0) + 1);
+            if (isCausal)
+                causal.set(id, (causal.get(id) ?? 0) + 1);
+        }
+    }
+    return { degree, causal };
+}
+/** 种子卡装配:邻居条目 + 因果优先排序 + 截断。 */
+function seedView(center, edges, byId, dm, neighborLimit) {
+    const list = [];
+    for (const e of edges) {
+        if (e.status !== 'active')
+            continue;
+        let otherId;
+        if (e.fromNodeId === center.id)
+            otherId = e.toNodeId;
+        else if (e.toNodeId === center.id)
+            otherId = e.fromNodeId;
+        else
+            continue;
+        const o = byId.get(otherId);
+        if (!o || !visible(o))
+            continue;
+        list.push({
+            id: o.id,
+            name: o.name,
+            type: o.type,
+            relation: e.relation,
+            causal: CAUSAL_SET.has(e.relation),
+            _deg: dm.degree.get(o.id) ?? 0,
+            _upd: o.updatedAt,
+        });
+    }
+    list.sort((a, b) => {
+        if (a.causal !== b.causal)
+            return a.causal ? -1 : 1;
+        if (a._deg !== b._deg)
+            return b._deg - a._deg;
+        if (a._upd !== b._upd)
+            return a._upd < b._upd ? -1 : 1; // updatedAt 新(大)先
+        return a.id < b.id ? -1 : 1;
+    });
+    const truncated = list.length > neighborLimit;
+    return {
+        node: {
+            id: center.id,
+            name: center.name,
+            type: center.type,
+            degree: dm.degree.get(center.id) ?? 0,
+            causalDegree: dm.causal.get(center.id) ?? 0,
+        },
+        neighbors: list.slice(0, neighborLimit).map(({ _deg, _upd, ...view }) => view),
+        truncated,
+    };
+}
+/**
+ * S-3/S-4:预览主函数。
+ * - seedId 视图:直接展开该节点(跳过挑选);不可见/悬挂 → 空 seeds。
+ * - 榜单视图:score = degree + causal×WEIGHT;同分链 causal→sources→updatedAt→id↑;
+ *   候选落入已选种子的"自身∪邻居"覆盖集则跳过(相邻合并,画布片不重复);
+ *   孤立节点(度 0)不入榜——画布只有中心一个点没有信息量。
+ */
+export function buildGraphPreview(nodes, edges, opts = {}) {
+    const byId = new Map(nodes.map((n) => [n.id, n]));
+    const dm = degreeMaps(nodes, edges);
+    const visNodes = nodes.filter(visible);
+    const visEdges = edges.filter((e) => e.status === 'active');
+    const stats = {
+        nodes: visNodes.length,
+        edges: visEdges.length,
+        causalEdges: visEdges.filter((e) => CAUSAL_SET.has(e.relation)).length,
+        pendingJobs: opts.pendingJobs ?? 0,
+        jobsTotal: opts.jobsTotal ?? 0,
+        ...(opts.deadJobs != null && opts.deadJobs > 0 ? { deadJobs: opts.deadJobs } : {}),
+    };
+    const seedLimit = Math.min(Math.max(Math.floor(opts.seedLimit ?? GRAPH_PREVIEW_SEEDS), 1), 20);
+    const neighborLimit = Math.min(Math.max(Math.floor(opts.neighborLimit ?? GRAPH_PREVIEW_NEIGHBORS), 1), 40);
+    if (opts.seedId !== undefined) {
+        const target = byId.get(opts.seedId);
+        if (!target || !visible(target))
+            return { seeds: [], stats };
+        return { seeds: [seedView(target, edges, byId, dm, neighborLimit)], stats };
+    }
+    const scored = visNodes
+        .map((n) => ({
+        n,
+        score: (dm.degree.get(n.id) ?? 0) + (dm.causal.get(n.id) ?? 0) * GRAPH_PREVIEW_CAUSAL_WEIGHT,
+    }))
+        .sort((a, b) => {
+        if (a.score !== b.score)
+            return b.score - a.score;
+        const ca = dm.causal.get(a.n.id) ?? 0;
+        const cb = dm.causal.get(b.n.id) ?? 0;
+        if (ca !== cb)
+            return cb - ca;
+        const sa = a.n.sourceRecordIds.length;
+        const sb = b.n.sourceRecordIds.length;
+        if (sa !== sb)
+            return sb - sa;
+        if (a.n.updatedAt !== b.n.updatedAt)
+            return a.n.updatedAt < b.n.updatedAt ? 1 : -1;
+        return a.n.id < b.n.id ? -1 : 1;
+    });
+    const picked = [];
+    const covered = new Set();
+    for (const { n, score } of scored) {
+        if (picked.length >= seedLimit)
+            break;
+        if (score === 0)
+            continue; // 孤立点不入榜(score 单调降,continue 等价于提前结束)
+        if (covered.has(n.id))
+            continue; // 相邻合并:已被前一种子的邻域覆盖
+        picked.push(n);
+        covered.add(n.id);
+        for (const e of visEdges) {
+            if (e.fromNodeId === n.id)
+                covered.add(e.toNodeId);
+            else if (e.toNodeId === n.id)
+                covered.add(e.fromNodeId);
+        }
+    }
+    return {
+        seeds: picked.map((n) => seedView(n, edges, byId, dm, neighborLimit)),
+        stats,
+    };
+}
+/**
+ * 全图星图数据块（纯函数，不查库）：可见节点轻量投影 × active 边，
+ * 双上限截断。**顺序纪律**：节点按入参序截断（调用方 loadGraph 的行序），
+ * 悬挂边（端点之一被截掉/不可见）在截断前剔除——星图上不画悬空线。
+ */
+export function buildFullView(nodes, edges, caps = {}) {
+    const nodeCap = Math.max(1, Math.floor(caps.nodeCap ?? GRAPH_PREVIEW_FULL_NODES));
+    const edgeCap = Math.max(1, Math.floor(caps.edgeCap ?? GRAPH_PREVIEW_FULL_EDGES));
+    const visibleNodes = nodes.filter(visible);
+    const nodesTruncated = visibleNodes.length > nodeCap;
+    const drawn = visibleNodes.slice(0, nodeCap);
+    const keep = new Set(drawn.map((n) => n.id));
+    const outEdges = [];
+    let edgesTruncated = false;
+    for (const e of edges) {
+        if (e.status !== 'active')
+            continue;
+        if (!keep.has(e.fromNodeId) || !keep.has(e.toNodeId))
+            continue;
+        if (outEdges.length >= edgeCap) {
+            edgesTruncated = true;
+            break;
+        }
+        outEdges.push({ from: e.fromNodeId, to: e.toNodeId, relation: e.relation, causal: CAUSAL_SET.has(e.relation) });
+    }
+    return {
+        nodes: drawn.map((n) => ({ id: n.id, name: n.name, type: n.type })),
+        edges: outEdges,
+        truncated: nodesTruncated || edgesTruncated,
+    };
+}

package/dist/graph/search.d.ts

@@ -9,23 +9,49 @@ export declare const GRAPH_FIELD_WEIGHTS: {
     readonly relations: 3;
     readonly type: 2;
 };
+/**
+ * as-of 回放可选参数(expiry-tiering Phase 5:图谱读时派生,不加冻结列)。
+ * 默认(缺席)= 当前态检索,行为与改前逐字一致。
+ */
+export interface GraphAsOfOptions {
+    /** ISO 8601 时刻:把"当时成立"的 superseded fact/边也纳入检索与回链;
+     *  archived 仍排除(那是删除传播的墓碑，来源已不在，回放也不该复活)。 */
+    asOf?: string;
+}
 /**
  * 图谱命中 → L1 记录 id 序列(§D 第 3 路 RRF 的输入;纯函数,无 I/O)。
  *
  * 图谱是**可重建派生投影**,节点/fact 的 `sourceRecordIds` 是它回链 L1 的唯一凭证
- * (types.ts:6-7)。此处把"节点排名"翻译成"L1 记录排名":
+ * (types.ts:6-7)。此处把"节点排名"翻译成"L1 记录排名",分两段:
+ *
+ * - **直连段**:命中节点自身 + 其 active facts 的来源(task_9 原语义、原顺序);
+ * - **1-hop 段**:命中节点沿 **active 边**的双向邻居(邻居需 active|disputed)的
+ *   节点自身来源,按邻居 updatedAt 新→旧追加,整段新增封顶
+ *   `GRAPH_HOP_RECORD_CAP`——这是图路"关系可达"增量价值的兑现面。
+ *   hop 段只取邻居节点自身来源,不取 fact 来源(hop 是联想不是证据,噪声从紧)。
  *
- * - **保序**:按命中的 score 降序依次展开来源,先出现的记录 = 更高排名;
- * - **去重**:同一 L1 记录可能被多个节点/fact 引用,只占首次出现的位置
- *   (重复占位会凭空抬高该记录在 RRF 里的权重);
+ * 两段共用纪律:
+ * - **保序**:先出现的记录 = 更高排名(直连段恒先于 hop 段);已被直连段占位的
+ *   id 不重复计入、也**不吃 hop 名额**(关联额度不被身份来源挤占);
+ * - **去重**:同一 L1 记录被多个节点/fact 引用,只占首次出现的位置;
  * - **节点自身来源优先于其 fact 来源**:节点的 sourceRecordIds 是它的身份来源,
  *   而单个 fact 的来源可能引向与该查询无关的旁支记录;
  * - **只取 active fact**:superseded 是历史状态,不该把旧记录拉进当前检索结果;
- * - **不查库**:返回的 id 可能已被删除(墓碑边界),由调用方按"取不到的跳过"处理。
+ * - **不查库**:返回的 id 可能已被删除(墓碑边界),由调用方按"取不到的跳过"处理,
+ *   不得补空占位(占位会在 RRF 里凭空加分)。
+ *
+ * edges/nodes 由调用方传入(loadGraph 结果,百~千量级全扫即可;>2k 再考虑预建索引,
+ * 见文件头演进阶梯)。族过滤不在本函数:邻居节点可跨族,兜底在 graphLane 尾部的
+ * 记录级 family/scope 双闸(宁可漏不可串落在记录上)。
+ */
+export declare function expandHitRecordIds(hits: readonly GraphNodeSearchResult[], nodes: readonly GraphNode[], edges: readonly GraphEdge[], opts?: GraphAsOfOptions): string[];
+/**
+ * 直连段回链(无 hop)——保留 task_9 的原语义形状(既有测试继续钉住);
+ * 生产链路一律走 expandHitRecordIds(向量种子并集 + 1-hop)。
  */
 export declare function graphHitRecordIds(hits: readonly GraphNodeSearchResult[]): string[];
 /**
  * 图谱节点检索:返回按 score 降序的命中(最多 limit 条;limit 钳制 1~20)。
  * 候选节点 = active | disputed(superseded/archived 不进检索)。
  */
-export declare function searchGraphNodes(nodes: readonly GraphNode[], edges: readonly GraphEdge[], query: string, limit: number): GraphNodeSearchResult[];
+export declare function searchGraphNodes(nodes: readonly GraphNode[], edges: readonly GraphEdge[], query: string, limit: number, opts?: GraphAsOfOptions): GraphNodeSearchResult[];

package/dist/graph/search.js

@@ -34,7 +34,7 @@
  * - score 只用于排序,不是事实置信度;无词法命中返回空,不兜底。
  */
 import { tokenize } from '../util/text.js';
-import { GRAPH_SEARCH_LIMIT_MAX } from './types.js';
+import { GRAPH_HOP_RECORD_CAP, GRAPH_SEARCH_LIMIT_MAX } from './types.js';
 /** 字段权重(检索命中计分;名称最高、关系词最低)。 */
 export const GRAPH_FIELD_WEIGHTS = {
     name: 6,
@@ -60,21 +60,54 @@ const FIELD_ORDER = ['name', 'aliases', 'tags', 'currentState', 'facts', 'relati
 function factValueText(value) {
     return Array.isArray(value) ? value.join(' ') : value;
 }
+/** ISO 字符串区间覆盖判定(字典序=时间序;空串视作未闭合)。 */
+function coversInterval(from, to, asOf) {
+    if (from && from > asOf)
+        return false;
+    if (to && asOf >= to)
+        return false;
+    return true;
+}
+/** fact 在回放时刻是否成立(active 恒成立;superseded 看区间)。archived/disputed 不含。 */
+function factValidAtAsOf(f, asOf) {
+    if (f.status === 'active')
+        return true;
+    if (f.status === 'superseded')
+        return coversInterval(f.validFrom, f.validTo, asOf);
+    return false;
+}
+/** 节点新度序(updatedAt 新→旧,同值按 id 升序——与检索结果排序同式)。 */
+function byNodeRecency(a, b) {
+    return a.updatedAt < b.updatedAt ? 1 : a.updatedAt > b.updatedAt ? -1 : a.id < b.id ? -1 : 1;
+}
 /**
  * 图谱命中 → L1 记录 id 序列(§D 第 3 路 RRF 的输入;纯函数,无 I/O)。
  *
  * 图谱是**可重建派生投影**,节点/fact 的 `sourceRecordIds` 是它回链 L1 的唯一凭证
- * (types.ts:6-7)。此处把"节点排名"翻译成"L1 记录排名":
+ * (types.ts:6-7)。此处把"节点排名"翻译成"L1 记录排名",分两段:
  *
- * - **保序**:按命中的 score 降序依次展开来源,先出现的记录 = 更高排名;
- * - **去重**:同一 L1 记录可能被多个节点/fact 引用,只占首次出现的位置
- *   (重复占位会凭空抬高该记录在 RRF 里的权重);
+ * - **直连段**:命中节点自身 + 其 active facts 的来源(task_9 原语义、原顺序);
+ * - **1-hop 段**:命中节点沿 **active 边**的双向邻居(邻居需 active|disputed)的
+ *   节点自身来源,按邻居 updatedAt 新→旧追加,整段新增封顶
+ *   `GRAPH_HOP_RECORD_CAP`——这是图路"关系可达"增量价值的兑现面。
+ *   hop 段只取邻居节点自身来源,不取 fact 来源(hop 是联想不是证据,噪声从紧)。
+ *
+ * 两段共用纪律:
+ * - **保序**:先出现的记录 = 更高排名(直连段恒先于 hop 段);已被直连段占位的
+ *   id 不重复计入、也**不吃 hop 名额**(关联额度不被身份来源挤占);
+ * - **去重**:同一 L1 记录被多个节点/fact 引用,只占首次出现的位置;
  * - **节点自身来源优先于其 fact 来源**:节点的 sourceRecordIds 是它的身份来源,
  *   而单个 fact 的来源可能引向与该查询无关的旁支记录;
  * - **只取 active fact**:superseded 是历史状态,不该把旧记录拉进当前检索结果;
- * - **不查库**:返回的 id 可能已被删除(墓碑边界),由调用方按"取不到的跳过"处理。
+ * - **不查库**:返回的 id 可能已被删除(墓碑边界),由调用方按"取不到的跳过"处理,
+ *   不得补空占位(占位会在 RRF 里凭空加分)。
+ *
+ * edges/nodes 由调用方传入(loadGraph 结果,百~千量级全扫即可;>2k 再考虑预建索引,
+ * 见文件头演进阶梯)。族过滤不在本函数:邻居节点可跨族,兜底在 graphLane 尾部的
+ * 记录级 family/scope 双闸(宁可漏不可串落在记录上)。
  */
-export function graphHitRecordIds(hits) {
+export function expandHitRecordIds(hits, nodes, edges, opts) {
+    const asOf = typeof opts?.asOf === 'string' && opts.asOf.length > 0 ? opts.asOf : undefined;
     const seen = new Set();
     const out = [];
     const take = (id) => {
@@ -83,31 +116,85 @@ export function graphHitRecordIds(hits) {
         seen.add(id);
         out.push(id);
     };
+    // 直连段(节点身份来源在前,有效 facts 在后;task_5.2:asOf 下额外纳入当时成立的 superseded fact)
     for (const h of hits) {
         for (const id of h.node.sourceRecordIds)
             take(id);
         for (const f of h.node.facts) {
-            if (f.status !== 'active')
+            const ok = asOf === undefined ? f.status === 'active' : factValidAtAsOf(f, asOf);
+            if (!ok)
                 continue;
             for (const id of f.sourceRecordIds ?? [])
                 take(id);
         }
     }
+    if (edges.length === 0)
+        return out;
+    // hop 段:可用边的双向邻居 ∉ 命中集,邻居去重,状态需 active|disputed
+    // (task_5.2:asOf 下"当时成立"的 superseded 边也可回链,邻居同理含当时成立的 superseded 节点)
+    const hitNodeIds = new Set(hits.map((h) => h.node.id));
+    const nodeById = new Map(nodes.map((n) => [n.id, n]));
+    const edgeUsable = (e) => e.status === 'active' || (asOf !== undefined && e.status === 'superseded' && coversInterval(e.validFrom, e.validTo, asOf));
+    const neighborUsable = (n) => n.status === 'active' || n.status === 'disputed'
+        || (asOf !== undefined && n.status === 'superseded' && coversInterval(n.createdAt, n.updatedAt, asOf));
+    const seenNeighbor = new Set();
+    const neighbors = [];
+    for (const e of edges) {
+        if (!edgeUsable(e))
+            continue;
+        const dirs = [
+            [e.fromNodeId, e.toNodeId],
+            [e.toNodeId, e.fromNodeId],
+        ];
+        for (const [self, other] of dirs) {
+            if (!hitNodeIds.has(self) || hitNodeIds.has(other) || seenNeighbor.has(other))
+                continue;
+            const n = nodeById.get(other);
+            if (!n || !neighborUsable(n))
+                continue;
+            seenNeighbor.add(other);
+            neighbors.push(n);
+        }
+    }
+    neighbors.sort(byNodeRecency);
+    let hopTaken = 0;
+    for (const n of neighbors) {
+        if (hopTaken >= GRAPH_HOP_RECORD_CAP)
+            break;
+        for (const id of n.sourceRecordIds) {
+            if (seen.has(id))
+                continue; // 已被直连段占用:不计入、不吃名额
+            if (hopTaken >= GRAPH_HOP_RECORD_CAP)
+                break;
+            take(id);
+            hopTaken++;
+        }
+    }
     return out;
 }
+/**
+ * 直连段回链(无 hop)——保留 task_9 的原语义形状(既有测试继续钉住);
+ * 生产链路一律走 expandHitRecordIds(向量种子并集 + 1-hop)。
+ */
+export function graphHitRecordIds(hits) {
+    return expandHitRecordIds(hits, [], []);
+}
 /**
  * 图谱节点检索:返回按 score 降序的命中(最多 limit 条;limit 钳制 1~20)。
  * 候选节点 = active | disputed(superseded/archived 不进检索)。
  */
-export function searchGraphNodes(nodes, edges, query, limit) {
+export function searchGraphNodes(nodes, edges, query, limit, opts) {
+    const asOf = typeof opts?.asOf === 'string' && opts.asOf.length > 0 ? opts.asOf : undefined;
     const tokens = [...new Set(tokenize(query))];
     const cappedLimit = Math.min(Math.max(Math.floor(limit) || 5, 1), GRAPH_SEARCH_LIMIT_MAX);
     if (tokens.length === 0)
         return [];
-    // nodeId → active 关系词 token 集(先建邻接表,防逐节点全量扫边)
+    // nodeId → 可用关系词 token 集(先建邻接表,防逐节点全量扫边;
+    // task_5.1:asOf 下纳入"当时成立"的 superseded 边)
     const relationTokensByNode = new Map();
     for (const edge of edges) {
-        if (edge.status !== 'active')
+        if (edge.status !== 'active'
+            && !(asOf !== undefined && edge.status === 'superseded' && coversInterval(edge.validFrom, edge.validTo, asOf)))
             continue;
         let set = relationTokensByNode.get(edge.fromNodeId);
         if (!set) {
@@ -126,6 +213,9 @@ export function searchGraphNodes(nodes, edges, query, limit) {
     }
     const results = [];
     for (const node of nodes) {
+        // 候选状态闸保持 active|disputed:task_5.1 的放宽面在 **fact/边**("纳入 superseded 且
+        // 区间覆盖 T 的 fact/edge")——GraphNode 没有 valid 区间列,节点主体复活无判据；
+        // 历史实体经"当时成立边"的邻居回链(task_5.2)重新可达,不需要翻状态。
         if (node.status !== 'active' && node.status !== 'disputed')
             continue;
         const fieldTokens = {
@@ -134,7 +224,7 @@ export function searchGraphNodes(nodes, edges, query, limit) {
             tags: new Set((node.tags ?? []).flatMap((t) => tokenize(t))),
             currentState: new Set(tokenize(node.currentState)),
             facts: new Set(node.facts
-                .filter((f) => f.status === 'active')
+                .filter((f) => (asOf === undefined ? f.status === 'active' : factValidAtAsOf(f, asOf)))
                 .flatMap((f) => tokenize(`${f.key} ${factValueText(f.value)}`))),
             relations: relationTokensByNode.get(node.id) ?? new Set(),
             type: new Set(tokenize(node.type)),

package/dist/graph/types.d.ts

@@ -134,9 +134,34 @@ export declare const GRAPH_JOB_BATCH = 8;
 export declare const GRAPH_PRIORITY_NEW = 10000;
 /** 存量补投影的优先级(启动/周期补齐;恒低于新蒸馏)。 */
 export declare const GRAPH_PRIORITY_BACKFILL = 100;
-/** 单 job 最大尝试次数:claim 时 +1,达到即转 dead(不再重试)。 */
+/** 单 job 最大尝试次数(永久错误:校验/解析类——3 次不过就 dead)。
+ *  瞬态错误(aborted/timeout/网络)走 GRAPH_JOB_TRANSIENT_MAX_ATTEMPTS。 */
 export declare const GRAPH_JOB_MAX_ATTEMPTS = 3;
+/** 瞬态错误(attempt 不消耗到 3 即 dead):网关负载或超时引起的 aborted、
+ *  terminated、网络抖动、模型空输出——这些与 prompt/数据无关，退避后重试即恢复。
+ *  6 次 ≈ 5 轮退避(~30 分钟)覆盖 local-35 负载低谷。 */
+export declare const GRAPH_JOB_TRANSIENT_MAX_ATTEMPTS = 6;
+/** 图谱投影 LLM 单次调用超时(含整条回退链):沿用 llm.timeoutMs(120s) 在 8-record
+ *  批 + 上下文节点/边 + 12 关系词 prompt 下真机撞线(14 dead 全是 aborted×13 + terminated×1)。
+ *  照 backfill callTimeoutMs 先例给 240s,按「路由数 × 单路由耗时」留余量。 */
+export declare const GRAPH_PROJECTION_CALL_TIMEOUT_MS = 240000;
 /** 失败指数退避基数:第 n 次失败后 nextAttemptAt = now + base × 2^(n-1)。 */
 export declare const GRAPH_JOB_BACKOFF_BASE_MS = 60000;
 /** 单次检索返回上限的硬钳制(工具与 RPC 两侧共用同一钳制值)。 */
 export declare const GRAPH_SEARCH_LIMIT_MAX = 20;
+/** §D 第 3 路路内向量种子的节点条数上限(种子只是联想起点,独立于词法路 limit)。 */
+export declare const GRAPH_VEC_SEED_CAP = 10;
+/** 1-hop 边扩展回链的新增记录数封顶(hop 段专用名额,直连段不占;防 hub 节点邻接爆量)。 */
+export declare const GRAPH_HOP_RECORD_CAP = 64;
+/** 面板图谱预览:种子榜上限(画布片数)。 */
+export declare const GRAPH_PREVIEW_SEEDS = 6;
+/** 面板图谱预览:单种子绘制的邻居上限(超出置 truncated)。 */
+export declare const GRAPH_PREVIEW_NEIGHBORS = 10;
+/** 面板图谱预览:种子评分中因果边的权重(score = degree + causal×此值)——
+ *  因果链比共现邻接更值得画,预览侧单源读 GRAPH_CAUSAL_RELATIONS。 */
+export declare const GRAPH_PREVIEW_CAUSAL_WEIGHT = 2;
+/** 全图星图（mode:'full'）节点上限：超限截断并置 truncated（截断标记而非硬拒——
+ *  星图是展示面，宁可少画几颗也不报错；G6 舒适区 <2000 留余量）。 */
+export declare const GRAPH_PREVIEW_FULL_NODES = 1500;
+/** 全图星图 active 边上限（同一 truncated 语义；悬挂边已在截断前剔除）。 */
+export declare const GRAPH_PREVIEW_FULL_EDGES = 3000;

package/dist/graph/types.js

@@ -6,9 +6,34 @@ export const GRAPH_JOB_BATCH = 8;
 export const GRAPH_PRIORITY_NEW = 10000;
 /** 存量补投影的优先级(启动/周期补齐;恒低于新蒸馏)。 */
 export const GRAPH_PRIORITY_BACKFILL = 100;
-/** 单 job 最大尝试次数:claim 时 +1,达到即转 dead(不再重试)。 */
+/** 单 job 最大尝试次数(永久错误:校验/解析类——3 次不过就 dead)。
+ *  瞬态错误(aborted/timeout/网络)走 GRAPH_JOB_TRANSIENT_MAX_ATTEMPTS。 */
 export const GRAPH_JOB_MAX_ATTEMPTS = 3;
+/** 瞬态错误(attempt 不消耗到 3 即 dead):网关负载或超时引起的 aborted、
+ *  terminated、网络抖动、模型空输出——这些与 prompt/数据无关，退避后重试即恢复。
+ *  6 次 ≈ 5 轮退避(~30 分钟)覆盖 local-35 负载低谷。 */
+export const GRAPH_JOB_TRANSIENT_MAX_ATTEMPTS = 6;
+/** 图谱投影 LLM 单次调用超时(含整条回退链):沿用 llm.timeoutMs(120s) 在 8-record
+ *  批 + 上下文节点/边 + 12 关系词 prompt 下真机撞线(14 dead 全是 aborted×13 + terminated×1)。
+ *  照 backfill callTimeoutMs 先例给 240s,按「路由数 × 单路由耗时」留余量。 */
+export const GRAPH_PROJECTION_CALL_TIMEOUT_MS = 240_000;
 /** 失败指数退避基数:第 n 次失败后 nextAttemptAt = now + base × 2^(n-1)。 */
 export const GRAPH_JOB_BACKOFF_BASE_MS = 60_000;
 /** 单次检索返回上限的硬钳制(工具与 RPC 两侧共用同一钳制值)。 */
 export const GRAPH_SEARCH_LIMIT_MAX = 20;
+/** §D 第 3 路路内向量种子的节点条数上限(种子只是联想起点,独立于词法路 limit)。 */
+export const GRAPH_VEC_SEED_CAP = 10;
+/** 1-hop 边扩展回链的新增记录数封顶(hop 段专用名额,直连段不占;防 hub 节点邻接爆量)。 */
+export const GRAPH_HOP_RECORD_CAP = 64;
+/** 面板图谱预览:种子榜上限(画布片数)。 */
+export const GRAPH_PREVIEW_SEEDS = 6;
+/** 面板图谱预览:单种子绘制的邻居上限(超出置 truncated)。 */
+export const GRAPH_PREVIEW_NEIGHBORS = 10;
+/** 面板图谱预览:种子评分中因果边的权重(score = degree + causal×此值)——
+ *  因果链比共现邻接更值得画,预览侧单源读 GRAPH_CAUSAL_RELATIONS。 */
+export const GRAPH_PREVIEW_CAUSAL_WEIGHT = 2;
+/** 全图星图（mode:'full'）节点上限：超限截断并置 truncated（截断标记而非硬拒——
+ *  星图是展示面，宁可少画几颗也不报错；G6 舒适区 <2000 留余量）。 */
+export const GRAPH_PREVIEW_FULL_NODES = 1500;
+/** 全图星图 active 边上限（同一 truncated 语义；悬挂边已在截断前剔除）。 */
+export const GRAPH_PREVIEW_FULL_EDGES = 3000;

package/dist/hooks/recall.js

@@ -1,6 +1,7 @@
 import { createUserMessage } from '@deepseek-ai/dsh-llm';
 import { createHash } from 'node:crypto';
 import { trace } from '../store/trace.js';
+import { filterInjectCandidates } from '../store/validity.js';
 import { RecallDedupeStore } from '../store/recall-dedupe.js';
 import { OccupancyStore } from '../store/occupancy.js';
 import { expirePendingInjections, registerPendingInjection, setInjectionMarker, } from './recall-ack.js';
@@ -459,6 +460,29 @@ usage) {
                         scoped = kept;
                     }
                 }
+                // ── 门2 被动注入硬当前态(expiry-tiering task_3.3/3.4,灰度闸**默认关**):
+                // 开时按 classifyValidity 现算态剔除 `expired`(仍在索引可检,只是不再自动
+                // 浮现进模型上下文);`expired_suspect` 保留并在注入行带"疑似失效"标注;
+                // superseded/retired 由门1 索引层结构性进不到候选(不在本层重复过滤)。
+                // 判据单源 `stateOfRecord`,本层不再写一份 valid_to/marker 比较(计划 §4 约束)。
+                // 关时不进分支零 getByIds——注入逐字与改前一致(零漂移)。
+                let suspectIds = new Set();
+                const tieringOn = cfg.validity?.tieringEnabled === true || live.get().validityTiering === true;
+                if (tieringOn && scoped.length > 0) {
+                    const nowV = Date.now();
+                    const byIdV = new Map(stores.l1.getByIds(scoped.map((h) => h.id)).map((r) => [r.id, r]));
+                    // 主体收敛在 validity.filterInjectCandidates(纯函数可单测,task_3.6)——
+                    // 这里只做数据装配与日志,不内联第二份判据。
+                    const filtered = filterInjectCandidates(scoped, (id) => byIdV.get(id), nowV);
+                    suspectIds = filtered.suspectIds;
+                    if (filtered.exited > 0) {
+                        logger.warn(`[memory] 门2 防御性拦截退场态候选 ${filtered.exited} 条(门1 应已挡住,出现即泄漏信号)`);
+                    }
+                    if (filtered.kept.length !== scoped.length) {
+                        logger.info(`[memory] 门2 时效过滤:剔除 expired ${scoped.length - filtered.kept.length - filtered.exited} 条(agent=${payload.agent.id})`);
+                    }
+                    scoped = filtered.kept;
+                }
                 // 召回去重:同会话已注入过的记录不再重复注入(模型上下文已持有,省 token)。
                 // 纯过滤——剩几条注几条,全量压制(0 条新鲜命中)是正确状态而非未命中。
                 // §E:压缩后增强轮跳过压制(压缩把已注入内容逐出了模型上下文)。
@@ -485,7 +509,10 @@ usage) {
                     usage?.recordAttempt(scoped.map((h) => h.id), []);
                     return decision;
                 }
-                const lines = applyRecallBudget(fresh.map((h) => `- [${h.scene_name ? `${h.type}|${h.scene_name}` : h.type}] ${h.content}`), { maxCharsPerMemory: cfg.recall.maxCharsPerMemory, maxTotalRecallChars: cfg.recall.maxTotalRecallChars });
+                const lines = applyRecallBudget(fresh.map((h) => `- [${h.scene_name ? `${h.type}|${h.scene_name}` : h.type}] ${h.content}` +
+                    // 门2 task_3.4:疑而不隐——valid_to 来源不可信的行保留注入但带标注,
+                    // 人/模型自行裁量。灰度关时 suspectIds 恒空,行形状逐字不变。
+                    (suspectIds.has(h.id) ? '（疑似失效:有效期来源不可信）' : '')), { maxCharsPerMemory: cfg.recall.maxCharsPerMemory, maxTotalRecallChars: cfg.recall.maxTotalRecallChars });
                 if (lines.length === 0) {
                     // §F 追踪:预算清零轮(截断后无完整行)
                     trace({
@@ -531,7 +558,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

@@ -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([
@@ -386,6 +399,8 @@ export async function apply(ctx, config) {
     runner.startIdleTimer();
     // 图谱周期补投影(cfg.graph.enabled 门控;30 分钟一次低速收敛)
     runner.startGraphBackfillTimer();
+    // 时效标注存量回填(expiry-tiering task_6.3:tieringEnabled 门控,低频、让位蒸馏)
+    runner.startValidityBackfillTimer();
     // 重建控制器(存储降级时不建——RPC 端点走 supported=false 分支)
     const rebuild = storageOk && !db.isDegraded()
         ? new RebuildController(ctx, config, stores, db, runner, logger, live)
@@ -455,7 +470,12 @@ export async function apply(ctx, config) {
     stores.l1.setFileSyncHook(fileSync);
     const recall = registerRecall(ctx, config, stores, logger, live, modes, dataDir, recallUsage);
     runner.setAfterRun(recall.invalidateProfile);
-    const toolSeals = registerMemoryTools(ctx, config, stores, logger, modes, live, ruminate, storageOk ? roomRegistry : undefined);
+    const toolSeals = registerMemoryTools(ctx, config, stores, logger, modes, live, ruminate, storageOk ? roomRegistry : undefined, {
+        // 确定性写面钩子(graph-write-plane R2/R3):runner 公开方法直连,工具三路径与
+        // distill 分支共用同一个入队实现,不存在第二套优先级/去重逻辑。
+        enqueueGraph: (ids) => runner.enqueueGraphFor(ids),
+        reprojectGraph: (ids) => runner.reprojectGraph(ids),
+    });
     // 激活槽位(active slot):工具面 + 常驻注入 + 服务端投影(均走 ctx.effect,可撤销)
     registerSlotTools(ctx, config, stores.slots, logger, modes, live, stores.l1);
     const slotRecall = registerSlotRecall(ctx, config, stores.slots, logger, live);

package/dist/llm.d.ts

@@ -156,7 +156,12 @@ export declare function planDistillEffort(ctx: Context, provider: string, model:
  * 适配器异常地没有发 block-end 时兜底。两者都累计会把输出翻倍。
  */
 export declare function callLLM(ctx: Context, cfg: MemoryConfig, opts: LlmCallOptions): Promise<string>;
-/** 带诊断日志的 parseJson:解析失败时记录原始输出摘录(模型输出异常排查的关键信息)。 */
+/** 带诊断日志的 parseJson:解析失败时记录原始输出摘录(模型输出异常排查的关键信息);修复/救援命中时 warn 一行。 */
 export declare function parseJsonLogged<T>(raw: string, what: string, logger?: MemoryLogger): T;
-/** 容错地解析 LLM 输出的 JSON(剥掉可能的 ```json 围栏)。 */
+/**
+ * 容错地解析 LLM 输出的 JSON。
+ *
+ * 旧版行为：剥 ```json``` 围栏 + 切到首个 `[`/`{` 到末尾 `]`/`}`,一次 JSON.parse。
+ * 新版同路径 + 三级容错(strict → repaired → salvaged),内部实现见 util/json-repair.ts。
+ */
 export declare function parseJson<T>(raw: string): T;