dsh-prime-memory 0.20.0-beta.2 → 0.20.0-beta.21

package/dist/store/session-modes.d.ts

@@ -44,14 +44,6 @@ export declare class SessionModeStore {
     resolvedRecall(sessionId: string, globalRecall: boolean): boolean;
     /** 设置会话级注入覆盖(undefined = 清除覆盖跟随全局。写穿持久化)。 */
     setRecall(sessionId: string, recall: boolean | undefined): void;
-    /** 长任务模式(缺省 = 关)。 */
-    getLongTask(sessionId: string): boolean;
-    /** 切换长任务模式(写穿持久化)。 */
-    setLongTask(sessionId: string, on: boolean): void;
-    /** 尾部压缩水位线(undefined = 尚未压缩过)。 */
-    getTailWatermark(sessionId: string): number | undefined;
-    /** 推进尾部压缩水位线(写穿持久化;只前进不回退)。 */
-    setTailWatermark(sessionId: string, turn: number): void;
     /** 会话级域锁定(多选):空数组 = 中心(智能档,无锁域)。 */
     getWings(sessionId: string): string[];
     /** 兼容读取(单选口径,取第一个锁定域):undefined = 中心。 */

package/dist/store/session-modes.js

@@ -92,8 +92,6 @@ export class SessionModeStore {
                         : undefined,
                 hallIncludeUnlabeled: typeof entry.hallIncludeUnlabeled === 'boolean' ? entry.hallIncludeUnlabeled : undefined,
                 hallIncludeGeneral: typeof entry.hallIncludeGeneral === 'boolean' ? entry.hallIncludeGeneral : undefined,
-                longTask: typeof entry.longTask === 'boolean' ? entry.longTask : undefined,
-                lastTailCompressedTurn: typeof entry.lastTailCompressedTurn === 'number' ? entry.lastTailCompressedTurn : undefined,
                 updatedAt: entry.updatedAt ?? now,
             });
             count++;
@@ -137,52 +135,6 @@ export class SessionModeStore {
             halls: entry?.halls,
             hallIncludeUnlabeled: entry?.hallIncludeUnlabeled,
             hallIncludeGeneral: entry?.hallIncludeGeneral,
-            longTask: entry?.longTask,
-            lastTailCompressedTurn: entry?.lastTailCompressedTurn,
-            updatedAt: Date.now(),
-        });
-        this.writeChain = this.writeChain.then(() => this.persist());
-    }
-    /** 长任务模式(缺省 = 关)。 */
-    getLongTask(sessionId) {
-        return this.entries.get(sessionId)?.longTask ?? false;
-    }
-    /** 切换长任务模式(写穿持久化)。 */
-    setLongTask(sessionId, on) {
-        const entry = this.entries.get(sessionId);
-        this.entries.set(sessionId, {
-            mode: entry?.mode ?? this.loaded,
-            recall: entry?.recall,
-            hall: entry?.hall,
-            halls: entry?.halls,
-            hallIncludeUnlabeled: entry?.hallIncludeUnlabeled,
-            hallIncludeGeneral: entry?.hallIncludeGeneral,
-            longTask: on,
-            lastTailCompressedTurn: entry?.lastTailCompressedTurn,
-            updatedAt: Date.now(),
-        });
-        this.writeChain = this.writeChain.then(() => this.persist());
-    }
-    /** 尾部压缩水位线(undefined = 尚未压缩过)。 */
-    getTailWatermark(sessionId) {
-        const t = this.entries.get(sessionId)?.lastTailCompressedTurn;
-        return typeof t === 'number' && Number.isFinite(t) ? t : undefined;
-    }
-    /** 推进尾部压缩水位线(写穿持久化;只前进不回退)。 */
-    setTailWatermark(sessionId, turn) {
-        const entry = this.entries.get(sessionId);
-        const prev = entry?.lastTailCompressedTurn;
-        if (typeof prev === 'number' && prev >= turn)
-            return;
-        this.entries.set(sessionId, {
-            mode: entry?.mode ?? this.loaded,
-            recall: entry?.recall,
-            hall: entry?.hall,
-            halls: entry?.halls,
-            hallIncludeUnlabeled: entry?.hallIncludeUnlabeled,
-            hallIncludeGeneral: entry?.hallIncludeGeneral,
-            longTask: entry?.longTask,
-            lastTailCompressedTurn: turn,
             updatedAt: Date.now(),
         });
         this.writeChain = this.writeChain.then(() => this.persist());
@@ -221,8 +173,6 @@ export class SessionModeStore {
             halls: locked === undefined ? entry?.halls : locked.length > 0 ? locked : undefined,
             hallIncludeUnlabeled: boundaries?.includeUnlabeled ?? entry?.hallIncludeUnlabeled,
             hallIncludeGeneral: boundaries?.includeGeneral ?? entry?.hallIncludeGeneral,
-            longTask: entry?.longTask,
-            lastTailCompressedTurn: entry?.lastTailCompressedTurn,
             updatedAt: Date.now(),
         });
         this.writeChain = this.writeChain.then(() => this.persist());
