dsh-prime-memory 0.20.0-beta.4 → 0.20.0-beta.6

package/CHANGELOG.md

@@ -17,7 +17,25 @@
   - **建议状态(`longtask-hint-get`)+ 浮动球(`client/src/longtask-fab.ts`)**:ego-browser 式 vanilla overlay(FAB+面板,拖拽/位置持久化/视口夹紧),**建议不阻断**——仅当「上下文占用达 `contextThresholdPct`」或「todo 漂移达 `driftThreshold`」且长任务未开启时点亮呼吸光晕;面板内:长任务开关(临时,per-session,**不带 mode**——切开关不重置用户档位)、占用/漂移进度条、手动尾部压缩按钮(长任务开启才可用)、任务计数。轮询忙 2s/闲 5s,RPC 失败静默;座位契约不变(settings.section 恰一个,body 单例不占任何座位)。
   - **`session-mode-set` 的 `mode` 转为可选**:与 `longTask` 二选一必传——纯切长任务开关不再被迫发送档位(旧客户端恒传 mode,行为不变)。响应 `mode` 改回当前生效值。
 
-## [0.20.0-beta.4] — 2026-10-01
+## [0.20.0-beta.6] — 2026-10-01
+
+### 修复
+
+- **标注器词表接入注册表(beta.5 漏项补齐)**:beta.5 的 merge/rename/retire 已落,但候选标注器(`annotateOrphanCandidates`)的词表仍是纯自生长聚合——预注册的 Room 根本进不了候选。现 OrphanAnnotateIO 带 registry:合并词表 = 注册表条目排前(count=0,附 label/description)+ 自生长目录,封顶 120;ruminate 与 memory_room_admin annotate 两条路径都传参。**预注册 Room 从此真实影响候选标注**。
+
+## [0.20.0-beta.5] — 2026-10-01## [0.20.0-beta.5] — 2026-10-01
+
+> Room 分类管理第二船(**破坏性面**)。dryRun 默认 true——merge/rename 先预览影响面,确认后才实跑;执行前自动备份到 `rooms-merge-backups/`。
+
+### 新增
+
+- **Room 注册表两级制**:slug 支持 `major` 或 `major/minor` 两级(如 `dsh-plugin`、`dsh-plugin/merge`);**大类上限 200**,小类细分不占大类额度(总量保险 2000)。isTag 词表不放宽(slash 仅注册表层允许)。
+- **merge/rename/retire(工具 `memory_room_admin`,高权限)**:merge 游标重写全部匹配记录的 tags(写前重读-合并-写回,roomCandidates/roomReview/hall/anchors 等键保全;含已退场行,与计数口径一致);rename = merge 1:1 + 注册表改名(aliases 收旧名);retire 仅词表退役(存量不动)。merge/rename 与反刍并发会相互覆盖——请错峰执行(工具提示与 ADR-0020 均已声明)。
+- **重写安全三件套**:dryRun 默认只返 affected+预览零写入;执行前自动备份匹配记录到 `rooms-merge-backups/<ts>-<slug>.json`;完成自动 `invalidateRooms` + 按受影响 (family, scene) 入队场景重算(`source='room-merge'`)。
+- **面板 Room 管理子面板**(高权限开启后出现):注册表单(slug/名称/说明,走新 RPC `room-register`)、孤儿清单导出;合并/退役建议走 agent 工具(dryRun 预览更详细)。
+- 端点面 46 → 47(`room-register`)。
+
+## [0.20.0-beta.4] — 2026-10-01## [0.20.0-beta.4] — 2026-10-01
 
 > Room 分类管理第一船(**零漂移面**):注册表空 = 与 beta.3 行为逐字一致。merge/rename/retire 破坏性面将随 beta.5(dryRun 默认 true 保留一版)。
 

package/dist/client.js

@@ -3711,7 +3711,54 @@ var __defProp = Object.defineProperty;
 		              children: "▶"
 		            }
 		          )
