dsh-prime-memory 0.26.31 → 0.26.33

package/dist/config.js

@@ -103,6 +103,12 @@ export function liveSettingsSchema() {
         /** 时效分级门2 面板开关:与部署 cfg.validity.tieringEnabled 取或(任一为真即启用
          *  注入侧 expired 过滤)。默认关;先面板验证再翻部署默认(照 keywordEnabled 先例)。 */
         validityTiering: Schema.boolean().default(false),
+        /**
+         * 记忆库侧栏入口开关（概览页可拨）：默认**开**（与其余进阶项默认关不同）。
+         * 必须在 live schema 里有名：schema 外的键写入会被丢弃，重启后读不回，
+         * 面板上拨了等于白拨（真机踩过的缺写点）。
+         */
+        explorerEnabled: Schema.boolean().default(true),
         /**
          * 存量回填（keyword / redistill）LLM 批调用的**运行时并行度**覆盖：
          * `0` = 跟随部署 `cfg.backfill.concurrency`；1–8 = 直接覆盖。

package/dist/contract.d.ts

@@ -131,6 +131,8 @@ export interface MemoryLiveSettings {
     memportEnabled: boolean;
     /** 时效分级门2 启用开关（概览区可拨）:true = 被动注入剔除 expired。与部署 cfg.validity.tieringEnabled 取或；关=注入与改前逐字一致。 */
     validityTiering: boolean;
+    /** 记忆库侧栏入口开关（概览区可拨）:true = 在左侧栏注册「记忆库」入口行 + 主面板。默认 true。 */
+    explorerEnabled: boolean;
     /** md 投射/后缀收敛的单次动作护栏运行时覆盖:0 = 跟随部署 `cfg.memExport.maxRecords`（默认 2000）。
      *  存在的理由：一次点完多少条属于“回填历史时才改一下”的旋钮，不该要求改 YAML + 重启。 */
     mdExportMaxRecords: number;
@@ -1335,12 +1337,15 @@ export interface GraphPreviewResponse {
         missing?: number;
     };
     /** mode==='full' 才出现;全图星图轻量块(可见节点×active 边,截断标记 truncated)。
-     *  不带此键时响应与旧形状逐字节一致——消费方按需读 `res.full?`。 */
+     *  不带此键时响应与旧形状逐字节一致——消费方按需读 `res.full?`。
+     *  节点 `aging`(0.5~1,3D 亮度通道)与 `source`(出处场景名,provenance fallback)同为可选键:无值时**缺席**。 */
     full?: {
         nodes: Array<{
             id: string;
             name: string;
             type: string;
+            aging?: number;
+            source?: string;
         }>;
         edges: Array<{
             from: string;
@@ -1358,6 +1363,64 @@ export interface GraphCleanupDeadRequest {
 export interface GraphCleanupDeadResponse {
     removed: number;
 }
+/**
+ * dsh-memory/record-links(记忆库入口的关联跳转:记录 → 实体 → 关系 → 其它记录)。
+ *
+ * L1 记录本身**不是图顶点**(`l1_records` DDL 冻结、无 relation 列),所以关联一律
+ * 经图投影的 `sourceRecordIds` **反查**得到——本端点是纯读面,不写图、不建边、
+ * 不改投影。图谱未启用时返回全空结构(不抛),与 graph-preview 的降级口径一致。
+ */
+export interface RecordLinksRequest {
+    /** 起点 L1 记录 id(≤200 字符;不存在 → `record: null` + 空集,不抛)。 */
+    recordId: string;
+    /** 邻居展开跳数,缺省 1,钳制 1..2(再深只会放大 hub 爆量,不给新信息)。 */
+    hops?: number;
+    /** 邻居与回落记录各自的条数上限,缺省 60,钳制 1..200。 */
+    limit?: number;
+}
+export interface RecordLinksResponse {
+    /** 层1 起点记录(悬挂 id → null)。 */
+    record: UiRecord | null;
+    /** 层2：该记录作为来源的实体节点（按 degree 降序）。 */
+    entities: Array<{
+        id: string;
+        name: string;
+        type: string;
+        degree: number;
+        causalDegree: number;
+        /** 来源记录预览（保最新、≤5 条，已排除起点自身）。 */
+        recordIds: string[];
+    }>;
+    /** 层3：实体的一度邻居。平行关系各占一条（同对节点两条关系 = 两行，不合并）。 */
+    neighbors: Array<{
+        id: string;
+        name: string;
+        type: string;
+        relation: string;
+        causal: boolean;
+        /** 该邻居经由哪个层2 实体连出——多实体起点下用于回溯「经由谁」。 */
+        viaEntityId: string;
+        degree: number;
+        /** 本邻居是第几跳（1 = 实体的直接邻居）。 */
+        hop: number;
+        /** 邻居的来源记录预览（≤5 条）——第三层「跳到记录」的落点。 */
+        recordIds: string[];
+    }>;
+    /** 回落记录:邻居实体的来源记录(去重、排除起点自身、updatedAt 倒序、≤limit)。 */
+    records: UiRecord[];
+    /**
+     * 取代链。方向语义由 marker 的位置决定,不能凭直觉写:
+     * `dsh_superseded` **写在退场的旧行上**、`by` 指向新行——
+     * 故 `prevIds` 是**数组**(本记录取代掉的旧行,`findSupersededTargets` 反查),
+     * `nextId` 是**单值**(取代本记录的新行;本记录仍活跃时为 null)。
+     */
+    supersede: {
+        prevIds: string[];
+        nextId: string | null;
+    };
+    /** 邻居或回落记录任一维触顶(渲染侧必须显式提示,不得静默少列)。 */
+    truncated: boolean;
+}
 /** dsh-memory/scenes(两族拼接的混合视图)。 */
 export interface ScenesResponse {
     items: Array<{
@@ -1954,6 +2017,7 @@ export interface DshMemoryRequestMap {
     'dsh-memory/graph-search': GraphSearchRequest;
     'dsh-memory/graph-node-get': GraphNodeGetRequest;
     'dsh-memory/graph-preview': GraphPreviewRequest;
+    'dsh-memory/record-links': RecordLinksRequest;
     'dsh-memory/graph-cleanup-dead': GraphCleanupDeadRequest;
     'dsh-memory/scenes': Record<string, never>;
     'dsh-memory/persona': Record<string, never>;
@@ -2037,6 +2101,7 @@ export interface DshMemoryResponseMap {
     'dsh-memory/graph-search': GraphSearchResponse;
     'dsh-memory/graph-node-get': GraphNodeGetResponse;
     'dsh-memory/graph-preview': GraphPreviewResponse;
+    'dsh-memory/record-links': RecordLinksResponse;
     'dsh-memory/graph-cleanup-dead': GraphCleanupDeadResponse;
     'dsh-memory/scenes': ScenesResponse;
     'dsh-memory/persona': PersonaResponse;

package/dist/graph/constraints.d.ts

@@ -13,6 +13,15 @@ export declare const GRAPH_NODE_TYPE_SET: ReadonlySet<string>;
 /** 记录生命周期四态(节点/fact/边通用)。 */
 export declare const GRAPH_STATUSES: readonly GraphRecordStatus[];
 export declare const GRAPH_STATUS_SET: ReadonlySet<string>;
+/**
+ * 节点是否进入「可画 / 可检 / 可关联」的候选集——读侧可见性判据的**单源**。
+ *
+ * 预览榜单、全图元素选择、关联反查三处必须同式,否则会出现「画布上有这个节点、
+ * 关联清单里查不到」或反之的对不齐。superseded/archived 是历史而非当前状态。
+ */
+export declare function isGraphNodeVisible(n: {
+    status: GraphRecordStatus;
+}): boolean;
 /** 因果边四词单源(投影提示词枚举、校验与面板预览加权共用——防两处词表漂移)。 */
 export declare const GRAPH_CAUSAL_RELATIONS: readonly ["导致", "因为", "修复了", "取代"];
 /** 规范中文关系词(提示词给枚举;校验不做白名单——关系是开放词表,只做长度钳制)。
@@ -49,3 +58,8 @@ export declare const GRAPH_CAP: {
  * 状态仍由 active facts 决定,不影响可追溯性主体。
  */
 export declare const GRAPH_SOURCE_RECORDS_CAP = 128;
+/**
+ * 星图老化剔除下限：`buildFullView` 收到 agingOf 时，aging 低于此值的节点不渲染（连悬挂边一起退）。
+ * 与 explorer 的 `agingWeightOf(..., floor=0.2)` 同值——下限即剔除线，低于它已经暗到看不出。
+ */
+export declare const GRAPH_AGING_CULL_FLOOR = 0.2;

package/dist/graph/constraints.js

@@ -4,6 +4,15 @@ export const GRAPH_NODE_TYPE_SET = new Set(GRAPH_NODE_TYPES);
 /** 记录生命周期四态(节点/fact/边通用)。 */
 export const GRAPH_STATUSES = ['active', 'superseded', 'disputed', 'archived'];
 export const GRAPH_STATUS_SET = new Set(GRAPH_STATUSES);
+/**
+ * 节点是否进入「可画 / 可检 / 可关联」的候选集——读侧可见性判据的**单源**。
+ *
+ * 预览榜单、全图元素选择、关联反查三处必须同式,否则会出现「画布上有这个节点、
+ * 关联清单里查不到」或反之的对不齐。superseded/archived 是历史而非当前状态。
+ */
+export function isGraphNodeVisible(n) {
+    return n.status === 'active' || n.status === 'disputed';
+}
 /** 因果边四词单源(投影提示词枚举、校验与面板预览加权共用——防两处词表漂移)。 */
 export const GRAPH_CAUSAL_RELATIONS = ['导致', '因为', '修复了', '取代'];
 /** 规范中文关系词(提示词给枚举;校验不做白名单——关系是开放词表,只做长度钳制)。
@@ -40,3 +49,8 @@ export const GRAPH_CAP = {
  * 状态仍由 active facts 决定,不影响可追溯性主体。
  */
 export const GRAPH_SOURCE_RECORDS_CAP = 128;
+/**
+ * 星图老化剔除下限：`buildFullView` 收到 agingOf 时，aging 低于此值的节点不渲染（连悬挂边一起退）。
+ * 与 explorer 的 `agingWeightOf(..., floor=0.2)` 同值——下限即剔除线，低于它已经暗到看不出。
+ */
+export const GRAPH_AGING_CULL_FLOOR = 0.2;

package/dist/graph/preview.d.ts

@@ -71,6 +71,17 @@ export interface FullViewNode {
     id: string;
     name: string;
     type: GraphNodeType;
+    /**
+     * 老化权重（0.5~1，与 UiRecord.agingWeight 同定义域）——3D 星图亮度通道的数据源。
+     * **可选键零漂移**：缺省（衰减关闭/无存活来源/调用方未注入 resolver）时该键**缺席**，
+     * 不是 undefined 占位——既有形状断言测试（三键）继续成立，老消费方 JSON 形状不变。
+     */
+    aging?: number;
+    /**
+     * 出处标签（provenance fallback）：来源记录的主场景名，如“字节Code M岗位”——
+     * 人物实体靠它回溯“在哪提到的”。同为可选键零漂移：无场景/未注入 resolver 时键缺席。
+     */
+    source?: string;
 }
 /** 全图边轻量项（causal 由单源词表判出，渲染侧不再抄词表）。 */
 export interface FullViewEdge {
@@ -88,6 +99,17 @@ export interface GraphFullView {
 export interface FullViewCaps {
     nodeCap?: number;
     edgeCap?: number;
+    /**
+     * 节点老化解析器（nodeId → aging | null）：由端点层查 L1 来源记录后注入，
+     * 本纯函数**不查库**。判据在调用方：节点无自己的老化——老化属于记录，
+     * 节点取全部存活来源中**最新**那条的 agingWeight（任一来源还新鲜，实体就不该显得旧）。
+     */
+    agingOf?: (id: string) => number | null;
+    /**
+     * 出处解析器（nodeId → 场景名 | null）：同 agingOf 一样由端点层查来源记录后注入，
+     * 本纯函数不查库。B 方案（投影期落库 context）上线后本项退为兜底。
+     */
+    sourceOf?: (id: string) => string | null;
 }
 /**
  * 全图星图数据块（纯函数，不查库）：可见节点轻量投影 × active 边，

package/dist/graph/preview.js

@@ -9,13 +9,11 @@
  * 判据与检索同源(search.ts):候选 = active|disputed 节点 × active 边;
  * 确定性 = 同输入两次调用逐位一致(同分裁决链落到 id 升序兜底)。
  */
-import { GRAPH_CAUSAL_RELATIONS } from './constraints.js';
+import { GRAPH_AGING_CULL_FLOOR, GRAPH_CAUSAL_RELATIONS, isGraphNodeVisible } 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';
-}
+/** 预览的节点可见性(与检索候选集同式):引用单源判据,不在此处重抄。 */
+const visible = isGraphNodeVisible;
 export function degreeMaps(nodes, edges) {
     const candidate = new Set(nodes.filter(visible).map((n) => n.id));
     const degree = new Map();
@@ -163,7 +161,17 @@ export function buildGraphPreview(nodes, edges, opts = {}) {
 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);
+    // 老化剔除线（仅当注入 agingOf 时生效）：aging < 0.2 的节点及其悬挂边不渲染。
+    // aging=null（衰减关/无存活来源）不剔——不能因为拿不到数值就把节点删掉。
+    const cullByAging = caps.agingOf !== undefined;
+    const visibleNodes = nodes.filter((n) => {
+        if (!visible(n))
+            return false;
+        if (!cullByAging)
+            return true;
+        const a = caps.agingOf(n.id);
+        return a == null || a >= GRAPH_AGING_CULL_FLOOR;
+    });
     const nodesTruncated = visibleNodes.length > nodeCap;
     const drawn = visibleNodes.slice(0, nodeCap);
     const keep = new Set(drawn.map((n) => n.id));
@@ -181,7 +189,17 @@ export function buildFullView(nodes, edges, caps = {}) {
         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 })),
+        nodes: drawn.map((n) => {
+            const base = { id: n.id, name: n.name, type: n.type };
+            // 有值才挂键（可选键零漂移：null/无 resolver → 键缺席，老消费方看到的形状不变）。
+            const aging = caps.agingOf?.(n.id) ?? null;
+            if (aging != null)
+                base.aging = aging;
+            const source = caps.sourceOf?.(n.id) ?? null;
+            if (source != null)
+                base.source = source;
+            return base;
+        }),
         edges: outEdges,
         truncated: nodesTruncated || edgesTruncated,
     };

package/dist/graph/record-links.d.ts

@@ -0,0 +1,61 @@
+import type { GraphEdge, GraphNode, GraphNodeType } from './types.js';
+/** 关联跳转的缺省条数上限(邻居与回落记录各吃一份)。 */
+export declare const RECORD_LINKS_LIMIT_DEFAULT = 60;
+/** 条数硬钳制上界(与 list-records 的单页上限同量级,再大没有可读性)。 */
+export declare const RECORD_LINKS_LIMIT_MAX = 200;
+/** 跳数上界:2 跳足够看清"经由谁连到谁";3 跳在百级图上是全图,在千级图上是噪声。 */
+export declare const RECORD_LINKS_HOPS_MAX = 2;
+/**
+ * 每个实体/邻居随带的来源记录预览条数(保最新)。
+ *
+ * 没有它,第三层「点邻居 → 跳到那条记录」就断了:面板拿到邻居 id 却不知道它
+ * 的来源是谁,只能再发一次 graph-node-get。截 5 条是为了不把整条来源链(上限 128)
+ * 塞进一个列表项。
+ */
+export declare const RECORD_LINKS_SOURCE_PREVIEW = 5;
+export interface RecordLinkEntity {
+    id: string;
+    name: string;
+    type: GraphNodeType;
+    /** active 边双向计数(与 preview.degreeMaps 同口径)。 */
+    degree: number;
+    causalDegree: number;
+    /** 来源记录预览(保最新、≤RECORD_LINKS_SOURCE_PREVIEW;起点自身已排除)。 */
+    recordIds: string[];
+}
+export interface RecordLinkNeighbor {
+    id: string;
+    name: string;
+    type: GraphNodeType;
+    /** 该条边的关系词(平行多边各占一条,不合并——合并就丢关系)。 */
+    relation: string;
+    causal: boolean;
+    /** 经由哪个上游节点连出(多层展开时形成"起点 → via → 邻居"的可回溯链)。 */
+    viaEntityId: string;
+    degree: number;
+    /** 本邻居是第几跳(1 = 实体的直接邻居)。 */
+    hop: number;
+    /** 邻居的来源记录预览(保最新、≤RECORD_LINKS_SOURCE_PREVIEW)——第三层跳转的落点。 */
+    recordIds: string[];
+}
+export interface RecordLinksResult {
+    /** 层2:起点记录作为来源的实体节点(degree 降序)。 */
+    entities: RecordLinkEntity[];
+    /** 层3:实体邻居(因果优先 → degree 降 → updatedAt 新 → id 升)。 */
+    neighbors: RecordLinkNeighbor[];
+    /** 回落记录的 id 集(已去重、已排除起点自身、按"来源节点排名"顺序、≤limit)。 */
+    neighborRecordIds: string[];
+    /** 邻居或回落记录任一维触顶。 */
+    truncated: boolean;
+}
+export interface RecordLinksOpts {
+    /** 1..RECORD_LINKS_HOPS_MAX,缺省 1。 */
+    hops?: number;
+    /** 1..RECORD_LINKS_LIMIT_MAX,缺省 RECORD_LINKS_LIMIT_DEFAULT。 */
+    limit?: number;
+}
+/**
+ * 主函数。`recordId` 命中零个实体时返回全空结构(不抛)——这条记录还没被投影进图
+ * (图谱默认关闭 / 投影未跑到 / 该记录无可抽实体),都是正常态而非错误态。
+ */
+export declare function buildRecordLinks(nodes: readonly GraphNode[], edges: readonly GraphEdge[], recordId: string, opts?: RecordLinksOpts): RecordLinksResult;

package/dist/graph/record-links.js

@@ -0,0 +1,167 @@
+/**
+ * 记忆库入口的关联跳转(读路径纯函数):L1 记录 → 实体 → 关系 → 其它记录。
+ *
+ * 为什么必须绕图投影:`l1_records` 的 DDL 是逐字节冻结的磁盘契约,记录行里
+ * **没有任何 relation/edges 字段**,L1 记录也不是图的顶点。所以"这条记忆和哪些
+ * 记忆相关"只能经 `graph_nodes/graph_edges` 的 `sourceRecordIds` **反查**得出——
+ * 关系是投影出来的,不是存出来的。反查一律在内存里做(`sourceRecordIds.includes`),
+ * 不走 SQL `LIKE '%"id"%'`:图谱量级为可重建投影(百~千级),全表读本就发生在上层
+ * `loadGraph`,内存扫描零成本;而 LIKE 匹配 JSON 文本有前缀误配风险。
+ *
+ * 三条不变式:
+ *   1) 只读:本文件不查库、不落库、不建边、不改投影——写面一律走既有 reproject 缝;
+ *   2) 判据与预览/检索同源:候选 = active|disputed 节点 × active 边(见 preview.visible);
+ *   3) 确定性 = 同输入两次调用逐位一致,同分裁决链落到 id 升序兜底。
+ */
+import { GRAPH_CAUSAL_RELATIONS, isGraphNodeVisible } from './constraints.js';
+import { degreeMaps } from './preview.js';
+const CAUSAL_SET = new Set(GRAPH_CAUSAL_RELATIONS);
+/** 关联跳转的缺省条数上限(邻居与回落记录各吃一份)。 */
+export const RECORD_LINKS_LIMIT_DEFAULT = 60;
+/** 条数硬钳制上界(与 list-records 的单页上限同量级,再大没有可读性)。 */
+export const RECORD_LINKS_LIMIT_MAX = 200;
+/** 跳数上界:2 跳足够看清"经由谁连到谁";3 跳在百级图上是全图,在千级图上是噪声。 */
+export const RECORD_LINKS_HOPS_MAX = 2;
+/**
+ * 每个实体/邻居随带的来源记录预览条数(保最新)。
+ *
+ * 没有它,第三层「点邻居 → 跳到那条记录」就断了:面板拿到邻居 id 却不知道它
+ * 的来源是谁,只能再发一次 graph-node-get。截 5 条是为了不把整条来源链(上限 128)
+ * 塞进一个列表项。
+ */
+export const RECORD_LINKS_SOURCE_PREVIEW = 5;
+/** 与预览同源的可见性判据(单源在 constraints)。 */
+const visible = isGraphNodeVisible;
+/** updatedAt 新(大)先;ISO 字符串可直接字典序比较。 */
+function byRecency(a, b) {
+    if (a.updatedAt !== b.updatedAt)
+        return a.updatedAt < b.updatedAt ? 1 : -1;
+    return a.id < b.id ? -1 : 1;
+}
+/** 来源预览:保最新尾部截断,并排除起点自身(它已在层1 展示)。 */
+function previewSources(node, excludeId) {
+    const keep = node.sourceRecordIds.filter((r) => r !== excludeId);
+    return keep.length > RECORD_LINKS_SOURCE_PREVIEW ? keep.slice(-RECORD_LINKS_SOURCE_PREVIEW) : keep;
+}
+/**
+ * 主函数。`recordId` 命中零个实体时返回全空结构(不抛)——这条记录还没被投影进图
+ * (图谱默认关闭 / 投影未跑到 / 该记录无可抽实体),都是正常态而非错误态。
+ */
+export function buildRecordLinks(nodes, edges, recordId, opts = {}) {
+    const empty = { entities: [], neighbors: [], neighborRecordIds: [], truncated: false };
+    const id = String(recordId ?? '').trim();
+    if (!id)
+        return empty;
+    const byId = new Map(nodes.map((n) => [n.id, n]));
+    const dm = degreeMaps(nodes, edges);
+    const limit = Math.min(Math.max(Math.floor(opts.limit ?? RECORD_LINKS_LIMIT_DEFAULT), 1), RECORD_LINKS_LIMIT_MAX);
+    const hops = Math.min(Math.max(Math.floor(opts.hops ?? 1), 1), RECORD_LINKS_HOPS_MAX);
+    const visEdges = edges.filter((e) => e.status === 'active');
+    // ── 层2:反查该记录作为来源的实体 ────────────────────────────
+    const entityNodes = nodes
+        .filter((n) => visible(n) && n.sourceRecordIds.includes(id))
+        .sort((a, b) => {
+        const da = dm.degree.get(a.id) ?? 0;
+        const db = dm.degree.get(b.id) ?? 0;
+        if (da !== db)
+            return db - da;
+        return byRecency(a, b);
+    });
+    if (entityNodes.length === 0)
+        return empty;
+    const entities = entityNodes.map((n) => ({
+        id: n.id,
+        name: n.name,
+        type: n.type,
+        degree: dm.degree.get(n.id) ?? 0,
+        causalDegree: dm.causal.get(n.id) ?? 0,
+        recordIds: previewSources(n, id),
+    }));
+    // ── 层3:沿 active 边逐跳展开(visited 防环;起点实体自身不重复入列) ──
+    let frontier = entityNodes;
+    /** 起点实体集:它们已在层2 展示过,不再当作「关联项」绕回来重复列出。 */
+    const entitySet = new Set(entityNodes.map((n) => n.id));
+    const seen = new Set([...entitySet]);
+    const rows = [];
+    /** 排名序的节点集(回落记录按它取,保证"越相关的邻居的来源越先出现")。 */
+    const rankedNodes = [...entityNodes];
+    for (let hop = 1; hop <= hops; hop += 1) {
+        const next = [];
+        for (const center of frontier) {
+            for (const e of visEdges) {
+                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;
+                if (entitySet.has(o.id))
+                    continue; // 环状图不把起点实体列成自己的邻居
+                rows.push({
+                    id: o.id,
+                    name: o.name,
+                    type: o.type,
+                    relation: e.relation,
+                    causal: CAUSAL_SET.has(e.relation),
+                    viaEntityId: center.id,
+                    degree: dm.degree.get(o.id) ?? 0,
+                    hop,
+                    recordIds: previewSources(o, id),
+                    _upd: o.updatedAt,
+                });
+                if (!seen.has(o.id)) {
+                    seen.add(o.id);
+                    next.push(o);
+                }
+            }
+        }
+        rankedNodes.push(...next);
+        frontier = next;
+        if (next.length === 0)
+            break;
+    }
+    rows.sort((a, b) => {
+        if (a.causal !== b.causal)
+            return a.causal ? -1 : 1;
+        if (a.hop !== b.hop)
+            return a.hop - b.hop;
+        if (a.degree !== b.degree)
+            return b.degree - a.degree;
+        if (a._upd !== b._upd)
+            return a._upd < b._upd ? -1 : 1;
+        if (a.id !== b.id)
+            return a.id < b.id ? -1 : 1;
+        return a.viaEntityId < b.viaEntityId ? -1 : 1;
+    });
+    const neighborsTruncated = rows.length > limit;
+    const kept = rows.slice(0, limit);
+    const neighbors = kept.map(({ _upd, ...row }) => row);
+    // ── 回落到记录:入选邻居 + 起点实体的来源记录,去重并排除起点自身 ──
+    const pickedIds = [];
+    const taken = new Set([id]);
+    let recordsTruncated = false;
+    for (const node of rankedNodes) {
+        for (const rid of node.sourceRecordIds) {
+            if (taken.has(rid))
+                continue;
+            if (pickedIds.length >= limit) {
+                recordsTruncated = true;
+                break;
+            }
+            taken.add(rid);
+            pickedIds.push(rid);
+        }
+        if (recordsTruncated)
+            break;
+    }
+    return {
+        entities,
+        neighbors,
+        neighborRecordIds: pickedIds,
+        truncated: neighborsTruncated || recordsTruncated,
+    };
+}

package/dist/graph/select.d.ts

@@ -0,0 +1,30 @@
+import { type FullViewEdge, type FullViewNode } from './preview.js';
+import type { GraphEdge, GraphNode } from './types.js';
+/** 骨架层占比(度量为 nodeCap)。 */
+export declare const EXPLORER_QUOTA_SKELETON = 0.6;
+/** 新鲜层占比(度量为 nodeCap)。 */
+export declare const EXPLORER_QUOTA_FRESH = 0.2;
+export interface ExplorerSelectCaps {
+    nodeCap?: number;
+    edgeCap?: number;
+}
+export interface ExplorerSelection {
+    nodes: FullViewNode[];
+    edges: FullViewEdge[];
+    /** 任一维触顶(渲染侧必须据此提示"仅画部分",不得静默少画)。 */
+    truncated: boolean;
+    /** 各层实际入选数(合计 === nodes.length;诊断与单测断言用)。 */
+    counts: {
+        skeleton: number;
+        fresh: number;
+        tail: number;
+    };
+    /** 截断前的可见节点总数(页面显示 "M/N 节点")。 */
+    totalVisible: number;
+    totalEdges: number;
+}
+/**
+ * 主函数。纯计算:不查库、不落库。`nodes`/`edges` 由调用方一次性装载
+ * (GraphStore.loadGraph),与 buildFullView 共享同一份入参。
+ */
+export declare function selectExplorerNodes(nodes: readonly GraphNode[], edges: readonly GraphEdge[], caps?: ExplorerSelectCaps): ExplorerSelection;

package/dist/graph/select.js

@@ -0,0 +1,124 @@
+/**
+ * 记忆库视图的元素选择(读路径纯函数):超上限时按**三层配额**选,而不是单一排序。
+ *
+ * 为什么不按 degree 从高到低截断:图谱里的老 hub(如"用户本人"、长期项目)度数恒高,
+ * 单一排序会把全部名额吃在它们和它们的一度邻居上,**昨天刚沉淀的新记忆永远进不了图**
+ * ——而"我刚记的东西在哪"恰恰是查询入口最先被问的问题。故拆三层:
+ *   骨架层(60%)  degree + causal×权重  —— 保证结构主干与因果链在画面里;
+ *   新鲜层(20%)  updatedAt 倒序,含 degree=0 —— 保证新记忆一定看得见;
+ *   长尾层(余量) 剩余按 degree 补 —— 防止只剩几个毛球,保留图的连通观感。
+ *
+ * 未超限时**全选**,且输出顺序与入参一致(即 `loadGraph` 行序)——与既有
+ * `buildFullView` 的截断语义逐位对齐,老消费方不受影响。
+ */
+import { GRAPH_PREVIEW_CAUSAL_WEIGHT, GRAPH_PREVIEW_FULL_EDGES, GRAPH_PREVIEW_FULL_NODES } from './types.js';
+import { GRAPH_CAUSAL_RELATIONS, isGraphNodeVisible } from './constraints.js';
+import { degreeMaps } from './preview.js';
+const CAUSAL_SET = new Set(GRAPH_CAUSAL_RELATIONS);
+/** 骨架层占比(度量为 nodeCap)。 */
+export const EXPLORER_QUOTA_SKELETON = 0.6;
+/** 新鲜层占比(度量为 nodeCap)。 */
+export const EXPLORER_QUOTA_FRESH = 0.2;
+/** 与预览/关联同源的可见性判据(单源在 constraints)。 */
+const visible = isGraphNodeVisible;
+/**
+ * 主函数。纯计算:不查库、不落库。`nodes`/`edges` 由调用方一次性装载
+ * (GraphStore.loadGraph),与 buildFullView 共享同一份入参。
+ */
+export function selectExplorerNodes(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 dm = degreeMaps(nodes, edges);
+    const visNodes = nodes.filter(visible);
+    const scoreOf = (n) => (dm.degree.get(n.id) ?? 0) + (dm.causal.get(n.id) ?? 0) * GRAPH_PREVIEW_CAUSAL_WEIGHT;
+    // ── 节点选择 ──────────────────────────────────────────────
+    const chosen = new Set();
+    let skeleton = 0;
+    let fresh = 0;
+    let tail = 0;
+    let nodesTruncated = false;
+    if (visNodes.length <= nodeCap) {
+        for (const n of visNodes)
+            chosen.add(n.id);
+    }
+    else {
+        nodesTruncated = true;
+        const byScore = (a, b) => {
+            const s = scoreOf(b) - scoreOf(a);
+            if (s !== 0)
+                return s;
+            return a.id < b.id ? -1 : 1;
+        };
+        const byFresh = (a, b) => {
+            if (a.updatedAt !== b.updatedAt)
+                return a.updatedAt < b.updatedAt ? 1 : -1;
+            return a.id < b.id ? -1 : 1;
+        };
+        // 每层至少留 1 个名额:cap 很小时 floor(cap×0.2)=0 会让新鲜层直接消失,
+        // 于是“刚记的东西看不见”这个要防的问题反而在最需要它的窄预算下发生。
+        const skeletonQuota = Math.max(1, Math.floor(nodeCap * EXPLORER_QUOTA_SKELETON));
+        const freshQuota = Math.max(1, Math.floor(nodeCap * EXPLORER_QUOTA_FRESH));
+        // 1) 骨架层:score 降序(孤立点 score=0 自然沉底,不会白占主干名额)
+        for (const n of [...visNodes].sort(byScore)) {
+            if (skeleton >= skeletonQuota)
+                break;
+            if (chosen.has(n.id))
+                continue;
+            chosen.add(n.id);
+            skeleton += 1;
+        }
+        // 2) 新鲜层:updatedAt 倒序,含 degree=0 的新点
+        for (const n of [...visNodes].sort(byFresh)) {
+            if (fresh >= freshQuota)
+                break;
+            if (chosen.has(n.id))
+                continue;
+            chosen.add(n.id);
+            fresh += 1;
+        }
+        // 3) 长尾层:剩余名额按 score 补满
+        for (const n of [...visNodes].sort(byScore)) {
+            if (chosen.size >= nodeCap)
+                break;
+            if (chosen.has(n.id))
+                continue;
+            chosen.add(n.id);
+            tail += 1;
+        }
+    }
+    // 输出保持入参顺序(loadGraph 行序),与 buildFullView 的截断语义同形
+    const outNodes = visNodes
+        .filter((n) => chosen.has(n.id))
+        .map((n) => ({ id: n.id, name: n.name, type: n.type }));
+    // ── 边选择:两端入选 → 因果优先 → 两端 score 和降序 → id 升序兜底 ──
+    const candidates = edges.filter((e) => e.status === 'active' && chosen.has(e.fromNodeId) && chosen.has(e.toNodeId));
+    const totalEdges = candidates.length;
+    const ranked = [...candidates].sort((a, b) => {
+        const ca = CAUSAL_SET.has(a.relation) ? 1 : 0;
+        const cb = CAUSAL_SET.has(b.relation) ? 1 : 0;
+        if (ca !== cb)
+            return cb - ca;
+        const sa = (dm.degree.get(a.fromNodeId) ?? 0) + (dm.degree.get(a.toNodeId) ?? 0)
+            + ((dm.causal.get(a.fromNodeId) ?? 0) + (dm.causal.get(a.toNodeId) ?? 0)) * GRAPH_PREVIEW_CAUSAL_WEIGHT;
+        const sb = (dm.degree.get(b.fromNodeId) ?? 0) + (dm.degree.get(b.toNodeId) ?? 0)
+            + ((dm.causal.get(b.fromNodeId) ?? 0) + (dm.causal.get(b.toNodeId) ?? 0)) * GRAPH_PREVIEW_CAUSAL_WEIGHT;
+        if (sa !== sb)
+            return sb - sa;
+        return a.id < b.id ? -1 : 1;
+    });
+    const edgesTruncated = ranked.length > edgeCap;
+    const outEdges = ranked.slice(0, edgeCap).map((e) => ({
+        from: e.fromNodeId,
+        to: e.toNodeId,
+        relation: e.relation,
+        causal: CAUSAL_SET.has(e.relation),
+    }));
+    return {
+        nodes: outNodes,
+        edges: outEdges,
+        truncated: nodesTruncated || edgesTruncated,
+        counts: { skeleton, fresh, tail },
+        totalVisible: visNodes.length,
+        totalEdges,
+    };
+}

package/dist/settings.js

@@ -90,6 +90,8 @@ const ALWAYS_ON = {
     memportEnabled: false,
     // 时效分级门2 灰度开关:默认关(注入与改前逐字一致)
     validityTiering: false,
+    // 记忆库侧栏入口:默认开(用户装了插件就能看到)
+    explorerEnabled: true,
     // md 投射护栏运行时覆盖:0 = 跟随部署 cfg.memExport.maxRecords（面板上可改）
     mdExportMaxRecords: 0,
     // 回填并行度运行时覆盖:0 = 跟随部署 cfg.backfill.concurrency（概览页滑块可改）
@@ -339,6 +341,7 @@ function resolveSettings(value) {
         mdSyncEnabled: v.mdSyncEnabled === true,
         memportEnabled: v.memportEnabled === true,
         validityTiering: v.validityTiering === true,
+        explorerEnabled: v.explorerEnabled !== false, // 默认 true，只有显式 false 才关
         // md 投射护栏钳 0~10000（与 live schema 同上限）；0 = 跟随部署默认
         mdExportMaxRecords: Math.min(10_000, Math.max(0, num(v.mdExportMaxRecords))),
         // 回填并行度钳 0~8（与 live schema 同上限）；0 = 跟随部署 cfg.backfill.concurrency