@@ -244,8 +194,6 @@ export class SessionModeStore {
             halls: entry?.halls,
             hallIncludeUnlabeled: entry?.hallIncludeUnlabeled,
             hallIncludeGeneral: entry?.hallIncludeGeneral,
-            longTask: entry?.longTask,
-            lastTailCompressedTurn: entry?.lastTailCompressedTurn,
             updatedAt: Date.now(),
         });
         this.writeChain = this.writeChain.then(() => this.persist());

package/dist/store/sqlite.d.ts

@@ -400,6 +400,8 @@ export declare class MemoryDb {
         halls?: readonly string[];
         /** Room 过滤(metadata.tags 含该 slug)。 */
         tag?: string;
+        /** 孤儿记忆筛选(true = 只列没有 Room 的记录;与 tag 互斥,tag 优先)。 */
+        untagged?: boolean;
         workspaceId?: string;
         /**
          * 退场(软删)筛查:三态。
@@ -445,6 +447,8 @@ export declare class MemoryDb {
         room: string;
         count: number;
     }>;
+    /** 孤儿记忆计数:没有任何 Room(tags 为空/缺失)的记录条数(含已退场,与 l1RoomCounts 同口径)。 */
+    untaggedL1Count(): number;
     /** Hall 域计数(八边形角数据源):按 metadata.hall 分组计数 + 未打标行数。失败返回空。 */
     wingL1Counts(): {
         counts: Record<string, number>;

package/dist/store/sqlite.js

@@ -1601,6 +1601,11 @@ export class MemoryDb {
                 where.push(`EXISTS (SELECT 1 FROM json_each(CASE WHEN json_valid(metadata_json) THEN metadata_json ELSE '{}' END, '$.tags') j WHERE j.value = ?)`);
                 params.push(opts.tag);
             }
+            else if (opts.untagged) {
+                // 孤儿记忆:没有任何 Room(tags 数组缺失/为空/字段非法)。与 room 计数同一
+                // json_valid 守卫口径;与 l1RoomCounts() 计数互补(rooms 计数 + 孤儿数 = 全量)。
+                where.push(`NOT EXISTS (SELECT 1 FROM json_each(CASE WHEN json_valid(metadata_json) THEN metadata_json ELSE '{}' END, '$.tags'))`);
+            }
             // 退场筛查(三态,见 opts.retired 注释):与 listRetiredL1 同一判据,保证
             // 「仅退场」视图与「已退场」区看到同一批行。
             if (opts.retired === false) {
@@ -1716,6 +1721,21 @@ export class MemoryDb {
             return [];
         }
     }
+    /** 孤儿记忆计数:没有任何 Room(tags 为空/缺失)的记录条数(含已退场,与 l1RoomCounts 同口径)。 */
+    untaggedL1Count() {
+        if (this.degraded)
+            return 0;
+        try {
+            const row = this.db
+                .prepare(`SELECT COUNT(*) AS n FROM l1_records r
+           WHERE NOT EXISTS (SELECT 1 FROM json_each(CASE WHEN json_valid(r.metadata_json) THEN r.metadata_json ELSE '{}' END, '$.tags'))`)
+                .get();
+            return Number(row?.n ?? 0);
+        }
+        catch {
+            return 0;
+        }
+    }
     /** Hall 域计数(八边形角数据源):按 metadata.hall 分组计数 + 未打标行数。失败返回空。 */
     wingL1Counts() {
         if (this.degraded)

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, mergeRoom, nextReview, pendingReviewCount, renameRoom, 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,153 @@ 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,
+                        };
+                    }
+                    // 实跑:受影响场景入队重算(source='room-merge')
+                    let requeued = 0;
+                    for (const family of r.families ?? []) {
+                        for (const scene of r.scenes ?? []) {
+                            stores.l1.enqueueSceneRecluster(family, [scene], `room-merge:${Date.now()}`, 'room-merge');
+                            requeued++;
+                        }
+                    }
+                    return {
+                        notice: `${action === 'merge' ? '合并' : '改名'}完成:${from} → ${to},重写 ${r.applied} 条` +
+                            `(备份:${r.backupFile ?? '无'})${requeued > 0 ? `;已入队 ${requeued} 个场景重算` : ''}。`,
+                        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',
@@ -778,6 +928,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/dsh.plugin.json

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

package/dist/hooks/long-task.d.ts

@@ -1,31 +0,0 @@
-import type { Context } from '@deepseek-ai/cordis';
-import type { MemoryConfig } from '../config.js';
-import type { ContextUsageStore } from '../store/context-usage.js';
-import type { SlotStore } from '../store/slots.js';
-import type { TodoRefStore } from '../store/todo-ref.js';
-import type { SessionModeStore } from '../store/session-modes.js';
-import type { MemoryLogger } from '../types.js';
-/** todo 参考槽位的受管标题(精确匹配;refreshByTitle 按它原地刷新)。 */
-export declare const TODO_REF_SLOT_TITLE = "\u957F\u4EFB\u52A1 \u00B7 \u4EFB\u52A1\u53C2\u8003(todo)";
-export interface LongTaskMonitorDeps {
-    cfg: MemoryConfig;
-    modes: SessionModeStore;
-    slots: SlotStore;
-    contextUsage: ContextUsageStore;
-    todoRef: TodoRefStore;
-    logger: MemoryLogger;
-}
-/**
- * 长任务模式的事件监听(总开关 cfg.longTask.enabled 关闭时不注册):
- *  - assistant/message 的官方 usage 输入侧 → 上下文使用量(最近值语义);
- *  - compaction/summary → 上下文坍缩归零;
- *  - todo/write → 仅长任务模式下:记录快照 + 漂移检测,并把任务清单刷进
- *    pinned `todo` 槽位(slot-recall 常驻注入,压缩后任务北极星仍在)。
- *
- * fail-open 纪律:任何异常只 warn,绝不影响会话事件主流程。
- */
-export declare function registerLongTaskMonitor(ctx: Context, deps: LongTaskMonitorDeps): () => void;
-/** 任务清单 → pinned todo 槽位(body ≤512,截断明示——截断不静默)。 */
-export declare function upsertTodoRefSlot(deps: LongTaskMonitorDeps, text: string): Promise<void>;
-/** 关闭 todo 参考槽位(长任务关闭时撤下注入;无槽位 = 幂等 no-op)。 */
-export declare function closeTodoRefSlot(deps: LongTaskMonitorDeps): Promise<boolean>;

package/dist/hooks/long-task.js

@@ -1,93 +0,0 @@
-/** todo 参考槽位的受管标题(精确匹配;refreshByTitle 按它原地刷新)。 */
-export const TODO_REF_SLOT_TITLE = '长任务 · 任务参考(todo)';
-/**
- * 长任务模式的事件监听(总开关 cfg.longTask.enabled 关闭时不注册):
- *  - assistant/message 的官方 usage 输入侧 → 上下文使用量(最近值语义);
- *  - compaction/summary → 上下文坍缩归零;
- *  - todo/write → 仅长任务模式下:记录快照 + 漂移检测,并把任务清单刷进
- *    pinned `todo` 槽位(slot-recall 常驻注入,压缩后任务北极星仍在)。
- *
- * fail-open 纪律:任何异常只 warn,绝不影响会话事件主流程。
- */
-export function registerLongTaskMonitor(ctx, deps) {
-    if (!deps.cfg.longTask.enabled)
-        return () => { };
-    const off = ctx.on('session/event', (session, event) => {
-        try {
-            const sid = String(session.id ?? session);
-            if (event.type === 'assistant/message') {
-                const usage = event.data
-                    .usage;
-                if (usage && typeof usage === 'object') {
-                    const total = num(usage.inputTokens) + num(usage.cacheReadTokens) + num(usage.cacheWriteTokens);
-                    if (total > 0)
-                        deps.contextUsage.record(sid, total);
-                }
-                return;
-            }
-            if (event.type === 'compaction/summary') {
-                // 压缩坍缩:上下文规模归零,建议阈值从新基数重新逼近。
-                deps.contextUsage.reset(sid);
-                return;
-            }
-            if (event.type === 'todo/write') {
-                // todo 参考只在长任务模式可用(用户显式开启才消耗注入预算)。
-                if (!deps.modes.getLongTask(sid))
-                    return;
-                const raw = event.data.todos;
-                if (!Array.isArray(raw))
-                    return;
-                const items = [];
-                for (const t of raw) {
-                    if (t === null || typeof t !== 'object')
-                        continue;
-                    const content = String(t.content ?? '').trim();
-                    if (!content)
-                        continue;
-                    const status = String(t.status ?? 'pending');
-                    items.push({ content, status });
-                }
-                if (items.length === 0)
-                    return;
-                const entry = deps.todoRef.record(sid, items);
-                void upsertTodoRefSlot(deps, entry.text).catch((err) => deps.logger.warn(`[memory] todo 参考槽位刷新失败(不影响事件流): ${msg(err)}`));
-            }
-        }
-        catch (err) {
-            deps.logger.warn(`[memory] 长任务监听处理失败: ${msg(err)}`);
-        }
-    });
-    return off;
-}
-/** 任务清单 → pinned todo 槽位(body ≤512,截断明示——截断不静默)。 */
-export async function upsertTodoRefSlot(deps, text) {
-    const MAX = 512;
-    let body = text;
-    if (byteLen(text) > MAX) {
-        let cut = text;
-        while (cut.length > 0 && byteLen(cut) + byteLen('\n…(已截断,完整清单见 todo 面板)') > MAX) {
-            cut = cut.slice(0, -1);
-        }
-        body = `${cut}\n…(已截断,完整清单见 todo 面板)`;
-    }
-    await deps.slots.refreshByTitle(TODO_REF_SLOT_TITLE, { body, pinned: true });
-}
-/** 关闭 todo 参考槽位(长任务关闭时撤下注入;无槽位 = 幂等 no-op)。 */
-export async function closeTodoRefSlot(deps) {
-    const found = deps.slots
-        .list()
-        .find((s) => s.title === TODO_REF_SLOT_TITLE && s.status === 'open');
-    if (!found)
-        return false;
-    await deps.slots.close(found.id, 'dropped');
-    return true;
-}
-function num(v) {
-    return typeof v === 'number' && Number.isFinite(v) && v > 0 ? v : 0;
-}
-function msg(err) {
-    return err instanceof Error ? err.message : String(err);
-}
-function byteLen(s) {
-    return new TextEncoder().encode(s).length;
-}

package/dist/store/context-usage.d.ts

@@ -1,28 +0,0 @@
-import type { MemoryLogger } from '../types.js';
-/**
- * 会话上下文使用量(长任务模式 §上下文估计)。
- *
- * 数据源:assistant/message 官方 usage 的输入侧(inputTokens + cache 读/写)——
- * 最新一条 assistant 消息的输入侧 ≈ 该时刻的上下文规模,取"最近值"而非累加
- * (每轮输入侧已含全部历史)。compaction/summary 后上下文坍缩,归零重计。
- *
- * 纯内存 per-session Map(热路径,session/event 每事件触达;不落盘——
- * 重启后首条 assistant 消息即可重建,丢失窗口无建议价值)。
- */
-export declare class ContextUsageStore {
-    private readonly logger?;
-    private readonly latest;
-    /** 上一次归零时间(compaction 诊断透出;可省)。 */
-    private readonly compactedAt;
-    constructor(logger?: MemoryLogger | undefined);
-    /** 记录最近一次官方输入侧 token 数(只增语义由调用方保证传"最新一轮")。 */
-    record(sessionId: string, inputTokens: number): void;
-    /** 压缩坍缩:归零并记录时刻。 */
-    reset(sessionId: string): void;
-    /** 最近输入侧 token 数(无样本 = undefined)。 */
-    latestTokens(sessionId: string): number | undefined;
-    /** 上下文占窗口百分比(窗口未知或无样本 = null)。 */
-    percentOfWindow(sessionId: string, contextWindowTokens: number | undefined): number | null;
-    /** 测试与停机清理。 */
-    clear(): void;
-}

package/dist/store/context-usage.js

@@ -1,47 +0,0 @@
-/**
- * 会话上下文使用量(长任务模式 §上下文估计)。
- *
- * 数据源:assistant/message 官方 usage 的输入侧(inputTokens + cache 读/写)——
- * 最新一条 assistant 消息的输入侧 ≈ 该时刻的上下文规模,取"最近值"而非累加
- * (每轮输入侧已含全部历史)。compaction/summary 后上下文坍缩,归零重计。
- *
- * 纯内存 per-session Map(热路径,session/event 每事件触达;不落盘——
- * 重启后首条 assistant 消息即可重建,丢失窗口无建议价值)。
- */
-export class ContextUsageStore {
-    logger;
-    latest = new Map();
-    /** 上一次归零时间(compaction 诊断透出;可省)。 */
-    compactedAt = new Map();
-    constructor(logger) {
-        this.logger = logger;
-    }
-    /** 记录最近一次官方输入侧 token 数(只增语义由调用方保证传"最新一轮")。 */
-    record(sessionId, inputTokens) {
-        if (!Number.isFinite(inputTokens) || inputTokens < 0)
-            return;
-        this.latest.set(sessionId, Math.round(inputTokens));
-    }
-    /** 压缩坍缩:归零并记录时刻。 */
-    reset(sessionId) {
-        if (this.latest.delete(sessionId))
-            this.compactedAt.set(sessionId, Date.now());
-    }
-    /** 最近输入侧 token 数(无样本 = undefined)。 */
-    latestTokens(sessionId) {
-        return this.latest.get(sessionId);
-    }
-    /** 上下文占窗口百分比(窗口未知或无样本 = null)。 */
-    percentOfWindow(sessionId, contextWindowTokens) {
-        const used = this.latest.get(sessionId);
-        if (used === undefined || !Number.isFinite(contextWindowTokens) || (contextWindowTokens ?? 0) <= 0) {
-            return null;
-        }
-        return Math.min(100, Math.round((used / contextWindowTokens) * 100));
-    }
-    /** 测试与停机清理。 */
-    clear() {
-        this.latest.clear();
-        this.compactedAt.clear();
-    }
-}