dsh-prime-memory 0.22.2 → 0.24.0

package/dist/stats.js

@@ -15,6 +15,7 @@ import { createRequire } from 'node:module';
 import { closeSync, openSync, readSync, statSync } from 'node:fs';
 import { join } from 'node:path';
 import { EFFORT_CHOICES, resolveDataDir } from './config.js';
+import { typeCatalogEntries } from './memory-types.js';
 import { effectiveCfg } from './pipeline/runner.js';
 import { emptyRecallStats } from './hooks/recall.js';
 import { buildRouteChain, decideSendableEffort, LAYER_DEFAULT_BUDGETS, layerChainOrNull, resolveModelContextWindow, resolveModelEfforts, resolveModelRoute } from './llm.js';
@@ -35,6 +36,15 @@ import { startWingBackfill } from './wing-backfill.js';
 import { errDetail } from './util/filelog.js';
 import { snapshotTokenCost } from './token-cost.js';
 import { computeMaturity } from './util/maturity.js';
+import { isFeedbackScore } from './store/recall-feedback.js';
+import { relinkWorkspaces } from './pipeline/workspace-relink.js';
+import { exportRecords, reconcileLedger } from './store/memory-md-export.js';
+import { disableProjectionFile } from './store/memory-md-disable.js';
+import { MEMORY_TYPE_DIRS, UNSORTED_DIR, resolveMemoriesRoot, targetFor } from './store/memory-md.js';
+import { ensureTypeSkeleton } from './store/memory-md-skeleton.js';
+import { sweepOrphanFiles } from './store/memory-md-orphan.js';
+import { collectProjectionFiles } from './store/memory-md-archive.js';
+import { syncFromFiles } from './pipeline/md-sync.js';
 const require = createRequire(import.meta.url);
 export const PLUGIN_VERSION = require('../package.json').version;
 /**
@@ -101,6 +111,12 @@ export const MEMORY_ENDPOINTS = [
     'dsh-memory/memport-scan',
     'dsh-memory/skills-list',
     'dsh-memory/session-recalled',
+    'dsh-memory/recall-feedback',
+    'dsh-memory/workspace-relink',
+    'dsh-memory/mem-export',
+    'dsh-memory/mem-reconcile',
+    'dsh-memory/mem-sync',
+    'dsh-memory/mem-orphans',
     'dsh-memory/skills-action',
 ];
 /** HTTP 路由前缀(客户端 fetch `/dsh-memory/rpc/<短方法名>`)。 */
@@ -138,6 +154,23 @@ function writeJson(res, status, body) {
     res.writeHead(status, { 'content-type': 'application/json' });
     res.end(JSON.stringify(body));
 }
