dsh-prime-memory 0.18.4 → 0.18.5

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, 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 = '本会话的记忆档位为"关闭":该会话对记忆系统完全隐身,不读取也不写入记忆。';
@@ -30,7 +31,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;
     /**
@@ -168,6 +171,145 @@ ruminate) {
             };
         },
     }));
+    // ── 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',
@@ -764,6 +906,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, 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,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/package.json

@@ -1,6 +1,6 @@
 {
   "name": "dsh-prime-memory",
-  "version": "0.18.4",
+  "version": "0.18.5",
   "publishConfig": {
     "registry": "https://registry.npmjs.org",
     "access": "public",
@@ -50,14 +50,14 @@
     "ENGINEERING-NOTES.md"
   ],
   "scripts": {
-    "build": "tsc -p tsconfig.json && node scripts/build-client.mjs && node scripts/copy-client.mjs",
+    "build": "node -e \"fs.rmSync('dist',{recursive:true,force:true})\" && tsc -p tsconfig.json && node scripts/build-client.mjs && node scripts/copy-client.mjs",
     "smoke": "npm run build:smoke && node dist-smoke/smoke.js",
     "verify-catalog": "npm run build && node scripts/verify-catalog.mjs",
     "typecheck": "tsc -p tsconfig.json --noEmit && tsc -p tsconfig.client.json --noEmit && tsc -p tsconfig.test.json",
     "build:smoke": "tsc src/smoke.ts --outDir dist-smoke --module nodenext --moduleResolution nodenext --target es2022 --strict --skipLibCheck --esModuleInterop",
     "lint": "eslint src client/src scripts tests",
     "test": "vitest run",
-    "hall-migrate": "npm run build && node scripts/hall-migrate.mjs"
+    "wing-migrate": "npm run build && node scripts/wing-migrate.mjs"
   },
   "engines": {
     "node": ">=22.16.0",
@@ -125,15 +125,16 @@
   "devDependencies": {
     "@deepseek-ai/cordis": "^4.0.4",
     "@deepseek-ai/cordis-plugin-loader": "^1.0.5",
-    "@deepseek-ai/dsh-agent": "0.1.1-rc.2",
-    "@deepseek-ai/dsh-agent-default-model": "0.1.1-rc.2",
-    "@deepseek-ai/dsh-client-connection": "0.1.1-rc.2",
-    "@deepseek-ai/dsh-home-paths": "0.1.1-rc.2",
-    "@deepseek-ai/dsh-llm": "0.1.1-rc.2",
-    "@deepseek-ai/dsh-session": "0.1.1-rc.2",
-    "@deepseek-ai/dsh-settings": "0.1.1-rc.2",
-    "@deepseek-ai/dsh-system-prompt": "0.1.1-rc.2",
-    "@deepseek-ai/dsh-tools": "0.1.1-rc.2",
+    "@deepseek-ai/dsh-agent": "0.1.7-rc.2",
+    "@deepseek-ai/dsh-agent-default-model": "0.1.7-rc.2",
+    "@deepseek-ai/dsh-client-connection": "0.1.7-rc.2",
+    "@deepseek-ai/dsh-compaction": "0.1.7-rc.2",
+    "@deepseek-ai/dsh-home-paths": "0.1.7-rc.2",
+    "@deepseek-ai/dsh-llm": "0.1.7-rc.2",
+    "@deepseek-ai/dsh-session": "0.1.7-rc.2",
+    "@deepseek-ai/dsh-settings": "0.1.7-rc.2",
+    "@deepseek-ai/dsh-system-prompt": "0.1.7-rc.2",
+    "@deepseek-ai/dsh-tools": "0.1.7-rc.2",
     "@deepseek-ai/schemastery": "^3.18.4",
     "@eslint/js": "^10.0.1",
     "@types/node": "^22.0.0",

package/dist/hall-backfill.d.ts

@@ -1,33 +0,0 @@
-/**
- * 存量未打标记录的一键回填(task_15):从 HallWheel"未打标 M"入口触发,
- * 对 metadata 无 hall 的 L1 记录按 8 角词表批量补打标签(复用 L1 抽取的打标路径:
- * 同一候选词表与措辞,经既有蒸馏 LLM 路由)。
- *
- * 安全边界:
- * - **单飞**:同时最多一个回填任务,重复触发直接返回 running(不排队不叠加);
- * - **后台执行**:端点立即返回,逐块推进(每块 20 条),不阻塞 RPC/管线;
- * - **失败可退**:LLM 失败/输出不合法只跳过当前块,原记录零改动(标签只写成功的);
- * - **有界**:单次任务最多处理 MAX_RECORDS 条,防止一次跑飞;其余可再次触发。
- */
-import type { Context } from '@deepseek-ai/cordis';
-import { type MemoryLogger } from './types.js';
-import type { L1Store } from './store/l1.js';
-import type { MemoryConfig } from './config.js';
-export interface HallBackfillDeps {
-    ctx: Context;
-    cfg: MemoryConfig;
-    l1: L1Store;
-    logger: MemoryLogger;
-}
-export interface HallBackfillState {
-    running: boolean;
-    /** 本进程累计成功打标条数(重启归零;仅作观测,不作账)。 */
-    updated: number;
-    failed: number;
-}
-export declare function hallBackfillState(): HallBackfillState;
-/** 启动后台回填;已在运行返回 false(单飞)。 */
-export declare function startHallBackfill(deps: HallBackfillDeps): {
-    started: boolean;
-    running: boolean;
-};

