dsh-prime-memory 0.18.5 → 0.18.7

package/dist/tools/index.js

@@ -3,7 +3,6 @@ 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, mergeRoom, nextReview, pendingReviewCount, renameRoom, skipReview, } from '../room-review.js';
 import { GRAPH_STATUS_LABELS } from '../prompts/graph-projection.js';
 import { redactSecrets } from '../util/redact.js';
 const OFF_NOTICE = '本会话的记忆档位为"关闭":该会话对记忆系统完全隐身,不读取也不写入记忆。';
@@ -31,9 +30,7 @@ function applyManualRedaction(record, cfg, logger) {
 }
 export function registerMemoryTools(ctx, cfg, stores, logger, modes, live, 
 /** 反刍控制器(可选:未装配时 ruminate 工具返回未启用提示)。 */
-ruminate, 
-/** Room 注册表(分类管理 beta.4;缺省 = memory_room_admin 返回未装配提示)。 */
-roomRegistry) {
+ruminate) {
     if (!cfg.tools)
         return;
     /**
@@ -133,6 +130,7 @@ roomRegistry) {
                         items: {
                             type: 'object',
                             properties: {
+                                id: { type: 'string', description: 'L1 record_id:可写入槽位 refs 或喂给 memory_receipts' },
                                 content: { type: 'string' },
                                 type: { type: 'string' },
                                 scene_name: { type: 'string' },
@@ -171,145 +169,6 @@ roomRegistry) {
             };
         },
     }));
-    // ── memory_room_admin: Room 粒度目录治理(分类管理 beta.4;beta.5 起 merge/rename/retire 已注册) ──
-    // list 免预算零风险;merge/rename/retire 走 dryRun 预览→实跑,执行前自动备份,完成入队场景重算。
-    ctx.tools.register(defineTool({
-        name: 'memory_room_admin',
-        description: 'Room 分类管理(目录粒度)。action="list" 列出注册表条目与自生长 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(高权限) | 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: {
-                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)}` };
-                }
-            }
-            if (action === 'update') {
-                if (!roomRegistry)
-                    return { notice: 'Room 注册表未装配(需要插件重载以初始化)。' };
-                if (!live.get().memoryMutate)
-                    return { notice: MUTATE_OFF_NOTICE };
-                const slug = String(args.slug ?? '').trim();
-                if (!slug)
-                    return { notice: 'update 需要 slug。' };
-                try {
-                    const ok = await roomRegistry.update(slug, {
-                        label: typeof args.label === 'string' ? args.label : undefined,
-                        description: typeof args.description === 'string' ? args.description : undefined,
-                    });
-                    return { notice: ok ? `已更新:${slug}(显示名/归类说明)。` : `无变化:${slug} 未找到或未提供非空字段。`, slug };
-                }
-                catch (err) {
-                    return { notice: `更新失败: ${err instanceof Error ? err.message : String(err)}` };
-                }
-            }
-            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,
-                        };
-                    }
-                    return {
-                        notice: `${action === 'merge' ? '合并' : '改名'}完成:${from} → ${to},重写 ${r.applied} 条` +
-                            `(备份:${r.backupFile ?? '无'})。`,
-                        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 原始对话 ──
     ctx.tools.register(defineTool({
         name: 'conversation_search',
@@ -906,87 +765,6 @@ roomRegistry) {
         },
     }));
     // ── 反刍状态查询(查看当前反刍进度) ──
-    // ── 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, registry: roomRegistry }, 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,10 +41,6 @@ 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/package.json

@@ -1,6 +1,6 @@
 {
   "name": "dsh-prime-memory",
-  "version": "0.18.5",
+  "version": "0.18.7",
   "publishConfig": {
     "registry": "https://registry.npmjs.org",
     "access": "public",
@@ -77,6 +77,7 @@
   "author": "drscrewdriver <597093681@qq.com>",
   "license": "MIT",
   "dependencies": {
+    "@deepseek-ai/cosmokit": "~1.8.5",
     "@node-rs/jieba": "^2.0.2",
     "sqlite-vec": "^0.1.7-alpha.2",
     "undici": "^7.29.0"

package/dist/room-review.d.ts

@@ -1,196 +0,0 @@
-/**
- * 孤儿记忆的 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;
-}
-/** 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>;
-    /** rename 收尾恢复先前状态用(active 条目改名后不掉出标注词表)。 */
-    bySlug?(slug: string): {
-        status: 'active' | 'retired';
-    } | undefined;
-    setStatus?(slug: string, status: 'active' | 'retired'): Promise<boolean>;
-}
-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;
-    /** Room 注册表(可选:未装配 = 词表只用自生长聚合,无注册条目)。 */
-    registry?: {
-        listActive(): Array<{
-            slug: string;
-            label?: string;
-            description?: string;
-        }>;
-    };
-}
-/**
- * 预标记消费器:活跃孤儿(≤limit 条)批量产候选并写 pending。
- * 写前重读合并(与 relabel 同纪律);失败单条跳过、原记录零改动。
- */
-export interface OrphanAnnotateOverrides {
-    /** 测试注入口:替换 LLM 候选标注器(默认走真实 callLLM 路径);第二参为合并词表。 */
-    chunkAnnotator?: (chunk: MemoryRecord[], catalog: ReadonlyArray<{
-        room: string;
-        count: number;
-        label?: string;
-        description?: string;
-    }>) => 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;
-}>;
-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)。
- *  归类语义:改名**不是退役**——merge 编排的 markMerged 会把旧条目置 retired,
- *  这里在改名后恢复其先前状态(active 条目改名后仍 active,不掉出标注词表)。 */
-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;
-    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;