dsh-prime-memory 0.26.30 → 0.26.32

package/dist/pipeline/intra-dedupe.js

@@ -176,6 +176,21 @@ export function clusterByVector(items, vectors, tau) {
     });
     return finish(items, clusters);
 }
+/**
+ * 把「被吸收 → 代表」关系映射成 receipt 输入项。
+ *
+ * 为什么用既有 `kind='merge'` + `candidateIds=[代表 id]` 而不新增表列/词表即可：
+ * 吸收本质上就是「本条被并入另一条」，`merge` 正是这个词；`candidateIds` 载代表项 id，
+ * 于是「本条被批内哪条吸收」只需一次 `(runId, recordId)` 回溯（inputDigest 含代表 id）。
+ * 关闭特性时 `absorbedBy` 为空 ⇒ 不产生任何额外行（凭证与改动前逐字节一致）。
+ */
+export function receiptItemsForAbsorbed(absorbedBy) {
+    return Object.entries(absorbedBy).map(([absorbedId, repId]) => ({
+        recordId: absorbedId,
+        candidateIds: [repId],
+        action: 'merge',
+    }));
+}
 /**
  * 一次完成：精确层 → （可选）向量层，并把“代表项→向量”与“被吸收→代表”两表一并交回。
  *

package/dist/pipeline/l1.js

@@ -16,7 +16,7 @@ import { normTags, normUsageScenario, readCognitiveHall, readWing } from '../met
 import { acceptTitle } from '../util/md-name.js';
 import { clampPriority } from '../util/priority.js';
 import { formatBatchConflictPrompt, getConflictDetectionSystemPrompt } from '../prompts/l1-dedup.js';
-import { preDedupeBatch } from './intra-dedupe.js';
+import { preDedupeBatch, receiptItemsForAbsorbed } from './intra-dedupe.js';
 import { resolveSourceAnchors, withSourceAnchors } from './anchors.js';
 import { stampValidity, validToSourceOf } from '../store/validity.js';
 import { familyForType, normPersistence, normScope, resolveRecordFamily, resolveRecordScope, WING_FALLBACK } from '../types.js';
@@ -542,11 +542,7 @@ routeHealth) {
         // 唯一零痕迹分支，批内吸收不能重蹈）。用既有 `kind='merge'` + candidateIds=[代表 id]：
         // 不新增表列、不扩词表，回答“本条被批内哪条吸收”只需一次 (runId, recordId) 回溯。
         // 关闭特性时 intraAbsorbedBy 为空 ⇒ 凭证与改动前逐字节一致。
-        const absorbedItems = Object.entries(intraAbsorbedBy).map(([absorbedId, repId]) => ({
-            recordId: absorbedId,
-            candidateIds: [repId],
-            action: 'merge',
-        }));
+        const absorbedItems = receiptItemsForAbsorbed(intraAbsorbedBy);
         const rows = buildReceipts(runId, new Date().toISOString(), [...items, ...absorbedItems]);
         persistReceiptsSafely((rows) => store.recordReceipts(rows), rows, logger);
         // §F 追踪捎带:六值决策词表聚合(与凭证同源,runner 侧并入 distill_run 事件)

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

package/dist/stats.d.ts

@@ -168,8 +168,9 @@ export interface EndpointDeps {
 /** 端点分发表(导出供测试直调:可精确注入 rebuild/ruminate 等可选控制器,验证 deps 接线)。 */
 export declare function handleEndpoint(endpoint: string, payload: unknown, deps: EndpointDeps): Promise<unknown>;
 /** 浏览器卡片字段(比 MemoryRecord 精简,去掉大 metadata;Hall 从 metadata 提取)。 */
