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

package/CHANGELOG.md

@@ -17,7 +17,18 @@
   - **建议状态(`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.3] — 2026-10-01
+## [0.20.0-beta.4] — 2026-10-01
+
+> Room 分类管理第一船(**零漂移面**):注册表空 = 与 beta.3 行为逐字一致。merge/rename/retire 破坏性面将随 beta.5(dryRun 默认 true 保留一版)。
+
+### 新增
+
+- **Room 注册表(`rooms-registry.json` sidecar)**:预先注册策划好的 Room(slug/label/description);损坏/为空 → 降级回退纯自生长目录,绝不阻塞面板与标注器;上限 200 防刷。`rooms-get` 端点层合并:注册条目 count=0 也进词表并带 `source`/`label`,响应新增 `registry` 全量字段(客户端可选读)。
+- **导出端点 `dsh-memory/rooms-export`**(kind=rooms|orphans,CSV 直出):rooms = 注册表∪自生长词表带计数;orphans = 无 Room 绑定的活跃记录清单(含候选/复查状态列)。
+- **工具 `memory_room_admin`**(action=list|register):list 列注册表+自生长总览;register 预注册 Room(高权限门,幂等补全)——配合 `memory_room_review` 的逐个复查,agent 有了「注册→预标记→逐个确认」的完整分类管理入口。
+- 客户端:Room chip 带「预注册/自生长」来源标示;孤儿 chip 带待复查语义。
+
+## [0.20.0-beta.3] — 2026-10-01## [0.20.0-beta.3] — 2026-10-01
 
 ### 新增
 

package/dist/client.js

@@ -3298,6 +3298,7 @@ var __defProp = Object.defineProperty;
 		  });
 		  const [roomPage, setRoomPage] = (0, import_react15.useState)(0);
 		  const [orphanCount, setOrphanCount] = (0, import_react15.useState)(0);
+		  const [roomRegistry, setRoomRegistry] = (0, import_react15.useState)([]);
 		  const [retiredFilter, setRetiredFilter] = (0, import_react15.useState)("");
 		  const [rooms, setRooms] = (0, import_react15.useState)([]);
 		  const [wingCatalog, setHallCatalog] = (0, import_react15.useState)(null);
@@ -3356,6 +3357,7 @@ var __defProp = Object.defineProperty;
 		      if (r && r.ok) {
 		        setRooms(r.value.rooms ?? []);
 		        setOrphanCount(r.value.orphanCount ?? 0);
+		        setRoomRegistry(r.value.registry ?? []);
 		      }
 		    }).catch(() => {
 		    });
@@ -3562,6 +3564,35 @@ var __defProp = Object.defineProperty;
 		            ]
 		          }
 		        ),
+		        rooms.length > 0 || orphanCount > 0 ? /* @__PURE__ */ (0, import_jsx_runtime15.jsx)(
+		          "button",
+		          {
+		            type: "button",
+		            title: "导出分类数据 CSV(Room 词表+计数)",
+		            onClick: () => {
+		              rpc("dsh-memory/rooms-export", { kind: "rooms" }).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-rooms.csv";
+		                a.click();
+		                URL.revokeObjectURL(url);
+		              }).catch(() => void 0);
+		            },
+		            style: {
+		              cursor: "pointer",
+		              fontSize: 12,
+		              padding: "2px 8px",
+		              borderRadius: 6,
+		              border: "1px solid var(--dsh-mem-border)",
+		              background: "transparent",
+		              color: "var(--dsh-mem-text-2)"
+		            },
+		            children: "导出 CSV"
+		          }
+		        ) : null,
 		        /* @__PURE__ */ (0, import_jsx_runtime15.jsx)(
 		          "button",
 		          {
@@ -3612,7 +3643,7 @@ var __defProp = Object.defineProperty;
 		        /* @__PURE__ */ (0, import_jsx_runtime15.jsxs)("div", { style: { display: "flex", flexWrap: "wrap", gap: 6, alignItems: "center", marginBottom: roomsOpen ? 6 : 0 }, children: [
 		          (roomsOpen ? rooms.slice(roomPage * ROOM_PAGE_SIZE, (roomPage + 1) * ROOM_PAGE_SIZE) : rooms.slice(0, 8)).map((r) => {
 		            const on = tagFilter === r.room && !untaggedOnly;
-		            return /* @__PURE__ */ (0, import_jsx_runtime15.jsx)(
+		            return /* @__PURE__ */ (0, import_jsx_runtime15.jsxs)(
 		              "button",
 		              {
 		                type: "button",
@@ -3634,7 +3665,10 @@ var __defProp = Object.defineProperty;
 		                  background: on ? "var(--dsh-mem-bg-inset)" : "transparent",
 		                  color: on ? "var(--dsh-mem-accent)" : "var(--dsh-mem-text-2)"
 		                },
-		                children: r.room + " · " + r.count
+		                children: [
+		                  r.label ? r.label + " · " + r.count : r.room + " · " + r.count,
+		                  r.source === "pre-registered" ? " ⭐" : ""
+		                ]
 		              },
 		              r.room
 		            );

package/dist/contract.d.ts

@@ -557,12 +557,39 @@ export interface WingOverviewResponse {
  * 降级/无 tags 时 `rooms` 为空数组(面板显示"暂无"),不报错。
  */
 export interface RoomsGetResponse {
-    /** Room 列表(按记录数降序,同数按名升序)。 */
+    /** Room 列表(按记录数降序,同数按名升序;注册表条目 count=0 并带 source/label)。
+     *  条目可选字段 source/label 由端点层合并注册表后附带(客户端可选读,零断裂)。 */
     rooms: RoomCount[];
     /** Room 总数(= rooms.length,冗余只为前端少写一次 .length)。 */
     total: number;
     /** 孤儿记忆数:没有任何 Room(tags 为空/缺失)的记录条数(与 rooms 同口径含已退场)。 */
     orphanCount: number;
+    /** 注册表条目(全量含 retired;分类管理面板用;未装配 = undefined)。 */
+    registry?: Array<{
+        slug: string;
+        label?: string;
+        description?: string;
+        source: 'pre-registered' | 'grown';
+        aliases?: string[];
+        status: 'active' | 'retired';
+    }>;
+}
+/** dsh-memory/rooms-export(分类数据导出,CSV 直出)。 */
+export interface RoomsExportRequest {
+    /** rooms = 词表+计数;orphans = 无 Room 绑定的记录清单。 */
+    kind: 'rooms' | 'orphans';
+    /** orphans 上限(1..10000,默认 2000)。 */
+    limit?: number;
+}
+export interface RoomsExportResponse {
+    kind: 'rooms' | 'orphans';
+    /** CSV 文本(首行表头;
+   行尾;RFC 4180 转义)。 */
+    csv: string;
+    /** 数据行数(不含表头)。 */
+    total: number;
+    /** truncated = 达到 limit 上限,结果可能不完整。 */
+    truncated: boolean;
 }
 /** dsh-memory/wing-backfill(一键回填,后台任务;端点立即返回,进度以 wing-overview 轮询)。 */
 export interface WingBackfillResponse {
@@ -1260,6 +1287,7 @@ export interface DshMemoryRequestMap {
     'dsh-memory/longtask-compress-tail': LongTaskCompressTailRequest;
     'dsh-memory/wing-overview': Record<string, never>;
     'dsh-memory/rooms-get': Record<string, never>;
+    'dsh-memory/rooms-export': RoomsExportRequest;
     'dsh-memory/wing-backfill': Record<string, never>;
     'dsh-memory/session-stats': SessionStatsRequest;
     'dsh-memory/settings-get': Record<string, never>;
@@ -1307,6 +1335,7 @@ export interface DshMemoryResponseMap {
     'dsh-memory/session-mode-set': SessionModeSetResponse;
     'dsh-memory/wing-overview': WingOverviewResponse;
     'dsh-memory/rooms-get': RoomsGetResponse;
+    'dsh-memory/rooms-export': RoomsExportResponse;
     'dsh-memory/wing-backfill': WingBackfillResponse;
     'dsh-memory/session-stats': SessionStatsResponse;
     'dsh-memory/settings-get': SettingsGetResponse;

package/dist/index.js

@@ -39,6 +39,7 @@ import { registerSlotRecall } from './hooks/slot-recall.js';
 import { registerLongTaskMonitor } from './hooks/long-task.js';
 import { ContextUsageStore } from './store/context-usage.js';
 import { TodoRefStore } from './store/todo-ref.js';
+import { RoomRegistryStore } from './store/rooms-registry.js';
 import { registerSlotsProjection } from './projection/slots.js';
 import { errDetail, withFileLog } from './util/filelog.js';
 import { buildRouteChain, resolveModelRoute, invalidateEffortCache } from './llm.js';
@@ -364,6 +365,9 @@ export async function apply(ctx, config) {
     // todo/write 快照参考(仅长任务会话;写 pinned 槽位走 slot-recall 常驻注入)。
     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,
@@ -376,7 +380,7 @@ export async function apply(ctx, config) {
     }
     const recall = registerRecall(ctx, config, stores, logger, live, modes, dataDir);
     runner.setAfterRun(recall.invalidateProfile);
-    registerMemoryTools(ctx, config, stores, logger, modes, live, ruminate);
+    registerMemoryTools(ctx, config, stores, logger, modes, live, ruminate, storageOk ? roomRegistry : undefined);
     // 激活槽位(active slot):工具面 + 常驻注入 + 服务端投影(均走 ctx.effect,可撤销)
     registerSlotTools(ctx, config, stores.slots, logger, modes, live, stores.l1);
     const slotRecall = registerSlotRecall(ctx, config, stores.slots, logger, live);
@@ -395,7 +399,7 @@ export async function apply(ctx, config) {
         runnerView: (sid, mode) => runner.sessionView(sid, mode),
         l0Count: (sid) => stores.l0.countBySession(sid),
         capabilities: () => db.getCapabilities(),
-    }, ruminate, storageOk ? { runner, slots: stores.slots, contextUsage, todoRef } : undefined);
+    }, ruminate, storageOk ? { runner, slots: stores.slots, contextUsage, todoRef } : undefined, storageOk ? roomRegistry : undefined);
     // bench 控制服务(config.benchControl 门控,默认关):仅基准/调试部署注册,
     // 供同进程的 bench-runner lifecycle 赛道触发 rebuild / 设置会话档位
     // (宿主侧 RPC 无 call(),见 bench-control.ts)

package/dist/pipeline/ruminate.js

@@ -4,6 +4,7 @@ import { errDetail } from '../util/filelog.js';
 import { runSceneConsolidation } from './l2.js';
 import { relabelPass } from './relabel.js';
 import { processSceneReclusterJobs } from './recluster.js';
+import { annotateOrphanCandidates } from '../room-review.js';
 import { runPersona } from './l3.js';
 const IDLE_STATUS = {
     running: false,
@@ -233,6 +234,17 @@ export class RuminateController {
             catch (err) {
                 this.logger.warn(`[memory] 场景重聚类调度失败(忽略): ${errDetail(err)}`);
             }
+            // 孤儿候选预标记(长尾治理):无 Room 的活跃孤儿对照现有 Room 词表产出
+            // 候选(roomReview='pending'),由 agent 用 memory_room_review 逐个复查;
+            // 每轮至多 40 条,吞错不拖垮反刍。
+            try {
+                const r = await annotateOrphanCandidates(this.ctx, this.cfg, { l1: this.stores.l1, logger: this.logger }, 40);
+                if (r.written > 0)
+                    this.status.detail = `孤儿候选预标记 ${r.written} 条(待 agent 复查,工具 memory_room_review)`;
+            }
+            catch (err) {
+                this.logger.warn(`[memory] 孤儿候选预标记失败(忽略): ${errDetail(err)}`);
+            }
             this.status.phase = 'done';
             this.finish(null);
         }

package/dist/room-review.d.ts

@@ -0,0 +1,118 @@
+/**
+ * 孤儿记忆的 Room 候选预标记 + agent 逐个复查(长尾治理)。
+ *
+ * 背景:Room 由 metadata.tags 自生长,但 tags 只在反刍 relabel 段随 wing 补打
+ * 顺带产出(每轮 ≤40 条、且只覆盖本轮补 wing 的记录)——「有 wing 无 tags」与
+ * 「预算用尽被 deferred」的记录成为无 Room 绑定的孤儿,且标注器不参考现有
+ * Room 词表,产出碎片化新 slug(81 个 Room 大多 1 条的成因)。
+ *
+ * 两段式:
+ *  1. **预标记(annotateOrphanCandidates)**:抽取活跃孤儿,LLM 对照**现有 Room
+ *     词表**产出候选(优先挂靠现有 Room,≤2 个新 slug 兜底),写
+ *     `metadata.roomCandidates` + `roomReview:'pending'`——不动 tags、不进
+ *     Room、不进召回,只是"待确认的建议"。
+ *  2. **逐个复查(memory_room_review 工具)**:agent 取下一条待复查记录
+ *     (带候选 + 现有 Room 词表),确认后 confirm 写入 tags(进 Room,高权限
+ *     门控),或 skip 跳过。确认/跳过都是显式动作,预标记本身零行为面。
+ *
+ * 存储即 metadata 保留键(与 relabel 写 tags 同款 patchMetadata 合并纪律,
+ * 写前重读):`roomCandidates` / `roomReview:'pending'|'confirmed'|'skipped'`。
+ * 两键不在 rooms 聚合(rooms 只读 $.tags)、不在快照哈希投影关注的治理列——
+ * 与既有 metadata 键同层,无 schema 变更。
+ */
+import type { Context } from '@deepseek-ai/cordis';
+import type { MemoryConfig } from './config.js';
+import type { MemoryLogger, MemoryRecord } from './types.js';
+export declare const ROOM_CANDIDATES_KEY = "roomCandidates";
+export declare const ROOM_REVIEW_KEY = "roomReview";
+export type RoomReviewState = 'pending' | 'confirmed' | 'skipped';
+/** 复查与候选操作对 L1 的最小依赖面(便于测试注入)。 */
+export interface RoomReviewStore {
+    list(opts: {
+        untagged?: boolean;
+        retired?: boolean;
+        limit: number;
+        offset: number;
+    }): {
+        items: MemoryRecord[];
+        total: number;
+    };
+    getByIds(ids: readonly string[]): MemoryRecord[];
+    patchMetadata(id: string, metadata: Record<string, unknown>): boolean;
+    listRooms(): Array<{
+        room: string;
+        count: number;
+    }>;
+    /** 确认写 tags 后失效 Room 计数缓存(30s TTL)。 */
+    invalidateRooms(): void;
+}
+export interface RoomCandidate {
+    id: string;
+    rooms: string[];
+}
+/** 解析标注器输出的逐条候选(容错:id 配对失败丢弃;isTag 校验;目录内优先,≤3)。 */
+export declare function parseRoomCandidateItems(parsed: ReadonlyArray<{
+    id: string;
+    rooms: readonly string[];
+}>, ids: ReadonlyArray<string>, roomCatalog: ReadonlyArray<{
+    room: string;
+    count: number;
+}>): RoomCandidate[];
+/** 候选标注系统 prompt:喂现有 Room 词表(带计数),优先挂靠、少量新建兜底。 */
+export declare function roomCandidateSystemPrompt(roomCatalog: ReadonlyArray<{
+    room: string;
+    count: number;
+}>): string;
+/** 候选标注器:一批孤儿记录 → 候选 Room(优先现有词表;失败返回空,调用方零改动)。 */
+export declare function roomCandidateChunk(ctx: Context, cfg: MemoryConfig, logger: MemoryLogger, chunk: MemoryRecord[], roomCatalog: ReadonlyArray<{
+    room: string;
+    count: number;
+}>): Promise<Array<{
+    id: string;
+    rooms: string[];
+}>>;
+export interface OrphanAnnotateIO {
+    l1: RoomReviewStore;
+    logger: MemoryLogger;
+}
+/**
+ * 预标记消费器:活跃孤儿(≤limit 条)批量产候选并写 pending。
+ * 写前重读合并(与 relabel 同纪律);失败单条跳过、原记录零改动。
+ */
+export interface OrphanAnnotateOverrides {
+    /** 测试注入口:替换 LLM 候选标注器(默认走真实 callLLM 路径)。 */
+    chunkAnnotator?: (chunk: MemoryRecord[]) => Promise<Array<{
+        id: string;
+        rooms: string[];
+    }>>;
+}
+export declare function annotateOrphanCandidates(ctx: Context, cfg: MemoryConfig, io: OrphanAnnotateIO, limit?: number, overrides?: OrphanAnnotateOverrides): Promise<{
+    selected: number;
+    candidates: number;
+    written: number;
+}>;
+/** 下一条待复查(供 agent 逐个过):记录摘要 + 候选 + 现有 Room 词表 + 剩余数。 */
+export declare function nextReview(l1: RoomReviewStore): {
+    id: string;
+    content: string;
+    type: string;
+    sceneName: string;
+    candidates: string[];
+    roomCatalog: Array<{
+        room: string;
+        count: number;
+    }>;
+    remaining: number;
+} | null;
+/** 待复查剩余数(面板/工具兜底信息)。 */
+export declare function pendingReviewCount(l1: RoomReviewStore): number;
+/**
+ * 确认复查结果:候选(或 agent 改写的)写入 metadata.tags(**进 Room**),
+ * 清候选、标 confirmed。**高权限门控由调用方执行**(与 memory_delete 同款)。
+ * 返回写入的 tags;id 不存在/状态非法返回 null。
+ */
+export declare function confirmReview(l1: RoomReviewStore, id: string, rooms: readonly string[]): {
+    tags: string[];
+} | null;
+/** 跳过:标 skipped(不再进 pending 队列)。已 confirmed 的记录不受 skip 影响(挂了 Room 的不算长尾)。 */
+export declare function skipReview(l1: RoomReviewStore, id: string): boolean;

package/dist/room-review.js

@@ -0,0 +1,199 @@
+import { isTag } from './metadata-validators.js';
+import { callLLM, parseJsonLogged } from './llm.js';
+export const ROOM_CANDIDATES_KEY = 'roomCandidates';
+export const ROOM_REVIEW_KEY = 'roomReview';
+/** 解析标注器输出的逐条候选(容错:id 配对失败丢弃;isTag 校验;目录内优先,≤3)。 */
+export function parseRoomCandidateItems(parsed, ids, roomCatalog) {
+    const idSet = new Set(ids);
+    const catalogSet = new Set(roomCatalog.map((r) => r.room));
+    const byId = new Map();
+    for (const item of parsed) {
+        if (!idSet.has(item.id))
+            continue;
+        const cleaned = [];
+        for (const r of item.rooms) {
+            const slug = typeof r === 'string' ? r.trim().toLowerCase() : '';
+            if (!slug || !isTag(slug))
+                continue;
+            if (!cleaned.includes(slug))
+                cleaned.push(slug);
+        }
+        // 目录内优先排前,其余兜底;截断到 3
+        cleaned.sort((a, b) => Number(catalogSet.has(b)) - Number(catalogSet.has(a)));
+        byId.set(item.id, cleaned.slice(0, 3));
+    }
+    return [...byId.entries()].map(([id, rooms]) => ({ id, rooms }));
+}
+/** 候选标注系统 prompt:喂现有 Room 词表(带计数),优先挂靠、少量新建兜底。 */
+export function roomCandidateSystemPrompt(roomCatalog) {
+    const catalog = roomCatalog.length > 0
+        ? roomCatalog
+            .slice(0, 40)
+            .map((r) => `- ${r.room}(现有 ${r.count} 条)`)
+            .join('\n')
+        : '(暂无现有 Room)';
+    return ('你是记忆库的 Room 归类器。给你若干条记忆(带 id)与现有 Room 词表(带计数),' +
+        '为每条记忆选出它最可能归属的 1-3 个 Room slug。规则:\n' +
+        '1. **优先从现有 Room 词表里选**(保持分类收敛,避免碎片化);\n' +
+        '2. 词表确实没有合适主题时,才提议最多 2 个新 slug(小写字母/数字/连字符);\n' +
+        '3. 完全无法判断时返回空数组(宁缺毋滥,不硬猜)。\n' +
+        `现有 Room 词表:\n${catalog}\n\n` +
+        '输出 JSON 数组:[{"id":"<原id>","rooms":["slug1","slug2"]}]。只输出 JSON,不要多余文字。');
+}
+/** 候选标注器:一批孤儿记录 → 候选 Room(优先现有词表;失败返回空,调用方零改动)。 */
+export async function roomCandidateChunk(ctx, cfg, logger, chunk, roomCatalog) {
+    const list = chunk.map((r, i) => `${i + 1}. id=${r.id}\n${r.content.slice(0, 300)}`).join('\n\n');
+    try {
+        const raw = await callLLM(ctx, cfg, {
+            system: roomCandidateSystemPrompt(roomCatalog),
+            user: `记忆列表:\n${list}`,
+            maxTokens: 4096,
+            layer: 'l1-extract',
+            logger,
+        });
+        const parsed = parseJsonLogged(raw, 'Room 候选标注', logger);
+        if (!Array.isArray(parsed))
+            return [];
+        const shape = parsed
+            .map((item) => ({
+            id: typeof item?.id === 'string' ? item.id : '',
+            rooms: Array.isArray(item?.rooms) ? item.rooms : [],
+        }))
+            .filter((x) => x.id !== '');
+        return parseRoomCandidateItems(shape, chunk.map((r) => r.id), roomCatalog);
+    }
+    catch (err) {
+        logger.warn(`[memory] Room 候选标注块失败(跳过 ${chunk.length} 条,原记录未改): ${err instanceof Error ? err.message : String(err)}`);
+        return [];
+    }
+}
+/** 活跃孤儿的选择器:untagged + 未退场,跳过已 skipped 的。 */
+function selectPendingOrphans(l1, limit) {
+    const out = [];
+    const seen = new Set();
+    for (let offset = 0; offset < 2000; offset += 200) {
+        const page = l1.list({ untagged: true, retired: false, limit: 200, offset });
+        for (const r of page.items) {
+            if (seen.has(r.id))
+                continue;
+            seen.add(r.id);
+            if (r.metadata?.[ROOM_REVIEW_KEY] === 'skipped')
+                continue;
+            out.push(r);
+            if (out.length >= limit)
+                return out;
+        }
+        if (page.items.length < 200)
+            break;
+    }
+    return out;
+}
+export async function annotateOrphanCandidates(ctx, cfg, io, limit = 40, overrides = {}) {
+    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();
+    const rows = overrides.chunkAnnotator !== undefined
+        ? await overrides.chunkAnnotator(selected)
+        : await roomCandidateChunk(ctx, cfg, io.logger, selected, rooms);
+    let written = 0;
+    for (const { id, rooms: candidates } of rows) {
+        if (candidates.length === 0)
+            continue;
+        const fresh = io.l1.getByIds([id])[0];
+        if (!fresh)
+            continue;
+        const meta = { ...(fresh.metadata ?? {}) };
+        meta[ROOM_CANDIDATES_KEY] = candidates;
+        meta[ROOM_REVIEW_KEY] = 'pending';
+        if (io.l1.patchMetadata(id, meta))
+            written++;
+    }
+    io.logger.info(`[memory] 孤儿候选预标记:选中 ${selected.length},产候选 ${rows.length},写 pending ${written} 条(待 agent 复查)`);
+    return { selected: selected.length, candidates: rows.length, written };
+}
+/** 待复查队列:pending 且有候选的活跃孤儿,按更新时间升序(最旧的先复查)。 */
+function pendingQueue(l1) {
+    const out = [];
+    const seen = new Set();
+    for (let offset = 0; offset < 2000; offset += 200) {
+        const page = l1.list({ untagged: true, retired: false, limit: 200, offset });
+        for (const r of page.items) {
+            if (seen.has(r.id))
+                continue;
+            seen.add(r.id);
+            const meta = (r.metadata ?? {});
+            if (meta[ROOM_REVIEW_KEY] === 'pending' && Array.isArray(meta[ROOM_CANDIDATES_KEY]))
+                out.push(r);
+        }
+        if (page.items.length < 200)
+            break;
+    }
+    return out.sort((a, b) => a.updatedAt - b.updatedAt);
+}
+/** 下一条待复查(供 agent 逐个过):记录摘要 + 候选 + 现有 Room 词表 + 剩余数。 */
+export function nextReview(l1) {
+    const queue = pendingQueue(l1);
+    if (queue.length === 0)
+        return null;
+    const r = queue[0];
+    const meta = (r.metadata ?? {});
+    return {
+        id: r.id,
+        content: r.content.slice(0, 600),
+        type: r.type,
+        sceneName: r.scene_name,
+        candidates: meta[ROOM_CANDIDATES_KEY] ?? [],
+        roomCatalog: l1.listRooms().slice(0, 40),
+        remaining: queue.length,
+    };
+}
+/** 待复查剩余数(面板/工具兜底信息)。 */
+export function pendingReviewCount(l1) {
+    return pendingQueue(l1).length;
+}
+/**
+ * 确认复查结果:候选(或 agent 改写的)写入 metadata.tags(**进 Room**),
+ * 清候选、标 confirmed。**高权限门控由调用方执行**(与 memory_delete 同款)。
+ * 返回写入的 tags;id 不存在/状态非法返回 null。
+ */
+export function confirmReview(l1, id, rooms) {
+    const found = l1.getByIds([id])[0];
+    if (!found)
+        return null;
+    const meta = { ...(found.metadata ?? {}) };
+    // 已确认/已跳过的不允许重复确认(防止 agent 循环空转)
+    if (meta[ROOM_REVIEW_KEY] === 'confirmed')
+        return null;
+    const cleaned = [];
+    for (const r of rooms) {
+        if (typeof r !== 'string')
+            continue;
+        const slug = r.trim().toLowerCase();
+        if (!slug || !isTag(slug) || cleaned.includes(slug))
+            continue;
+        cleaned.push(slug);
+    }
+    if (cleaned.length === 0)
+        return null;
+    meta.tags = cleaned;
+    delete meta[ROOM_CANDIDATES_KEY];
+    meta[ROOM_REVIEW_KEY] = 'confirmed';
+    if (!l1.patchMetadata(id, meta))
+        return null;
+    l1.invalidateRooms();
+    return { tags: cleaned };
+}
+/** 跳过:标 skipped(不再进 pending 队列)。已 confirmed 的记录不受 skip 影响(挂了 Room 的不算长尾)。 */
+export function skipReview(l1, id) {
+    const found = l1.getByIds([id])[0];
+    if (!found)
+        return false;
+    const meta = { ...(found.metadata ?? {}) };
+    if (meta[ROOM_REVIEW_KEY] === 'confirmed')
+        return false;
+    meta[ROOM_REVIEW_KEY] = 'skipped';
+    return l1.patchMetadata(id, meta);
+}

package/dist/stats.d.ts

@@ -3,6 +3,7 @@ import { type MemoryConfig } from './config.js';
 import { type RecallSessionStats } from './hooks/recall.js';
 import type { RebuildController } from './pipeline/rebuild.js';
 import type { RuminateController } from './pipeline/ruminate.js';
+import type { RoomRegistryStore } from './store/rooms-registry.js';
 import { type LiveSettingsHandle } from './settings.js';
 import type { GraphStore } from './store/graph-store.js';
 import type { L0Store } from './store/l0.js';
@@ -27,7 +28,7 @@ export interface MemoryStatusSource {
     pending(): number;
 }
 /**
- * 端点全集运行时清单(36 个,与 tests/contract-keys.test.ts 的 ENDPOINTS 及
+ * 端点全集运行时清单(与 tests/contract-keys.test.ts 的 ENDPOINTS 及
  * contract.ts 类型映射表三方对齐,漂移由键集 diff 测试暴露)。
  * 注意:本清单同时是 HTTP 前缀路由 `/dsh-memory/rpc/<短名>` 的**放行白名单**
  * (见下方 SHORT_ENDPOINTS),漏一条 = 该端点在面板里静默消失(404 被客户端
@@ -105,6 +106,8 @@ interface MemoryRpcSources {
     sessionInfo?: SessionInfoSource;
     /** 长任务端点依赖(未装配 = 端点恒 disabled,面板不挂载)。 */
     longTask?: LongTaskEndpointDeps;
+    /** Room 注册表(未装配 = rooms-get 不带 registry,rooms-export 不可用)。 */
+    roomRegistry?: RoomRegistryStore;
 }
 /** 端点 deps 的注入面(ctx/cfg/stores/logger 由调用方绑定,其余由此处决定)。 */
 export type EndpointDepsInput = Omit<EndpointDeps, 'ctx' | 'cfg' | 'stores' | 'logger'>;
@@ -128,7 +131,9 @@ export declare function registerMemoryRpc(ctx: Context, cfg: MemoryConfig, store
 /** 反刍控制器(存储降级时为 undefined):经 buildEndpointDeps 落入 deps.ruminate。 */
 ruminate?: RuminateController, 
 /** 长任务端点依赖(cfg.longTask.enabled 门控;缺省 = 端点恒 disabled)。 */
-longTaskDeps?: LongTaskEndpointDeps): void;
+longTaskDeps?: LongTaskEndpointDeps, 
+/** Room 分类管理依赖(注册表;缺省 = rooms-get 不带 registry、rooms-export 恒 404 语义)。 */
+roomRegistry?: RoomRegistryStore): void;
 export interface EndpointDeps {
     ctx: Context;
     cfg: MemoryConfig;
@@ -153,6 +158,8 @@ export interface EndpointDeps {
     sessionInfo?: SessionInfoSource;
     /** 长任务端点依赖(未装配 = 端点恒 disabled,面板不挂载)。 */
     longTask?: LongTaskEndpointDeps;
+    /** Room 注册表(未装配 = rooms-get 不带 registry,rooms-export 不可用)。 */
+    roomRegistry?: RoomRegistryStore;
 }
 /** 端点分发表(导出供测试直调:可精确注入 rebuild/ruminate 等可选控制器,验证 deps 接线)。 */
 export declare function handleEndpoint(endpoint: string, payload: unknown, deps: EndpointDeps): Promise<unknown>;

package/dist/stats.js

@@ -36,7 +36,7 @@ import { snapshotTokenCost } from './token-cost.js';
 const require = createRequire(import.meta.url);
 export const PLUGIN_VERSION = require('../package.json').version;
 /**
- * 端点全集运行时清单(36 个,与 tests/contract-keys.test.ts 的 ENDPOINTS 及
+ * 端点全集运行时清单(与 tests/contract-keys.test.ts 的 ENDPOINTS 及
  * contract.ts 类型映射表三方对齐,漂移由键集 diff 测试暴露)。
  * 注意:本清单同时是 HTTP 前缀路由 `/dsh-memory/rpc/<短名>` 的**放行白名单**
  * (见下方 SHORT_ENDPOINTS),漏一条 = 该端点在面板里静默消失(404 被客户端
@@ -55,6 +55,7 @@ export const MEMORY_ENDPOINTS = [
     'dsh-memory/longtask-compress-tail',
     'dsh-memory/wing-overview',
     'dsh-memory/rooms-get',
+    'dsh-memory/rooms-export',
     'dsh-memory/wing-backfill',
     'dsh-memory/session-stats',
     'dsh-memory/settings-get',
@@ -217,6 +218,7 @@ export function buildEndpointDeps(base, sources, controller) {
         sessionInfo: sources.sessionInfo,
         ruminate: controller,
         longTask: sources.longTask,
+        roomRegistry: sources.roomRegistry,
     };
     return { ...base, ...injected };
 }
@@ -224,7 +226,9 @@ export function registerMemoryRpc(ctx, cfg, stores, logger, status, live, modes,
 /** 反刍控制器(存储降级时为 undefined):经 buildEndpointDeps 落入 deps.ruminate。 */
 ruminate, 
 /** 长任务端点依赖(cfg.longTask.enabled 门控;缺省 = 端点恒 disabled)。 */
-longTaskDeps) {
+longTaskDeps, 
+/** Room 分类管理依赖(注册表;缺省 = rooms-get 不带 registry、rooms-export 恒 404 语义)。 */
+roomRegistry) {
     /** 当前是否持有一段有效注册(dispose 完成后清空,允许服务重上线时重注册)。 */
     let holding = false;
     /** 当前 handle 绑定的 connection 实例(internal/service 第二参;用于识别实例替换)。 */
@@ -390,7 +394,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, longTask: longTaskDeps } = deps;
+    const { cfg, stores, status, live, modes, dataDir, rebuild, ruminate, embedManager, sessionInfo, longTask: longTaskDeps, roomRegistry } = deps;
     switch (endpoint) {
         case 'dsh-memory/stats':
             return buildStats(cfg, stores, status);
@@ -647,10 +651,88 @@ export async function handleEndpoint(endpoint, payload, deps) {
         // ── Room 分类计数(标签自生长分类;展开 metadata.tags 聚合,零 schema) ──
         case 'dsh-memory/rooms-get': {
             const rooms = stores.l1.listRooms();
-            const v = { rooms, total: rooms.length, orphanCount: stores.l1.untaggedL1Count() };
+            // 端点层合并注册表(Agent A 设计):注册表 active 条目 count=0 补齐并带
+            // source/label;自生长条目标 source='grown'。不动 listRooms() 的缓存语义。
+            const merged = rooms.map((r) => ({ ...r, source: 'grown' }));
+            const registry = roomRegistry?.listActive() ?? [];
+            for (const e of registry) {
+                const idx = merged.findIndex((r) => r.room === e.slug);
+                if (idx === -1) {
+                    merged.push({ room: e.slug, count: 0, source: 'pre-registered', label: e.label });
+                }
+                else {
+                    merged[idx] = { ...merged[idx], source: 'pre-registered', label: e.label ?? merged[idx].label };
+                }
+            }
+            const v = {
+                rooms: merged,
+                total: merged.length,
+                orphanCount: stores.l1.untaggedL1Count(),
+                registry: roomRegistry?.list().map((e) => ({
+                    slug: e.slug,
+                    label: e.label,
+                    description: e.description,
+                    source: e.source,
+                    aliases: e.aliases,
+                    status: e.status,
+                })),
+            };
+            return v;
+        }
+        case 'dsh-memory/rooms-export': {
+            const p = (payload ?? {});
+            const kind = p.kind === 'orphans' ? 'orphans' : p.kind === 'rooms' ? 'rooms' : '';
+            if (!kind)
+                throw new Error(`頖kind: ${String(p.kind)}(允rooms/orphans)` + ')');
+            const limit = Math.min(Math.max(Number(p.limit) || 2000, 1), 10_000);
+            const esc = (v) => {
+                const t = String(v ?? '');
+                return /[,\r\n"]/.test(t) ? '"' + t.replace(/"/g, '""') + '"' : t;
+            };
+            if (kind === 'rooms') {
+                const registry = roomRegistry?.list() ?? [];
+                const counts = new Map(stores.l1.listRooms().map((r) => [r.room, r.count]));
+                const lines = ['slug,count,source,label,description,status,aliases'];
+                let n = 0;
+                const seen = new Set();
+                for (const e of registry) {
+                    lines.push([e.slug, String(counts.get(e.slug) ?? 0), e.source, e.label ?? '', e.description ?? '', e.status, (e.aliases ?? []).join('|')].map(esc).join(','));
+                    seen.add(e.slug);
+                    n++;
+                }
+                for (const r of stores.l1.listRooms()) {
+                    if (seen.has(r.room))
+                        continue;
+                    lines.push([r.room, String(r.count), 'grown', '', '', 'active', ''].map(esc).join(','));
+                    n++;
+                }
+                const v = { kind, csv: lines.join('\r\n'), total: n, truncated: false };
+                return v;
+            }
+            // orphans:无 Room 绑定的活跃记录清单(id/type/scene/updated/content/候选/状态)
+            const header = 'id,type,scene_name,updated_at,content,room_candidates,room_review';
+            const lines = [header];
+            let n = 0;
+            let truncated = false;
+            for (let offset = 0; offset < limit; offset += 200) {
+                const page = stores.l1.list({ untagged: true, retired: false, limit: 200, offset });
+                for (const r of page.items) {
+                    if (n >= limit) {
+                        truncated = true;
+                        break;
+                    }
+                    const meta = (r.metadata ?? {});
+                    lines.push([r.id, r.type, r.scene_name, new Date(r.updatedAt).toISOString(), r.content,
+                        Array.isArray(meta.roomCandidates) ? meta.roomCandidates.join('|') : '',
+                        String(meta.roomReview ?? '')].map(esc).join(','));
+                    n++;
+                }
+                if (truncated || page.items.length < 200)
+                    break;
+            }
+            const v = { kind, csv: lines.join('\r\n'), total: n, truncated };
             return v;
         }
-        // ── 一键回填(task_15):后台任务,单飞;端点立即返回,进度看 wing-overview ──
         case 'dsh-memory/wing-backfill': {
             const r = startWingBackfill({
                 ctx: deps.ctx,

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

@@ -0,0 +1,52 @@
+import type { MemoryLogger } from '../types.js';
+/** 版本常量(file-versions 同款集中纪律;registry 为独立 sidecar 文件)。 */
+export declare const ROOMS_REGISTRY_FILE_VERSION: 1;
+export interface RoomRegistryEntry {
+    /** Room slug(小写字母数字连字符;与自生长 tags 同域,isTag 校验)。 */
+    slug: string;
+    /** 人类可读名(面板/标注器提示;可中文)。 */
+    label?: string;
+    /** 归类说明(喂标注器,对 LLM 归类价值最高)。 */
+    description?: string;
+    /** 来源:pre-registered(预注册)| grown(从自生长 slug 收编)。 */
+    source: 'pre-registered' | 'grown';
+    /** 合并/改名时的旧 slug(标注器与导出消歧;不参与 list({tag}) 查询)。 */
+    aliases?: string[];
+    status: 'active' | 'retired';
+    createdAt: string;
+    updatedAt: string;
+}
+export type RoomRegistryInput = Pick<RoomRegistryEntry, 'slug'> & Partial<Pick<RoomRegistryEntry, 'label' | 'description' | 'source' | 'aliases'>>;
+export declare class RoomRegistryStore {
+    private readonly logger?;
+    private readonly file;
+    private entries;
+    private rev;
+    private loaded;
+    private degraded;
+    private degradedLogged;
+    private writeChain;
+    constructor(dataDir: string, logger?: MemoryLogger | undefined);
+    /** 载入(启动时 await 一次)。缺失 = 合法空表;损坏/不可读 = 只读降级(回退自生长目录)。 */
+    init(): Promise<void>;
+    private ensureLoaded;
+    /** 全量条目(含 retired;副本返回,活引用纪律)。 */
+    list(): RoomRegistryEntry[];
+    /** active 条目(rooms-get 合并与标注器词表来源)。 */
+    listActive(): RoomRegistryEntry[];
+    /** 精确 slug 查找(含 retired;含别名命中)。 */
+    bySlug(slug: string): RoomRegistryEntry | undefined;
+    /** 注册(幂等:已存在——含别名命中——时原地补全 label/description,不新建)。上限 200 防刷。 */
+    register(input: RoomRegistryInput): Promise<{
+        entry: RoomRegistryEntry;
+        created: boolean;
+    }>;
+    /** 改状态(active↔retired);无变化返回 false。 */
+    setStatus(slug: string, status: 'active' | 'retired'): Promise<boolean>;
+    /** 改名(merge 1:1 收尾):slug 换名 + 旧 slug 进 aliases。新名与既有条目冲突时走 merge。 */
+    renameSlug(oldSlug: string, newSlug: string): Promise<boolean>;
+    /** 合并收尾:fromSlug 条目转 retired + toSlug 进 aliases(记录重写由调用方游标执行)。 */
+    markMerged(fromSlug: string, toSlug: string): Promise<boolean>;
+    /** 写穿持久化(串行链;失败降级内存态并告警一次)。 */
+    private persist;
+}

package/dist/store/rooms-registry.js

@@ -0,0 +1,204 @@
+/**
+ * Room 注册表(预注册词表,分类管理 beta.4)。
+ *
+ * 动机:Room 此前纯自生长(metadata.tags 涌现),tags 标注器不参考词表——
+ * 「81 个 Room 大多 1 条」的碎片化即来源于此。注册表让「策划好的分类」先行:
+ * 候选标注器与 tags 标注器优先挂靠注册表 slug;零计数注册条目也进词表。
+ *
+ * 存储:slots 式 sidecar(`rooms-registry.json`),全量载入内存 + 写穿原子持久化,
+ * `rev` 乐观观察计数。**读侧分类**(occupancy 同款):文件缺失 = 合法空表;
+ * 损坏/不可读 → 告警 + 只读降级(内存态照常生效,停止回写)——降级即**回退纯
+ * 自生长目录**,绝不阻塞 rooms-get / 标注器(R2 红线)。
+ */
+import * as path from 'node:path';
+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;
+/** aliases 上限(合并/改名历史)。 */
+const ALIASES_CAP = 16;
+export class RoomRegistryStore {
+    logger;
+    file;
+    entries = [];
+    rev = 0;
+    loaded = false;
+    degraded;
+    degradedLogged = false;
+    writeChain = Promise.resolve();
+    constructor(dataDir, logger) {
+        this.logger = logger;
+        this.file = path.join(dataDir, 'rooms-registry.json');
+    }
+    /** 载入(启动时 await 一次)。缺失 = 合法空表;损坏/不可读 = 只读降级(回退自生长目录)。 */
+    async init() {
+        await ensureDir(path.dirname(this.file));
+        const read = await readJsonStrict(this.file);
+        if (!read.ok) {
+            if (read.reason !== 'missing') {
+                this.degraded = `${read.reason}${'detail' in read && read.detail ? `: ${read.detail}` : ''}`;
+                this.logger?.warn(`[memory] Room 注册表只读降级(回退纯自生长目录): ${this.degraded}`);
+            }
+            this.loaded = true;
+            return;
+        }
+        if (read.value.version !== ROOMS_REGISTRY_FILE_VERSION) {
+            this.logger?.warn(`[memory] Room 注册表版本 ${String(read.value.version)} 未知,按当前形状读取`);
+        }
+        const rooms = Array.isArray(read.value.rooms) ? read.value.rooms : [];
+        for (const r of rooms) {
+            if (!r || typeof r.slug !== 'string' || !isTag(r.slug))
+                continue; // 非法 slug 丢弃(session-modes 同款纪律)
+            this.entries.push({
+                slug: r.slug,
+                label: typeof r.label === 'string' ? r.label : undefined,
+                description: typeof r.description === 'string' ? r.description : undefined,
+                source: r.source === 'grown' ? 'grown' : 'pre-registered',
+                aliases: Array.isArray(r.aliases) ? r.aliases.filter((a) => typeof a === 'string' && a !== '') : undefined,
+                status: r.status === 'retired' ? 'retired' : 'active',
+                createdAt: typeof r.createdAt === 'string' ? r.createdAt : '',
+                updatedAt: typeof r.updatedAt === 'string' ? r.updatedAt : '',
+            });
+        }
+        this.rev = typeof read.value.rev === 'number' ? read.value.rev : 0;
+        this.loaded = true;
+    }
+    ensureLoaded() {
+        if (!this.loaded)
+            throw new Error('Room 注册表未初始化(先 await init())');
+    }
+    /** 全量条目(含 retired;副本返回,活引用纪律)。 */
+    list() {
+        this.ensureLoaded();
+        return this.entries.map((e) => ({ ...e }));
+    }
+    /** active 条目(rooms-get 合并与标注器词表来源)。 */
+    listActive() {
+        return this.list().filter((e) => e.status === 'active');
+    }
+    /** 精确 slug 查找(含 retired;含别名命中)。 */
+    bySlug(slug) {
+        this.ensureLoaded();
+        const found = this.entries.find((e) => e.slug === slug || (e.aliases ?? []).includes(slug));
+        return found ? { ...found } : undefined;
+    }
+    /** 注册(幂等:已存在——含别名命中——时原地补全 label/description,不新建)。上限 200 防刷。 */
+    async register(input) {
+        this.ensureLoaded();
+        const slug = String(input.slug ?? '').trim().toLowerCase();
+        if (!slug || !isTag(slug))
+            throw new Error(`非法 Room slug: ${String(input.slug)}(需小写字母数字连字符)`);
+        const found = this.entries.find((e) => e.slug === slug || (e.aliases ?? []).includes(slug));
+        if (found) {
+            let changed = false;
+            if (!found.label && typeof input.label === 'string' && input.label.trim()) {
+                found.label = input.label.trim().slice(0, 60);
+                changed = true;
+            }
+            if (!found.description && typeof input.description === 'string' && input.description.trim()) {
+                found.description = input.description.trim().slice(0, 300);
+                changed = true;
+            }
+            if (changed) {
+                found.updatedAt = new Date().toISOString();
+                this.rev++;
+                await this.persist();
+            }
+            return { entry: { ...found }, created: false };
+        }
+        if (this.entries.length >= REGISTRY_CAP) {
+            throw new Error(`Room 注册表已达上限(${REGISTRY_CAP}),请先 retire/合并部分条目`);
+        }
+        const now = new Date().toISOString();
+        const entry = {
+            slug,
+            label: typeof input.label === 'string' && input.label.trim() ? input.label.trim().slice(0, 60) : undefined,
+            description: typeof input.description === 'string' && input.description.trim()
+                ? input.description.trim().slice(0, 300)
+                : undefined,
+            source: input.source === 'grown' ? 'grown' : 'pre-registered',
+            aliases: Array.isArray(input.aliases) && input.aliases.length > 0 ? input.aliases.slice(0, ALIASES_CAP) : undefined,
+            status: 'active',
+            createdAt: now,
+            updatedAt: now,
+        };
+        this.entries.push(entry);
+        this.rev++;
+        await this.persist();
+        return { entry: { ...entry }, created: true };
+    }
+    /** 改状态(active↔retired);无变化返回 false。 */
+    async setStatus(slug, status) {
+        this.ensureLoaded();
+        const found = this.entries.find((e) => e.slug === slug);
+        if (!found || found.status === status)
+            return false;
+        found.status = status;
+        found.updatedAt = new Date().toISOString();
+        this.rev++;
+        await this.persist();
+        return true;
+    }
+    /** 改名(merge 1:1 收尾):slug 换名 + 旧 slug 进 aliases。新名与既有条目冲突时走 merge。 */
+    async renameSlug(oldSlug, newSlug) {
+        this.ensureLoaded();
+        if (!isTag(newSlug))
+            throw new Error(`非法 Room slug: ${newSlug}`);
+        const found = this.entries.find((e) => e.slug === oldSlug);
+        if (!found)
+            return false;
+        if (this.entries.some((e) => e.slug === newSlug)) {
+            throw new Error(`目标 slug 已存在: ${newSlug}(应走 merge 而非 rename)`);
+        }
+        found.slug = newSlug;
+        found.aliases = [...new Set([...(found.aliases ?? []), oldSlug])].slice(0, ALIASES_CAP);
+        found.updatedAt = new Date().toISOString();
+        this.rev++;
+        await this.persist();
+        return true;
+    }
+    /** 合并收尾:fromSlug 条目转 retired + toSlug 进 aliases(记录重写由调用方游标执行)。 */
+    async markMerged(fromSlug, toSlug) {
+        this.ensureLoaded();
+        const found = this.entries.find((e) => e.slug === fromSlug);
+        if (!found)
+            return false;
+        found.status = 'retired';
+        const target = this.entries.find((e) => e.slug === toSlug);
+        if (target) {
+            target.aliases = [...new Set([...(target.aliases ?? []), fromSlug])].slice(0, ALIASES_CAP);
+            target.updatedAt = new Date().toISOString();
+        }
+        found.updatedAt = new Date().toISOString();
+        this.rev++;
+        await this.persist();
+        return true;
+    }
+    /** 写穿持久化(串行链;失败降级内存态并告警一次)。 */
+    async persist() {
+        if (this.degraded)
+            return;
+        this.writeChain = this.writeChain.then(async () => {
+            const data = {
+                version: ROOMS_REGISTRY_FILE_VERSION,
+                rev: this.rev + 1,
+                rooms: this.entries,
+            };
+            try {
+                await ensureDir(path.dirname(this.file));
+                await atomicWriteText(this.file, JSON.stringify(data, null, 2));
+                this.rev = data.rev;
+            }
+            catch (err) {
+                this.degraded = err instanceof Error ? err.message : String(err);
+                if (!this.degradedLogged) {
+                    this.degradedLogged = true;
+                    this.logger?.warn(`[memory] Room 注册表写入失败,只读降级: ${this.degraded}`);
+                }
+            }
+        });
+        await this.writeChain;
+    }
+}

package/dist/tools/index.d.ts

@@ -22,6 +22,7 @@ import type { PersonaStore } from '../store/persona.js';
 import type { SceneStore } from '../store/scenes.js';
 import type { SessionModeStore } from '../store/session-modes.js';
 import type { MemoryFamily, MemoryLogger } from '../types.js';
+import type { RoomRegistryStore } from '../store/rooms-registry.js';
 export declare function registerMemoryTools(ctx: Context, cfg: MemoryConfig, stores: {
     l0: L0Store;
     l1: L1Store;
@@ -31,4 +32,6 @@ export declare function registerMemoryTools(ctx: Context, cfg: MemoryConfig, sto
     graph?: GraphStore;
 }, logger: MemoryLogger, modes: SessionModeStore, live: LiveSettingsHandle, 
 /** 反刍控制器(可选:未装配时 ruminate 工具返回未启用提示)。 */
-ruminate?: RuminateController): void;
+ruminate?: RuminateController, 
+/** Room 注册表(分类管理 beta.4;缺省 = memory_room_admin 返回未装配提示)。 */
+roomRegistry?: RoomRegistryStore): void;

package/dist/tools/index.js

@@ -3,6 +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 { applyGovernanceWeights } from '../store/governance.js';
 import { resolveRepoScope } from '../repo-scope.js';
 import { GRAPH_STATUS_LABELS } from '../prompts/graph-projection.js';
@@ -32,7 +33,9 @@ function applyManualRedaction(record, cfg, logger) {
 }
 export function registerMemoryTools(ctx, cfg, stores, logger, modes, live, 
 /** 反刍控制器(可选:未装配时 ruminate 工具返回未启用提示)。 */
-ruminate) {
+ruminate, 
+/** Room 注册表(分类管理 beta.4;缺省 = memory_room_admin 返回未装配提示)。 */
+roomRegistry) {
     if (!cfg.tools)
         return;
     /**
@@ -182,6 +185,76 @@ ruminate) {
             };
         },
     }));
+    // ── memory_room_admin: Room 粒度目录治理(分类管理 beta.4)────────────────
+    // list/register 免预算零风险;merge/rename/retire 属破坏性面(beta.5),暂不注册。
+    ctx.tools.register(defineTool({
+        name: 'memory_room_admin',
+        description: 'Room 分类管理(目录粒度)。action="list" 列出注册表条目与自生长 Room 计数;' +
+            'action="register" 预注册一个 Room(高权限;slug 需小写字母数字连字符,可选人类可读名与归类说明——' +
+            '注册后候选标注器与 tags 标注器会优先把记忆挂到这些 Room 上,是治理碎片化的推荐入口)。',
+        parameters: {
+            action: { type: 'string', required: true, description: 'list(列目录)| register(预注册 Room,高权限)' },
+            slug: { type: 'string', description: 'register 的 Room slug(小写字母数字连字符)' },
+            label: { type: 'string', description: 'register 的人类可读名(可选,可中文)' },
+            description: { type: 'string', description: 'register 的归类说明(可选;喂给标注器帮助归类)' },
+        },
+        output: {
+            schema: {
+                type: 'object',
+                properties: {
+                    notice: { type: 'string' },
+                    rooms: { type: 'string' },
+                    slug: { type: 'string' },
+                    created: { type: 'boolean' },
+                },
+                additionalProperties: false,
+            },
+            render: (_args, value) => [{ type: 'text', text: value.notice ?? JSON.stringify(value) }],
+        },
+        execute: async (args) => {
+            const action = String(args.action ?? '');
+            if (action === 'list') {
+                if (!roomRegistry)
+                    return { notice: 'Room 注册表未装配(需要插件重载以初始化)。' };
+                const registry = roomRegistry.list();
+                const counts = stores.l1.listRooms();
+                const countOf = (slug) => counts.find((r) => r.room === slug)?.count ?? 0;
+                const regLines = registry.map((e) => `- ${e.slug}${e.label ? `(${e.label})` : ''} [${e.source}/${e.status}] 现有 ${countOf(e.slug)} 条${e.description ? ` — ${e.description}` : ''}`);
+                const grownOnly = counts.filter((r) => !registry.some((e) => e.slug === r.room));
+                return {
+                    notice: `注册表 ${registry.length} 条(上限 200),自生长未注册 ${grownOnly.length} 个。\n` +
+                        (regLines.join('\n') || '(注册表为空——用 action=register 预注册)') +
+                        `\n自生长未注册:${grownOnly.map((r) => `${r.room}(${r.count})`).join(", ") || "无"}`,
+                    rooms: `${registry.length}+${grownOnly.length}`,
+                };
+            }
+            if (action === 'register') {
+                if (!roomRegistry)
+                    return { notice: 'Room 注册表未装配(需要插件重载以初始化)。' };
+                if (!live.get().memoryMutate)
+                    return { notice: MUTATE_OFF_NOTICE };
+                const slug = String(args.slug ?? '').trim();
+                try {
+                    const r = await roomRegistry.register({
+                        slug,
+                        label: typeof args.label === 'string' ? args.label : undefined,
+                        description: typeof args.description === 'string' ? args.description : undefined,
+                    });
+                    return {
+                        notice: r.created
+                            ? `已预注册 Room:${r.entry.slug}${r.entry.label ? `(${r.entry.label})` : ''}。候选标注器将优先把相关记忆挂到它上面。`
+                            : `Room 已存在:${r.entry.slug}(本次只补全了缺失的 label/description)。`,
+                        slug: r.entry.slug,
+                        created: r.created,
+                    };
+                }
+                catch (err) {
+                    return { notice: `注册失败: ${err instanceof Error ? err.message : String(err)}` };
+                }
+            }
+            return { notice: `非法 action:${action}(允许 list/register;merge/rename/retire 将在后续版本提供)。` };
+        },
+    }));
     // ── conversation_search: L0 原始对话 ──
     ctx.tools.register(defineTool({
         name: 'conversation_search',
@@ -778,6 +851,87 @@ ruminate) {
         },
     }));
     // ── 反刍状态查询(查看当前反刍进度) ──
+    // ── memory_room_review:孤儿记忆的 Room 候选逐个复查(agent 长尾治理)──────
+    // next/annotate 只读或预算内标注(无需门);confirm/skip 改写 metadata,
+    // confirm 吃 live.memoryMutate 高权限门(与 memory_delete 同款)。
+    ctx.tools.register(defineTool({
+        name: 'memory_room_review',
+        description: '孤儿记忆(无 Room 绑定)的逐个复查:action="next" 取下一条待复查记录(带系统预标记的候选 Room 与现有词表,agent 依据记录内容判定);' +
+            'action="confirm" 按 id 把 1-3 个 Room slug 写入该记忆(高权限);action="skip" 跳过(不再进队列);' +
+            'action="annotate" 立即对一批孤儿做候选预标记(平时由反刍自动推进)。建议长会话空闲时逐个过,保持分类收敛——优先挂靠现有 Room。',
+        parameters: {
+            action: { type: 'string', required: true, description: 'next(取下一条)| confirm(确认写入)| skip(跳过)| annotate(批量预标记)' },
+            id: { type: 'string', description: 'confirm/skip 的目标记录 id(action=next 返回的 id)' },
+            rooms: { type: 'string', description: 'confirm 的 Room slug 列表(逗号分隔,1-3 个,小写字母数字连字符;可含词表外新 slug)' },
+        },
+        output: {
+            schema: {
+                type: 'object',
+                properties: {
+                    notice: { type: 'string' },
+                    id: { type: 'string' },
+                    content: { type: 'string' },
+                    candidates: { type: 'string' },
+                    roomCatalog: { type: 'string' },
+                    remaining: { type: 'number' },
+                    confirmedTags: { type: 'string' },
+                    annotated: { type: 'number' },
+                    deferred: { type: 'number' },
+                },
+                additionalProperties: false,
+            },
+            render: (_args, value) => [{ type: 'text', text: value.notice ?? JSON.stringify(value) }],
+        },
+        execute: async (args) => {
+            const action = String(args.action ?? '');
+            const io = { l1: stores.l1, logger };
+            if (action === 'next') {
+                const item = nextReview(io.l1);
+                if (!item)
+                    return { notice: '没有待复查的孤儿记忆(roomCandidates 队列为空)。可用 action=annotate 先做一轮候选预标记。' };
+                return {
+                    id: item.id,
+                    content: item.content,
+                    candidates: item.candidates.join(', '),
+                    roomCatalog: item.roomCatalog.map((r) => `${r.room}(${r.count})`).join(', '),
+                    remaining: item.remaining,
+                };
+            }
+            if (action === 'annotate') {
+                const r = await annotateOrphanCandidates(ctx, cfg, io, 40);
+                return {
+                    notice: `候选预标记完成:选中 ${r.selected} 条,产候选 ${r.candidates} 条,写 pending ${r.written} 条。用 action=next 逐个复查。`,
+                    annotated: r.candidates,
+                    deferred: r.selected - r.written,
+                };
+            }
+            if (action === 'confirm') {
+                if (!live.get().memoryMutate)
+                    return { notice: MUTATE_OFF_NOTICE };
+                const id = String(args.id ?? '').trim();
+                if (!id)
+                    return { notice: 'confirm 需要 id(action=next 返回的 id)。' };
+                const rooms = String(args.rooms ?? '')
+                    .split(/[,,、]/)
+                    .map((x) => x.trim())
+                    .filter(Boolean);
+                if (rooms.length === 0)
+                    return { notice: 'confirm 需要 rooms(逗号分隔的 1-3 个 Room slug)。' };
+                const r = confirmReview(io.l1, id, rooms);
+                if (!r)
+                    return { notice: `确认失败:id=${id} 不存在、已被确认过、或 rooms 全部非法(需 1-3 个合法 slug)。` };
+                return { notice: `已挂到 Room:${r.tags.join(', ')}(面板下一次刷新即可见)。`, confirmedTags: r.tags.join(', '), id };
+            }
+            if (action === 'skip') {
+                const id = String(args.id ?? '').trim();
+                if (!id)
+                    return { notice: 'skip 需要 id。' };
+                const ok = skipReview(io.l1, id);
+                return { notice: ok ? `已跳过 ${id}(不再进复查队列)。` : `跳过失败:id=${id} 不存在。`, id };
+            }
+            return { notice: `非法 action:${action}(允许 next/confirm/skip/annotate)。剩余待复查 ${pendingReviewCount(stores.l1)} 条。` };
+        },
+    }));
     ctx.tools.register(defineTool({
         name: 'memory_ruminate_status',
         description: '查询当前记忆反刍的状态与进度(是否运行中、当前阶段、已完成/总会话数等)。\n\n注意:在 DSH Web GUI 的对话中无法直接调用此工具,因为模型可调用工具列表不包含 ruminate_status。如需查询进度,请在记忆库面板的蒸馏面板查看。',

package/dist/types.d.ts

@@ -41,6 +41,10 @@ export interface RoomCount {
     room: string;
     /** 该 Room 下的记录数(与 `wingL1Counts()` 同口径:含 retired 行)。 */
     count: number;
+    /** 来源标示(rooms-get 端点层合并注册表后附带;'grown' = 自生长,可缺省)。 */
+    source?: 'pre-registered' | 'grown';
+    /** 人类可读名(注册表条目才有;面板 chip 可用 label 展示)。 */
+    label?: string;
 }
 /** 记录族标签推断:work_* 前缀 → work,其余(含 auto 档兜底)→ chat。 */
 export declare function familyForType(type: string): MemoryFamily;

package/dsh.plugin.json

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