dsh-prime-memory 0.18.5 → 0.18.7

package/dist/room-review.js

@@ -1,281 +0,0 @@
-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 };
-    // 合并词表:注册表条目排前(附 description,对 LLM 归类价值最高),封顶 120;
-    // 无注册表 = 纯自生长聚合(计数降序)。整批共享一张词表(一次 LLM 调用)。
-    const grown = io.l1.listRooms();
-    const regActive = io.registry?.listActive() ?? [];
-    const regSet = new Set(regActive.map((e) => e.slug));
-    const merged = [
-        ...regActive.map((e) => ({ room: e.slug, count: 0, label: e.label, description: e.description })),
-        ...grown.filter((r) => !regSet.has(r.room)).map((r) => ({ room: r.room, count: r.count })),
-    ].slice(0, 120);
-    const rows = overrides.chunkAnnotator !== undefined
-        ? await overrides.chunkAnnotator(selected, merged)
-        : await roomCandidateChunk(ctx, cfg, io.logger, selected, merged);
-    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);
-}
-/** merge 单飞哨兵(模块级;与 ruminate/wing-backfill 的时间错开由调用方保证)。 */
-let roomMergeRunning = false;
-/**
- * Room merge/rename 编排(破坏性动作,分类管理 beta.5):
- *  - dryRun(缺省 true):只统计 affected + 前 6 条预览,**零写入**;
- *  - 实跑:执行前备份(matching rows → rooms-merge-backups/)→ 游标重写
- *    (写前重读-合并-写回,其余 metadata 键保全)→ 注册表 markMerged/renameSlug
- *    → 返回受影响 (family, scene) 供调用方入队 recluster('room-merge');
- *  - 单飞:并发 merge 直接抛错;与 relabel/ruminate 的时间错开由调用方保证。
- * 抛错语义:非法参数/注册表冲突直接抛(调用方转 notice)。
- */
-export async function mergeRoom(io, from, to, opts = {}) {
-    const dryRun = opts.dryRun !== false;
-    const cap = Math.min(Math.max(opts.cap ?? 500, 1), 2000);
-    if (from === to)
-        throw new Error('from 与 to 相同');
-    if (!from.trim())
-        throw new Error('from 不能为空');
-    if (roomMergeRunning)
-        throw new Error('Room merge 已在进行中(单飞)');
-    const previewRows = io.l1.listByTagAll(from, 7);
-    const affected = io.l1.listByTagAll(from, cap + 1).length;
-    const preview = previewRows.slice(0, 6).map((r) => r.id);
-    if (dryRun)
-        return { dryRun: true, affected, preview, applied: 0, hasMore: affected > cap };
-    if (roomMergeRunning)
-        throw new Error('Room merge 已在进行中(单飞)');
-    roomMergeRunning = true;
-    try {
-        const backup = io.l1.backupTagRecords(from);
-        io.logger.info(`[memory] Room merge 备份:${from} → ${to},${backup.count} 条 → ${backup.file}`);
-        let applied = 0;
-        const hasMore = false; // 循环到收敛,单次调用内 hasMore 恒 false(重写返回值沿用结果形状)
-        const families = new Set();
-        const scenes = new Set();
-        // 游标重写:上限 cap/次,hasMore 时继续(总量受 cap×轮次约束,单飞内收敛)
-        for (;;) {
-            const r = io.l1.rewriteTag(from, to, cap);
-            applied += r.rewritten;
-            for (const f of r.families)
-                families.add(f);
-            for (const sc of r.scenes)
-                scenes.add(sc);
-            if (!r.hasMore || r.rewritten === 0)
-                break;
-        }
-        await io.registry.markMerged(from, to);
-        io.l1.invalidateRooms();
-        io.logger.info(`[memory] Room merge 完成:${from} → ${to},重写 ${applied} 条;受影响场景 ${scenes.size} 个`);
-        return {
-            dryRun: false,
-            affected,
-            preview,
-            applied,
-            hasMore,
-            backupFile: backup.file,
-            ...(families.size > 0 || scenes.size > 0 ? { families: [...families], scenes: [...scenes] } : {}),
-        };
-    }
-    finally {
-        roomMergeRunning = false;
-    }
-}
-/** rename = merge 1:1 + 注册表改名(冲突时抛错提示走 merge)。
- *  归类语义:改名**不是退役**——merge 编排的 markMerged 会把旧条目置 retired,
- *  这里在改名后恢复其先前状态(active 条目改名后仍 active,不掉出标注词表)。 */
-export async function renameRoom(io, from, to, opts = {}) {
-    const priorStatus = io.registry.bySlug?.(from)?.status ?? 'active';
-    const r = await mergeRoom(io, from, to, opts);
-    if (!r.dryRun && r.applied > 0) {
-        await io.registry.renameSlug(from, to);
-        if (priorStatus === 'active')
-            await io.registry.setStatus?.(to, 'active');
-    }
-    return r;
-}
-/** 下一条待复查(供 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/store/recall-usage.d.ts

@@ -1,43 +0,0 @@
-import type { MemoryLogger } from '../types.js';
-export declare const RECALL_USAGE_FILE_VERSION: 1;
-export interface RecallUsageEntry {
-    attempts: number;
-    used: number;
-    lastAttemptAt: number | null;
-    lastUsedAt: number | null;
-}
-export interface RecallUsageSummary {
-    /** 有统计的记忆条数。 */
-    tracked: number;
-    /** 尝试总次数(Σ attempts)。 */
-    attempted: number;
-    /** 使用总次数(Σ used)。 */
-    used: number;
-    /** 使用率(百分比整数;attempted=0 时 0)。 */
-    rate: number;
-}
-export declare class RecallUsageStore {
-    private readonly logger?;
-    private readonly file;
-    private entries;
-    private loaded;
-    private degraded;
-    private degradedLogged;
-    private writeTimer;
-    private writeChain;
-    constructor(dataDir: string, logger?: MemoryLogger | undefined);
-    init(): Promise<void>;
-    private ensureLoaded;
-    /** 一轮召回:候选集 attempts++/lastAttemptAt=now;used 子集额外 used++/lastUsedAt=now
-     *  (used 不在候选内 = 防御路径,同样算一次尝试——用了就是被尝试过)。 */
-    recordAttempt(candidateIds: readonly string[], usedIds: readonly string[]): void;
-    get(id: string): RecallUsageEntry | undefined;
-    summary(): RecallUsageSummary;
-    /** 立即落盘(去抖窗口内的兜底;测试/停机用)。 */
-    flush(): Promise<void>;
-    /** 同步等待在途写(测试用;无在途写时立即返回)。 */
-    flushSync(): void;
-    private prune;
-    private schedulePersist;
-    private persist;
-}

