dsh-prime-memory 0.18.2 → 0.18.5

package/dist/util/redact.js

@@ -0,0 +1,228 @@
+/**
+ * §C 载荷脱敏(memorax-absorb Wave 2 / task_14)——捕获边界的密钥擦除。
+ *
+ * 用户在对话里贴入的密钥(PEM/Bearer/JWT/Cookie/厂商 API key/邮箱/长号/高熵 ID)
+ * 若原样进 L0/L1,会被逐轮召回注入上下文并在 UI 展示。本模块在捕获单点把它们
+ * 替换为类型化占位符 `[REDACTED:<KIND>]`——占位符保留类别语义,关键词检索仍可命中。
+ *
+ * 词表/正则/allowlist/span 合并算法以 memorax `payload-redaction.ts` 为基准逐条移植
+ * (全文快照见计划 evidence/payload-redaction-snapshot.ts;findings.md 有等价内联)。
+ *
+ * 契约(sanitize 同款,tests/redact.test.ts 钉住):
+ * - 纯函数,零 I/O 零时钟零随机;输入原样返回(未命中)= 引用不变无关紧要,字符串不可变;
+ * - **幂等**:已是 `[REDACTED:KIND]` 的值不会被二次匹配;
+ * - 安全值 allowlist 命中不脱(`example`/`change-me`/`$VAR`/`${{…}}` 等);
+ * - 本函数**永不抛错**的保证由调用方 try/catch 兜底(capture 接线层,§C 红线:失败放行原文)。
+ */
+const PLACEHOLDER_VALUE_PATTERN = /^\[REDACTED:[A-Z_]+\]$/;
+const SENSITIVE_KEY_SOURCE = String.raw `(?:[A-Za-z_$][A-Za-z0-9_$-]*)?(?:password|passwd|pwd|client[-_$]?secret|consumer[-_$]?secret|api[-_$]?key|access[-_$]?token|refresh[-_$]?token|auth[-_$]?token|id[-_$]?token|private[-_$]?key|secret[-_$]?access[-_$]?key|secret[-_$]?key|credential|secret|token)`;
+const CREDENTIAL_VALUE_SOURCE = String.raw `(?:\[REDACTED:[A-Z_]+\]|\$\{\{[^\r\n]*?\}\}|\{\{[^\r\n]*?\}\}|\$\{[^}\r\n]+\}|\$[A-Za-z_][A-Za-z0-9_]*|"(?:\\.|[^"\\\r\n])*"|'(?:\\.|[^'\\\r\n])*'|[^,;#}\]\)\r\n]+)`;
+/** 安全值 allowlist:命中即放行(示例/占位/环境变量引用/类型名等,脱了只会毁记忆)。 */
+const SAFE_CREDENTIAL_VALUE_PATTERN = /^(?:\[REDACTED:[A-Z_]+\]|\$\{\{[^\r\n]*\}\}|\{\{[^\r\n]*\}\}|\$\{[A-Z_][A-Z0-9_]*\}|\$[A-Z_][A-Z0-9_]*|(?:process\.)?env\.[A-Z_][A-Z0-9_]*|<[^>]+>|--\S+|x{2,}|\*{2,}|\.{3}|sk[_-]x+|example|sample|change-?me|(?:your|replace)[-_][a-z0-9_-]+|string|str|number|boolean|unknown|any|null|undefined|none)$/i;
+const RULES = [
+    {
+        // PEM 私钥块:至对应 END,截断文件时取到文末
+        pattern: /-----BEGIN ((?:(?:RSA|EC|DSA|OPENSSH|ENCRYPTED) )?PRIVATE KEY|PGP PRIVATE KEY BLOCK)-----[\s\S]*?(?:-----END \1-----|$)/gi,
+        kind: 'PRIVATE_KEY',
+        priority: 100,
+    },
+    {
+        pattern: /(?:^|[\r\n])[ \t]*(?:Proxy-)?Authorization[ \t]*:[ \t]*([^ \t\r\n][^\r\n]*)/gim,
+        group: 1,
+        kind: 'AUTH_TOKEN',
+        priority: 95,
+    },
+    {
+        pattern: /(?:^|[^A-Za-z0-9_-])(?:Bearer|Basic)\s+["']?([A-Za-z0-9._~+/=-]{16,})(?![A-Za-z0-9._~+/=-])/gi,
+        group: 1,
+        kind: 'AUTH_TOKEN',
+        priority: 94,
+    },
+    {
+        // JWT 三段形态
+        pattern: /\beyJ[A-Za-z0-9_-]{5,}\.eyJ[A-Za-z0-9_-]{5,}\.[A-Za-z0-9_-]{16,}\b/g,
+        kind: 'AUTH_TOKEN',
+        priority: 94,
+    },
+    {
+        pattern: /(?:^|[\r\n])[ \t]*(?:Set-Cookie|Cookie)\s*:\s*([^\r\n]+)/gim,
+        group: 1,
+        kind: 'COOKIE',
+        priority: 92,
+    },
+    {
+        // 声明式赋值:key: value / key = value(含 export/const/let/var 前缀与引号键)
+        pattern: new RegExp(String.raw `(?:^|[\r\n;,{}])[ \t]*(?:-[ \t]+)?(?:(?:export|const|let|var)[ \t]+)*["']?${SENSITIVE_KEY_SOURCE}["']?[ \t]*[:=][ \t]*(${CREDENTIAL_VALUE_SOURCE})`, 'gim'),
+        group: 1,
+        kind: 'CREDENTIAL',
+        priority: 85,
+        accept: (value) => !isSafeCredentialValue(value),
+    },
+    {
+        // CLI 形态:--api-key value / --api-key=value
+        pattern: new RegExp(String.raw `--${SENSITIVE_KEY_SOURCE}(?![A-Za-z0-9_$-])(?:[ \t]+|=[ \t]*)(${CREDENTIAL_VALUE_SOURCE})`, 'gi'),
+        group: 1,
+        kind: 'CREDENTIAL',
+        priority: 85,
+        accept: (value) => !isSafeCredentialValue(value),
+    },
+    {
+        // URL query 形态:?api_key=...
+        pattern: new RegExp(String.raw `[?&]${SENSITIVE_KEY_SOURCE}(?![A-Za-z0-9_$-])=([^&#\s"'<>]+)`, 'gi'),
+        group: 1,
+        kind: 'CREDENTIAL',
+        priority: 85,
+        accept: (value) => !isSafeCredentialValue(value),
+    },
+    {
+        // URL userinfo 形态:scheme://user:pass@
+        pattern: /\b[A-Za-z][A-Za-z0-9+.-]*:\/\/[^\s/:@]*:([^\s/@]+)@/g,
+        group: 1,
+        kind: 'CREDENTIAL',
+        priority: 85,
+        accept: (value) => !isSafeCredentialValue(value),
+    },
+    // ── 已知厂商 API key 形态(9 条) ──
+    { pattern: /\bsk-(?:proj-)?[A-Za-z0-9_-]{16,}[A-Za-z0-9]\b/g, kind: 'API_KEY', priority: 80 },
+    { pattern: /\bsk_[A-Za-z0-9_-]{8,}\b/g, kind: 'API_KEY', priority: 80 },
+    { pattern: /\b(?:gh[pousr]_[A-Za-z0-9]{20,}|github_pat_[A-Za-z0-9_]{20,})\b/g, kind: 'API_KEY', priority: 80 },
+    { pattern: /\b(?:AKIA|ASIA)[A-Z0-9]{16}\b/g, kind: 'API_KEY', priority: 80 },
+    { pattern: /\bxox[baprs]-[A-Za-z0-9-]{16,}[A-Za-z0-9]\b/g, kind: 'API_KEY', priority: 80 },
+    { pattern: /\b(?:(?:sk|rk)_live_[A-Za-z0-9]{16,}|whsec_[A-Za-z0-9]{16,})\b/g, kind: 'API_KEY', priority: 80 },
+    { pattern: /\bglpat-[A-Za-z0-9_-]{16,}[A-Za-z0-9]\b/g, kind: 'API_KEY', priority: 80 },
+    { pattern: /\bAIza[0-9A-Za-z_-]{35}\b/g, kind: 'API_KEY', priority: 80 },
+    { pattern: /\bnpm_[A-Za-z0-9]{36}\b/g, kind: 'API_KEY', priority: 80 },
+    {
+        // 邮箱(前后向断言防误切)
+        pattern: /(?<![A-Z0-9._%+-])[A-Z0-9._%+-]{1,64}@[A-Z0-9](?:[A-Z0-9.-]{0,251}[A-Z0-9])?\.[A-Z]{2,63}(?![A-Z0-9-]|\.[A-Z0-9])/gi,
+        kind: 'EMAIL',
+        priority: 70,
+    },
+    {
+        // UUID
+        pattern: /(?<![A-Za-z0-9])[0-9A-Fa-f]{8}-(?:[0-9A-Fa-f]{4}-){3}[0-9A-Fa-f]{12}(?![A-Za-z0-9])/g,
+        kind: 'OPAQUE_ID',
+        priority: 60,
+    },
+    {
+        // hex 64/40/32(含字母才脱——纯数字是普通长号,交 LONG_NUMBER)
+        pattern: /(?<![A-Za-z0-9])(?:[0-9A-Fa-f]{64}|[0-9A-Fa-f]{40}|[0-9A-Fa-f]{32})(?![A-Za-z0-9])/g,
+        kind: 'OPAQUE_ID',
+        priority: 60,
+        accept: (value) => /[A-Fa-f]/.test(value),
+    },
+    {
+        // ≥24 位字母数字高熵启发式(熵参数见 looksLikeHighEntropyOpaqueId)
+        pattern: /(?<![A-Za-z0-9])[A-Za-z0-9]{24,}(?![A-Za-z0-9])/g,
+        kind: 'OPAQUE_ID',
+        priority: 60,
+        accept: looksLikeHighEntropyOpaqueId,
+    },
+    {
+        // ≥9 位数字串(含电话形);日期形放行
+        pattern: /(?<![A-Za-z0-9.])\+?(?:\d|\(\d)[\d ()-]*\d[Xx]?\)?(?![A-Za-z0-9]|\.\d)/g,
+        kind: 'LONG_NUMBER',
+        priority: 50,
+        accept: (value) => {
+            if (value.replace(/\D/g, '').length < 9)
+                return false;
+            const normalized = value.trim().replace(/[()]/g, '');
+            return (!/^(?:19|20)\d{2}-\d{1,2}-\d{1,2}(?:[ T-]\d{1,2})?$/.test(normalized) &&
+                !/^(?:19|20)\d{2}\s+\d{1,2}\s+\d{1,2}(?:\s+\d{1,2})?$/.test(normalized));
+        },
+    },
+];
+/**
+ * 对文本执行 8 类脱敏。规则各自扫描 → 收集值级 span → 合并重叠 → 重拼插入占位符。
+ * 同一位置被多条规则命中时取更长/更高优先级的 span。
+ */
+export function redactSecrets(text) {
+    if (!text)
+        return { text, counts: {}, redacted: false };
+    const spans = [];
+    for (const rule of RULES)
+        collectRuleSpans(text, rule, spans);
+    const selected = mergeOverlappingSpans(spans);
+    if (selected.length === 0)
+        return { text, counts: {}, redacted: false };
+    const counts = {};
+    const output = [];
+    let offset = 0;
+    for (const span of selected) {
+        output.push(text.slice(offset, span.start), `[REDACTED:${span.kind}]`);
+        counts[span.kind] = (counts[span.kind] ?? 0) + 1;
+        offset = span.end;
+    }
+    output.push(text.slice(offset));
+    return { text: output.join(''), counts, redacted: true };
+}
+function collectRuleSpans(text, rule, spans) {
+    rule.pattern.lastIndex = 0;
+    for (const match of text.matchAll(rule.pattern)) {
+        const value = match[rule.group ?? 0];
+        if (match.index === undefined || !value || PLACEHOLDER_VALUE_PATTERN.test(value.trim()))
+            continue;
+        if (rule.accept && !rule.accept(value))
+            continue;
+        const relativeStart = match[0].lastIndexOf(value);
+        if (relativeStart < 0)
+            continue;
+        spans.push({
+            start: match.index + relativeStart,
+            end: match.index + relativeStart + value.length,
+            kind: rule.kind,
+            priority: rule.priority,
+        });
+    }
+}
+function isSafeCredentialValue(rawValue) {
+    let value = rawValue.trim();
+    if ((value.startsWith('"') && value.endsWith('"')) || (value.startsWith("'") && value.endsWith("'"))) {
+        value = value.slice(1, -1).trim();
+    }
+    return !value || SAFE_CREDENTIAL_VALUE_PATTERN.test(value);
+}
+/** 高熵判定:小写≥2 ∧ 大写≥2 ∧ 数字≥2 ∧ 字符类切换≥4 ∧ 最长连续字母段≤5 ∧ 去重字符≥12。 */
+function looksLikeHighEntropyOpaqueId(value) {
+    let lowercase = 0;
+    let uppercase = 0;
+    let digits = 0;
+    let transitions = 0;
+    let letterRun = 0;
+    let longestLetterRun = 0;
+    let previousWasDigit;
+    const unique = new Set();
+    for (const character of value) {
+        const isDigit = character >= '0' && character <= '9';
+        if (isDigit) {
+            digits += 1;
+            letterRun = 0;
+        }
+        else {
+            if (character >= 'a' && character <= 'z')
+                lowercase += 1;
+            else
+                uppercase += 1;
+            letterRun += 1;
+            longestLetterRun = Math.max(longestLetterRun, letterRun);
+        }
+        if (previousWasDigit !== undefined && previousWasDigit !== isDigit)
+            transitions += 1;
+        previousWasDigit = isDigit;
+        unique.add(character);
+    }
+    return lowercase >= 2 && uppercase >= 2 && digits >= 2 && transitions >= 4 && longestLetterRun <= 5 && unique.size >= 12;
+}
+function mergeOverlappingSpans(spans) {
+    const sorted = [...spans].sort((left, right) => left.start - right.start || right.end - left.end || right.priority - left.priority);
+    const merged = [];
+    for (const span of sorted) {
+        const previous = merged.at(-1);
+        if (!previous || span.start >= previous.end) {
+            merged.push({ ...span });
+            continue;
+        }
+        previous.end = Math.max(previous.end, span.end);
+    }
+    return merged;
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "dsh-prime-memory",
-  "version": "0.18.2",
+  "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();
-}