dsh-prime-memory 0.26.9 → 0.26.11

package/dist/pipeline/runner.js

@@ -3,6 +3,7 @@ import { GRAPH_PRIORITY_NEW } from '../graph/types.js';
 import { NoDistillRouteError } from '../llm.js';
 import { startValidityBackfill } from '../validity-backfill.js';
 import { drscRowToConversationMessage } from '../clients/drsc.js';
+import { graphFeatureOn } from '../graph/gate.js';
 import { trace } from '../store/trace.js';
 import { emptyPending, freshWarmup, groupPendingBySession, loadPending, PENDING_MODES, pendingPathFor, savePending, } from '../store/pending.js';
 import { errDetail } from '../util/filelog.js';
@@ -41,6 +42,8 @@ export function pickNextTaskIndex(tasks) {
  *   primaryEffort;非链模式旧键对静态回退条目盖章接管(存量兼容)。
  * - 输出预算/输入预算/通道覆盖/远程嵌入覆盖:非零/非空运行时值直接注入对应子树。
  */
+// 外部（tools / index）用的同一判据从这里取，避免两处各写一份。
+export { graphFeatureOn };
 export function effectiveCfg(cfg, live) {
     const s = live?.get();
     const eff = s?.reasoningEffort ?? '';
@@ -145,6 +148,12 @@ export function effectiveCfg(cfg, live) {
     const vtOverride = s?.validityTiering !== undefined
         ? { validity: { ...(cfg.validity ?? {}), tieringEnabled: cfg.validity?.tieringEnabled === true || s.validityTiering === true } }
         : null;
+    // 知识图谱投影(issue #16):live.graphEnabled 与部署 cfg.graph.enabled 取或。
+    // 这里**直接复用 graphFeatureOn**，而不是再手写一遍“部署开关 或 面板开关”：
+    // 判据一旦有两份，将来改一处漏一处就会出现“面板显示开、覆盖算出来却是关”类的分叉。
+    const grOverride = s?.graphEnabled !== undefined
+        ? { graph: { ...(cfg.graph ?? { enabled: false }), enabled: graphFeatureOn(cfg, live) } }
+        : null;
     // md 投射/后缀收敛的单次动作护栏运行时覆盖(0 = 跟随部署 cfg.memExport.maxRecords)。
     // 只覆盖条数护栏，不动 enabled/root——开关与根路径仍属部署配置。
     const mdx = s?.mdExportMaxRecords ?? 0;
@@ -153,7 +162,7 @@ export function effectiveCfg(cfg, live) {
     // 不动 maxRecords/timeBudgetMs/callTimeoutMs——那三个仍属部署护栏，要改得改 YAML。
     const bf = s?.backfillConcurrency ?? 0;
     const backfillOverride = bf > 0 ? { backfill: { ...(cfg.backfill ?? {}), concurrency: bf } } : null;
-    if (!override && !budgets && !maxInput && !fallbacksTakeover && !chainEffort && !chainFallbacks && !effortInject && !layerChains && !hasChannel && !embedOverride && !cfOverride && !memExportOverride && !backfillOverride && !kwOverride && !rdOverride && !mdsOverride && !mpOverride && !vtOverride)
+    if (!override && !budgets && !maxInput && !fallbacksTakeover && !chainEffort && !chainFallbacks && !effortInject && !layerChains && !hasChannel && !embedOverride && !cfOverride && !memExportOverride && !backfillOverride && !kwOverride && !rdOverride && !mdsOverride && !mpOverride && !vtOverride && !grOverride)
         return cfg;
     return {
         ...cfg,
@@ -164,6 +173,7 @@ export function effectiveCfg(cfg, live) {
         ...(mdsOverride ?? {}),
         ...(mpOverride ?? {}),
         ...(vtOverride ?? {}),
+        ...(grOverride ?? {}),
         ...(memExportOverride ?? {}),
         ...(backfillOverride ?? {}),
         llm: {
@@ -266,20 +276,22 @@ export class MemoryRunner {
         const graphs = this.stores.graph;
         if (graphs) {
             graphs.recoverRunning();
-            if (this.cfg.graph?.enabled) {
-                this.ctx.effect(() => {
-                    const timer = setTimeout(() => {
-                        if (this.stopped)
-                            return;
-                        const jobs = graphs.queueMissing(9000);
-                        if (jobs > 0) {
-                            this.logger.info(`[memory] 图谱存量补投影:${jobs} 个任务入队`);
-                            this.maybeQueueGraphTask();
-                        }
-                    }, STARTUP_RETRY_DELAY_MS);
-                    return () => clearTimeout(timer);
-                });
-            }
+            // **无条件**挂启动补跑，开关在 tick 内判：
+            // 若在这里就判门注册，面板热开启后存量要等重启才补（issue #16 的半开态）。
+            this.ctx.effect(() => {
+                const timer = setTimeout(() => {
+                    if (this.stopped)
+                        return;
+                    if (!graphFeatureOn(this.cfg, this.live))
+                        return;
+                    const jobs = graphs.queueMissing(9000);
+                    if (jobs > 0) {
+                        this.logger.info(`[memory] 图谱存量补投影:${jobs} 个任务入队`);
+                        this.maybeQueueGraphTask();
+                    }
+                }, STARTUP_RETRY_DELAY_MS);
+                return () => clearTimeout(timer);
+            });
         }
     }
     /** 启动补跑:对每个非空桶的每个会话切片入队一次蒸馏尝试(受 live 开关与
@@ -468,12 +480,28 @@ export class MemoryRunner {
      */
     startGraphBackfillTimer() {
         const graphs = this.stores.graph;
-        if (!graphs || !this.cfg.graph?.enabled)
+        // 只依赖 store 存在：**不能**在注册时判 graph 开关 —— timer 只在 init 注册一次，
+        // 那样运行时开启后存量永远补不到（issue #16 的实证半开态）。开关改在 tick 内判。
+        if (!graphs)
             return;
+        // 热开启即时补一批：否则用户拨开开关要等一个周期（30 分钟）才看到图谱动起来。
+        this.ctx.on('loader/volatile-update', (paths) => {
+            if (!paths.some((p) => p[0] === 'live'))
+                return;
+            if (!graphFeatureOn(this.cfg, this.live))
+                return;
+            const jobs = graphs.queueMissing(500);
+            if (jobs > 0) {
+                this.logger.info(`[memory] 图谱热开启补投影:${jobs} 个任务入队`);
+                this.maybeQueueGraphTask();
+            }
+        });
         this.ctx.effect(() => {
             const timer = setInterval(() => {
                 if (this.stopped)
                     return;
+                if (!graphFeatureOn(this.cfg, this.live))
+                    return;
                 const jobs = graphs.queueMissing(500);
                 if (jobs > 0) {
                     this.logger.debug?.(`[memory] 图谱周期补投影:${jobs} 个任务入队`);
@@ -522,8 +550,14 @@ export class MemoryRunner {
      * 用户后续开启由启动/周期补投影兜底(与 distill 分支同一口径)。
      */
     enqueueGraphFor(recordIds) {
-        if (recordIds.length === 0 || !this.stores.graph || !this.cfg.graph?.enabled)
+        if (recordIds.length === 0 || !this.stores.graph)
+            return;
+        if (!graphFeatureOn(this.cfg, this.live)) {
+            // 关闭期写入也要记账：`graph_projected_records` 只按 record_id+version 记账、无内容版本，
+            // 若不抹掉，重开后 queueMissing 会认为“这条已投过”而永不补 → 图谱内容永久陈旧。
+            this.stores.graph.invalidateProjected(recordIds);
             return;
+        }
         this.stores.graph.queueGraphProjection([...recordIds], GRAPH_PRIORITY_NEW);
         this.maybeQueueGraphTask();
     }
@@ -535,7 +569,9 @@ export class MemoryRunner {
      */
     reprojectGraph(recordIds) {
         const graphs = this.stores.graph;
-        if (!graphs || !this.cfg.graph?.enabled || recordIds.length === 0)
+        if (!graphs || recordIds.length === 0)
+            return { queued: 0, jobIds: [] };
+        if (!graphFeatureOn(this.cfg, this.live))
             return { queued: 0, jobIds: [] };
         const r = graphs.forceReprojectRecord(recordIds);
         if (r.queued > 0)
@@ -544,7 +580,8 @@ export class MemoryRunner {
     }
     /**
      * 图谱投影泵入队判定:
-     * - 双门:部署级 cfg.graph.enabled + 运行时 live.enabled/distill,任一为假不入队;
+     * - 双门:`graphFeatureOn`（部署 cfg.graph.enabled **或** 面板 live.graphEnabled）
+     *   + 运行时 live.enabled/distill,任一为假不入队;
      * - 占位:同一时刻至多一个 graph 任务在队列(靠 graphPumpQueued 标志),永不与
      *   live 抢位(pickNextTaskIndex 保证 live > graph);
      * - 退避/attempts 封顶:由 GraphStore.claimNext 的 WHERE 过滤与 fail 转 dead 承接,
@@ -554,7 +591,7 @@ export class MemoryRunner {
         const graphs = this.stores.graph;
         if (!graphs || this.stopped || this.graphPumpQueued)
             return;
-        if (!this.cfg.graph?.enabled)
+        if (!graphFeatureOn(this.cfg, this.live))
             return;
         const liveNow = this.live.get();
         if (!(liveNow.enabled && liveNow.distill))
@@ -663,7 +700,7 @@ export class MemoryRunner {
             if ((opts?.force || sliceLen >= effective) && !backedOff) {
                 newRecords = await this.extractSessionSlice(sessionId, mode, cfg, effective, opts);
                 // 新记录入投影队列(优先级恒高于存量补投影)并拉起图谱泵;入队本身廉价,
-                // 部署未开图谱(cfg.graph.enabled)时不入队——用户后续开启由启动补投影兜底。
+                // 开关关时由 enqueueGraphFor 抹投影凭证(避免重开后永久陈旧)，重开由补投影兜底。
                 // (写面 R2:分支本体抽成 enqueueGraphFor,与工具三路径同源,不再两处漂移。)
                 this.enqueueGraphFor(newRecords.map((r) => r.id));
             }

package/dist/pipeline/workspace-relink.js

@@ -13,8 +13,13 @@ export async function relinkWorkspaces(deps) {
     const report = {
         dryRun, scanned: 0, matched: 0, unchanged: 0, toWrite: 0, written: 0, remaining: 0, byWorkspace: {},
     };
-    if (routes.length === 0)
-        return report;
+    // 空路由表 = **未配置**（issue #13 把默认值改成 `[]`）。这里必须显式拒绕：
+    // 旧行为是返回全零报告，面板显示“扫 0 / 剩 0” —— 看起来像“已经做完了”，
+    // 真正的原因（一条路由都没配）反而看不见。
+    if (routes.length === 0) {
+        throw new Error('未配置任何内容路由规则（workspaceSource.routes 为空）：'
+            + '先在配置里写下至少一条 {path, anyOf}，再执行归属回填');
+    }
     let offset = 0;
     let batch = [];
     // 计数在此结算：`flush()` 会清空 batch，调用点再拿 `batch.length` 必然归零。

package/dist/room-review.d.ts

@@ -75,7 +75,7 @@ export interface RoomCandidate {
     id: string;
     rooms: string[];
 }
-/** 解析标注器输出的逐条候选(容错:id 配对失败丢弃;isTag 校验;目录内优先,≤3)。 */
+/** 解析标注器输出的逐条候选(容错:id 配对失败丢弃;isRoomSlug 校验(两级制);目录内优先,≤3)。 */
 export declare function parseRoomCandidateItems(parsed: ReadonlyArray<{
     id: string;
     rooms: readonly string[];

package/dist/room-review.js

@@ -1,8 +1,8 @@
-import { isTag } from './metadata-validators.js';
+import { isRoomSlug } 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)。 */
+/** 解析标注器输出的逐条候选(容错:id 配对失败丢弃;isRoomSlug 校验(两级制);目录内优先,≤3)。 */
 export function parseRoomCandidateItems(parsed, ids, roomCatalog) {
     const idSet = new Set(ids);
     const catalogSet = new Set(roomCatalog.map((r) => r.room));
@@ -13,7 +13,9 @@ export function parseRoomCandidateItems(parsed, ids, roomCatalog) {
         const cleaned = [];
         for (const r of item.rooms) {
             const slug = typeof r === 'string' ? r.trim().toLowerCase() : '';
-            if (!slug || !isTag(slug))
+            // 两级制(`major` 或 `major/minor`)：与 rooms-registry 同一判据。用 isTag 会把
+            // `mpu/qos` 这类合法子类静默丢掉——注册表收得下、写回却挂不上(issue #12)。
+            if (!slug || !isRoomSlug(slug))
                 continue;
             if (!cleaned.includes(slug))
                 cleaned.push(slug);
@@ -35,7 +37,8 @@ export function roomCandidateSystemPrompt(roomCatalog) {
     return ('你是记忆库的 Room 归类器。给你一条记忆与现有 Room 词表(带计数),' +
         '为这条记忆选出它最可能归属的 1-3 个 Room slug。规则:\n' +
         '1. **优先从现有 Room 词表里选**(保持分类收敛,避免碎片化);\n' +
-        '2. 词表确实没有合适主题时,才提议最多 2 个新 slug(小写字母/数字/连字符);\n' +
+        '2. 词表确实没有合适主题时,才提议最多 2 个新 slug(小写字母/数字/连字符;' +
+        '两级制写成 `大类/子类` 形式,如 `mpu/qos`,全串至多一个斜杠);\n' +
         '3. 完全无法判断时返回空数组(宁缺毋滥,不硬猜)。\n' +
         `现有 Room 词表:\n${catalog}\n\n` +
         '输出 JSON 对象:{"rooms":["slug1","slug2"]}。只输出 JSON,不要多余文字。');
@@ -264,7 +267,9 @@ export function confirmReview(l1, id, rooms) {
         if (typeof r !== 'string')
             continue;
         const slug = r.trim().toLowerCase();
-        if (!slug || !isTag(slug) || cleaned.includes(slug))
+        // 同 parseRoomCandidateItems：走两级制判据，否则 `mpu/qos` 会被判非法、
+        // confirm 返回 null 且错误文案误导成"id 不存在"(issue #12)。
+        if (!slug || !isRoomSlug(slug) || cleaned.includes(slug))
             continue;
         cleaned.push(slug);
     }

package/dist/settings.js

@@ -82,6 +82,8 @@ const ALWAYS_ON = {
     memoryMutate: false,
     conflictFreeze: false,
     skillsEnabled: false,
+    // 知识图谱投影:默认关(部署 cfg.graph.enabled 仍可强制开;这里只做追加开)
+    graphEnabled: false,
     keywordEnabled: false,
     redistillEnabled: false,
     mdSyncEnabled: false,
@@ -329,6 +331,8 @@ function resolveSettings(value) {
         conflictFreeze: v.conflictFreeze === true,
         // 轨2 技能结晶:严格 === true(默认关,新功能默认关)
         skillsEnabled: v.skillsEnabled === true,
+        // 知识图谱投影:严格 === true(默认关);与部署 graph.enabled 取或后生效
+        graphEnabled: v.graphEnabled === true,
         // 存量回填/进阶功能启用开关:严格 === true(默认关)
         keywordEnabled: v.keywordEnabled === true,
         redistillEnabled: v.redistillEnabled === true,

package/dist/stats.js

@@ -1119,9 +1119,13 @@ export async function handleEndpoint(endpoint, payload, deps) {
                 return v;
             }
             if (kind === 'records') {
-                const tag = String(p.tag ?? '').trim();
+                // 与 list-records 同口径(见下方 tagSel):Room slug 是自生长的两级制形状,
+                // 非法形状在这里就拒,不做“静默返回空 CSV”。
+                const tag = typeof p.tag === 'string' ? p.tag.trim().slice(0, 64) : '';
                 if (!tag)
                     throw new Error('kind=records 需要 tag(目标 Room slug)');
+                if (!isRoomSlug(tag))
+                    throw new Error('tag 非法(两级制:major 或 major/minor,各段小写字母数字连字符)');
                 const header = 'id,type,scene_name,updated_at,tags,content';
                 const lines = [header];
                 let n = 0;
@@ -1351,6 +1355,7 @@ export async function handleEndpoint(endpoint, payload, deps) {
                     memoryMutate: false,
                     conflictFreeze: live?.get()?.conflictFreeze === true,
                     skillsEnabled: live?.get()?.skillsEnabled === true,
+                    graphEnabled: live?.get()?.graphEnabled === true,
                     keywordEnabled: live?.get()?.keywordEnabled === true,
                     redistillEnabled: live?.get()?.redistillEnabled === true,
                     mdSyncEnabled: live?.get()?.mdSyncEnabled === true,
@@ -1402,7 +1407,7 @@ export async function handleEndpoint(endpoint, payload, deps) {
             const patch = (payload ?? {});
             const clean = {};
             // 布尔开关组:memoryMutate(高权限写删门)与主开关同列;conflictFreeze(§C 人工冲突裁决)
-            for (const key of ['enabled', 'capture', 'distill', 'recall', 'memoryMutate', 'conflictFreeze', 'skillsEnabled', 'keywordEnabled', 'redistillEnabled', 'mdSyncEnabled', 'memportEnabled', 'toolRoom', 'toolGraph', 'toolRuminate', 'toolConflict', 'toolMutate', 'toolSkills']) {
+            for (const key of ['enabled', 'capture', 'distill', 'recall', 'memoryMutate', 'conflictFreeze', 'skillsEnabled', 'graphEnabled', 'keywordEnabled', 'redistillEnabled', 'mdSyncEnabled', 'memportEnabled', 'toolRoom', 'toolGraph', 'toolRuminate', 'toolConflict', 'toolMutate', 'toolSkills']) {
                 if (typeof patch[key] === 'boolean')
                     clean[key] = patch[key];
             }
@@ -2117,7 +2122,9 @@ export async function handleEndpoint(endpoint, payload, deps) {
                 throw new Error('蒸馏开关已关闭,请先开启蒸馏再重建');
             if (!cfg.extract.enabled)
                 throw new Error('部署配置已停用蒸馏(extract.enabled=false),无法重建');
-            const result = rebuild.start();
+            // force 只跨“水位落差”的二次确认；“L0 无正文而检索库非空”仍由 start() 硬拒。
+            const p = (payload ?? {});
+            const result = rebuild.start(p.force === true);
             deps.logger.info('[memory] 收到重建指令(设置页按钮)');
             return result;
         }

package/dist/store/graph-store.d.ts

@@ -163,6 +163,18 @@ export declare class GraphStore {
         queued: number;
         jobIds: string[];
     };
+    /**
+     * 只抹“已投影”凭证，**不排队**（issue #16 关闭期防护）。
+     *
+     * 关闭期写路径不入队，但记录内容已经变了；而 `graph_projected_records` 只按
+     * `record_id + projector_version` 记账、**不记内容版本** —— 不抹掉的话，重开后
+     * `queueMissing` 会认为“这条投过了”而永不补，图谱就永久陈旧（只能靠人工
+     * `memory_reproject`）。
+     *
+     * 不在这里入队：关闭期入队会造成“投了永不泵”的陈旧队列（与 `reprojectGraph`
+     * 关闭时回零同源），重开时由 `queueMissing` 统一补。
+     */
+    invalidateProjected(recordIds: readonly string[]): void;
     /**
      * 确定性边提案落库面(graph-write-plane R4 兜底支路):把"工具传入的显式边提案"
      * 当作一次确定性投影输入,经 `applyGraphProjection` **纯函数**校验后在同一事务内
@@ -236,6 +248,14 @@ export declare class GraphStore {
      * 返回新建 job 数。
      */
     queueMissing(limit: number): number;
+    /**
+     * 尚未投影（当前版本）且无在途 mapping 的 L1 条数。
+     *
+     * 面板“首次开启投影大概要花多少”的分母（issue #16）：本方法必须与 `queueMissing`
+     * 用**同一段 WHERE** —— 两处口径一旦分叉，面板报的数字就不是实际会被拉起的量。
+     * 只读聚合，不写库。
+     */
+    countMissing(): number;
     /**
      * 删除传播(L1 批量删除后的惰性墓碑):来源在 L1 已全部不存在的 active/disputed
      * 节点与边标 archived(保留行,expand 可见墓碑)。挂在 MemoryDb.deleteL1Batch

package/dist/store/graph-store.js

@@ -529,7 +529,7 @@ export class GraphStore {
         catch (err) {
             this.logger?.warn(`${TAG} 预览 job 计数失败(计数回零): ${err instanceof Error ? err.message : String(err)}`);
         }
-        const r = buildGraphPreview(nodes, edges, { seedId, pendingJobs, jobsTotal, deadJobs });
+        const r = buildGraphPreview(nodes, edges, { seedId, pendingJobs, jobsTotal, deadJobs, missing: this.countMissing() });
         if (mode === 'full')
             return { ...r, full: buildFullView(nodes, edges) };
         return r;
@@ -650,6 +650,33 @@ export class GraphStore {
             return { queued: 0, jobIds: [] };
         }
     }
+    /**
+     * 只抹“已投影”凭证，**不排队**（issue #16 关闭期防护）。
+     *
+     * 关闭期写路径不入队，但记录内容已经变了；而 `graph_projected_records` 只按
+     * `record_id + projector_version` 记账、**不记内容版本** —— 不抹掉的话，重开后
+     * `queueMissing` 会认为“这条投过了”而永不补，图谱就永久陈旧（只能靠人工
+     * `memory_reproject`）。
+     *
+     * 不在这里入队：关闭期入队会造成“投了永不泵”的陈旧队列（与 `reprojectGraph`
+     * 关闭时回零同源），重开时由 `queueMissing` 统一补。
+     */
+    invalidateProjected(recordIds) {
+        if (!this.db || recordIds.length === 0)
+            return;
+        const ids = [...new Set(recordIds)];
+        try {
+            this.tx(() => {
+                for (const chunk of chunkOf(ids)) {
+                    const ph = chunk.map(() => '?').join(',');
+                    this.db.prepare(`DELETE FROM graph_projected_records WHERE record_id IN (${ph})`).run(...chunk);
+                }
+            });
+        }
+        catch (err) {
+            this.logger?.warn(`${TAG} 投影凭证失效失败(忽略): ${err instanceof Error ? err.message : String(err)}`);
+        }
+    }
     /**
      * 确定性边提案落库面(graph-write-plane R4 兜底支路):把"工具传入的显式边提案"
      * 当作一次确定性投影输入,经 `applyGraphProjection` **纯函数**校验后在同一事务内
@@ -947,6 +974,28 @@ export class GraphStore {
             return 0;
         }
     }
+    /**
+     * 尚未投影（当前版本）且无在途 mapping 的 L1 条数。
+     *
+     * 面板“首次开启投影大概要花多少”的分母（issue #16）：本方法必须与 `queueMissing`
+     * 用**同一段 WHERE** —— 两处口径一旦分叉，面板报的数字就不是实际会被拉起的量。
+     * 只读聚合，不写库。
+     */
+    countMissing() {
+        if (!this.db)
+            return 0;
+        try {
+            const row = this.db
+                .prepare(`SELECT COUNT(*) AS n FROM l1_records r
+           WHERE NOT EXISTS (SELECT 1 FROM graph_projected_records p WHERE p.record_id = r.record_id AND p.projector_version = ?)
+             AND NOT EXISTS (SELECT 1 FROM graph_job_records m WHERE m.record_id = r.record_id)`)
+                .get(GRAPH_PROJECTOR_VERSION);
+            return Number(row?.n ?? 0);
+        }
+        catch {
+            return 0;
+        }
+    }
     // ============================
     // 删除传播(B10)
     // ============================

package/dist/store/sqlite.d.ts

@@ -623,6 +623,23 @@ export declare class MemoryDb {
      * 使"无锚点"与"锚点为空"在类型层就是两件事。
      */
     private toL0Record;
+    /**
+     * 有 L0 正文的会话 id，按**首条消息时间升序**（流式重建的会话游标）。
+     *
+     * 为什么不是直接 `listL0All()`：那个接口全量拉正文（3 万条约 88MB）且整个重建期
+     * 常驻。按会话走 `idx_l0_session_id` 点查，峰值降到单会话量级。
+     * 排序与 `groupL0Sessions` 的“会话按首条时间升序”同一口径（情境链按时间衔接）。
+     */
+    l0SessionIds(): string[];
+    /** 某会话的全部 L0 正文（时间升序；走 idx_l0_session_id，只占单会话内存）。 */
+    l0MessagesBySession(sessionId: string): L0MessageRecord[];
+    /**
+     * 仅取 L0 消息 id 集（post-watermark 判据用）。
+     *
+     * 刻意**不读 `message_text`**：判据只需要 id，而正文才是内存大头。
+     * 2.5 万条 id 约 1.5MB，比全量快照小一个数量级。
+     */
+    l0MessageIds(): Set<string>;
     /** L0 全量列举(重建快照用;按时间升序,事务一致性避开 JSONL 追加竞态)。 */
     listL0All(): L0MessageRecord[];
     /** 重建成本预估(一次全表聚合:会话数 / 消息数 / 字符量)。 */
@@ -631,6 +648,31 @@ export declare class MemoryDb {
         messages: number;
         chars: number;
     };
+    /**
+     * 重建水位探针（issue #14）。
+     *
+     * 回答三个问题：
+     * - 本地 L0 **覆盖到什么时候**（`l0Iso`）：L0 正文已于 T8.4 写停，这个值是
+     *   **常量**，不会随使用前移；
+     * - 检索库现有多少条、其中多少条**晚于**该水位（`l1After`）：**仅用于面板提示**
+     *   “本次重建只覆盖到 X”，**绝不用作拒绝门槛** —— L1 的 `created_time` 每次
+     *   蒸馏都会前移，拿它做阈值会把重建永久锁死；
+     * - `l0SessionCount`：面板口径（多少个会话的正文在快照里）。
+     *
+     * 注意 `l0_conversations` **没有 `created_time` 列**，只有 `recorded_at`(TEXT)
+     * 与 `timestamp`(INTEGER ms)：主用前者（与 L1 同为 ISO 文本可直接比），
+     * 空串回退后者。两列都建了索引，`MAX` 走覆盖索引。
+     *
+     * L0 全空时 `l0Iso` 为 `null`，此时 `l1After` 取 `l1Total`（没有水位而 L1 有记录
+     * = 一条都重蒸不出来），而不是 0 —— 否则面板会把“最危险的情况”显示成“无影响”。
+     */
+    rebuildWatermark(): {
+        l0Iso: string | null;
+        l0Ms: number | null;
+        l0SessionCount: number;
+        l1Total: number;
+        l1After: number;
+    };
     /** 向量表行数(backfill 判据:与元数据行数的差值即缺失向量数;不可用时返回 -1)。 */
     countL1Vec(): number;
     countL0Vec(): number;

package/dist/store/sqlite.js

@@ -2405,6 +2405,63 @@ export class MemoryDb {
             rec.step = r.step;
         return rec;
     }
+    /**
+     * 有 L0 正文的会话 id，按**首条消息时间升序**（流式重建的会话游标）。
+     *
+     * 为什么不是直接 `listL0All()`：那个接口全量拉正文（3 万条约 88MB）且整个重建期
+     * 常驻。按会话走 `idx_l0_session_id` 点查，峰值降到单会话量级。
+     * 排序与 `groupL0Sessions` 的“会话按首条时间升序”同一口径（情境链按时间衔接）。
+     */
+    l0SessionIds() {
+        if (this.degraded)
+            return [];
+        try {
+            const rows = this.db
+                .prepare('SELECT session_id FROM l0_conversations GROUP BY session_id ORDER BY MIN(timestamp) ASC')
+                .all();
+            return rows.map((r) => r.session_id).filter((s) => typeof s === 'string' && s !== '');
+        }
+        catch (err) {
+            this.logger?.warn(`${TAG} L0 会话列表失败(返回空): ${err instanceof Error ? err.message : String(err)}`);
+            return [];
+        }
+    }
+    /** 某会话的全部 L0 正文（时间升序；走 idx_l0_session_id，只占单会话内存）。 */
+    l0MessagesBySession(sessionId) {
+        if (this.degraded || !sessionId)
+            return [];
+        try {
+            const rows = this.db
+                .prepare('SELECT record_id, session_id, role, message_text, recorded_at, timestamp, turn, step FROM l0_conversations WHERE session_id = ? ORDER BY timestamp ASC')
+                .all(sessionId);
+            return rows.map((r) => this.toL0Record(r));
+        }
+        catch (err) {
+            this.logger?.warn(`${TAG} L0 会话读取失败(session=${sessionId}): ${err instanceof Error ? err.message : String(err)}`);
+            return [];
+        }
+    }
+    /**
+     * 仅取 L0 消息 id 集（post-watermark 判据用）。
+     *
+     * 刻意**不读 `message_text`**：判据只需要 id，而正文才是内存大头。
+     * 2.5 万条 id 约 1.5MB，比全量快照小一个数量级。
+     */
+    l0MessageIds() {
+        const out = new Set();
+        if (this.degraded)
+            return out;
+        try {
+            for (const r of this.db.prepare('SELECT record_id FROM l0_conversations').iterate()) {
+                if (typeof r.record_id === 'string' && r.record_id !== '')
+                    out.add(r.record_id);
+            }
+        }
+        catch (err) {
+            this.logger?.warn(`${TAG} L0 id 集读取失败(按空处理): ${err instanceof Error ? err.message : String(err)}`);
+        }
+        return out;
+    }
     /** L0 全量列举(重建快照用;按时间升序,事务一致性避开 JSONL 追加竞态)。 */
     listL0All() {
         if (this.degraded)
@@ -2434,6 +2491,47 @@ export class MemoryDb {
             return { sessions: 0, messages: 0, chars: 0 };
         }
     }
+    /**
+     * 重建水位探针（issue #14）。
+     *
+     * 回答三个问题：
+     * - 本地 L0 **覆盖到什么时候**（`l0Iso`）：L0 正文已于 T8.4 写停，这个值是
+     *   **常量**，不会随使用前移；
+     * - 检索库现有多少条、其中多少条**晚于**该水位（`l1After`）：**仅用于面板提示**
+     *   “本次重建只覆盖到 X”，**绝不用作拒绝门槛** —— L1 的 `created_time` 每次
+     *   蒸馏都会前移，拿它做阈值会把重建永久锁死；
+     * - `l0SessionCount`：面板口径（多少个会话的正文在快照里）。
+     *
+     * 注意 `l0_conversations` **没有 `created_time` 列**，只有 `recorded_at`(TEXT)
+     * 与 `timestamp`(INTEGER ms)：主用前者（与 L1 同为 ISO 文本可直接比），
+     * 空串回退后者。两列都建了索引，`MAX` 走覆盖索引。
+     *
+     * L0 全空时 `l0Iso` 为 `null`，此时 `l1After` 取 `l1Total`（没有水位而 L1 有记录
+     * = 一条都重蒸不出来），而不是 0 —— 否则面板会把“最危险的情况”显示成“无影响”。
+     */
+    rebuildWatermark() {
+        const empty = { l0Iso: null, l0Ms: null, l0SessionCount: 0, l1Total: 0, l1After: 0 };
+        if (this.degraded)
+            return empty;
+        try {
+            const l0 = this.db
+                .prepare('SELECT COUNT(DISTINCT session_id) AS s, MAX(recorded_at) AS iso, MAX(timestamp) AS ms FROM l0_conversations')
+                .get();
+            const ms = typeof l0?.ms === 'number' ? l0.ms : null;
+            const rawIso = typeof l0?.iso === 'string' ? l0.iso.trim() : '';
+            const iso = rawIso !== '' ? rawIso : ms === null ? null : new Date(ms).toISOString();
+            const total = this.db.prepare('SELECT COUNT(*) AS n FROM l1_records').get();
+            const l1Total = total?.n ?? 0;
+            const l1After = iso
+                ? this.db.prepare('SELECT COUNT(*) AS n FROM l1_records WHERE created_time > ?').get(iso).n ?? 0
+                : l1Total;
+            return { l0Iso: iso, l0Ms: ms, l0SessionCount: l0?.s ?? 0, l1Total, l1After };
+        }
+        catch (err) {
+            this.logger?.warn(`${TAG} 重建水位探针失败(按空处理): ${err instanceof Error ? err.message : String(err)}`);
+            return empty;
+        }
+    }
     /** 向量表行数(backfill 判据:与元数据行数的差值即缺失向量数;不可用时返回 -1)。 */
     countL1Vec() {
         if (this.degraded || !this.stmtSearchL1Vec)

package/dist/tools/index.js

@@ -14,6 +14,7 @@
 import { createHash } from 'node:crypto';
 import { defineTool } from '@deepseek-ai/dsh-tools';
 import { DOWNGRADE_TARGET, familyOf, isKnownType, typeEnumSep } from '../memory-types.js';
+import { graphFeatureOn } from '../graph/gate.js';
 import { drscRoleOf } from '../clients/drsc.js';
 import { RECEIPTS_QUERY_LIMIT_MAX, dimensionOf, toReceiptView, buildReceipts, newRunId } from '../store/receipts.js';
 import { persistReceiptsSafely } from '../store/receipts.js';
@@ -1049,7 +1050,7 @@ graphWrite) {
         },
     })));
     // ── 图谱工具(读;受与 memory_search 同款的档位/注入拒读门 + 族过滤) ──
-    const GRAPH_OFF_NOTICE = '图谱功能未启用:部署配置 graph.enabled 未开启,当前没有可用的知识图谱。';
+    const GRAPH_OFF_NOTICE = '知识图谱未启用：请在概览页开启「知识图谱」（或部署配置 graph.enabled），当前没有任何可用的知识图谱。';
     // memory_search_graph: 图谱节点检索(紧凑节点卡)
     reg('graph', () => ctx.tools.register(defineTool({
         name: 'memory_search_graph',
@@ -1203,7 +1204,7 @@ graphWrite) {
         },
         execute: async (args) => {
             const graph = stores.graph;
-            if (!graph || !cfg.graph?.enabled)
+            if (!graph || !graphFeatureOn(cfg, live))
                 return { queued: 0, job_ids: [], skipped_ids: [], notice: GRAPH_OFF_NOTICE };
             if (!graphWrite)
                 return { queued: 0, job_ids: [], skipped_ids: [], notice: '图谱写面未接线(runner 未装配),无法入队。' };
@@ -1273,7 +1274,7 @@ graphWrite) {
             if (!live.get().memoryMutate)
                 return { notice: MUTATE_OFF_NOTICE };
             const graph = stores.graph;
-            if (!graph || !cfg.graph?.enabled)
+            if (!graph || !graphFeatureOn(cfg, live))
                 return { notice: GRAPH_OFF_NOTICE };
             if (!graphWrite)
                 return { notice: '图谱写面未接线(runner 未装配),无法迁移。' };

package/dsh.plugin.json

@@ -1,7 +1,7 @@
 {
   "id": "dsh-prime-memory",
   "name": "dsh-prime-memory",
-  "version": "0.26.9",
+  "version": "0.26.11",
   "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 分层蒸馏记忆插件:自动捕获对话、抽取原子记忆、整合场景块、蒸馏核心画像,并在模型步骤前自动召回注入。"
@@ -13,7 +13,7 @@
   },
   "license": "MIT",
   "engines": {
-    "dsh": "0.1.0-rc.2 || 0.1.0-rc.3 || 0.1.0-rc.6 || 0.1.0-rc.7 || 0.1.0-rc.8 || 0.1.1-rc.1 || 0.1.1-rc.2 || 0.1.2-rc.1 || 0.1.5-rc.1 || 0.1.5-rc.2 || 0.1.5-rc.3 || 0.1.7-rc.1 || 0.1.7-rc.2 || 0.2.0-rc.1 || 0.2.0-rc.2 || 0.2.1-rc.1 || 0.2.1-rc.2"
+    "dsh": "0.1.0-rc.2 || 0.1.0-rc.3 || 0.1.0-rc.6 || 0.1.0-rc.7 || 0.1.0-rc.8 || 0.1.1-rc.1 || 0.1.1-rc.2 || 0.1.2-rc.1 || 0.1.5-rc.1 || 0.1.5-rc.2 || 0.1.5-rc.3 || 0.1.7-rc.1 || 0.1.7-rc.2 || 0.2.0-rc.1 || 0.2.0-rc.2 || 0.2.1-rc.1 || 0.2.1-rc.2 || 0.2.1-rc.3"
   },
   "components": {
     "host": "dist/index.js",