package/dist/store/recall-usage.js

@@ -1,149 +0,0 @@
-/**
- * 召回使用统计 sidecar(老化权重效果统计的数据面)。
- *
- * 口径(用户裁定):**进 topN(被注入上下文)才算被使用**;参与尝试未进 = 只有
- * attempts。每轮召回 recordAttempt(候选集, 注入集)——内存即时、去抖原子持久化
- * (召回是热路径,统计只碰内存 Map)。
- *
- * 存储:`recall-usage.json` slots 式 sidecar,与 rooms-registry/session-modes 同族
- * 纪律:缺失 = 合法空表;损坏/不可读 → 只读降级(内存态照常,停止回写),绝不阻塞
- * 召回读路径(R2 红线)。
- */
-import * as path from 'node:path';
-import { readJsonStrict, atomicWriteText, ensureDir } from '../util/io.js';
-export const RECALL_USAGE_FILE_VERSION = 1;
-/** 条目上限(防已退场/被取代记忆的 id 无限累积):超限按 lastAttemptAt 淘汰最旧。 */
-const MAX_ENTRIES = 50_000;
-/** 去抖持久化间隔(召回热路径;窗口内断电最多丢最近统计,不影响记忆本体)。 */
-const PERSIST_DEBOUNCE_MS = 5_000;
-export class RecallUsageStore {
-    logger;
-    file;
-    entries = new Map();
-    loaded = false;
-    degraded;
-    degradedLogged = false;
-    writeTimer;
-    writeChain = Promise.resolve();
-    constructor(dataDir, logger) {
-        this.logger = logger;
-        this.file = path.join(dataDir, 'recall-usage.json');
-    }
-    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] 召回使用统计只读降级: ${this.degraded}`);
-            }
-            this.loaded = true;
-            return;
-        }
-        const raw = read.value.entries ?? {};
-        for (const [id, e] of Object.entries(raw)) {
-            if (!e || typeof e.attempts !== 'number')
-                continue;
-            this.entries.set(id, {
-                attempts: e.attempts,
-                used: typeof e.used === 'number' ? e.used : 0,
-                lastAttemptAt: typeof e.lastAttemptAt === 'number' ? e.lastAttemptAt : null,
-                lastUsedAt: typeof e.lastUsedAt === 'number' ? e.lastUsedAt : null,
-            });
-        }
-        this.loaded = true;
-    }
-    ensureLoaded() {
-        if (!this.loaded)
-            throw new Error('召回使用统计未初始化(先 await init())');
-    }
-    /** 一轮召回:候选集 attempts++/lastAttemptAt=now;used 子集额外 used++/lastUsedAt=now
-     *  (used 不在候选内 = 防御路径,同样算一次尝试——用了就是被尝试过)。 */
-    recordAttempt(candidateIds, usedIds) {
-        this.ensureLoaded();
-        if (candidateIds.length === 0 && usedIds.length === 0)
-            return;
-        const now = Date.now();
-        const cand = new Set(candidateIds);
-        for (const id of cand) {
-            const e = this.entries.get(id) ?? { attempts: 0, used: 0, lastAttemptAt: null, lastUsedAt: null };
-            e.attempts += 1;
-            e.lastAttemptAt = now;
-            this.entries.set(id, e);
-        }
-        for (const id of usedIds) {
-            const e = this.entries.get(id) ?? { attempts: 0, used: 0, lastAttemptAt: null, lastUsedAt: null };
-            e.used += 1;
-            if (!cand.has(id)) {
-                e.attempts += 1;
-                e.lastAttemptAt = now;
-            }
-            e.lastUsedAt = now;
-            this.entries.set(id, e);
-        }
-        this.prune();
-        this.schedulePersist();
-    }
-    get(id) {
-        this.ensureLoaded();
-        const e = this.entries.get(id);
-        return e ? { ...e } : undefined;
-    }
-    summary() {
-        this.ensureLoaded();
-        let attempted = 0;
-        let used = 0;
-        for (const e of this.entries.values()) {
-            attempted += e.attempts;
-            used += e.used;
-        }
-        return { tracked: this.entries.size, attempted, used, rate: attempted > 0 ? Math.round((used / attempted) * 100) : 0 };
-    }
-    /** 立即落盘(去抖窗口内的兜底;测试/停机用)。 */
-    flush() {
-        if (this.writeTimer) {
-            clearTimeout(this.writeTimer);
-            this.writeTimer = undefined;
-        }
-        return this.persist();
-    }
-    /** 同步等待在途写(测试用;无在途写时立即返回)。 */
-    flushSync() {
-        void this.flush();
-    }
-    prune() {
-        if (this.entries.size <= MAX_ENTRIES)
-            return;
-        const byOldest = [...this.entries.entries()].sort((a, b) => (a[1].lastAttemptAt ?? 0) - (b[1].lastAttemptAt ?? 0));
-        for (const [id] of byOldest.slice(0, this.entries.size - MAX_ENTRIES))
-            this.entries.delete(id);
-    }
-    schedulePersist() {
-        if (this.degraded || this.writeTimer)
-            return;
-        this.writeTimer = setTimeout(() => {
-            this.writeTimer = undefined;
-            void this.persist();
-        }, PERSIST_DEBOUNCE_MS);
-        this.writeTimer.unref?.(); // 不为统计写hold进程(停机即丢窗口内统计,可接受)
-    }
-    async persist() {
-        if (this.degraded)
-            return;
-        this.writeChain = this.writeChain.then(async () => {
-            try {
-                await ensureDir(path.dirname(this.file));
-                const data = { version: RECALL_USAGE_FILE_VERSION, entries: Object.fromEntries(this.entries) };
-                await atomicWriteText(this.file, JSON.stringify(data));
-            }
-            catch (err) {
-                this.degraded = err instanceof Error ? err.message : String(err);
-                if (!this.degradedLogged) {
-                    this.degradedLogged = true;
-                    this.logger?.warn(`[memory] 召回使用统计写入失败,只读降级: ${this.degraded}`);
-                }
-            }
-        });
-        await this.writeChain;
-    }
-}

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

@@ -1,66 +0,0 @@
-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'>>;
-/**
- * 两级 Room slug(`major` 或 `major/minor`):事实源在 metadata-validators.ts
- * (normTags 写回闸同源放行),此处 re-export 兼容既有导入。
- */
-export { isRoomSlug } from '../metadata-validators.js';
-/** 大类归属:`major/minor` 取 major;平级 slug 自身即大类。 */
-export declare function majorOf(slug: string): string;
-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;
-    }>;
-    /** 编辑已有条目的 label/description(注册后可重编辑;未提供的字段不动;未找到=false)。 */
-    update(slug: string, patch: {
-        label?: string;
-        description?: string;
-    }): Promise<boolean>;
-    /** 改状态(active↔retired);无变化返回 false。 */
-    setStatus(slug: string, status: 'active' | 'retired'): Promise<boolean>;
-    /** 改名(merge 1:1 收尾):slug 换名 + 旧 slug 进 aliases。新名与既有条目冲突时走 merge。
-     *  目标用两级制词表(isRoomSlug)——把 standalone room 归类到 hall 下(改名 major/minor)
-     *  走的就是这条路;isTag 会误拒带 slash 的目标。 */
-    renameSlug(oldSlug: string, newSlug: string): Promise<boolean>;
-    /** 合并收尾:fromSlug 条目转 retired + toSlug 进 aliases(记录重写由调用方游标执行)。 */
-    markMerged(fromSlug: string, toSlug: string): Promise<boolean>;
-    /** 写穿持久化(串行链;失败降级内存态并告警一次)。 */
-    private persist;
-}