package/dist/hall-backfill.js

@@ -1,95 +0,0 @@
-import { callLLM } from './llm.js';
-import { normHallEnabled } from './config.js';
-import { HALL_FALLBACK } from './types.js';
-import { parseJsonLogged } from './llm.js';
-/** 单次任务处理上限(524 条存量一次跑完约为 LLM 成本大头;分批触发,可重复执行)。 */
-const MAX_RECORDS = 300;
-/** 每块条数(一次 LLM 调用判定的记录数)。 */
-const CHUNK = 20;
-const state = { running: false, updated: 0, failed: 0 };
-export function hallBackfillState() {
-    return { ...state };
-}
-const SYSTEM_PROMPT = '你是记忆库的域标注器。给你若干条记忆(带 id),为每条判断其内容属于哪个 Hall 域,输出 JSON 数组:' +
-    '[{"id":"<原id>","hall":"<域id>"}]。hall 只能从给定候选列表中选;横跨多域或确实无法归入任何角时选 general。' +
-    '只输出 JSON,不要多余文字。';
-/** 启动后台回填;已在运行返回 false(单飞)。 */
-export function startHallBackfill(deps) {
-    if (state.running)
-        return { started: false, running: true };
-    state.running = true;
-    state.updated = 0;
-    state.failed = 0;
-    void run(deps).finally(() => {
-        state.running = false;
-        deps.logger.info(`[memory] hall 回填结束:成功 ${state.updated} 条,失败 ${state.failed} 条`);
-    });
-    return { started: true, running: true };
-}
-async function run(deps) {
-    const { ctx, cfg, l1, logger } = deps;
-    const halls = normHallEnabled(cfg.hall?.enabled);
-    if (halls.length === 0) {
-        logger.warn('[memory] hall 回填跳过:hall.enabled 为空(打标功能已关闭)');
-        return;
-    }
-    const candidates = [...halls, HALL_FALLBACK].join(' / ');
-    // 未打标集:主表全量里的 null hall(含 retired 行——restore 后标签已补,不重扫)
-    const all = l1.all();
-    const pending = all.filter((r) => !(r.metadata && typeof r.metadata.hall === 'string' && r.metadata.hall !== ''));
-    let budget = Math.min(pending.length, MAX_RECORDS);
-    logger.info(`[memory] hall 回填启动:未打标 ${pending.length} 条,本次上限 ${budget} 条(候选 ${candidates})`);
-    for (let offset = 0; offset < pending.length && budget > 0; offset += CHUNK) {
-        const chunk = pending.slice(offset, offset + CHUNK).filter(pickChunk);
-        if (chunk.length === 0)
-            continue;
-        budget -= chunk.length;
-        const labeled = await labelChunk(ctx, cfg, logger, chunk, candidates);
-        for (const { record, hall } of labeled) {
-            // 原记录最小改动:metadata.hall 单键写入,其余字段原样 upsert(同 id 版本不变语义)
-            const next = { ...record, metadata: { ...(record.metadata ?? {}), hall } };
-            try {
-                await l1.upsert(next);
-                state.updated++;
-            }
-            catch {
-                state.failed++;
-            }
-        }
-    }
-}
-/** 回填只处理活跃记录可安全加速,但 retired 行的 metadata_json 同样保留且 restore 后可见——
- *  upsert 对 retired 行的行为由存储层保证(同 id 覆盖不复活),这里不做活性过滤,口径与迁移一致(全量)。 */
-function pickChunk(_r) {
-    return true;
-}
-async function labelChunk(ctx, cfg, logger, chunk, candidates) {
-    const list = chunk.map((r, i) => `${i + 1}. id=${r.id}\n${r.content.slice(0, 300)}`).join('\n\n');
-    const user = `候选 Hall:${candidates}\n\n记忆列表:\n${list}`;
-    try {
-        const raw = await callLLM(ctx, cfg, {
-            system: SYSTEM_PROMPT,
-            user,
-            maxTokens: 4096,
-            layer: 'l1-extract',
-            logger,
-        });
-        const parsed = parseJsonLogged(raw, 'hall 回填', logger);
-        if (!Array.isArray(parsed))
-            return [];
-        const byId = new Map(chunk.map((r) => [r.id, r]));
-        const out = [];
-        for (const item of parsed) {
-            const record = typeof item?.id === 'string' ? byId.get(item.id) : undefined;
-            const hall = typeof item?.hall === 'string' ? item.hall.trim() : '';
-            if (record && hall)
-                out.push({ record, hall });
-        }
-        return out;
-    }
-    catch (err) {
-        logger.warn(`[memory] hall 回填块失败(跳过 ${chunk.length} 条,原记录未改): ${err instanceof Error ? err.message : String(err)}`);
-        state.failed += chunk.length;
-        return [];
-    }
-}

