dsh-prime-memory 0.22.1 → 0.24.0

package/dist/stats.js

@@ -15,10 +15,12 @@ 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';
 import { mergeRoom, renameRoom } from './room-review.js';
+import { scanSources } from './memport/scan.js';
 import { projectDistillChain, validateDistillChain } from './settings.js';
 import { RECEIPTS_QUERY_LIMIT_MAX, dimensionOf, toReceiptView } from './store/receipts.js';
 import { getTraceStore } from './store/trace.js';
@@ -33,6 +35,16 @@ import { isWingCorner } from './store/session-modes.js';
 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;
 /**
@@ -93,6 +105,19 @@ export const MEMORY_ENDPOINTS = [
     'dsh-memory/cleanup-retired',
     'dsh-memory/snapshots-list',
     'dsh-memory/snapshot-restore',
+    'dsh-memory/memory-sources-list',
+    'dsh-memory/memory-sources-add',
+    'dsh-memory/memory-sources-retire',
+    '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/<短方法名>`)。 */
 const RPC_ROUTE_PREFIX = '/dsh-memory/rpc';
@@ -129,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) => {
@@ -173,6 +215,8 @@ export function buildEndpointDeps(base, sources, controller) {
         sessionInfo: sources.sessionInfo,
         ruminate: controller,
         roomRegistry: sources.roomRegistry,
+        memorySources: sources.memorySources,
+        skillStore: sources.skillStore,
     };
     return { ...base, ...injected };
 }