-/** 老化权重(与读路径 applyDecayWeight 同式):max(0.5, 0.5^(Δ天/半衰期));半衰期 ≤0 = 关 → null。 */
-export declare function agingWeightOf(updatedAtMs: number | undefined, halfLifeDays: number, now?: number): number | null;
+/** 老化权重(与读路径 applyDecayWeight 同式):max(floor, 0.5^(Δ天/半衰期));半衰期 ≤0 = 关 → null。
+ *  `floor` 缺省 0.5(召回/列表旧口径不变);星图传 0.2 以拉开更细的新年差异。 */
+export declare function agingWeightOf(updatedAtMs: number | undefined, halfLifeDays: number, now?: number, floor?: number): number | null;
 export declare function hitToUiRecord(r: {
     id: string;
     content: string;

package/dist/stats.js

@@ -109,6 +109,7 @@ export const MEMORY_ENDPOINTS = [
     'dsh-memory/graph-search',
     'dsh-memory/graph-node-get',
     'dsh-memory/graph-preview',
+    'dsh-memory/record-links',
     'dsh-memory/graph-cleanup-dead',
     'dsh-memory/scenes',
     'dsh-memory/persona',
@@ -1415,6 +1416,7 @@ export async function handleEndpoint(endpoint, payload, deps) {
                     mdSyncEnabled: live?.get()?.mdSyncEnabled === true,
                     memportEnabled: live?.get()?.memportEnabled === true,
                     validityTiering: live?.get()?.validityTiering === true,
+                    explorerEnabled: live?.get()?.explorerEnabled !== false, // 默认 true
                     mdExportMaxRecords: live?.get()?.mdExportMaxRecords ?? 0,
                     backfillConcurrency: live?.get()?.backfillConcurrency ?? 0,
                 }),
@@ -1461,7 +1463,7 @@ export async function handleEndpoint(endpoint, payload, deps) {
             const patch = (payload ?? {});
             const clean = {};
             // 布尔开关组:memoryMutate(高权限写删门)与主开关同列;conflictFreeze(§C 人工冲突裁决)
-            for (const key of ['enabled', 'capture', 'distill', 'recall', 'memoryMutate', 'conflictFreeze', 'skillsEnabled', 'graphEnabled', 'keywordEnabled', 'redistillEnabled', 'mdSyncEnabled', 'memportEnabled', 'toolRoom', 'toolGraph', 'toolRuminate', 'toolConflict', 'toolMutate', 'toolSkills']) {
+            for (const key of ['enabled', 'capture', 'distill', 'recall', 'memoryMutate', 'conflictFreeze', 'skillsEnabled', 'graphEnabled', 'keywordEnabled', 'redistillEnabled', 'mdSyncEnabled', 'memportEnabled', 'explorerEnabled', 'toolRoom', 'toolGraph', 'toolRuminate', 'toolConflict', 'toolMutate', 'toolSkills']) {
                 if (typeof patch[key] === 'boolean')
                     clean[key] = patch[key];
             }
@@ -2117,7 +2119,80 @@ export async function handleEndpoint(endpoint, payload, deps) {
                 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);
+            // 老化 + 出处两条展示通道：节点无自己的老化/场景——都属于来源记录。
+            // 一次 sourceMeta() 同时供两算：aging 取最新存活来源的 agingWeight（下限 0.2 拉开亮度）；
+            // source 取主场景名（provenance fallback，B 方案落库后退为兜底）。无值→不挂键（可选键零漂移）。
+            let agingOf;
+            let sourceOf;
+            if (mode === 'full') {
+                const halfLife = stores.l1.decayHalfLife;
+                const meta = graph.sourceMeta();
+                sourceOf = (id) => meta.get(id)?.scene ?? null;
+                if (halfLife > 0) {
+                    agingOf = (id) => {
+                        const m = meta.get(id);
+                        // 星图专用下限 0.2：让 0.2~1 的亮度差异可见（召回/列表仍用缺省 0.5，不受影响）。
+                        return m == null ? null : agingWeightOf(m.ms, halfLife, undefined, 0.2);
+                    };
+                }
+            }
+            return graph.buildPreview(seedId, mode, agingOf, sourceOf);
+        }
+        case 'dsh-memory/record-links': {
+            // 记忆库入口的关联跳转(记录 → 实体 → 关系 → 其它记录)。图侧一次 loadGraph 供三算
+            // (见 GraphStore.buildExplorer),记录侧在这里装配:UiRecord 的 agingWeight / usage /
+            // maturity 必须与 list-records **同口径**,否则同一个入口与设置页会给出两套数。
+            const p = (payload ?? {});
+            const recordId = typeof p.recordId === 'string' ? p.recordId.trim().slice(0, 200) : '';
+            // hops/limit 不在这里重复钳制——钳制判据单源在 graph/record-links.ts。
+            const hops = typeof p.hops === 'number' ? p.hops : undefined;
+            const limit = typeof p.limit === 'number' ? p.limit : undefined;
+            const graph = stores.graph;
+            const emptyResp = {
+                record: null,
+                entities: [],
+                neighbors: [],
+                records: [],
+                supersede: { prevIds: [], nextId: null },
+                truncated: false,
+            };
+            // 图谱未启用 / 记录不存在 / 该记录尚未投影:都是正常态而非错误态,统一回空结构不抛。
+            if (!graph || !recordId)
+                return emptyResp;
+            const { links } = graph.buildExplorer(recordId, { hops, limit });
+            const rawById = new Map(stores.l1.getByIds([recordId, ...links.neighborRecordIds]).map((r) => [r.id, r]));
+            const toUi = (id) => {
+                const r = rawById.get(id);
+                if (!r)
+                    return null;
+                return hitToUiRecord(r, {
+                    agingWeight: agingWeightOf(r.updatedAt, stores.l1.decayHalfLife),
+                    usage: stores.usage?.get(r.id) ?? null,
+                    userRelevance: stores.feedback?.meanOf(r.id) ?? null,
+                    userMark: stores.feedback?.lastOf(r.id) ?? null,
+                });
+            };
+            const record = toUi(recordId);
+            const records = [];
+            for (const id of links.neighborRecordIds) {
+                const u = toUi(id);
+                if (u)
+                    records.push(u);
+            }
+            // 取代链方向由 marker 的位置决定:dsh_superseded **写在退场的旧行上**、by 指向新行。
+            // 故 nextId 读本行的 marker(单值)、prevIds 走反向查(数组,LIKE 全扫缝)。
+            const nextId = readSupersedeMarker(rawById.get(recordId)?.metadata)?.by ?? null;
+            const prevIds = stores.l1.findSupersededTargets(recordId);
+            if (!record && links.entities.length === 0)
+                return { ...emptyResp, records, truncated: links.truncated };
+            return {
+                record,
+                entities: links.entities,
+                neighbors: links.neighbors,
+                records,
+                supersede: { prevIds, nextId },
+                truncated: links.truncated,
+            };
         }
         case 'dsh-memory/graph-cleanup-dead': {
             const graph = stores.graph;
@@ -2429,12 +2504,13 @@ export async function handleEndpoint(endpoint, payload, deps) {
     }
 }
 /** 浏览器卡片字段(比 MemoryRecord 精简,去掉大 metadata;Hall 从 metadata 提取)。 */
-/** 老化权重(与读路径 applyDecayWeight 同式):max(0.5, 0.5^(Δ天/半衰期));半衰期 ≤0 = 关 → null。 */
-export function agingWeightOf(updatedAtMs, halfLifeDays, now = Date.now()) {
+/** 老化权重(与读路径 applyDecayWeight 同式):max(floor, 0.5^(Δ天/半衰期));半衰期 ≤0 = 关 → null。
+ *  `floor` 缺省 0.5(召回/列表旧口径不变);星图传 0.2 以拉开更细的新年差异。 */
+export function agingWeightOf(updatedAtMs, halfLifeDays, now = Date.now(), floor = 0.5) {
     if (!(halfLifeDays > 0))
         return null;
     const ageDays = Math.max(0, (now - (updatedAtMs ?? 0)) / 86_400_000);
-    return Math.max(0.5, Math.pow(0.5, ageDays / halfLifeDays));
+    return Math.max(floor, Math.pow(0.5, ageDays / halfLifeDays));
 }
 export function hitToUiRecord(r, extra) {
     // 退场判据 marker 单源(门1 解耦,与 `isRetired`/`retiredL1Sql` 同口径)。

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

@@ -1,6 +1,8 @@
 import type { DatabaseSync } from 'node:sqlite';
 import { buildFullView } from '../graph/preview.js';
 import type { GraphPreviewResult } from '../graph/preview.js';
+import type { RecordLinksResult } from '../graph/record-links.js';
+import type { ExplorerSelection } from '../graph/select.js';
 import type { GraphEdge, GraphNode, GraphNodeSearchResult, GraphProjectionJob, GraphProjectionResult } from '../graph/types.js';
 import type { MemoryFamily, MemoryLogger, MemoryRecord } from '../types.js';
 /**
@@ -123,10 +125,44 @@ export declare class GraphStore {
      * 降级(db 未就绪)返**全零结构**不抛——预览是展示面,永不拖垮端点。
      * mode==='full' 时响应附 `full` 轻量块;**缺省时该键缺席**(可选键零漂移纪律,
      * 不是 undefined 占位——消费方 `'full' in res` 与 JSON 形状双判据都干净)。
+     * `agingOf`/`sourceOf` 仅在 mode==='full' 时生效(星图亮度与出处通道):本层不认识 L1,
+     * 由端点层查来源记录后注入判据(nodeId → aging | null / 场景名 | null)。
      */
-    buildPreview(seedId?: string, mode?: 'full'): GraphPreviewResult & {
+    buildPreview(seedId?: string, mode?: 'full', agingOf?: (id: string) => number | null, sourceOf?: (id: string) => string | null): GraphPreviewResult & {
         full?: ReturnType<typeof buildFullView>;
     };
+    /**
+     * 节点 → 存活来源记录的最新时间 + 主场景标签。
+     * `graph-preview(mode:'full')` 老化与出处两条展示通道的数据源：
+     *   - `ms`：最新存活来源的 `updated_time`（老化属于记录不属于投影节点，端点层据此算 agingWeight）；
+     *   - `scene`：来源记录中出现最多的非空 `scene_name`（provenance fallback：人物实体靠场景回溯“在哪提到的”，
+     *     如“字节Code M岗位”；无场景则 null，不猜）。B 方案（投影期落库 context）上线后本项退为兜底。
+     * 只认有值的行：全来源无有效时间戳的节点**不进表**。降级返空表不抛。
+     */
+    sourceMeta(): Map<string, {
+        ms: number;
+        scene: string | null;
+    }>;
+    /**
+     * 投影作业三档计数(预览与记忆库视图共用同一分母)。
+     * db 未就绪或计数失败一律回零并 warn——计数是展示面,不值得拖垮端点。
+     */
+    private jobCounts;
+    /**
+     * 记忆库视图存储缝(契约 `dsh-memory/record-links` 的图侧数据源)。
+     *
+     * **一次 `loadGraph()` 供三算**(种子榜 / 元素选择 / 关联反查):三者必须看到
+     * 同一份图,否则会出现“画布上有这个节点、关联清单里查不到”或反之——那比慢
+     * 一点严重点。记录侧(UiRecord 装配与取代链)在 stats 端点层做,本方法不碰 l1 表。
+     */
+    buildExplorer(recordId?: string, opts?: {
+        hops?: number;
+        limit?: number;
+    }): {
+        preview: GraphPreviewResult;
+        view: ExplorerSelection;
+        links: RecordLinksResult;
+    };
     /**
      * 清理历史 dead 作业行（纯审计痕迹删除，不影响已重入队的记录）。
      * olderThanMs: 只删早于 now-olderThanMs 的；缺省删全部 dead。

package/dist/store/graph-store.js

@@ -21,6 +21,8 @@ import { randomBytes } from 'node:crypto';
 import { applyGraphProjection } from '../graph/apply.js';
 import { expandHitRecordIds, searchGraphNodes } from '../graph/search.js';
 import { buildFullView, buildGraphPreview } from '../graph/preview.js';
+import { buildRecordLinks } from '../graph/record-links.js';
+import { selectExplorerNodes } from '../graph/select.js';
 import { GRAPH_JOB_BACKOFF_BASE_MS, GRAPH_JOB_BATCH, GRAPH_JOB_MAX_ATTEMPTS, GRAPH_JOB_TRANSIENT_MAX_ATTEMPTS, GRAPH_PRIORITY_BACKFILL, GRAPH_PRIORITY_NEW, GRAPH_PROJECTOR_VERSION, GRAPH_VEC_SEED_CAP, } from '../graph/types.js';
 import { normPersistence } from '../types.js';
 import { classifyValidity, isExitedState, validToSourceOf } from './validity.js';
@@ -510,29 +512,133 @@ export class GraphStore {
      * 降级(db 未就绪)返**全零结构**不抛——预览是展示面,永不拖垮端点。
      * mode==='full' 时响应附 `full` 轻量块;**缺省时该键缺席**(可选键零漂移纪律,
      * 不是 undefined 占位——消费方 `'full' in res` 与 JSON 形状双判据都干净)。
+     * `agingOf`/`sourceOf` 仅在 mode==='full' 时生效(星图亮度与出处通道):本层不认识 L1,
+     * 由端点层查来源记录后注入判据(nodeId → aging | null / 场景名 | null)。
      */
-    buildPreview(seedId, mode) {
+    buildPreview(seedId, mode, agingOf, sourceOf) {
         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;
+        const { pendingJobs, jobsTotal, deadJobs } = this.jobCounts();
+        const r = buildGraphPreview(nodes, edges, { seedId, pendingJobs, jobsTotal, deadJobs, missing: this.countMissing() });
+        if (mode === 'full')
+            return { ...r, full: buildFullView(nodes, edges, { agingOf, sourceOf }) };
+        return r;
+    }
+    /**
+     * 节点 → 存活来源记录的最新时间 + 主场景标签。
+     * `graph-preview(mode:'full')` 老化与出处两条展示通道的数据源：
+     *   - `ms`：最新存活来源的 `updated_time`（老化属于记录不属于投影节点，端点层据此算 agingWeight）；
+     *   - `scene`：来源记录中出现最多的非空 `scene_name`（provenance fallback：人物实体靠场景回溯“在哪提到的”，
+     *     如“字节Code M岗位”；无场景则 null，不猜）。B 方案（投影期落库 context）上线后本项退为兜底。
+     * 只认有值的行：全来源无有效时间戳的节点**不进表**。降级返空表不抛。
+     */
+    sourceMeta() {
+        const out = new Map();
+        if (!this.db)
+            return out;
+        try {
+            const { nodes } = this.loadGraph();
+            const sources = new Set();
+            for (const n of nodes)
+                for (const id of n.sourceRecordIds)
+                    sources.add(id);
+            if (sources.size === 0)
+                return out;
+            const updatedById = new Map();
+            const sceneById = new Map();
+            for (const chunk of chunkOf([...sources])) {
+                const ph = chunk.map(() => '?').join(',');
+                for (const row of this.db
+                    .prepare(`SELECT record_id, updated_time, scene_name FROM l1_records WHERE record_id IN (${ph})`)
+                    .all(...chunk)) {
+                    const ms = Date.parse(String(row.updated_time ?? ''));
+                    if (Number.isFinite(ms))
+                        updatedById.set(row.record_id, ms);
+                    const sc = String(row.scene_name ?? '').trim();
+                    if (sc)
+                        sceneById.set(row.record_id, sc);
+                }
+            }
+            for (const n of nodes) {
+                let latest = -1;
+                const tally = new Map();
+                for (const id of n.sourceRecordIds) {
+                    const ms = updatedById.get(id);
+                    if (ms != null)
+                        latest = Math.max(latest, ms);
+                    const sc = sceneById.get(id);
+                    if (sc)
+                        tally.set(sc, (tally.get(sc) ?? 0) + 1);
+                }
+                if (latest < 0)
+                    continue; // 无有效时间戳：不挂（aging 与 scene 同进退）
+                let scene = null;
+                let best = 0;
+                for (const [s, c] of tally)
+                    if (c > best) {
+                        best = c;
+                        scene = s;
+                    }
+                out.set(n.id, { ms: latest, scene });
+            }
+            return out;
+        }
+        catch (err) {
+            this.logger?.warn(`${TAG} 来源元信息读取失败(老化/出处通道整轮缺省): ${err instanceof Error ? err.message : String(err)}`);
+            return new Map();
+        }
+    }
+    /**
+     * 投影作业三档计数(预览与记忆库视图共用同一分母)。
+     * db 未就绪或计数失败一律回零并 warn——计数是展示面,不值得拖垮端点。
+     */
+    jobCounts() {
+        const db = this.db;
+        if (!db)
+            return { pendingJobs: 0, jobsTotal: 0, 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;
+            const count = (where) => db.prepare(`SELECT COUNT(1) AS c FROM graph_projection_jobs${where}`).get().c;
+            return {
+                pendingJobs: count(` WHERE status IN ('pending','running','failed')`),
+                jobsTotal: count(''),
+                deadJobs: count(` WHERE status = 'dead'`),
+            };
         }
         catch (err) {
-            this.logger?.warn(`${TAG} 预览 job 计数失败(计数回零): ${err instanceof Error ? err.message : String(err)}`);
+            this.logger?.warn(`${TAG} job 计数失败(计数回零): ${err instanceof Error ? err.message : String(err)}`);
+            return { pendingJobs: 0, jobsTotal: 0, deadJobs: 0 };
         }
-        const r = buildGraphPreview(nodes, edges, { seedId, pendingJobs, jobsTotal, deadJobs, missing: this.countMissing() });
-        if (mode === 'full')
-            return { ...r, full: buildFullView(nodes, edges) };
-        return r;
+    }
+    /**
+     * 记忆库视图存储缝(契约 `dsh-memory/record-links` 的图侧数据源)。
+     *
+     * **一次 `loadGraph()` 供三算**(种子榜 / 元素选择 / 关联反查):三者必须看到
+     * 同一份图,否则会出现“画布上有这个节点、关联清单里查不到”或反之——那比慢
+     * 一点严重点。记录侧(UiRecord 装配与取代链)在 stats 端点层做,本方法不碰 l1 表。
+     */
+    buildExplorer(recordId, opts = {}) {
+        const emptyStats = { nodes: 0, edges: 0, causalEdges: 0, pendingJobs: 0, jobsTotal: 0 };
+        if (!this.db) {
+            return {
+                preview: { seeds: [], stats: emptyStats },
+                view: {
+                    nodes: [], edges: [], truncated: false,
+                    counts: { skeleton: 0, fresh: 0, tail: 0 }, totalVisible: 0, totalEdges: 0,
+                },
+                links: { entities: [], neighbors: [], neighborRecordIds: [], truncated: false },
+            };
+        }
+        const { nodes, edges } = this.loadGraph();
+        const jc = this.jobCounts();
+        return {
+            preview: buildGraphPreview(nodes, edges, {
+                pendingJobs: jc.pendingJobs, jobsTotal: jc.jobsTotal, deadJobs: jc.deadJobs, missing: this.countMissing(),
+            }),
+            view: selectExplorerNodes(nodes, edges),
+            links: buildRecordLinks(nodes, edges, recordId ?? '', opts),
+        };
     }
     /**
      * 清理历史 dead 作业行（纯审计痕迹删除，不影响已重入队的记录）。

package/dsh.plugin.json

@@ -1,7 +1,7 @@
 {
   "id": "dsh-prime-memory",
   "name": "dsh-prime-memory",
-  "version": "0.26.30",
+  "version": "0.26.32",
   "description": {
     "en": "Layered distilled memory plugin (L0 capture → L1 atomic memory → L2 scenes → L3 persona) with automatic recall injection before each model step.",
     "zh": "L0~L3 分层蒸馏记忆插件:自动捕获对话、抽取原子记忆、整合场景块、蒸馏核心画像,并在模型步骤前自动召回注入。"

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "dsh-prime-memory",
-  "version": "0.26.30",
+  "version": "0.26.32",
   "publishConfig": {
     "registry": "https://registry.npmjs.org",
     "access": "public",