package/dist/hall-migrate.d.ts

@@ -1,32 +0,0 @@
-import type { MemoryLogger } from './types.js';
-/** 新词表下的全部合法 hall 值(8 角 + 跨域兜底)。 */
-export declare const HALL_VALID_VALUES: readonly string[];
-export interface HallMigrationReport {
-    dbPath: string;
-    dryRun: boolean;
-    /** 主表全量行数(含 retired;与 hallL1Counts 的扫描口径一致)。 */
-    total: number;
-    /** retired 行数(valid_to 非空或带退场标记——迁移**不加过滤**,全量扫描自动覆盖)。 */
-    retired: number;
-    active: number;
-    /** 逐值计数(含 retired 行;null 单列)。 */
-    byHall: Record<string, number>;
-    unlabeled: number;
-    /** 不在新词表内的历史值(按 R10 不删已有标签,仅报告)。 */
-    unknownValues: Record<string, number>;
-    /** metadata 解析失败的行数(备份仍写入原始 JSON)。 */
-    corruptMetadata: number;
-    /** apply 模式写出的备份文件路径(dry-run 为 null)。 */
-    backupPath: string | null;
-    /** 结论:expected = 全部值合法(迁移无需改写);unknown = 存在历史遗留值(已报告,保留)。 */
-    verdict: 'expected' | 'unknown-values';
-}
-export interface HallMigrationOptions {
-    dbPath: string;
-    /** true = 只读报告,不写备份;false = 先备份 metadata_json 再出报告。 */
-    dryRun?: boolean;
-    /** 备份输出目录(缺省 = db 同目录 hall-migrate-backup/)。 */
-    backupDir?: string;
-    logger?: MemoryLogger;
-}
-export declare function runHallMigration(opts: HallMigrationOptions): HallMigrationReport;

package/dist/hall-migrate.js