@@ -180,7 +224,11 @@ export function registerMemoryRpc(ctx, cfg, stores, logger, status, live, modes,
 /** 反刍控制器(存储降级时为 undefined):经 buildEndpointDeps 落入 deps.ruminate。 */
 ruminate, 
 /** Room 分类管理依赖(注册表;缺省 = rooms-get 不带 registry、rooms-export 恒 404 语义)。 */
-roomRegistry) {
+roomRegistry, 
+/** 外部来源注册表（轨3 Connect；经 buildEndpointDeps 落入 deps.memorySources）。 */
+memorySources, 
+/** 技能存储（轨2；经 buildEndpointDeps 落入 deps.skillStore）。 */
+skillStore) {
     /** 当前是否持有一段有效注册(dispose 完成后清空,允许服务重上线时重注册)。 */
     let holding = false;
     /** 当前 handle 绑定的 connection 实例(internal/service 第二参;用于识别实例替换)。 */
@@ -201,7 +249,7 @@ roomRegistry) {
                     const value = await handleEndpoint(endpoint, payload, buildEndpointDeps({ ctx, cfg, stores, logger }, 
                     // roomRegistry 必须随 sources 下发——漏带 = 面板侧 room-* 恒"未装配"
                     // (工具面直传不受影响;2026-10-02 beta.9 实测回归)
-                    { status, live, modes, dataDir, rebuild, embedManager, sessionInfo, roomRegistry }, ruminate));
+                    { status, live, modes, dataDir, rebuild, embedManager, sessionInfo, roomRegistry, memorySources, skillStore }, ruminate));
                     return { ok: true, value };
                 }
                 catch (err) {
@@ -349,7 +397,7 @@ function sanitizeSettings(s) {
 }
 /** 端点分发表(导出供测试直调:可精确注入 rebuild/ruminate 等可选控制器,验证 deps 接线)。 */
 export async function handleEndpoint(endpoint, payload, deps) {
-    const { cfg, stores, status, live, modes, dataDir, rebuild, ruminate, embedManager, sessionInfo, roomRegistry } = deps;
+    const { cfg, stores, status, live, modes, dataDir, rebuild, ruminate, embedManager, sessionInfo, roomRegistry, memorySources, skillStore } = deps;
     switch (endpoint) {
         case 'dsh-memory/stats':
             return buildStats(cfg, stores, status);
@@ -386,6 +434,234 @@ export async function handleEndpoint(endpoint, payload, deps) {
             };
             return v;
         }
+        case 'dsh-memory/session-recalled': {
+            // 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: [], 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) => {
+                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)
                 throw new Error('档位存储未初始化');
@@ -499,6 +775,150 @@ export async function handleEndpoint(endpoint, payload, deps) {
             };
             return v;
         }
+        // ── 轨3 外部记忆来源（Connect）：登记/列表/退役/只读扫描。整面默认关（cfg.memport.enabled）。
+        case 'dsh-memory/memory-sources-list': {
+            const enabled = cfg.memport?.enabled === true;
+            const v = {
+                sources: enabled && memorySources
+                    ? memorySources.list().map((e) => ({
+                        id: e.id,
+                        kind: e.kind,
+                        path: e.path,
+                        label: e.label,
+                        lastScanAt: e.lastScanAt,
+                        lastImportAt: e.lastImportAt,
+                        disabled: e.disabled,
+                        status: e.status,
+                    }))
+                    : [],
+                memoryMutate: live?.get().memoryMutate === true,
+            };
+            return v;
+        }
+        case 'dsh-memory/memory-sources-add': {
+            if (cfg.memport?.enabled !== true)
+                throw new Error('外部记忆来源未启用（config memport.enabled）。');
+            if (!memorySources)
+                throw new Error('外部来源注册表未装配（需要插件重载以初始化）。');
+            if (!live?.get().memoryMutate)
+                throw new Error('记忆写删未开放：请在记忆库面板开启「高权限模式」后才能登记外部来源。');
+            const p = (payload ?? {});
+            const r = await memorySources.register({
+                id: String(p.id ?? '').trim(),
+                kind: String(p.kind ?? 'file') ?? 'file',
+                path: String(p.path ?? '').trim(),
+                label: typeof p.label === 'string' ? p.label : undefined,
+            });
+            const v = {
+                id: r.entry.id,
+                created: r.created,
+                notice: r.created ? '已登记来源。' : '来源已存在（已按新 path/label 原地更新）。',
+            };
+            return v;
+        }
+        case 'dsh-memory/memory-sources-retire': {
+            if (cfg.memport?.enabled !== true)
+                throw new Error('外部记忆来源未启用（config memport.enabled）。');
+            if (!memorySources)
+                throw new Error('外部来源注册表未装配（需要插件重载以初始化）。');
+            if (!live?.get().memoryMutate)
+                throw new Error('记忆写删未开放：请在记忆库面板开启「高权限模式」后才能管理外部来源。');
+            const p = (payload ?? {});
+            const changed = await memorySources.setStatus(String(p.id ?? '').trim(), p.active === true ? 'active' : 'retired');
+            const v = {
+                changed,
+                notice: !changed
+                    ? '未找到该来源。'
+                    : p.active === true
+                        ? '已恢复来源。'
+                        : '已退役来源（不删已导入数据；来源路径与 ext_key 仍在，可重放）。',
+            };
+            return v;
+        }
+        case 'dsh-memory/memport-scan': {
+            if (cfg.memport?.enabled !== true) {
+                const v = { enabled: false, sources: [], notice: '外部记忆扫描未启用（config memport.enabled）。' };
+                return v;
+            }
+            if (!memorySources) {
+                const v = { enabled: true, sources: [], notice: '外部来源注册表未装配。' };
+                return v;
+            }
+            const p = (payload ?? {});
+            const all = memorySources.listEnabled();
+            const targets = p.sourceId ? all.filter((e) => e.id === p.sourceId) : all;
+            const maxRecords = cfg.memport?.scanMaxRecords ?? 5000;
+            // 只读扫描：不写库（写走 memory_import）。逐个标扫描时间（失败不影响预览）。
+            const sources = await scanSources({ sources: targets, l1: stores.l1, maxRecords });
+            const nowIso = new Date().toISOString();
+            for (const s of targets)
+                await memorySources.markScanned(s.id, nowIso);
+            const v = { enabled: true, sources };
+            return v;
+        }
+        // ── 轨2 技能（SkillsTab）：列表 + 人工审阅动作（晋升/归档/pin/改档）。整面默认关（cfg.skills.enabled）。
+        case 'dsh-memory/skills-list': {
+            const enabled = cfg.skills?.enabled === true || live?.get().skillsEnabled === true;
+            const v = {
+                enabled,
+                allowPromote: cfg.skills?.allowPromote === true,
+                memoryMutate: live?.get().memoryMutate === true,
+                skills: enabled && skillStore
+                    ? skillStore.list().map((s) => ({
+                        id: s.id,
+                        title: s.title,
+                        status: s.status,
+                        tier: s.injectionTier,
+                        pinned: s.pinned,
+                        sessionCount: skillStore.sessionCount(s.id),
+                        updatedAt: s.updatedAt,
+                    }))
+                    : [],
+            };
+            return v;
+        }
+        case 'dsh-memory/skills-action': {
+            if (!(cfg.skills?.enabled === true || live?.get().skillsEnabled === true))
+                throw new Error('技能功能未启用（在概览页开启「技能」开关，或 config skills.enabled）。');
+            if (!skillStore)
+                throw new Error('技能存储未装配。');
+            if (!live?.get().memoryMutate)
+                throw new Error('记忆写删未开放：请在记忆库面板开启「高权限模式」后才能管理技能。');
+            const p = (payload ?? {});
+            const id = String(p.id ?? '').trim();
+            if (!id)
+                throw new Error('id 不能为空');
+            const minSessions = cfg.skills.minSessions;
+            const v = { changed: false, notice: '' };
+            if (p.action === 'promote') {
+                // 人工审阅晋升：不受自动闸 allowPromote 约束，但仍需证据达阈（不凭空的晋升）。
+                if (skillStore.sessionCount(id) < minSessions)
+                    return { changed: false, notice: `证据会话数不足（<${minSessions}），暂不能晋升。` };
+                const ok = await skillStore.tryPromote(id, minSessions, { allowPromote: true });
+                return { changed: ok, notice: ok ? '已晋升为 active。' : '未找到候选或状态已变。' };
+            }
+            if (p.action === 'archive') {
+                const ok = await skillStore.archive(id, String(p.reason ?? 'manual').slice(0, 120) || 'manual');
+                return { changed: ok, notice: ok ? '已归档（不再注入，可恢复）。' : '未找到或已归档。' };
+            }
+            if (p.action === 'pin') {
+                const ok = await skillStore.update(id, { pinned: true });
+                return { changed: ok, notice: ok ? '已固定。' : '未找到技能。' };
+            }
+            if (p.action === 'unpin') {
+                const ok = await skillStore.update(id, { pinned: false });
+                return { changed: ok, notice: ok ? '已取消固定。' : '未找到技能。' };
+            }
+            if (p.action === 'set-tier') {
+                const tier = p.tier === 'full' || p.tier === 'excerpt' || p.tier === 'hint' ? p.tier : null;
+                if (!tier)
+                    throw new Error('tier 非法（仅 full/excerpt/hint）');
+                const ok = await skillStore.update(id, { injectionTier: tier });
+                return { changed: ok, notice: ok ? `已设为 ${tier} 档。` : '未找到技能。' };
+            }
+            void v;
+            throw new Error(`未知 action: ${String(p.action)}`);
+        }
         case 'dsh-memory/room-register': {
             if (!roomRegistry)
                 throw new Error('Room 注册表未装配(需要插件重载以初始化)。');
@@ -812,6 +1232,7 @@ export async function handleEndpoint(endpoint, payload, deps) {
                     embedRemoteBaseURL: '', embedRemoteApiKey: '', embedRemoteModel: '', embedRemoteDimensions: 0,
                     memoryMutate: false,
                     conflictFreeze: live?.get()?.conflictFreeze === true,
+                    skillsEnabled: live?.get()?.skillsEnabled === true,
                 }),
                 // 静态部署上限(cordis.patch.yml):运行时开关与它取 AND
                 ceilings: { capture: cfg.capture.enabled, distill: cfg.extract.enabled, recall: cfg.recall.enabled },
@@ -850,7 +1271,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', 'toolRoom', 'toolGraph', 'toolRuminate', 'toolConflict', 'toolMutate']) {
+            for (const key of ['enabled', 'capture', 'distill', 'recall', 'memoryMutate', 'conflictFreeze', 'skillsEnabled', 'toolRoom', 'toolGraph', 'toolRuminate', 'toolConflict', 'toolMutate']) {
                 if (typeof patch[key] === 'boolean')
                     clean[key] = patch[key];
             }
@@ -1005,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;
@@ -1043,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;
@@ -1066,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;
@@ -1107,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 }, { 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 工具共用同一形状 ──
         // 端点层同样不给"提示文案"出口的例外只有一条:**队列未开启**不是调用错误而是
@@ -1228,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,
@@ -1236,6 +1694,7 @@ export async function handleEndpoint(endpoint, payload, deps) {
                     dir: '',
                     name: '',
                     diffs: [],
+                    items: preview,
                 };
                 return resp;
             }
@@ -1243,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,
@@ -1252,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;
         }
@@ -1714,6 +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,
+            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,
     };
 }
 /**