+/**
+ * 面板检索软超时（用户裁决：删除后检索面短暂变慢不得挂死面板）：竞速到期即
+ * 返回业务错误（客户端显示可重试的提示，而不是永远「加载中」）。底层检索
+ * 稍后自然完成时其结果被 race 吸收，不产生未处理拒绝。
+ */
+function raceTimeout(p, ms, message) {
+    let timer;
+    const timeout = new Promise((_, reject) => {
+        timer = setTimeout(() => reject(new Error(message)), ms);
+    });
+    return Promise.race([p, timeout]).finally(() => {
+        if (timer !== undefined)
+            clearTimeout(timer);
+    });
+}
+/** 面板关键词检索的软超时上限：正常检索是毫秒级，8s 足够宽裕。 */
+const SEARCH_SOFT_TIMEOUT_MS = 8_000;
 /** 读取 JSON 请求体(上限 8MB:面板最大载荷为 list-records 分页与图谱检索)。 */
 function readJsonBody(req) {
     return new Promise((resolve, reject) => {
@@ -402,19 +435,232 @@ export async function handleEndpoint(endpoint, payload, deps) {
             return v;
         }
         case 'dsh-memory/session-recalled': {
-            // G-live：返回本会话（按 ownerId）已注入、尚未被压缩覆盖的召回记忆。
+            // G-live：返回本会话（按 sessionKey，与投影 header.id / pill sessionId 同源）已注入、
+            // 尚未被压缩覆盖的召回记忆。
             const p = (payload ?? {});
             const sessionId = expectSessionId(p.sessionId);
             const ids = stores.recalled?.list(sessionId) ?? [];
             if (ids.length === 0)
-                return { sessionId, records: [] };
+                return { sessionId, records: [], typeCatalog: typeCatalogEntries() };
+            // 压缩水位之上的那批：正文已被摘要取代。与 retired 正交（真实实现见 session-recalled.ts）。
+            const superseded = stores.recalled?.supersededOf(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
                 .map((id) => byId.get(id))
                 .filter((r) => r !== undefined)
-                .map((r) => hitToUiRecord(r, { agingWeight: agingWeightOf(r.updatedAt, halfLife), usage: stores.usage?.get(r.id) ?? null }));
-            return { sessionId, records };
+                .map((r) => {
+                const ui = hitToUiRecord(r, {
+                    agingWeight: agingWeightOf(r.updatedAt, halfLife),
+                    usage: stores.usage?.get(r.id) ?? null,
+                    userRelevance: stores.feedback?.meanOf(r.id) ?? null,
+                    userMark: stores.feedback?.lastOf(r.id) ?? null,
+                });
+                return superseded?.has(r.id) === true ? { ...ui, superseded: true } : ui;
+            });
+            return { sessionId, records, typeCatalog: typeCatalogEntries() };
+        }
+        case 'dsh-memory/recall-feedback': {
+            // 人在召回卡上给一条召回记忆打分：0..5 = 相关度（只聚合，不改写任何排序分）；
+            // -1 = 声明过时，做两件事：退场该记录（软删可恢复）+ 排一条下一轮向模型的播报
+            //（取走即离队，不常驻）。条目**不**从本会话活召回集摘掉——它得留在列表里显示删除线。
+            if (cfg.recallFeedback?.enabled !== true)
+                throw new Error('召回反馈未开启（cfg.recallFeedback.enabled）');
+            const feedback = stores.feedback;
+            if (feedback === undefined)
+                throw new Error('召回反馈存储未装配');
+            const p = (payload ?? {});
+            const sessionId = expectSessionId(typeof p.sessionId === 'string' ? p.sessionId : undefined);
+            if (typeof p.id !== 'string' || p.id.length === 0)
+                throw new Error('id 缺失');
+            if (p.id.length > 512)
+                throw new Error('id 过长(≤512 字符)');
+            const id = p.id;
+            if (!isFeedbackScore(p.score))
+                throw new Error('score 必须是 -1 或 0..5');
+            // 结构性护栏（代替全局高权限模式）：只能给**本会话真召回过、且还活着**的记录打分。
+            // 否则一个面对 web 的写端点就能退场任意 id；而这张卡上本来也只列得出这些。
+            const alive = stores.recalled?.list(sessionId) ?? [];
+            if (!alive.includes(id))
+                throw new Error('该记忆不在本会话的召回集里（可能已被压缩覆盖）');
+            const entry = feedback.rate(id, p.score);
+            let retired = false;
+            let announced = false;
+            // 退场**前**的记录快照（带 workspaceId/name）——失效联动要靠它算落点，
+            // 而 `retire` 只改 `valid_to`，不会动这两列，所以取在退场前后等价，取在前更直白。
+            let rec;
+            if (p.score === -1) {
+                rec = stores.l1.getByIds([id])[0];
+                const retiredAt = new Date().toISOString();
+                retired = stores.l1.retire([id], { at: retiredAt, reason: 'obsolete' }) > 0;
+                // 不再摘除：条目要留在列表里显示删除线。检索侧已由 detachL1FromRetrieval 阻断再注入。
+                // 并且标成**受保护**：这张列表不再被压缩清掉，但仍有上限淘汰——判过时的条目
+                // 是人的裁决凭证，不能因为“后面又召回了几条”而被挤出去。
+                stores.recalled?.protect(sessionId, [id]);
+                if (cfg.recallFeedback?.announce !== false && stores.notices !== undefined && rec !== undefined) {
+                    const title = (rec.content.split('\n').find((l) => l.trim().length > 0) ?? rec.content).trim().slice(0, 120);
+                    stores.notices.push(sessionId, { id, title, at: Date.now() });
+                    announced = true;
+                }
+                deps.logger.info(`[memory] 用户声明记忆过时并退场(session=${sessionId}, ${retired ? '已退场' : '本已退场'}): ${id}`);
+                // 失效联动（N11，用户裁决改异步）：退场成立后**后台**去动投射文件——
+                // 文件改名/建凭证不再阻塞本 RPC（面板只等库侧结果）；它内部已收敛所有
+                // 失败为 'failed'，这里再兜一层 catch 只落日志。响应不再带 fileDisabled
+                // （面板无消费方），磁盘凭证的对账走 mem-reconcile。
+                if (retired && rec !== undefined && cfg.memExport?.enabled === true && stores.mdLedger !== undefined) {
+                    void disableProjectionFile({
+                        // 传退场**后**的快照：渲染出的 frontmatter 才带 `retired: true`，
+                        // 凭证自己就能说清它为什么存在。
+                        record: { ...rec, validTo: Date.parse(retiredAt) || Date.now() },
+                        cfgRoot: cfg.memExport.root,
+                        dataDir: deps.dataDir,
+                        ledger: stores.mdLedger,
+                        logger: deps.logger,
+                    })
+                        .then((outcome) => deps.logger.info(`[memory] 投射文件失效联动(后台): ${id} → ${outcome}`))
+                        .catch((err) => deps.logger.warn(`[memory] 投射文件失效联动(后台)异常: ${err instanceof Error ? err.message : String(err)}`));
+                }
+            }
+            return {
+                id,
+                score: p.score,
+                rating: { last: entry.last, rated: entry.rated, mean: entry.mean, obsolete: entry.obsolete },
+                retired,
+                announced,
+            };
+        }
+        case 'dsh-memory/workspace-relink': {
+            // 存量记忆的 workspace 回填（内容路由）。**缺省干跑**：先看命中率与分布报告，再决定真写。
+            // 真写额外要求高权限门（它改的是库里的列，虽然只改 `workspace_id`）。
+            const wsSrc = effectiveCfg(cfg, live).workspaceSource;
+            if (wsSrc?.enabled !== true)
+                throw new Error('内容路由未开启（cfg.workspaceSource.enabled）');
+            const p = (payload ?? {});
+            const dryRun = p.dryRun !== false;
+            if (!dryRun && live?.get().memoryMutate !== true)
+                throw new Error('真写归属列需要高权限模式（memoryMutate）');
+            return relinkWorkspaces({
+                l1: {
+                    list: (o) => stores.l1.list(o),
+                    setWorkspaceIds: (items) => stores.l1.setWorkspaceIds(items),
+                },
+                routes: wsSrc.routes,
+                dryRun,
+                maxRecords: wsSrc.maxRecords,
+                timeBudgetMs: wsSrc.timeBudgetMs,
+                logger: deps.logger,
+            });
+        }
+        case 'dsh-memory/mem-export': {
+            // 单向导出：库 → md 文件 + 账本。**不写检索面**（用例钉住：导出前后 hashRecords 相同）。
+            // 先查配置门再查装配门：“整面默认关”时该听到的是“没开”，不是“没装配”。
+            const exp = cfg.memExport;
+            if (exp?.enabled !== true)
+                throw new Error('md 投射未开启（cfg.memExport.enabled）');
+            const md = stores.mdLedger;
+            if (md === undefined)
+                throw new Error('md 投射账本未装配');
+            // 命名回填：没名字的记录先拿到全库唯一的 `name`，再算落点。
+            // 不回填就是真机那个形状：1166 条 name 全空、42 条挤进 17 个同名文件，
+            // 文件互相覆盖 + 导出每轮重刷 + 反向同步把一份内容回灌给多条。
+            // 它只写 `name` 列（不在快照哈希字段表里），所以 hashRecords 仍逐字不变。
+            const all = stores.l1.all();
+            const naming = stores.l1.assignMissingNames(all, { persist: true });
+            if (naming.failed > 0) {
+                deps.logger?.warn(`[memory] md 投射命名回填失败 ${naming.failed} 条(下轮导出会重试)`);
+            }
+            // 类型目录骨架（pm-name-distill Phase 4）：37 类目录各放一个 `_index.md`（类名 + 库里条数）。
+            // 目录集合从词表真源派生（在 ensureTypeSkeleton 内），这里只喂 countsByType 与 roots。
+            // 单根必补；workspace 根**按需**——只给本轮 `targetFor` 算出真有落点（inWorkspace）的根补，
+            // 不建空 workspace 根（消失的 workspace 已由 targetFor 护栏退回单根，这里不绕过它造目录树）。
+            // 配置门在前（enabled!==true 已在上头抛错），故关着时该端点根本到不了这里 → 骨架零动作。
+            const countsByType = new Map();
+            const skeletonRoots = new Set([resolveMemoriesRoot(exp.root, deps.dataDir, deps.logger)]);
+            for (const r of all) {
+                const dir = MEMORY_TYPE_DIRS.has(r.type) ? r.type : UNSORTED_DIR;
+                countsByType.set(dir, (countsByType.get(dir) ?? 0) + 1);
+                const t = targetFor(r, exp.root, deps.dataDir, deps.logger);
+                if (t.inWorkspace)
+                    skeletonRoots.add(t.root);
+            }
+            await ensureTypeSkeleton({ roots: [...skeletonRoots], countsByType, logger: deps.logger });
+            const rep = await exportRecords({
+                records: all,
+                cfgRoot: exp.root,
+                dataDir: deps.dataDir,
+                ledger: md,
+                maxRecords: exp.maxRecords,
+                timeBudgetMs: exp.timeBudgetMs,
+                logger: deps.logger,
+            });
+            return { ...rep, named: naming.named, nameFailed: naming.failed };
+        }
+        case 'dsh-memory/mem-reconcile': {
+            // 只读对账：不写库、不写文件，只按账本基线出四态报告（所以不需高权限门）。
+            const exp = cfg.memExport;
+            if (exp?.enabled !== true)
+                throw new Error('md 投射未开启（cfg.memExport.enabled）');
+            const md = stores.mdLedger;
+            if (md === undefined)
+                throw new Error('md 投射账本未装配');
+            return reconcileLedger({
+                records: stores.l1.all(),
+                cfgRoot: exp.root,
+                dataDir: deps.dataDir,
+                ledger: md,
+                maxRecords: exp.maxRecords,
+                timeBudgetMs: exp.timeBudgetMs,
+                logger: deps.logger,
+            });
+        }
+        case 'dsh-memory/mem-sync': {
+            // P2 反向同步：文件 → 库。与导出的**风险不对称**——导出只写文件，本项会写库，
+            // 所以多两道门：要先开投射（没导出过 = 账本为空 = 判不出“谁变了”），要高权限。
+            const syn = cfg.mdSync;
+            if (syn?.enabled !== true)
+                throw new Error('md 反向同步未开启（cfg.mdSync.enabled）');
+            if (cfg.memExport?.enabled !== true)
+                throw new Error('md 反向同步需先开启 md 投射（cfg.memExport.enabled）');
+            if (!live?.get().memoryMutate)
+                throw new Error('记忆写删未开放：请在记忆库面板开启「高权限模式」后才能回灌文件侧修改。');
+            const md = stores.mdLedger;
+            if (md === undefined)
+                throw new Error('md 投射账本未装配');
+            return syncFromFiles({
+                store: stores.l1,
+                ledger: md,
+                cfgRoot: cfg.memExport.root,
+                dataDir: deps.dataDir,
+                maxFiles: syn.maxFiles,
+                timeBudgetMs: syn.timeBudgetMs,
+                logger: deps.logger,
+            });
+        }
+        case 'dsh-memory/mem-orphans': {
+            // P4.4 孤儿归档：只搬“账本记着我们写过、但现在没记录认领它”的投射文件。
+            // 门序与同步侧一致：配置门 → 装配门 → 高权限门（干跑不需要）。**默认干跑**：
+            // 搬文件在用户眼里和删文件差不离，必须显式要。
+            const exp = cfg.memExport;
+            if (exp?.enabled !== true)
+                throw new Error('md 投射未开启（cfg.memExport.enabled）');
+            const md = stores.mdLedger;
+            if (md === undefined)
+                throw new Error('md 投射账本未装配');
+            const p = (payload ?? {});
+            const dryRun = p.dryRun !== false;
+            if (!dryRun && live?.get().memoryMutate !== true) {
+                throw new Error('孤儿文件归档需要高权限模式（memoryMutate）');
+            }
+            return sweepOrphanFiles({
+                records: stores.l1.all(),
+                cfgRoot: exp.root,
+                dataDir: deps.dataDir,
+                ledger: md,
+                dryRun,
+                maxFiles: exp.maxRecords,
+                timeBudgetMs: exp.timeBudgetMs,
+                logger: deps.logger,
+            });
         }
         case 'dsh-memory/session-mode-set': {
             if (!modes)
@@ -1180,12 +1426,16 @@ export async function handleEndpoint(endpoint, payload, deps) {
             const wingCatalog = offset === 0
                 ? [...WING_CATALOG.map((h) => ({ id: h.id, label: h.label })), { id: WING_FALLBACK, label: '跨域' }]
                 : undefined;
+            // 类型词表目录随首屏下发（task_1.5：单一真源在 `memory-types.ts`，client 不手抄）。
+            const typeCatalog = offset === 0 ? typeCatalogEntries() : undefined;
             // 关键词路径:复用检索唯一缝(与召回同源),取回后做场景/Wing 过滤 + 手工分页。
             // 检索侧单次上限 200:分页窗口触达上限时显式标记 truncated(结果可能不完整)。
             if (p.query && p.query.trim()) {
                 const SEARCH_CAP = 200;
                 const wanted = offset + limit + 1;
-                const hits = await stores.l1.search(p.query, Math.min(wanted, SEARCH_CAP), { type: p.type || undefined });
+                // 软超时护栏（用户裁决）：删除/繁重后台动作后的短暂检索迟滞不得把面板
+                // 永久钉在「加载中」。到期返回可重试的业务错误。
+                const hits = await raceTimeout(stores.l1.search(p.query, Math.min(wanted, SEARCH_CAP), { type: p.type || undefined }), SEARCH_SOFT_TIMEOUT_MS, `检索超时(${Math.round(SEARCH_SOFT_TIMEOUT_MS / 1000)}s):检索面短暂繁忙,请重试或缩小关键词`);
                 let filtered = p.scene ? hits.filter((h) => h.scene_name === p.scene) : hits;
                 // Wing / Room 过滤(检索命中不含 metadata):按 id 批量取回元数据后过滤
                 let metaById = null;
@@ -1218,18 +1468,40 @@ export async function handleEndpoint(endpoint, payload, deps) {
                         return true;
                     });
                 }
-                const pageIds = filtered.slice(offset, offset + limit).map((h) => h.id);
-                const updatedById = new Map(stores.l1.getByIds(pageIds).map((r) => [r.id, r.updatedAt]));
+                const page = filtered.slice(offset, offset + limit);
+                const pageIds = page.map((h) => h.id);
+                // 检索命中(`L1SearchHit`)只带 7 个字段,不含 createdAt/timestamps/version/
+                // metadata/validTo——卡片上的「创建/活跃时间」与 R7 来源锚点因此恒为占位值。
+                // 旧缺陷有两层:① 这些字段从未补过;② `metaById` 只在勾了 Wing/tag 过滤时才建,
+                // 于是连 metadata 都不补——锚点在默认视图下永远显示 `-`。这里按 id 回查主表
+                // 做完整水合,与浏览路径同口径;正文/得分仍以命中为准(FTS 可能给的是摘要)。
+                const fullById = new Map(stores.l1.getByIds(pageIds).map((r) => [r.id, r]));
                 const resp = {
-                    items: filtered.slice(offset, offset + limit).map((h) => hitToUiRecord({ ...h, metadata: metaById?.get(h.id) }, {
-                        agingWeight: agingWeightOf(updatedById.get(h.id), stores.l1.decayHalfLife),
-                        usage: stores.usage?.get(h.id) ?? null,
-                    })),
+                    items: page.map((h) => {
+                        const full = fullById.get(h.id);
+                        return hitToUiRecord({
+                            ...full,
+                            id: h.id,
+                            content: h.content,
+                            type: h.type,
+                            priority: h.priority,
+                            scene_name: h.scene_name,
+                            family: h.family,
+                            score: h.score,
+                            metadata: full?.metadata ?? metaById?.get(h.id),
+                        }, {
+                            agingWeight: agingWeightOf(full?.updatedAt, stores.l1.decayHalfLife),
+                            usage: stores.usage?.get(h.id) ?? null,
+                            userRelevance: stores.feedback?.meanOf(h.id) ?? null,
+                            userMark: stores.feedback?.lastOf(h.id) ?? null,
+                        });
+                    }),
                     hasMore: filtered.length > offset + limit,
                     total: null,
                     truncated: wanted > SEARCH_CAP,
                     scenes: offset === 0 ? stores.l1.distinctScenes() : undefined,
                     wingCatalog,
+                    typeCatalog,
                     usageSummary: stores.usage?.summary() ?? null,
                 };
                 return resp;
@@ -1241,12 +1513,15 @@ export async function handleEndpoint(endpoint, payload, deps) {
                 items: items.map((r) => 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,
                 })),
                 hasMore: offset + items.length < total,
                 total,
                 truncated: false,
                 scenes: offset === 0 ? stores.l1.distinctScenes() : undefined,
                 wingCatalog,
+                typeCatalog,
                 usageSummary: stores.usage?.summary() ?? null,
             };
             return resp;
@@ -1282,7 +1557,7 @@ export async function handleEndpoint(endpoint, payload, deps) {
             // (live.conflictFreeze 覆盖静态 cfg.conflictFreeze.enabled)。此前这里直接读
             // cfg.conflictFreeze.enabled —— 面板开关写的是 live,而部署静态值恒 false,
             // 于是开关已开、settings.yaml 已落 true,本页仍报"矛盾冻结未开启"。
-            return listConflictPairs({ l1: stores.l1, conflictFreezeEnabled: effectiveCfg(cfg, live).conflictFreeze?.enabled === true, usage: stores.usage, decayHalfLifeDays: effectiveCfg(cfg, live).recall?.decayHalfLifeDays }, { limit: Number(p.limit) || undefined });
+            return listConflictPairs({ l1: stores.l1, conflictFreezeEnabled: effectiveCfg(cfg, live).conflictFreeze?.enabled === true, usage: stores.usage, decayHalfLifeDays: effectiveCfg(cfg, live).recall?.decayHalfLifeDays, feedback: stores.feedback }, { limit: Number(p.limit) || undefined });
         }
         // ── §C 矛盾冻结裁决(task_25):与 memory_resolve_conflict 工具共用同一形状 ──
         // 端点层同样不给"提示文案"出口的例外只有一条:**队列未开启**不是调用错误而是
@@ -1403,6 +1678,14 @@ export async function handleEndpoint(endpoint, payload, deps) {
                 }
             }
             if (dryRun) {
+                // 待删清单要给人看：`targets` 只是计数，人无法从计数判断“这批是不是该删的那批”。
+                // 取前 50 条预览（全量列表会把面板撑爆，而判据只需抽看）。
+                const preview = stores.l1.getByIds(targets.slice(0, 50)).map((r) => ({
+                    id: r.id,
+                    name: r.name ?? '',
+                    type: r.type,
+                    retiredAt: r.validTo === undefined ? '' : new Date(r.validTo).toISOString(),
+                }));
                 const resp = {
                     dryRun: true,
                     targets: targets.length,
@@ -1411,6 +1694,7 @@ export async function handleEndpoint(endpoint, payload, deps) {
                     dir: '',
                     name: '',
                     diffs: [],
+                    items: preview,
                 };
                 return resp;
             }
@@ -1418,7 +1702,18 @@ export async function handleEndpoint(endpoint, payload, deps) {
                 const resp = { dryRun: false, targets: 0, purged: 0, aborted: false, dir: '', name: '', diffs: [] };
                 return resp;
             }
-            const r = await stores.l1.purgeRetired(targets, 'cleanup-retired');
+            // 删前先把该批记录抓在手里：删完再读就什么都读不到了（归档正文与预览清单都要用它们）。
+            const purgeRecords = stores.l1.getByIds(targets);
+            // N12：投射面开着时把该批的投射文件（含 `.disable`）一并收进快照目录。
+            // 关着时 `files` 为 undefined ⇒ `exportThenPurge` 行为与改动前逐字一致。
+            const files = cfg.memExport?.enabled === true
+                ? await collectProjectionFiles(purgeRecords, cfg.memExport.root, deps.dataDir, deps.logger)
+                : undefined;
+            const r = await stores.l1.purgeRetired(targets, 'cleanup-retired', { files });
+            // F19：图投影的两张索引表全仓原本**只增不减**。记录行删了而投影行还在，
+            // 从快照恢复回来的记录会被当成“已投影”而永不重投影（检索图静默缺一条，不报错）。
+            // 只在真删成功时抹：干跑与中止都不动图——图是派生索引，不该因为一次预览被改。
+            const graphForgotten = !r.aborted && r.purged > 0 ? (stores.graph?.forgetRecords(targets) ?? 0) : 0;
             const resp = {
                 dryRun: false,
                 targets: targets.length,
@@ -1427,6 +1722,16 @@ export async function handleEndpoint(endpoint, payload, deps) {
                 dir: r.dir,
                 name: r.name,
                 diffs: r.diffs,
+                otherChanged: r.otherChanged,
+                archiveMd: r.archiveMd,
+                files: r.files,
+                graphForgotten,
+                items: purgeRecords.slice(0, 50).map((x) => ({
+                    id: x.id,
+                    name: x.name ?? '',
+                    type: x.type,
+                    retiredAt: x.validTo === undefined ? '' : new Date(x.validTo).toISOString(),
+                })),
             };
             return resp;
         }
@@ -1889,10 +2194,17 @@ export function hitToUiRecord(r, extra) {
         retiredReason: retired ? (mark?.reason ?? 'unknown') : null,
         agingWeight: extra?.agingWeight ?? null,
         usage: extra?.usage ?? null,
-        // G3 成熟度：读时派生（priority + used + 老化），无额外端点/存储。
-        maturity: computeMaturity({ priority: r.priority ?? 60, usage: extra?.usage ?? null, agingWeight: extra?.agingWeight ?? null }),
+        // G3 成熟度：读时派生（priority + used + 老化 + 人工最近一笔），无额外端点/存储。
+        maturity: computeMaturity({
+            priority: r.priority ?? 60,
+            usage: extra?.usage ?? null,
+            agingWeight: extra?.agingWeight ?? null,
+            mark: extra?.userMark ?? null,
+        }),
         // G1 使用场景：从命名空间保留键读出（功能关/无键 → undefined）。
         usageScenario: Array.isArray(r.metadata?.dsh_usage_scenario) ? r.metadata?.dsh_usage_scenario : undefined,
+        // 人给相关度均值：读时从 sidecar 派生（不进存储/快照）；未打分 → 字段缺席。
+        userRelevance: extra?.userRelevance ?? undefined,
     };
 }
 /**

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

@@ -97,6 +97,14 @@ export declare class EmbeddingManager {
     private applyBusy;
     private reindex;
     private reindexCancel;
+    /**
+     * 上一次重建的留痕（类型就地取自契约，不另开 import）。
+     *
+     * 为什么必须存：进度条只在 `running` 期间存在，而“待补 0 条”的重建会瞬间跑完，
+     * 界面上与“点了没反应”长得一模一样——真机反馈就是这么读的。留痕存**前后待补数**，
+     * 让“效果”是两个可比数字而不是一句“我转了一下”。
+     */
+    private reindexLast;
     /**
      * 向量计数缓存(分级 TTL)。
      *

package/dist/store/embedding-source.js

@@ -187,6 +187,14 @@ export class EmbeddingManager {
         cancelled: false,
     };
     reindexCancel = false;
+    /**
+     * 上一次重建的留痕（类型就地取自契约，不另开 import）。
+     *
+     * 为什么必须存：进度条只在 `running` 期间存在，而“待补 0 条”的重建会瞬间跑完，
+     * 界面上与“点了没反应”长得一模一样——真机反馈就是这么读的。留痕存**前后待补数**，
+     * 让“效果”是两个可比数字而不是一句“我转了一下”。
+     */
+    reindexLast;
     /**
      * 向量计数缓存(分级 TTL)。
      *
@@ -471,6 +479,27 @@ export class EmbeddingManager {
     async reindexNow() {
         this.reindexCancel = false;
         this.reindex = { running: true, l1Done: 0, l1Total: 0, l0Done: 0, l0Total: 0, startedAt: Date.now(), cancelled: false };
+        // 重建**前**的待补数：先破缓存再取，否则拿到的可能是 TTL 里的旧值（那会让“前后差”假报 0）。
+        // 口径故意与界面用的同一个（相减法），不拿精确口径去对展示数字，否则两边永远对不上。
+        this.invalidateVecCache();
+        const v0 = this.vectorCounts();
+        const missingBefore = { l1: v0.l1.missing, l0: v0.l0.missing };
+        const finish = (cancelled, error) => {
+            this.invalidateVecCache();
+            const v1 = this.vectorCounts();
+            const at = Date.now();
+            this.reindexLast = {
+                finishedAt: at,
+                durationMs: Math.max(0, at - this.reindex.startedAt),
+                processed: this.reindex.l1Done + this.reindex.l0Done,
+                planned: this.reindex.l1Total + this.reindex.l0Total,
+                failed: failedTotal,
+                cancelled,
+                ...(error === undefined ? {} : { error }),
+                missingBefore,
+                missingAfter: { l1: v1.l1.missing, l0: v1.l0.missing },
+            };
+        };
         let failedTotal = 0;
         try {
             const r1 = await this.deps.l1.reindex({
@@ -493,6 +522,7 @@ export class EmbeddingManager {
             this.reindex.cancelled = cancelled;
             this.reindex.running = false;
             this.invalidateVecCache(); // 收尾:计数必须立刻反映重建结果(TTL 可能还压着 1s 旧值)
+            finish(cancelled);
             return { cancelled, failedTotal };
         }
         catch (err) {
@@ -500,6 +530,7 @@ export class EmbeddingManager {
             this.reindex.running = false;
             this.reindex.error = message;
             this.invalidateVecCache();
+            finish(false, message);
             return { cancelled: false, failedTotal, error: `重嵌入失败: ${message}` };
         }
     }
@@ -538,7 +569,7 @@ export class EmbeddingManager {
             download: this.downloader.getProgress(),
             apply: { phase: this.applyPhase, message: this.applyMessage, startedAt: this.applyStartedAt, busy: this.applyBusy },
             local: this.localSvc ? { state: this.localSvc.getState(), error: this.localSvc.getLoadError() } : null,
-            reindex: { ...this.reindex },
+            reindex: { ...this.reindex, last: this.reindexLast },
             vectors: this.vectorsCached(),
             activeNote: this.activeNote,
         };
@@ -562,7 +593,13 @@ export class EmbeddingManager {
         const count = (kind) => {
             const skip = this.deps.db.getVecSkipSet(kind);
             const embedded = kind === 'l1' ? this.deps.db.countL1Vec() : this.deps.db.countL0Vec();
-            const total = kind === 'l1' ? this.deps.db.countL1() : this.deps.db.countL0();
+            // 相减法还有第二条前提，之前漏了：**分母必须是活跃行**。退场行按设计就合法地没有
+            // 向量（撤检索面时 vec 行被 detach），把它们算进 total 会让 missing 恒等于退场数、
+            // 永不归零；而真正驱动补齐的 `countVecMissing`/`getL1ForReindex` 都排除退场行，于是
+            // 界面上同时出现“待补 114 条”与“重建索引无事可做”。本机实测：1280 总 / 114 退场 /
+            // 1166 活跃且全部已嵌，正是这个形状。`countL1Retired` 失败给 -1，按 0 处理退回旧行为。
+            const retired = kind === 'l1' ? Math.max(0, this.deps.db.countL1Retired()) : 0;
+            const total = (kind === 'l1' ? this.deps.db.countL1() : this.deps.db.countL0()) - retired;
             // 缺失数走**相减**而非 LEFT JOIN:见下方 vectorsCached 上方的说明。
             const missing = embedded < 0 || total < 0 ? -1 : Math.max(0, total - embedded - skip.size);
             return { embedded, total, missing, skipped: skip.size };

package/dist/store/file-versions.d.ts

@@ -27,3 +27,5 @@ export declare const SESSION_RECALLED_FILE_VERSION = 1;
 export declare const PENDING_FILE_VERSION = 1;
 /** `reconcile-state.json`。 */
 export declare const RECONCILE_STATE_FILE_VERSION = 1;
+/** `mem-md-ledger.json`（md 投射指纹账本，N9；派生态，删了可重建）。*/
+export declare const MEM_MD_LEDGER_FILE_VERSION = 1;

package/dist/store/file-versions.js

@@ -27,3 +27,5 @@ export const SESSION_RECALLED_FILE_VERSION = 1;
 export const PENDING_FILE_VERSION = 1;
 /** `reconcile-state.json`。 */
 export const RECONCILE_STATE_FILE_VERSION = 1;
+/** `mem-md-ledger.json`（md 投射指纹账本，N9；派生态，删了可重建）。*/
+export const MEM_MD_LEDGER_FILE_VERSION = 1;

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

@@ -106,6 +106,20 @@ export declare class GraphStore {
      * 记录跳过。返回实际新建的 job 数。
      */
     queueGraphProjection(recordIds: readonly string[], priority: number): number;
+    /**
+     * 记录被物理删除后，把两张**索引表**里指向它的行一并抹掉。
+     *
+     * 为什么必需（F19）：`graph_projected_records` 之前全仓**只增不减**。记录行删了而投影行还在，
+     * 就留下两类静默问题：① 投影进度表里挂着一批查不到主人的 record_id；② 从快照**恢复**回来的
+     * 记录因为投影行已存在而被当成“已投影”，**永远不会重投影**（检索图里就这么缺一条，不报错）。
+     *
+     * 只删索引行，**不动图节点/边**：节点是跨记录聚合出来的事实，归图自己的生命周期管。
+     * 失败只 warn 并返回已删数——清理的既成事实不应被旁路索引拖挂。
+     *
+     * @param ids - 已被物理删除的记录 id。
+     * @returns 从投影表删掉的行数。
+     */
+    forgetRecords(ids: readonly string[]): number;
     /**
      * 取下一个可执行 job 并置 running(attempts +1):只认当前 projectorVersion,
      * attempts 封顶与退避窗口在 WHERE 里过滤;来源全缺失 → job 判 dead 返 null

package/dist/store/graph-store.js

@@ -514,6 +514,41 @@ export class GraphStore {
             return 0;
         }
     }
+    /**
+     * 记录被物理删除后，把两张**索引表**里指向它的行一并抹掉。
+     *
+     * 为什么必需（F19）：`graph_projected_records` 之前全仓**只增不减**。记录行删了而投影行还在，
+     * 就留下两类静默问题：① 投影进度表里挂着一批查不到主人的 record_id；② 从快照**恢复**回来的
+     * 记录因为投影行已存在而被当成“已投影”，**永远不会重投影**（检索图里就这么缺一条，不报错）。
+     *
+     * 只删索引行，**不动图节点/边**：节点是跨记录聚合出来的事实，归图自己的生命周期管。
+     * 失败只 warn 并返回已删数——清理的既成事实不应被旁路索引拖挂。
+     *
+     * @param ids - 已被物理删除的记录 id。
+     * @returns 从投影表删掉的行数。
+     */
+    forgetRecords(ids) {
+        if (!this.db || ids.length === 0)
+            return 0;
+        const db = this.db;
+        let removed = 0;
+        try {
+            // 分批：IN 列表不能无限长（与入队/去重查询同一个口径）
+            for (let i = 0; i < ids.length; i += 500) {
+                const chunk = ids.slice(i, i + 500);
+                const ph = chunk.map(() => '?').join(',');
+                db.prepare(`DELETE FROM graph_projected_records WHERE record_id IN (${ph})`).run(...chunk);
+                const jobInfo = db.prepare(`DELETE FROM graph_job_records WHERE record_id IN (${ph})`).run(...chunk);
+                removed += chunk.length;
+                void jobInfo;
+            }
+            return removed;
+        }
+        catch (err) {
+            this.logger?.warn(`${TAG} 图索引遗录清理失败(忽略): ${err instanceof Error ? err.message : String(err)}`);
+            return removed;
+        }
+    }
     /**
      * 取下一个可执行 job 并置 running(attempts +1):只认当前 projectorVersion,
      * attempts 封顶与退避窗口在 WHERE 里过滤;来源全缺失 → job 判 dead 返 null