@@ -1,88 +0,0 @@
-/**
- * hall 词表迁移(task_14):v0.12 5 值词表 → 8 角 + general 跨域兜底的**有界 targeted pass**。
- *
- * 关键事实(决定本迁移的形态):
- * - 4 个保留 id(work/relationships/finance/journey)在新词表下仍是合法角,**存量标签零改动**;
- * - `general` 保留为跨域兜底值(不重写、不删除);
- * - 4 个新角无存量。因此本迁移**不改任何行的 hall 值**——它做的是:
- *   ① 备份 metadata_json(apply 模式);② **扫 L1 主表全量(含 retired 行)**逐行核对;
- *   ③ 落报告:逐值计数(含 null)/活性与 retired 拆分/未知值清单。
- *
- * 幂等:连续执行两次报告一致(扫描是纯读)。共享扫描函数 = `MemoryDb.scanL1Metadata`
- * (单一所有者;计划 B 的引用门禁复用同一函数,不写第二份扫描)。
- */
-import { openSync, closeSync, writeSync, existsSync, mkdirSync } from 'node:fs';
-import * as path from 'node:path';
-import { MemoryDb } from './store/sqlite.js';
-import { HALL_CATALOG, HALL_FALLBACK } from './types.js';
-/** 新词表下的全部合法 hall 值(8 角 + 跨域兜底)。 */
-export const HALL_VALID_VALUES = [...HALL_CATALOG.map((h) => h.id), HALL_FALLBACK];
-export function runHallMigration(opts) {
-    const db = new MemoryDb(opts.dbPath, 0, opts.logger);
-    // 开库即建表/补列(CREATE TABLE IF NOT EXISTS 惯例);未 init 则句柄未打开,扫描恒 0
-    db.init();
-    try {
-        const report = {
-            dbPath: opts.dbPath,
-            dryRun: !!opts.dryRun,
-            total: 0,
-            retired: 0,
-            active: 0,
-            byHall: {},
-            unlabeled: 0,
-            unknownValues: {},
-            corruptMetadata: 0,
-            backupPath: null,
-            verdict: 'expected',
-        };
-        let backupFd = null;
-        if (!report.dryRun) {
-            const dir = opts.backupDir ?? path.join(path.dirname(opts.dbPath), 'hall-migrate-backup');
-            if (!existsSync(dir))
-                mkdirSync(dir, { recursive: true });
-            const backupPath = path.join(dir, `metadata-backup-${new Date().toISOString().replace(/[:.]/g, '-')}.jsonl`);
-            backupFd = openSync(backupPath, 'w');
-            report.backupPath = backupPath;
-        }
-        try {
-            report.total = db.scanL1Metadata((recordId, metadata) => {
-                const hall = metadata && typeof metadata.hall === 'string' && metadata.hall !== '' ? metadata.hall : null;
-                // metadata 缺失/解析失败与"无 hall"同样计入未打标(存量 524 null 的主口径)
-                // 备份:原始 metadata_json 原样落盘(apply 模式;dry-run 不写任何文件)
-                if (backupFd !== null) {
-                    writeSync(backupFd, JSON.stringify({ recordId, metadata }) + '\n');
-                }
-                if (hall === null) {
-                    report.unlabeled++;
-                }
-                else {
-                    report.byHall[hall] = (report.byHall[hall] ?? 0) + 1;
-                    if (!HALL_VALID_VALUES.includes(hall)) {
-                        report.unknownValues[hall] = (report.unknownValues[hall] ?? 0) + 1;
-                    }
-                }
-            });
-            // retired 拆分:退场判定与存储层同口径(valid_to 非空 ∨ dsh_superseded 标记)。
-            // 扫描本身**不加过滤**(全表 SELECT 自动覆盖 retired),这里仅分类计数。
-            report.active = report.total - countRetired(db);
-            report.retired = report.total - report.active;
-        }
-        finally {
-            if (backupFd !== null)
-                closeSync(backupFd);
-        }
-        report.verdict = Object.keys(report.unknownValues).length > 0 ? 'unknown-values' : 'expected';
-        return report;
-    }
-    finally {
-        db.close();
-    }
-}
-/** retired 行计数(与 sqlite 层退场判定同口径;用于验证"全量扫描不漏 retired")。 */
-function countRetired(db) {
-    // 借道 scanL1Metadata 之外的轻量路径不可得(retired 判定在行级字段),
-    // 这里直接用 hallL1Counts 的同族 SQL:valid_to 非空 ∨ metadata 带 dsh_superseded。
-    // 为保持"单一所有者",经由 scanL1Metadata 之外不再开第二条 SQL——改为返回占位 0,
-    // 由 retire 拆分调用方(db.retiredL1Count)提供。
-    return db.retiredL1Count();
-}