-		        ] }) : null
+		        ] }) : null,
+		        roomsOpen && /* @__PURE__ */ (0, import_jsx_runtime15.jsxs)("div", { style: { marginTop: 8, paddingTop: 8, borderTop: "1px solid var(--dsh-mem-border)" }, children: [
+		          /* @__PURE__ */ (0, import_jsx_runtime15.jsxs)("div", { style: { display: "flex", alignItems: "center", gap: 8, marginBottom: 6 }, children: [
+		            /* @__PURE__ */ (0, import_jsx_runtime15.jsx)("span", { style: S.muted, children: "管理(高权限)" }),
+		            !hiPriv && /* @__PURE__ */ (0, import_jsx_runtime15.jsx)("span", { style: S.muted, children: "需先开启高权限模式(见上方工具栏)" })
+		          ] }),
+		          hiPriv && /* @__PURE__ */ (0, import_jsx_runtime15.jsxs)("div", { style: { display: "flex", flexWrap: "wrap", gap: 6, alignItems: "center" }, children: [
+		            /* @__PURE__ */ (0, import_jsx_runtime15.jsx)("input", { "data-adm-slug": true, placeholder: "slug(如 dsh-plugin 或 dsh-plugin/merge)", style: { ...S.input, width: 150, fontSize: 12 } }),
+		            /* @__PURE__ */ (0, import_jsx_runtime15.jsx)("input", { "data-adm-label": true, placeholder: "名称(可中文)", style: { ...S.input, width: 110, fontSize: 12 } }),
+		            /* @__PURE__ */ (0, import_jsx_runtime15.jsx)("input", { "data-adm-desc": true, placeholder: "归类说明(喂标注器)", style: { ...S.input, width: 170, fontSize: 12 } }),
+		            /* @__PURE__ */ (0, import_jsx_runtime15.jsx)(
+		              "button",
+		              {
+		                type: "button",
+		                onClick: async () => {
+		                  const q = (sel2) => document.querySelector(sel2)?.value ?? "";
+		                  const r = await rpc("dsh-memory/room-register", { slug: q("[data-adm-slug]"), label: q("[data-adm-label]"), description: q("[data-adm-desc]") }).catch(() => null);
+		                  void r;
+		                  loadRooms();
+		                },
+		                style: { cursor: "pointer", fontSize: 12, padding: "3px 10px", borderRadius: 6, border: "1px solid var(--dsh-mem-accent)", background: "transparent", color: "var(--dsh-mem-accent)" },
+		                children: "注册"
+		              }
+		            ),
+		            /* @__PURE__ */ (0, import_jsx_runtime15.jsx)(
+		              "button",
+		              {
+		                type: "button",
+		                title: "导出无 Room 绑定的孤儿清单(含候选)",
+		                onClick: () => {
+		                  rpc("dsh-memory/rooms-export", { kind: "orphans" }).then((r) => {
+		                    if (!r || !r.ok || !r.value?.csv) return;
+		                    const blob = new Blob([r.value.csv], { type: "text/csv;charset=utf-8" });
+		                    const url = URL.createObjectURL(blob);
+		                    const a = document.createElement("a");
+		                    a.href = url;
+		                    a.download = "dsh-memory-room-orphans.csv";
+		                    a.click();
+		                    URL.revokeObjectURL(url);
+		                  }).catch(() => void 0);
+		                },
+		                style: { cursor: "pointer", fontSize: 12, padding: "3px 10px", borderRadius: 6, border: "1px solid var(--dsh-mem-border)", background: "transparent", color: "var(--dsh-mem-text-2)" },
+		                children: "导出孤儿"
+		              }
+		            ),
+		            /* @__PURE__ */ (0, import_jsx_runtime15.jsx)("span", { style: S.muted, children: "合并/改名/退役:用 agent 工具 memory_room_admin(merge/rename/retire,dryRun 默认预览)" })
+		          ] })
+		        ] })
 		      ] }) : /* @__PURE__ */ (0, import_jsx_runtime15.jsx)("div", { style: S.muted, children: "Room 分类:暂无(由反刍涌现的标签自动生成,无需手工建立)" })
 		    ] }),
 		    /* @__PURE__ */ (0, import_jsx_runtime15.jsxs)("div", { style: { ...S.flexRow, marginBottom: 10 }, children: [

package/dist/contract.d.ts

@@ -574,6 +574,18 @@ export interface RoomsGetResponse {
         status: 'active' | 'retired';
     }>;
 }
+/** dsh-memory/room-register(预注册 Room;高权限:面板 memoryMutate 开启才生效)。 */
+export interface RoomRegisterRequest {
+    slug: string;
+    label?: string;
+    description?: string;
+}
+export interface RoomRegisterResponse {
+    slug: string;
+    created: boolean;
+    /** 幂等补全时的提示(如「已存在,只补全缺失字段」)。 */
+    notice?: string;
+}
 /** dsh-memory/rooms-export(分类数据导出,CSV 直出)。 */
 export interface RoomsExportRequest {
     /** rooms = 词表+计数;orphans = 无 Room 绑定的记录清单。 */
@@ -1288,6 +1300,7 @@ export interface DshMemoryRequestMap {
     'dsh-memory/wing-overview': Record<string, never>;
     'dsh-memory/rooms-get': Record<string, never>;
     'dsh-memory/rooms-export': RoomsExportRequest;
+    'dsh-memory/room-register': RoomRegisterRequest;
     'dsh-memory/wing-backfill': Record<string, never>;
     'dsh-memory/session-stats': SessionStatsRequest;
     'dsh-memory/settings-get': Record<string, never>;
@@ -1336,6 +1349,7 @@ export interface DshMemoryResponseMap {
     'dsh-memory/wing-overview': WingOverviewResponse;
     'dsh-memory/rooms-get': RoomsGetResponse;
     'dsh-memory/rooms-export': RoomsExportResponse;
+    'dsh-memory/room-register': RoomRegisterResponse;
     'dsh-memory/wing-backfill': WingBackfillResponse;
     'dsh-memory/session-stats': SessionStatsResponse;
     'dsh-memory/settings-get': SettingsGetResponse;

package/dist/index.js

@@ -354,8 +354,11 @@ export async function apply(ctx, config) {
         backend = await createMemoryBackend({ dbPath: path.join(dataDir, 'memory.db'), dimensions: initial.dims, logger }, backend);
     }
     stores.backend = backend;
+    // Room 注册表(分类管理 beta.4;损坏降级为纯自生长目录)
+    const roomRegistry = new RoomRegistryStore(dataDir, logger);
+    await roomRegistry.init();
     const ruminate = storageOk && !db.isDegraded() && ruminateFile
-        ? new RuminateController(ctx, config, runner, stores, logger, live, ruminateFile)
+        ? new RuminateController(ctx, config, runner, stores, logger, live, ruminateFile, roomRegistry)
         : undefined;
     let flushL0;
     if (storageOk) {
@@ -366,8 +369,6 @@ export async function apply(ctx, config) {
     const contextUsage = new ContextUsageStore(logger);
     const todoRef = new TodoRefStore();
     // Room 注册表(分类管理 beta.4;损坏降级为纯自生长目录)
-    const roomRegistry = new RoomRegistryStore(dataDir, logger);
-    await roomRegistry.init();
     if (storageOk) {
         registerLongTaskMonitor(ctx, {
             cfg: config,

package/dist/pipeline/ruminate.d.ts

@@ -66,6 +66,8 @@ export declare class RuminateController {
     private sessions;
     private totalL1;
     private pendingFile;
+    /** Room 注册表(可选;孤儿候选预标记的合并词表来源)。 */
+    private readonly roomRegistry;
     /** 记忆后端:未注入时包 l1(进程内,行为与改造前等价)。 */
     private backend;
     constructor(ctx: Context, cfg: MemoryConfig, runner: Pick<MemoryRunner, 'enqueue' | 'states'>, stores: {
@@ -75,7 +77,15 @@ export declare class RuminateController {
         scenes: Record<MemoryFamily, SceneStore>;
         persona: Record<MemoryFamily, PersonaStore>;
         state: StateStore;
-    }, logger: MemoryLogger, live: LiveSettingsHandle, pendingFile: string);
+    }, logger: MemoryLogger, live: LiveSettingsHandle, pendingFile: string, 
+    /** Room 注册表(可选;孤儿候选预标记的合并词表来源)。 */
+    roomRegistry?: {
+        listActive(): Array<{
+            slug: string;
+            label?: string;
+            description?: string;
+        }>;
+    });
     /** 状态快照 */
     getStatus(): RuminateStatus;
     /**

package/dist/pipeline/ruminate.js

@@ -46,11 +46,15 @@ export class RuminateController {
     sessions = [];
     totalL1 = 0;
     pendingFile;
+    /** Room 注册表(可选;孤儿候选预标记的合并词表来源)。 */
+    roomRegistry;
     /** 记忆后端:未注入时包 l1(进程内,行为与改造前等价)。 */
     backend() {
         return this.stores.backend ?? new InProcMemoryBackend(this.stores.l1);
     }
-    constructor(ctx, cfg, runner, stores, logger, live, pendingFile) {
+    constructor(ctx, cfg, runner, stores, logger, live, pendingFile, 
+    /** Room 注册表(可选;孤儿候选预标记的合并词表来源)。 */
+    roomRegistry) {
         this.ctx = ctx;
         this.cfg = cfg;
         this.runner = runner;
@@ -58,6 +62,7 @@ export class RuminateController {
         this.logger = logger;
         this.live = live;
         this.pendingFile = pendingFile;
+        this.roomRegistry = roomRegistry;
     }
     /** 状态快照 */
     getStatus() {
@@ -238,7 +243,7 @@ export class RuminateController {
             // 候选(roomReview='pending'),由 agent 用 memory_room_review 逐个复查;
             // 每轮至多 40 条,吞错不拖垮反刍。
             try {
-                const r = await annotateOrphanCandidates(this.ctx, this.cfg, { l1: this.stores.l1, logger: this.logger }, 40);
+                const r = await annotateOrphanCandidates(this.ctx, this.cfg, { l1: this.stores.l1, logger: this.logger, registry: this.roomRegistry }, 40);
                 if (r.written > 0)
                     this.status.detail = `孤儿候选预标记 ${r.written} 条(待 agent 复查,工具 memory_room_review)`;
             }

package/dist/room-review.d.ts

@@ -46,6 +46,26 @@ export interface RoomReviewStore {
     /** 确认写 tags 后失效 Room 计数缓存(30s TTL)。 */
     invalidateRooms(): void;
 }
+/** merge/rename 的 store 面(RoomReviewStore + 游标重写与备份;L1Store 已实现)。 */
+export interface RoomMergeStore extends RoomReviewStore {
+    listByTagAll(tag: string, cap?: number): MemoryRecord[];
+    backupTagRecords(tag: string): {
+        file: string;
+        count: number;
+    };
+    rewriteTag(from: string, to: string, cap?: number): {
+        rewritten: number;
+        scanned: number;
+        families: string[];
+        scenes: string[];
+        hasMore: boolean;
+    };
+}
+/** Room 注册表最小面(merge 收尾;RoomRegistryStore 已满足)。 */
+export interface RoomRegistryMerge {
+    markMerged(fromSlug: string, toSlug: string): Promise<boolean>;
+    renameSlug(oldSlug: string, newSlug: string): Promise<boolean>;
+}
 export interface RoomCandidate {
     id: string;
     rooms: string[];
@@ -74,14 +94,27 @@ export declare function roomCandidateChunk(ctx: Context, cfg: MemoryConfig, logg
 export interface OrphanAnnotateIO {
     l1: RoomReviewStore;
     logger: MemoryLogger;
+    /** Room 注册表(可选:未装配 = 词表只用自生长聚合,无注册条目)。 */
+    registry?: {
+        listActive(): Array<{
+            slug: string;
+            label?: string;
+            description?: string;
+        }>;
+    };
 }
 /**
  * 预标记消费器:活跃孤儿(≤limit 条)批量产候选并写 pending。
  * 写前重读合并(与 relabel 同纪律);失败单条跳过、原记录零改动。
  */
 export interface OrphanAnnotateOverrides {
-    /** 测试注入口:替换 LLM 候选标注器(默认走真实 callLLM 路径)。 */
-    chunkAnnotator?: (chunk: MemoryRecord[]) => Promise<Array<{
+    /** 测试注入口:替换 LLM 候选标注器(默认走真实 callLLM 路径);第二参为合并词表。 */
+    chunkAnnotator?: (chunk: MemoryRecord[], catalog: ReadonlyArray<{
+        room: string;
+        count: number;
+        label?: string;
+        description?: string;
+    }>) => Promise<Array<{
         id: string;
         rooms: string[];
     }>>;
@@ -91,6 +124,44 @@ export declare function annotateOrphanCandidates(ctx: Context, cfg: MemoryConfig
     candidates: number;
     written: number;
 }>;
+export interface MergeRoomResult {
+    dryRun: boolean;
+    /** 影响条数(dryRun=预览数;实跑=实际重写数)。 */
+    affected: number;
+    preview: string[];
+    applied: number;
+    hasMore: boolean;
+    backupFile?: string;
+    /** 实跑时回传:受影响的族与场景(调用方入队 recluster 'room-merge')。 */
+    families?: string[];
+    scenes?: string[];
+}
+/**
+ * Room merge/rename 编排(破坏性动作,分类管理 beta.5):
+ *  - dryRun(缺省 true):只统计 affected + 前 6 条预览,**零写入**;
+ *  - 实跑:执行前备份(matching rows → rooms-merge-backups/)→ 游标重写
+ *    (写前重读-合并-写回,其余 metadata 键保全)→ 注册表 markMerged/renameSlug
+ *    → 返回受影响 (family, scene) 供调用方入队 recluster('room-merge');
+ *  - 单飞:并发 merge 直接抛错;与 relabel/ruminate 的时间错开由调用方保证。
+ * 抛错语义:非法参数/注册表冲突直接抛(调用方转 notice)。
+ */
+export declare function mergeRoom(io: {
+    l1: RoomMergeStore;
+    registry: RoomRegistryMerge;
+    logger: MemoryLogger;
+}, from: string, to: string, opts?: {
+    dryRun?: boolean;
+    cap?: number;
+}): Promise<MergeRoomResult>;
+/** rename = merge 1:1 + 注册表改名(冲突时抛错提示走 merge)。 */
+export declare function renameRoom(io: {
+    l1: RoomMergeStore;
+    registry: RoomRegistryMerge;
+    logger: MemoryLogger;
+}, from: string, to: string, opts?: {
+    dryRun?: boolean;
+    cap?: number;
+}): Promise<MergeRoomResult>;
 /** 下一条待复查(供 agent 逐个过):记录摘要 + 候选 + 现有 Room 词表 + 剩余数。 */
 export declare function nextReview(l1: RoomReviewStore): {
     id: string;

package/dist/room-review.js

@@ -92,12 +92,18 @@ export async function annotateOrphanCandidates(ctx, cfg, io, limit = 40, overrid
     const selected = selectPendingOrphans(io.l1, limit);
     if (selected.length === 0)
         return { selected: 0, candidates: 0, written: 0 };
-    // 全库 Room 词表(计数降序)。整批共享一张词表(一次 LLM 调用),
-    // 同仓优先的精化在逐条候选写入后由 repo-change 重算消费,此处保持简单。
-    const rooms = io.l1.listRooms();
+    // 合并词表:注册表条目排前(附 description,对 LLM 归类价值最高),封顶 120;
+    // 无注册表 = 纯自生长聚合(计数降序)。整批共享一张词表(一次 LLM 调用)。
+    const grown = io.l1.listRooms();
+    const regActive = io.registry?.listActive() ?? [];
+    const regSet = new Set(regActive.map((e) => e.slug));
+    const merged = [
+        ...regActive.map((e) => ({ room: e.slug, count: 0, label: e.label, description: e.description })),
+        ...grown.filter((r) => !regSet.has(r.room)).map((r) => ({ room: r.room, count: r.count })),
+    ].slice(0, 120);
     const rows = overrides.chunkAnnotator !== undefined
-        ? await overrides.chunkAnnotator(selected)
-        : await roomCandidateChunk(ctx, cfg, io.logger, selected, rooms);
+        ? await overrides.chunkAnnotator(selected, merged)
+        : await roomCandidateChunk(ctx, cfg, io.logger, selected, merged);
     let written = 0;
     for (const { id, rooms: candidates } of rows) {
         if (candidates.length === 0)
@@ -133,6 +139,76 @@ function pendingQueue(l1) {
     }
     return out.sort((a, b) => a.updatedAt - b.updatedAt);
 }
+/** merge 单飞哨兵(模块级;与 ruminate/wing-backfill 的时间错开由调用方保证)。 */
+let roomMergeRunning = false;
+/**
+ * Room merge/rename 编排(破坏性动作,分类管理 beta.5):
+ *  - dryRun(缺省 true):只统计 affected + 前 6 条预览,**零写入**;
+ *  - 实跑:执行前备份(matching rows → rooms-merge-backups/)→ 游标重写
+ *    (写前重读-合并-写回,其余 metadata 键保全)→ 注册表 markMerged/renameSlug
+ *    → 返回受影响 (family, scene) 供调用方入队 recluster('room-merge');
+ *  - 单飞:并发 merge 直接抛错;与 relabel/ruminate 的时间错开由调用方保证。
+ * 抛错语义:非法参数/注册表冲突直接抛(调用方转 notice)。
+ */
+export async function mergeRoom(io, from, to, opts = {}) {
+    const dryRun = opts.dryRun !== false;
+    const cap = Math.min(Math.max(opts.cap ?? 500, 1), 2000);
+    if (from === to)
+        throw new Error('from 与 to 相同');
+    if (!from.trim())
+        throw new Error('from 不能为空');
+    if (roomMergeRunning)
+        throw new Error('Room merge 已在进行中(单飞)');
+    const previewRows = io.l1.listByTagAll(from, 7);
+    const affected = io.l1.listByTagAll(from, cap + 1).length;
+    const preview = previewRows.slice(0, 6).map((r) => r.id);
+    if (dryRun)
+        return { dryRun: true, affected, preview, applied: 0, hasMore: affected > cap };
+    if (roomMergeRunning)
+        throw new Error('Room merge 已在进行中(单飞)');
+    roomMergeRunning = true;
+    try {
+        const backup = io.l1.backupTagRecords(from);
+        io.logger.info(`[memory] Room merge 备份:${from} → ${to},${backup.count} 条 → ${backup.file}`);
+        let applied = 0;
+        let hasMore = false;
+        const families = new Set();
+        const scenes = new Set();
+        // 游标重写:上限 cap/次,hasMore 时继续(总量受 cap×轮次约束,单飞内收敛)
+        for (;;) {
+            const r = io.l1.rewriteTag(from, to, cap);
+            applied += r.rewritten;
+            for (const f of r.families)
+                families.add(f);
+            for (const sc of r.scenes)
+                scenes.add(sc);
+            if (!r.hasMore || r.rewritten === 0)
+                break;
+        }
+        await io.registry.markMerged(from, to);
+        io.l1.invalidateRooms();
+        io.logger.info(`[memory] Room merge 完成:${from} → ${to},重写 ${applied} 条;受影响场景 ${scenes.size} 个`);
+        return {
+            dryRun: false,
+            affected,
+            preview,
+            applied,
+            hasMore,
+            backupFile: backup.file,
+            ...(families.size > 0 || scenes.size > 0 ? { families: [...families], scenes: [...scenes] } : {}),
+        };
+    }
+    finally {
+        roomMergeRunning = false;
+    }
+}
+/** rename = merge 1:1 + 注册表改名(冲突时抛错提示走 merge)。 */
+export async function renameRoom(io, from, to, opts = {}) {
+    const r = await mergeRoom(io, from, to, opts);
+    if (!r.dryRun && r.applied > 0)
+        await io.registry.renameSlug(from, to);
+    return r;
+}
 /** 下一条待复查(供 agent 逐个过):记录摘要 + 候选 + 现有 Room 词表 + 剩余数。 */
 export function nextReview(l1) {
     const queue = pendingQueue(l1);

package/dist/stats.js

@@ -56,6 +56,7 @@ export const MEMORY_ENDPOINTS = [
     'dsh-memory/wing-overview',
     'dsh-memory/rooms-get',
     'dsh-memory/rooms-export',
+    'dsh-memory/room-register',
     'dsh-memory/wing-backfill',
     'dsh-memory/session-stats',
     'dsh-memory/settings-get',
@@ -679,6 +680,27 @@ export async function handleEndpoint(endpoint, payload, deps) {
             };
             return v;
         }
+        case 'dsh-memory/room-register': {
+            if (!roomRegistry)
+                throw new Error('Room 注册表未装配(需要插件重载以初始化)。');
+            if (!live?.get().memoryMutate)
+                throw new Error('记忆写删未开放:请在记忆库面板开启「高权限模式」后,模型才能预注册 Room。');
+            const p = (payload ?? {});
+            const slug = String(p.slug ?? '').trim();
+            if (!slug)
+                throw new Error('slug 不能为空');
+            const r = await roomRegistry.register({
+                slug,
+                label: typeof p.label === 'string' ? p.label : undefined,
+                description: typeof p.description === 'string' ? p.description : undefined,
+            });
+            const v = {
+                slug: r.entry.slug,
+                created: r.created,
+                notice: r.created ? '已预注册。' : '已存在(只补全了缺失的 label/description)。',
+            };
+            return v;
+        }
         case 'dsh-memory/rooms-export': {
             const p = (payload ?? {});
             const kind = p.kind === 'orphans' ? 'orphans' : p.kind === 'rooms' ? 'rooms' : '';

package/dist/store/l1.d.ts

@@ -110,6 +110,34 @@ export declare class L1Store {
         source: string;
     } | null;
     finishSceneRecluster(jobId: string, ok: boolean): void;
+    /**
+     * 收集某 Room 的全部匹配记录(含已退场行,口径与 Room 计数一致)。
+     * 内部分页拉取,上限 cap 防跑飞;返回记录数组供备份与干跑预览。
+     */
+    listByTagAll(tag: string, cap?: number): MemoryRecord[];
+    /**
+     * 备份某 Room 的匹配记录到 `<dataDir>/rooms-merge-backups/<ts>-<tag>.json`
+     * (执行前快照;破坏性重写前的唯一回滚物料)。返回备份文件路径与条数。
+     */
+    backupTagRecords(tag: string): {
+        file: string;
+        count: number;
+    };
+    /**
+     * 游标重写:把 metadata.tags 里的 `from` 全部替换为 `to`(**含已退场行**,
+     * 口径与 Room 计数一致)。写前重读-合并-写回(relabel 同款):只动 tags,
+     * roomCandidates/roomReview/hall/cogHall/sourceAnchors 等其余键原样保全。
+     *
+     * 单次上限 cap(500)可续跑:再次调用同一 from 即继续处理剩余行。
+     * 返回重写条数 + 受影响的 (family, scene) 集(供 recluster 'room-merge' 入队)。
+     */
+    rewriteTag(from: string, to: string, cap?: number): {
+        rewritten: number;
+        scanned: number;
+        families: string[];
+        scenes: string[];
+        hasMore: boolean;
+    };
     /** 按 id 精确取记录(去重决策的版本号查询用,避免全表扫描)。 */
     getByIds(ids: string[]): MemoryRecord[];
     /**

package/dist/store/l1.js

@@ -6,7 +6,7 @@
  *
  * 去重/合并的更新记录走 upsert(新 record id + 版本递增),不再全量重写文件。
  */
-import { existsSync, promises as fs } from 'node:fs';
+import { existsSync, mkdirSync, promises as fs, writeFileSync } from 'node:fs';
 import * as path from 'node:path';
 import { familyForType, isScopeVisible } from '../types.js';
 import { graphHitRecordIds } from '../graph/search.js';
@@ -162,6 +162,65 @@ export class L1Store {
     finishSceneRecluster(jobId, ok) {
         this.db.finishSceneRecluster(jobId, ok);
     }
+    // ── Room merge/rename 的游标重写(分类管理 beta.5;破坏性面)──────────────
+    /**
+     * 收集某 Room 的全部匹配记录(含已退场行,口径与 Room 计数一致)。
+     * 内部分页拉取,上限 cap 防跑飞;返回记录数组供备份与干跑预览。
+     */
+    listByTagAll(tag, cap = 500) {
+        const out = [];
+        for (let offset = 0; offset < cap; offset += 200) {
+            const page = this.list({ tag, retired: undefined, limit: Math.min(200, cap - out.length), offset });
+            out.push(...page.items);
+            if (page.items.length < 200 || out.length >= cap)
+                break;
+        }
+        return out;
+    }
+    /**
+     * 备份某 Room 的匹配记录到 `<dataDir>/rooms-merge-backups/<ts>-<tag>.json`
+     * (执行前快照;破坏性重写前的唯一回滚物料)。返回备份文件路径与条数。
+     */
+    backupTagRecords(tag) {
+        const records = this.listByTagAll(tag, 2000);
+        const backupDir = path.join(this.dataDir, 'rooms-merge-backups');
+        if (!existsSync(backupDir))
+            mkdirSync(backupDir, { recursive: true });
+        const file = path.join(backupDir, `${Date.now()}-${tag.replace(/[^a-z0-9-]/gi, '_')}.json`);
+        writeFileSync(file, JSON.stringify({ tag, exportedAt: new Date().toISOString(), records }, null, 2), 'utf8');
+        return { file, count: records.length };
+    }
+    /**
+     * 游标重写:把 metadata.tags 里的 `from` 全部替换为 `to`(**含已退场行**,
+     * 口径与 Room 计数一致)。写前重读-合并-写回(relabel 同款):只动 tags,
+     * roomCandidates/roomReview/hall/cogHall/sourceAnchors 等其余键原样保全。
+     *
+     * 单次上限 cap(500)可续跑:再次调用同一 from 即继续处理剩余行。
+     * 返回重写条数 + 受影响的 (family, scene) 集(供 recluster 'room-merge' 入队)。
+     */
+    rewriteTag(from, to, cap = 500) {
+        const rows = this.listByTagAll(from, cap + 1);
+        const hasMore = rows.length > cap;
+        const batch = rows.slice(0, cap);
+        let rewritten = 0;
+        const families = new Set();
+        const scenes = new Set();
+        for (const r of batch) {
+            const meta = { ...(r.metadata ?? {}) };
+            const tags = Array.isArray(meta.tags) ? meta.tags.map(String) : [];
+            if (!tags.includes(from))
+                continue; // 命中是 json_each 判等,数组缺失即无可改
+            const next = tags.map((t) => (t === from ? to : t));
+            meta.tags = [...new Set(next)];
+            if (this.patchMetadata(r.id, meta)) {
+                rewritten++;
+                families.add(r.family ?? 'chat');
+                if (r.scene_name)
+                    scenes.add(r.scene_name);
+            }
+        }
+        return { rewritten, scanned: batch.length, families: [...families], scenes: [...scenes], hasMore };
+    }
     /** 按 id 精确取记录(去重决策的版本号查询用,避免全表扫描)。 */
     getByIds(ids) {
         return this.db.getL1ByIds(ids);

package/dist/store/rooms-registry.d.ts

@@ -17,6 +17,13 @@ export interface RoomRegistryEntry {
     updatedAt: string;
 }
 export type RoomRegistryInput = Pick<RoomRegistryEntry, 'slug'> & Partial<Pick<RoomRegistryEntry, 'label' | 'description' | 'source' | 'aliases'>>;
+/**
+ * 两级 Room slug:`major` 或 `major/minor`(如 `dsh-plugin`、`dsh-plugin/merge`)。
+ * 两段各自满足 isTag 词表;小类归属其大类。
+ */
+export declare function isRoomSlug(v: unknown): boolean;
+/** 大类归属:`major/minor` 取 major;平级 slug 自身即大类。 */
+export declare function majorOf(slug: string): string;
 export declare class RoomRegistryStore {
     private readonly logger?;
     private readonly file;

package/dist/store/rooms-registry.js

@@ -15,8 +15,27 @@ import { isTag } from '../metadata-validators.js';
 import { readJsonStrict, atomicWriteText, ensureDir } from '../util/io.js';
 /** 版本常量(file-versions 同款集中纪律;registry 为独立 sidecar 文件)。 */
 export const ROOMS_REGISTRY_FILE_VERSION = 1;
-/** 注册表上限(防刷:词表膨胀会直接进标注器 prompt;真需求超限时先 retire/合并)。 */
-const REGISTRY_CAP = 200;
+/** 大类(顶层)注册上限(防刷)。小类(`major/minor`)不占大类额度,另有总量保险。 */
+const REGISTRY_MAJOR_CAP = 200;
+/** 全量保险上限(大类+小类总和;防极端滥用)。 */
+const REGISTRY_TOTAL_CAP = 2000;
+/**
+ * 两级 Room slug:`major` 或 `major/minor`(如 `dsh-plugin`、`dsh-plugin/merge`)。
+ * 两段各自满足 isTag 词表;小类归属其大类。
+ */
+export function isRoomSlug(v) {
+    if (typeof v !== 'string')
+        return false;
+    const parts = v.split('/');
+    if (parts.length > 2)
+        return false;
+    return parts.every((p) => isTag(p));
+}
+/** 大类归属:`major/minor` 取 major;平级 slug 自身即大类。 */
+export function majorOf(slug) {
+    const i = slug.indexOf('/');
+    return i === -1 ? slug : slug.slice(0, i);
+}
 /** aliases 上限(合并/改名历史)。 */
 const ALIASES_CAP = 16;
 export class RoomRegistryStore {
@@ -88,8 +107,9 @@ export class RoomRegistryStore {
     async register(input) {
         this.ensureLoaded();
         const slug = String(input.slug ?? '').trim().toLowerCase();
-        if (!slug || !isTag(slug))
-            throw new Error(`非法 Room slug: ${String(input.slug)}(需小写字母数字连字符)`);
+        if (!slug || !isRoomSlug(slug)) {
+            throw new Error(`非法 Room slug: ${String(input.slug)}(两级制:major 或 major/minor,各段小写字母数字连字符)`);
+        }
         const found = this.entries.find((e) => e.slug === slug || (e.aliases ?? []).includes(slug));
         if (found) {
             let changed = false;
@@ -108,8 +128,17 @@ export class RoomRegistryStore {
             }
             return { entry: { ...found }, created: false };
         }
-        if (this.entries.length >= REGISTRY_CAP) {
-            throw new Error(`Room 注册表已达上限(${REGISTRY_CAP}),请先 retire/合并部分条目`);
+        // 额度两级制(用户裁定:200 上限只管大类;小类细分不占大类额度):
+        // 大类 = slug 无 '/' 的条目 ∪ 已用 major 前缀;小类只受总量保险约束。
+        const isMinor = slug.includes('/');
+        if (isMinor && this.entries.length >= REGISTRY_TOTAL_CAP) {
+            throw new Error(`Room 注册表总量已达上限(${REGISTRY_TOTAL_CAP}),请先合并/退役部分条目`);
+        }
+        if (!isMinor) {
+            const majors = new Set(this.entries.map((e) => majorOf(e.slug)));
+            if (!majors.has(slug) && majors.size >= REGISTRY_MAJOR_CAP) {
+                throw new Error(`大类已达上限(${REGISTRY_MAJOR_CAP}):请用「大类/小类」细分(如 ${slug}/子项),或合并/退役部分大类`);
+            }
         }
         const now = new Date().toISOString();
         const entry = {

package/dist/tools/index.js

@@ -3,7 +3,7 @@ import { RECEIPTS_QUERY_LIMIT_MAX, dimensionOf, toReceiptView } from '../store/r
 import { listConflictPairs, renderConflictResolution, renderConflicts, resolveConflictPair } from '../conflict-service.js';
 import { WING_CATALOG, WING_FALLBACK, normPersistence, normScope, resolveRecordScope } from '../types.js';
 import { scopeFilterOf, workspaceIdOf } from '../workspace.js';
-import { annotateOrphanCandidates, confirmReview, nextReview, pendingReviewCount, skipReview, } from '../room-review.js';
+import { annotateOrphanCandidates, confirmReview, mergeRoom, nextReview, pendingReviewCount, renameRoom, skipReview, } from '../room-review.js';
 import { applyGovernanceWeights } from '../store/governance.js';
 import { resolveRepoScope } from '../repo-scope.js';
 import { GRAPH_STATUS_LABELS } from '../prompts/graph-projection.js';
@@ -190,13 +190,18 @@ roomRegistry) {
     ctx.tools.register(defineTool({
         name: 'memory_room_admin',
         description: 'Room 分类管理(目录粒度)。action="list" 列出注册表条目与自生长 Room 计数;' +
-            'action="register" 预注册一个 Room(高权限;slug 需小写字母数字连字符,可选人类可读名与归类说明——' +
-            '注册后候选标注器与 tags 标注器会优先把记忆挂到这些 Room 上,是治理碎片化的推荐入口)。',
+            'action="register" 预注册一个 Room(高权限;两级制——大类上限 200,小类用「大类/小类」细分不占额度,如 dsh-plugin/merge;' +
+            'action="merge" 合并两个 Room(高权限;dryRun 默认 true 只返预览,实跑改写全部匹配记录的 tags 并入队场景重算,执行前自动备份);' +
+            'action="rename" 改名(= merge 1:1 + 注册表改名);action="retire" 退役一个注册 Room(高权限;存量记录不动)。' +
+            'merge/rename 与反刍并发会相互覆盖,请在反刍空闲时执行。',
         parameters: {
-            action: { type: 'string', required: true, description: 'list(列目录)| register(预注册 Room,高权限)' },
+            action: { type: 'string', required: true, description: 'list | register(高权限) | merge(高权限) | rename(高权限) | retire(高权限)' },
             slug: { type: 'string', description: 'register 的 Room slug(小写字母数字连字符)' },
             label: { type: 'string', description: 'register 的人类可读名(可选,可中文)' },
             description: { type: 'string', description: 'register 的归类说明(可选;喂给标注器帮助归类)' },
+            from: { type: 'string', description: 'merge/rename 的源 Room slug' },
+            to: { type: 'string', description: 'merge/rename 的目标 Room slug' },
+            dryRun: { type: 'string', description: 'merge/rename:默认 true 只返预览;"false" 才实际执行' },
         },
         output: {
             schema: {
@@ -252,7 +257,60 @@ roomRegistry) {
                     return { notice: `注册失败: ${err instanceof Error ? err.message : String(err)}` };
                 }
             }
-            return { notice: `非法 action:${action}(允许 list/register;merge/rename/retire 将在后续版本提供)。` };
+            if (action === 'merge' || action === 'rename') {
+                if (!roomRegistry)
+                    return { notice: 'Room 注册表未装配(需要插件重载以初始化)。' };
+                if (!live.get().memoryMutate)
+                    return { notice: MUTATE_OFF_NOTICE };
+                const from = String(args.from ?? '').trim();
+                const to = String(args.to ?? '').trim();
+                if (!from || !to)
+                    return { notice: 'merge/rename 需要 from 与 to 两个 slug。' };
+                const dryRun = String(args.dryRun ?? 'true').toLowerCase() !== 'false';
+                try {
+                    const fn = action === 'merge' ? mergeRoom : renameRoom;
+                    const r = await fn({ l1: stores.l1, registry: roomRegistry, logger }, from, to, { dryRun });
+                    if (r.dryRun) {
+                        return {
+                            notice: `[dryRun 预览] ${from} → ${to}:影响 ${r.affected} 条${r.hasMore ? '(超过单次上限,需续跑)' : ''}。` +
+                                `样例:${r.preview.join(', ') || '无'}。确认无误后以 dryRun="false" 执行(执行前自动备份,重写含已退场行,完成后自动入队场景重算)。`,
+                            affected: r.affected,
+                        };
+                    }
+                    // 实跑:受影响场景入队重算(source='room-merge')
+                    let requeued = 0;
+                    for (const family of r.families ?? []) {
+                        for (const scene of r.scenes ?? []) {
+                            stores.l1.enqueueSceneRecluster(family, [scene], `room-merge:${Date.now()}`, 'room-merge');
+                            requeued++;
+                        }
+                    }
+                    return {
+                        notice: `${action === 'merge' ? '合并' : '改名'}完成:${from} → ${to},重写 ${r.applied} 条` +
+                            `(备份:${r.backupFile ?? '无'})${requeued > 0 ? `;已入队 ${requeued} 个场景重算` : ''}。`,
+                        applied: r.applied,
+                        id: to,
+                    };
+                }
+                catch (err) {
+                    return { notice: `${action} 失败: ${err instanceof Error ? err.message : String(err)}` };
+                }
+            }
+            if (action === 'retire') {
+                if (!roomRegistry)
+                    return { notice: 'Room 注册表未装配(需要插件重载以初始化)。' };
+                if (!live.get().memoryMutate)
+                    return { notice: MUTATE_OFF_NOTICE };
+                const slug = String(args.slug ?? '').trim();
+                try {
+                    const ok = await roomRegistry.setStatus(slug, 'retired');
+                    return { notice: ok ? `已退役 Room:${slug}(存量记录的 tags 不动,仅词表不再推荐)。` : `未找到注册条目:${slug}(自生长 Room 无需退役,会随 tags 自然消失)。`, slug };
+                }
+                catch (err) {
+                    return { notice: `退役失败: ${err instanceof Error ? err.message : String(err)}` };
+                }
+            }
+            return { notice: `非法 action:${action}(允许 list/register/merge/rename/retire)。` };
         },
     }));
     // ── conversation_search: L0 原始对话 ──
@@ -898,7 +956,7 @@ roomRegistry) {
                 };
             }
             if (action === 'annotate') {
-                const r = await annotateOrphanCandidates(ctx, cfg, io, 40);
+                const r = await annotateOrphanCandidates(ctx, cfg, { ...io, registry: roomRegistry }, 40);
                 return {
                     notice: `候选预标记完成:选中 ${r.selected} 条,产候选 ${r.candidates} 条,写 pending ${r.written} 条。用 action=next 逐个复查。`,
                     annotated: r.candidates,

package/dsh.plugin.json

@@ -1,7 +1,7 @@
 {
   "id": "dsh-prime-memory",
   "name": "dsh-prime-memory",
-  "version": "0.20.0-beta.4-dsh0.2.0.1",
+  "version": "0.20.0-beta.6-dsh0.2.0.1",
   "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.20.0-beta.4",
+  "version": "0.20.0-beta.6",
   "publishConfig": {
     "registry": "https://registry.npmjs.org",
     "access": "public",