dsh-prime-memory 0.26.5 → 0.26.9

package/dist/pipeline/l2.js

@@ -1,71 +1,93 @@
 import { callLLM, parseJsonLogged, resolveLayerTokens } from '../llm.js';
 import { buildScenePrompt, formatSceneSummaries } from '../prompts/scene.js';
 import { Bm25Index } from '../store/bm25.js';
+import { chunkByCharBudget, MAX_SCENE_CHUNK_CHARS } from './l1.js';
 const REQUEST_RE = /\[PERSONA_UPDATE_REQUEST\]\s*reason:\s*([\s\S]*?)\[\/PERSONA_UPDATE_REQUEST\]/;
 export async function runSceneConsolidation(ctx, cfg, scenes, newMemories, logger, family) {
     if (!cfg.l2.enabled || newMemories.length === 0) {
         return { changed: 0 };
     }
     const summaries = await scenes.list();
-    // ── 组装 prompt ──
-    const memoriesJson = JSON.stringify(newMemories.map((m) => ({
-        record_id: m.id,
-        content: m.content,
-        type: m.type,
-        priority: m.priority,
-        scene_name: m.scene_name,
-        // repo 归属(ADR-0015 T1.9/T1.10):L2 场景归属决策可见项目边界——
-        // this-repo 记录不得并入跨项目场景;'' = 未归属(不引导分组)。
-        repoKeyName: m.repoKeyName ?? '',
-        applicability: m.applicability ?? '',
-        timestamps: m.timestamps.map((t) => new Date(t).toISOString()),
-    })), null, 2);
+    // 跨块共享的上下文：相关场景全文只选一次（BM25 按全量新记忆选），各块复用。
     const sceneSummaries = formatSceneSummaries(summaries);
     const sceneContents = await pickSceneContents(scenes, summaries, newMemories, cfg.l2.sceneContextLimit);
-    const { systemPrompt, userPrompt } = buildScenePrompt({
-        memoriesJson,
-        sceneSummaries,
-        sceneContents,
-        currentTimestamp: new Date().toISOString(),
-        existingSceneFiles: summaries.map((s) => s.path),
-        maxScenes: cfg.l2.maxScenes,
-        family,
-    });
-    const raw = await callLLM(ctx, cfg, {
-        system: systemPrompt,
-        user: userPrompt,
-        maxTokens: resolveLayerTokens(cfg, 'l2'),
-        layer: 'l2',
-        logger,
-    });
-    // ── 解析:先取 PERSONA_UPDATE_REQUEST 标记,再解析操作数组 ──
-    const reqMatch = REQUEST_RE.exec(raw);
-    const personaRequestedReason = reqMatch?.[1]?.trim() || undefined;
-    const opsRaw = reqMatch ? raw.replace(REQUEST_RE, '') : raw;
-    const ops = parseJsonLogged(opsRaw, 'L2 场景操作', logger);
-    if (!Array.isArray(ops))
-        throw new Error('L2 输出不是操作数组');
+    // R1 分块分载：把 newMemories 按字符预算切块逐块整合（旧版一次塞整族 backlog → 大库必撞超时）。
+    // 单块（小 backlog）时与改前逐字一致（零漂移）；多块时跨块合并判断为近似（诚实降级）。
+    const perChunk = Math.min(MAX_SCENE_CHUNK_CHARS, Math.max(20_000, cfg.llm.maxInputChars - 42_000));
+    const chunks = chunkByCharBudget(newMemories, perChunk);
+    if (chunks.length > 1) {
+        logger.info(`[memory] L2 输入超预算(${newMemories.length} 条新记忆),分 ${chunks.length} 块整合(每块 ≤${perChunk} 字符)`);
+    }
     let changed = 0;
-    for (const op of ops) {
-        if (!op || typeof op.path !== 'string')
-            continue;
+    let failedChunks = 0;
+    let personaRequestedReason;
+    for (const chunk of chunks) {
+        const memoriesJson = JSON.stringify(chunk.map((m) => ({
+            record_id: m.id,
+            content: m.content,
+            type: m.type,
+            priority: m.priority,
+            scene_name: m.scene_name,
+            // repo 归属(ADR-0015 T1.9/T1.10):L2 场景归属决策可见项目边界——
+            // this-repo 记录不得并入跨项目场景;'' = 未归属(不引导分组)。
+            repoKeyName: m.repoKeyName ?? '',
+            applicability: m.applicability ?? '',
+            timestamps: m.timestamps.map((t) => new Date(t).toISOString()),
+        })), null, 2);
+        const { systemPrompt, userPrompt } = buildScenePrompt({
+            memoriesJson,
+            sceneSummaries,
+            sceneContents,
+            currentTimestamp: new Date().toISOString(),
+            existingSceneFiles: summaries.map((s) => s.path),
+            maxScenes: cfg.l2.maxScenes,
+            family,
+        });
         try {
-            if (op.op === 'write' && typeof op.content === 'string') {
-                await scenes.write(op.path, op.content);
-                changed++;
-                logger.debug?.(`[memory] L2 写入场景 ${op.path} (${op.content.length} 字符)`);
-            }
-            else if (op.op === 'delete') {
-                await scenes.write(op.path, '[DELETED]');
-                changed++;
-                logger.debug?.(`[memory] L2 删除场景 ${op.path}`);
+            const raw = await callLLM(ctx, cfg, {
+                system: systemPrompt,
+                user: userPrompt,
+                maxTokens: resolveLayerTokens(cfg, 'l2'),
+                layer: 'l2',
+                logger,
+            });
+            // 解析:先取 PERSONA_UPDATE_REQUEST 标记,再解析操作数组
+            const reqMatch = REQUEST_RE.exec(raw);
+            if (reqMatch?.[1]?.trim())
+                personaRequestedReason = reqMatch[1].trim();
+            const opsRaw = reqMatch ? raw.replace(REQUEST_RE, '') : raw;
+            const ops = parseJsonLogged(opsRaw, 'L2 场景操作', logger);
+            if (!Array.isArray(ops))
+                throw new Error('L2 输出不是操作数组');
+            for (const op of ops) {
+                if (!op || typeof op.path !== 'string')
+                    continue;
+                try {
+                    if (op.op === 'write' && typeof op.content === 'string') {
+                        await scenes.write(op.path, op.content);
+                        changed++;
+                        logger.debug?.(`[memory] L2 写入场景 ${op.path} (${op.content.length} 字符)`);
+                    }
+                    else if (op.op === 'delete') {
+                        await scenes.write(op.path, '[DELETED]');
+                        changed++;
+                        logger.debug?.(`[memory] L2 删除场景 ${op.path}`);
+                    }
+                }
+                catch (err) {
+                    logger.warn(`[memory] L2 操作失败 ${op.path}: ${err instanceof Error ? err.message : String(err)}`);
+                }
             }
         }
         catch (err) {
-            logger.warn(`[memory] L2 操作失败 ${op.path}: ${err instanceof Error ? err.message : String(err)}`);
+            // R1 块级容错：单块超时/崩只丢这块，不掀全族（旧行为是整抛）
+            failedChunks++;
+            logger.warn(`[memory] L2 分块整合失败(family=${family},${chunk.length} 条记忆本块丢弃): ${err instanceof Error ? err.message : String(err)}`);
+            continue;
         }
     }
-    logger.info(`[memory] L2 场景整合完成(family=${family}):${newMemories.length} 条新记忆 → ${changed} 个文件操作(场景总数 ${summaries.length})` +
+    logger.info(`[memory] L2 场景整合完成(family=${family}):${newMemories.length} 条新记忆 → ${changed} 个文件操作(场景总数 ${summaries.length}` +
+        (chunks.length > 1 ? `,分 ${chunks.length} 块、失败 ${failedChunks} 块` : '') + `)` +
         (personaRequestedReason ? `,请求 L3 更新:${personaRequestedReason}` : ''));
     return { changed, personaRequestedReason };
 }

package/dist/pipeline/md-sync.js

@@ -32,7 +32,7 @@
  */
 import { opendir, readFile, realpath, stat } from 'node:fs/promises';
 import { join, resolve, sep } from 'node:path';
-import { DISABLE_SUFFIX, digest, recordDigest, targetFor } from '../store/memory-md.js';
+import { DISABLE_SUFFIX, digest, isRetiredRecord, recordDigest, targetFor } from '../store/memory-md.js';
 import { exportRecords } from '../store/memory-md-export.js';
 import { parseMdFile } from '../store/memory-md-parse.js';
 import { normalizeContentMd } from '../util/md-normalize.js';
@@ -360,7 +360,9 @@ export async function syncFromFiles(deps) {
             // 自校验（N13）：`.disable` 也带 `hash`。**只留痕、不改裁决**——后缀即“人已判过时”，
             // 若因凭证正文被手改一字节就把退场锁死，等于让人改坏凭证就丢掉处置意图。
             noteHash(parseMdFile(text), abs);
-            if (rec.validTo !== undefined) {
+            // 门1 解耦:退场判据是 marker 单源(`isRetiredRecord` 与库侧同口径)——
+            // retire 不再闭 valid_to,拿 validTo 判"已退场"会让第二轮重复计数、永不收敛到 same。
+            if (isRetiredRecord(rec)) {
                 report.same += 1;
                 if (entry === undefined)
                     await stampDisabled(ledger, rec, abs, text);

package/dist/pipeline/ruminate.js

@@ -167,6 +167,8 @@ export class RuminateController {
         //   经 runTurn 的 `bucket.push(...messages)` 会重复入桶 → 反刍后待处理计数“还原/变多”。）
         this.runner.enqueue(session.sessionId, [], session.mode, {
             force: true,
+            // R6：反刍与 rebuild 同为用户显式动作 → 越过抽取退避，保证"催一把"能真跑不被跳过
+            bypassBackoff: true,
             onTurnDone: (records) => {
                 this.totalL1 += records;
                 this.status.recordsBuilt = this.totalL1;

package/dist/pipeline/runner.d.ts

@@ -22,6 +22,7 @@ import type { SceneStore } from '../store/scenes.js';
 import type { StateStore } from '../store/state.js';
 import type { ConversationMessage, ExtractMode, MemoryFamily, MemoryLogger } from '../types.js';
 import type { FamilyStates } from './l1.js';
+import type { RouteHealthStore } from '../store/route-health.js';
 export interface MemoryStores {
     /**
      * DRSC 客户端(T8.4 读切):蒸馏背景窗的历史供给面(op=session&tail&redact=1)。
@@ -44,6 +45,8 @@ export interface MemoryStores {
     feedback?: {
         rekey(oldId: string, newId: string): boolean;
     };
+    /** R9 路由健康学习（可选）：未传则 runExtraction 不启用自适应块长学习。 */
+    routeHealth?: RouteHealthStore;
 }
 /** 管线任务(优先级调度:live > graph > rebuild)。 */
 export interface PipelineTask {
@@ -97,6 +100,8 @@ export declare class MemoryRunner {
     private extractFailures;
     /** 图谱泵在队列中的占位标志(同一时刻至多一个 graph 任务;护栏四件套之一)。 */
     private graphPumpQueued;
+    /** R7：已入队、尚未消费的 force-flush 键集（`session:mode`），同键不重复入队（治积压刷屏）。 */
+    private flushQueued;
     private readonly pendingFile;
     /** 分族 checkpoint(init 后可用;重建收尾也从这里读活引用)。 */
     states: FamilyStates;
@@ -132,6 +137,7 @@ export declare class MemoryRunner {
      *  onTurnDone 在该任务真正跑完后回调,携带本轮新增记录数(供反刍统计真实产出)。 */
     enqueue(sessionId: string, messages: ConversationMessage[], mode: ExtractMode, opts?: {
         force?: boolean;
+        bypassBackoff?: boolean;
         onTurnDone?: (records: number) => void;
     }): void;
     /** 重建任务入队(低优先级:让位于正常轮次;由 RebuildController 分块驱动)。 */
@@ -158,6 +164,32 @@ export declare class MemoryRunner {
      * 每轮 drain 至多消费一个 graph 任务且永远让位 live)。
      */
     startGraphBackfillTimer(): void;
+    /**
+     * validity 标注存量回填的接线(task_6.3):低频、让位于蒸馏——启动 3 分钟后首轮,
+     * 之后每 6h 一次(首轮收敛后多数轮是纯扫描 no-op;defer 的部分自动续上)。
+     * 门控跟灰度闸走:tieringEnabled(部署 ∨ 面板)关时不进任务——功能关着时
+     * 存量 metadata 逐字不变(零漂移,与 keyword-backfill 的门控同法)。
+     */
+    startValidityBackfillTimer(): void;
+    private runValidityBackfillTick;
+    /**
+     * 确定性写面的公共入队钩子(graph-write-plane R2):非蒸馏写入路径
+     * (`memory_add`/`memory_import`/`memory_update`)落库成功后把涉及记录投进
+     * 投影队——与 distill 分支同源同优先级,闭合"只有蒸馏才投影"的旁路缺口
+     * (用户手加记录长期 projected=None 的真根因)。部署未开图谱时 no-op,
+     * 用户后续开启由启动/周期补投影兜底(与 distill 分支同一口径)。
+     */
+    enqueueGraphFor(recordIds: readonly string[]): void;
+    /**
+     * 强制重投的写面入口(graph-write-plane R3):把上游 R10 的内部
+     * `forceReprojectRecord` 接到泵上——删凭证、高优入队、拉泵;幂等由
+     * 在途 mapping 的 PK 去重保证。图谱未启用时直接回零(不开"投了永不泵"
+     * 的陈旧队列口子,纠正通道的语义前提是图谱通路存在)。
+     */
+    reprojectGraph(recordIds: readonly string[]): {
+        queued: number;
+        jobIds: string[];
+    };
     /**
      * 图谱投影泵入队判定:
      * - 双门:部署级 cfg.graph.enabled + 运行时 live.enabled/distill,任一为假不入队;

package/dist/pipeline/runner.js

@@ -1,5 +1,7 @@
 import { resolveDataDir } from '../config.js';
 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 { trace } from '../store/trace.js';
 import { emptyPending, freshWarmup, groupPendingBySession, loadPending, PENDING_MODES, pendingPathFor, savePending, } from '../store/pending.js';
@@ -82,6 +84,8 @@ export function effectiveCfg(cfg, live) {
         : null;
     const layerChains = layerPick && Object.keys(layerPick).length ? layerPick : null;
     const maxInput = s && s.distillMaxInputChars > 0 ? s.distillMaxInputChars : null;
+    // R10 蒸馏超时运行时覆盖：>0 才注入 llm.timeoutMs，否则跟随静态配置
+    const timeoutOv = s && s.distillTimeoutMs > 0 ? s.distillTimeoutMs : null;
     // 旧档位键的全局接管(含给静态回退条目盖章):仅非链模式保留(旧存量值兼容)
     const fallbacksTakeover = !chainMode && eff && cfg.llm?.fallbacks?.length
         ? cfg.llm.fallbacks.map((f) => ({ ...f, reasoningEffort: eff }))
@@ -136,6 +140,11 @@ export function effectiveCfg(cfg, live) {
     const mpOverride = s?.memportEnabled !== undefined
         ? { memport: { ...(cfg.memport ?? {}), enabled: cfg.memport?.enabled === true || s.memportEnabled === true } }
         : null;
+    // 时效分级门2 灰度闸:live.validityTiering 与部署 cfg.validity.tieringEnabled 取或
+    // (同一先例)。两字都假时回 `{tieringEnabled:false}` 与缺省形状等价，注入侧零漂移不破。
+    const vtOverride = s?.validityTiering !== undefined
+        ? { validity: { ...(cfg.validity ?? {}), tieringEnabled: cfg.validity?.tieringEnabled === true || s.validityTiering === true } }
+        : null;
     // md 投射/后缀收敛的单次动作护栏运行时覆盖(0 = 跟随部署 cfg.memExport.maxRecords)。
     // 只覆盖条数护栏，不动 enabled/root——开关与根路径仍属部署配置。
     const mdx = s?.mdExportMaxRecords ?? 0;
@@ -144,7 +153,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)
+    if (!override && !budgets && !maxInput && !fallbacksTakeover && !chainEffort && !chainFallbacks && !effortInject && !layerChains && !hasChannel && !embedOverride && !cfOverride && !memExportOverride && !backfillOverride && !kwOverride && !rdOverride && !mdsOverride && !mpOverride && !vtOverride)
         return cfg;
     return {
         ...cfg,
@@ -154,6 +163,7 @@ export function effectiveCfg(cfg, live) {
         ...(rdOverride ?? {}),
         ...(mdsOverride ?? {}),
         ...(mpOverride ?? {}),
+        ...(vtOverride ?? {}),
         ...(memExportOverride ?? {}),
         ...(backfillOverride ?? {}),
         llm: {
@@ -162,6 +172,7 @@ export function effectiveCfg(cfg, live) {
             ...(override ?? {}),
             ...(budgets ? { budgets } : {}),
             ...(maxInput ? { maxInputChars: maxInput } : {}),
+            ...(timeoutOv ? { timeoutMs: timeoutOv } : {}),
             ...(fallbacksTakeover ? { fallbacks: fallbacksTakeover } : {}),
             ...(chainEffort ? { primaryEffort: chainEffort } : {}),
             ...(chainFallbacks ? { fallbacks: chainFallbacks } : {}),
@@ -205,6 +216,8 @@ export class MemoryRunner {
     extractFailures = new Map();
     /** 图谱泵在队列中的占位标志(同一时刻至多一个 graph 任务;护栏四件套之一)。 */
     graphPumpQueued = false;
+    /** R7：已入队、尚未消费的 force-flush 键集（`session:mode`），同键不重复入队（治积压刷屏）。 */
+    flushQueued = new Set();
     pendingFile;
     /** 分族 checkpoint(init 后可用;重建收尾也从这里读活引用)。 */
     states;
@@ -350,9 +363,25 @@ export class MemoryRunner {
     /** 一轮对话结束后入队(L0 落盘由 capture 在 turn/end 即时完成,不排蒸馏队列)。
      *  onTurnDone 在该任务真正跑完后回调,携带本轮新增记录数(供反刍统计真实产出)。 */
     enqueue(sessionId, messages, mode, opts) {
+        // R7：闲置/反刍/换档触发的 force-flush（空消息 + force）按 (session,mode) 去重，
+        // 同键未消费前不重复入队（一次长阻塞不再积压几十个 no-op 排空刷屏）。
+        const isFlush = opts?.force === true && messages.length === 0;
+        const fkey = isFlush ? `${sessionId}:${mode}` : '';
+        if (isFlush && this.flushQueued.has(fkey))
+            return;
+        if (isFlush)
+            this.flushQueued.add(fkey);
         this.pushTask({
             kind: 'live',
-            run: () => this.runTurn(sessionId, messages, mode, opts),
+            run: async () => {
+                try {
+                    return await this.runTurn(sessionId, messages, mode, opts);
+                }
+                finally {
+                    if (isFlush)
+                        this.flushQueued.delete(fkey); // 无论成败都释占，避免键泄漏永久屏蔽后续 flush
+                }
+            },
             ...(opts?.onTurnDone ? { onDone: (r) => opts.onTurnDone?.(typeof r === 'number' ? r : 0) } : {}),
         });
     }
@@ -454,6 +483,65 @@ export class MemoryRunner {
             return () => clearInterval(timer);
         });
     }
+    /**
+     * validity 标注存量回填的接线(task_6.3):低频、让位于蒸馏——启动 3 分钟后首轮,
+     * 之后每 6h 一次(首轮收敛后多数轮是纯扫描 no-op;defer 的部分自动续上)。
+     * 门控跟灰度闸走:tieringEnabled(部署 ∨ 面板)关时不进任务——功能关着时
+     * 存量 metadata 逐字不变(零漂移,与 keyword-backfill 的门控同法)。
+     */
+    startValidityBackfillTimer() {
+        this.ctx.effect(() => {
+            let loop = null;
+            const first = setTimeout(() => {
+                this.runValidityBackfillTick();
+                loop = setInterval(() => this.runValidityBackfillTick(), 6 * 3_600_000);
+            }, 180_000);
+            return () => { clearTimeout(first); if (loop !== null)
+                clearInterval(loop); };
+        });
+    }
+    runValidityBackfillTick() {
+        if (this.stopped)
+            return;
+        const eff = effectiveCfg(this.cfg, this.live);
+        if (eff.validity?.tieringEnabled !== true)
+            return;
+        startValidityBackfill({
+            l1: this.stores.l1,
+            logger: this.logger,
+            // task_7.7 接缝:回填改过标注的记录顺手重投保鲜图谱(图谱未启用时 reprojectGraph 自己回零)。
+            reproject: (ids) => { this.reprojectGraph(ids); },
+            shouldCancel: () => this.stopped,
+        });
+    }
+    /**
+     * 确定性写面的公共入队钩子(graph-write-plane R2):非蒸馏写入路径
+     * (`memory_add`/`memory_import`/`memory_update`)落库成功后把涉及记录投进
+     * 投影队——与 distill 分支同源同优先级,闭合"只有蒸馏才投影"的旁路缺口
+     * (用户手加记录长期 projected=None 的真根因)。部署未开图谱时 no-op,
+     * 用户后续开启由启动/周期补投影兜底(与 distill 分支同一口径)。
+     */
+    enqueueGraphFor(recordIds) {
+        if (recordIds.length === 0 || !this.stores.graph || !this.cfg.graph?.enabled)
+            return;
+        this.stores.graph.queueGraphProjection([...recordIds], GRAPH_PRIORITY_NEW);
+        this.maybeQueueGraphTask();
+    }
+    /**
+     * 强制重投的写面入口(graph-write-plane R3):把上游 R10 的内部
+     * `forceReprojectRecord` 接到泵上——删凭证、高优入队、拉泵;幂等由
+     * 在途 mapping 的 PK 去重保证。图谱未启用时直接回零(不开"投了永不泵"
+     * 的陈旧队列口子,纠正通道的语义前提是图谱通路存在)。
+     */
+    reprojectGraph(recordIds) {
+        const graphs = this.stores.graph;
+        if (!graphs || !this.cfg.graph?.enabled || recordIds.length === 0)
+            return { queued: 0, jobIds: [] };
+        const r = graphs.forceReprojectRecord(recordIds);
+        if (r.queued > 0)
+            this.maybeQueueGraphTask();
+        return r;
+    }
     /**
      * 图谱投影泵入队判定:
      * - 双门:部署级 cfg.graph.enabled + 运行时 live.enabled/distill,任一为假不入队;
@@ -478,7 +566,10 @@ export class MemoryRunner {
                 this.graphPumpQueued = false;
                 if (this.stopped)
                     return;
-                const had = await runGraphProjection(this.ctx, effectiveCfg(this.cfg, this.live), graphs, this.logger);
+                const had = await runGraphProjection(this.ctx, effectiveCfg(this.cfg, this.live), graphs, this.logger, 
+                // G-vec 缺陷修的嵌入缝:惰性取 L1 同一嵌入源(活切换不被钉死),
+                // 未就绪/失败 embedText 回 undefined = 不补写(词法路不受影响)。
+                (t) => this.stores.l1.embedText(t));
                 // 有实际投影(说明队列还有积压)才续排;claim 落空则停泵,等下一个触发源
                 if (had)
                     this.maybeQueueGraphTask();
@@ -568,15 +659,13 @@ export class MemoryRunner {
             const effective = effectiveExtractThreshold(this.warmup[mode], cfg.extract.minMessages);
             const sliceLen = bucket.reduce((n, m) => (m.sessionId === sessionId ? n + 1 : n), 0);
             // 抽取失败退避:重建轮(noBufferCap,用户显式动作、有自己的失败/取消 UI)豁免
-            const backedOff = !opts?.noBufferCap && this.inExtractBackoff(sessionId);
+            const backedOff = !opts?.noBufferCap && !opts?.bypassBackoff && this.inExtractBackoff(sessionId);
             if ((opts?.force || sliceLen >= effective) && !backedOff) {
                 newRecords = await this.extractSessionSlice(sessionId, mode, cfg, effective, opts);
                 // 新记录入投影队列(优先级恒高于存量补投影)并拉起图谱泵;入队本身廉价,
-                // 部署未开图谱(cfg.graph.enabled)时不入队——用户后续开启由启动补投影兜底
-                if (newRecords.length > 0 && this.stores.graph && this.cfg.graph?.enabled) {
-                    this.stores.graph.queueGraphProjection(newRecords.map((r) => r.id), GRAPH_PRIORITY_NEW);
-                    this.maybeQueueGraphTask();
-                }
+                // 部署未开图谱(cfg.graph.enabled)时不入队——用户后续开启由启动补投影兜底。
+                // (写面 R2:分支本体抽成 enqueueGraphFor,与工具三路径同源,不再两处漂移。)
+                this.enqueueGraphFor(newRecords.map((r) => r.id));
             }
             else {
                 this.logger.debug?.(backedOff
@@ -723,9 +812,12 @@ export class MemoryRunner {
             (oldId, newId) => {
                 this.stores.usage?.rekey(oldId, newId);
                 this.stores.feedback?.rekey(oldId, newId);
-            });
+            }, this.stores.routeHealth);
+            // R9: 本轮学到的跑通块长落盘（best-effort，失败不阻蒸馏）
+            await this.stores.routeHealth?.save().catch(() => { });
             if (!result.skipped) {
-                this.pending[mode] = rest;
+                // R1′ 部分消费：成功块出桶、抽取失败块留桶下轮重投（rest ∪ failedMessages）
+                this.pending[mode] = [...rest, ...(result.failedMessages ?? [])];
                 // 重建轮(force)不是有机对话,不推进爬坡
                 if (!opts?.force)
                     this.warmup[mode] = advanceWarmupThreshold(this.warmup[mode], cfg.extract.minMessages);
@@ -777,6 +869,12 @@ export class MemoryRunner {
                 ok: false,
                 errorKind: err instanceof Error ? err.name : 'error',
             });
+            // R4:无可用蒸馏路由=配置缺失、非模型慢——不进退避(否则把"没配"误当故障反复退避)，只顺延。
+            if (err instanceof NoDistillRouteError) {
+                this.logger.warn(`[memory] 无可用蒸馏路由,本轮蒸馏顺延、不记退避(session=${sessionId},mode=${mode})`);
+                await this.persistPending(opts?.noBufferCap).catch(() => { });
+                return [];
+            }
             // 指数退避:压制闲置兜底/补跑在 LLM 故障期间的连环重试(成功消费时清零)
             const streak = (this.extractFailures.get(sessionId)?.streak ?? 0) + 1;
             const delayMs = extractionBackoffMs(streak);

package/dist/pipeline/slot-migrate.d.ts

@@ -22,11 +22,12 @@ export interface SlotMigrateStoreFace {
     list(): Slot[];
     close(id: string, status: 'done' | 'dropped'): Promise<boolean>;
 }
-/** 迁移需要的 L1 只读面（validTo 非空 = 已退场（epoch ms），不作为信息载体）。 */
+/** 迁移需要的 L1 只读面（门1 解耦：退场判据是 marker 单源——metadata 带 `dsh_superseded`
+ *  即已退场；valid_to 只是现实有效期，带着它不算退场）。 */
 export interface SlotMigrateL1Face {
     getByIds(ids: string[]): Array<{
         id: string;
-        validTo?: number | null;
+        metadata?: unknown;
     }>;
 }
 /** 一条可迁移槽位（预览用，执行前即可展示）。 */

package/dist/pipeline/slot-migrate.js

@@ -1,4 +1,5 @@
 import { errDetail } from '../util/filelog.js';
+import { readSupersedeMarker } from '../store/supersede.js';
 /** 判定 + 挑选可迁移槽位（纯读，无副作用；面板预览与反刍执行共用）。 */
 export function pickMigratableSlots(slots, l1) {
     if (l1 === undefined)
@@ -6,9 +7,9 @@ export function pickMigratableSlots(slots, l1) {
     const open = slots.filter((s) => s.status === 'open' && s.pinned === true && s.kind === 'rule');
     if (open.length === 0)
         return [];
-    // 一次批量取全部 refs，避免 N 次查询。
+    // 一次批量取全部 refs，避免 N 次查询。存活 = 无退场 marker（门1 解耦同口径）。
     const allRefs = [...new Set(open.flatMap((s) => s.refs ?? []))];
-    const alive = new Set(l1.getByIds(allRefs).filter((r) => r.validTo === undefined || r.validTo === null).map((r) => r.id));
+    const alive = new Set(l1.getByIds(allRefs).filter((r) => readSupersedeMarker(r.metadata) === undefined).map((r) => r.id));
     const out = [];
     for (const s of open) {
         const carrier = (s.refs ?? []).find((r) => alive.has(r));

package/dist/projection/recall.d.ts

@@ -58,6 +58,13 @@ export interface RecallItemView {
      * 读侧据此把「已被摘要取代的旧召回」与「此刻仍在上下文里的召回」区分开。
      */
     superseded?: true;
+    /**
+     * 时效定性快照(task_3.5,expiry-tiering 门2 展示面)：仅在 `expired`/`expired_suspect`
+     * 两档写键(泡泡如实标"已于 X 失效/疑似失效")；current/historical 等缺席=旧帧兼容。
+     */
+    validity?: import('../store/validity.js').ValidityState;
+    /** 现实有效期(ISO)：与 `validity` 同进同退，只在写 validity 时带上。 */
+    validUntil?: string;
 }
 /** 持久态：本会话的活召回 id 集 + 判脏序号。 */
 export interface RecallProjectionState {
@@ -89,13 +96,13 @@ interface SchemaLike<T> {
 }
 /** state 校验（registry 用它挡掉损坏/过期的 checkpoint 行）。 */
 export declare const stateSchema: SchemaLike<RecallProjectionState>;
-/** view 校验（出网前调用；未知键容忍，同 slots 投影的语义边界）。 */
 export declare const viewSchema: SchemaLike<RecallView>;
 /** 投影需要的 L1 只读面（结构化声明，避免跨模块类型耦合）。
- *  判退场要 `validTo`/`metadata`，故直接 Pick 自 MemoryRecord，不在投影里自写时间比较。
+ *  判退场要 `validTo`/`metadata`，时效定性还要 `persistence`/`validFrom`，
+ *  故直接 Pick 自 MemoryRecord，不在投影里自写时间比较。
  *  `name` 是名称蒸馏产出的短标题，优先作为展示标题。 */
 export interface RecallL1Face {
-    getByIds(ids: string[]): Array<Pick<MemoryRecord, 'id' | 'type' | 'content' | 'priority' | 'metadata' | 'validTo' | 'name'>>;
+    getByIds(ids: string[]): Array<Pick<MemoryRecord, 'id' | 'type' | 'content' | 'priority' | 'metadata' | 'validFrom' | 'validTo' | 'persistence' | 'name'>>;
 }
 /** 投影需要的反馈只读面（缺席 = view 不带 rating，旧行为）。 */
 export interface RecallFeedbackFace {

package/dist/projection/recall.js

@@ -1,4 +1,5 @@
 import { isRetired } from '../store/supersede.js';
+import { stateOfRecord } from '../store/validity.js';
 export const MEMORY_RECALL_KEY = 'memoryRecall';
 /** view 最多透出条数（最近在上；超出部分只计入 count，防 wire 体量失控）。 */
 export const RECALL_VIEW_CAP = 20;
@@ -43,6 +44,7 @@ export const stateSchema = {
     },
 };
 /** view 校验（出网前调用；未知键容忍，同 slots 投影的语义边界）。 */
+const VALIDITY_STATES_VIEW = ['current', 'historical', 'expired', 'expired_suspect', 'superseded', 'retired'];
 export const viewSchema = {
     parse: (value) => {
         const what = 'memoryRecall.view';
@@ -73,6 +75,12 @@ export const viewSchema = {
                 invalid(at, 'retired 只能是 true 或缺席');
             if (item.superseded !== undefined && item.superseded !== true)
                 invalid(at, 'superseded 只能是 true 或缺席');
+            // 时效标注(task_3.5)：缺席=旧帧容忍；有则必须六态枚举内，validUntil 必字符串。
+            if (item.validity !== undefined && VALIDITY_STATES_VIEW.indexOf(item.validity) < 0) {
+                invalid(at, 'validity 必须是六态之一或缺席');
+            }
+            if (item.validUntil !== undefined)
+                requireString(item.validUntil, at, 'validUntil');
         });
         return value;
     },
@@ -150,6 +158,11 @@ function makeView(state, l1, feedback) {
             ? r.metadata?.dsh_usage_scenario
             : undefined;
         const rating = feedback?.lastOf(id);
+        // 时效标注(task_3.5)：只对"过时两档"写键——current/historical 不必让人看见时效噪声；
+        // 旧帧无此键，读侧缺席即活跃。判定现算（stateOfRecord），不吃落库快照；
+        // 未退场行才会真判过时两档（退场行由 retired 键表达，validity 不再叠加）。
+        const vState = isRetired(r) ? undefined : stateOfRecord(r, Date.now());
+        const showValidity = vState === 'expired' || vState === 'expired_suspect';
         items.push({
             id: r.id,
             type: r.type,
@@ -162,6 +175,7 @@ function makeView(state, l1, feedback) {
             ...(isRetired(r) ? { retired: true } : {}),
             // 已被摘要取代：正文已不在上下文里。与 retired 正交，两者可同时在。
             ...(superseded.has(id) ? { superseded: true } : {}),
+            ...(showValidity ? { validity: vState, validUntil: r.validTo === undefined ? '' : new Date(r.validTo).toISOString() } : {}),
         });
     }
     const next = { rev: state.rev, sessionId: state.sessionId, count: state.ids.length, items };

package/dist/settings.js

@@ -70,6 +70,7 @@ const ALWAYS_ON = {
     distillChain: [],
     distillBudgets: { extract: 0, dedup: 0, l2: 0, l3: 0, graph: 0 },
     distillMaxInputChars: 0,
+    distillTimeoutMs: 0,
     distillLayerChains: { l1: [], l2: [], l3: [] },
     distillMode: '',
     directBaseURL: '',
@@ -85,6 +86,8 @@ const ALWAYS_ON = {
     redistillEnabled: false,
     mdSyncEnabled: false,
     memportEnabled: false,
+    // 时效分级门2 灰度开关:默认关(注入与改前逐字一致)
+    validityTiering: false,
     // md 投射护栏运行时覆盖:0 = 跟随部署 cfg.memExport.maxRecords（面板上可改）
     mdExportMaxRecords: 0,
     // 回填并行度运行时覆盖:0 = 跟随部署 cfg.backfill.concurrency（概览页滑块可改）
@@ -307,6 +310,8 @@ function resolveSettings(value) {
             graph: num(rawBudgets.graph),
         },
         distillMaxInputChars: num(v.distillMaxInputChars),
+        // R10 蒸馏超时运行时覆盖：钳 0~600000（与 live schema 同上限）；0 = 跟随部署 llm.timeoutMs
+        distillTimeoutMs: Math.min(600_000, Math.max(0, num(v.distillTimeoutMs))),
         // 蒸馏通道:mode 白名单(非法归 '' = 跟随部署);端点与密钥截断防御但保留原始内容
         distillMode: v.distillMode === 'host' || v.distillMode === 'direct' ? v.distillMode : '',
         directBaseURL: typeof v.directBaseURL === 'string' ? v.directBaseURL.slice(0, 2000) : '',
@@ -329,6 +334,7 @@ function resolveSettings(value) {
         redistillEnabled: v.redistillEnabled === true,
         mdSyncEnabled: v.mdSyncEnabled === true,
         memportEnabled: v.memportEnabled === true,
+        validityTiering: v.validityTiering === true,
         // md 投射护栏钳 0~10000（与 live schema 同上限）；0 = 跟随部署默认
         mdExportMaxRecords: Math.min(10_000, Math.max(0, num(v.mdExportMaxRecords))),
         // 回填并行度钳 0~8（与 live schema 同上限）；0 = 跟随部署 cfg.backfill.concurrency

package/dist/stats.d.ts

@@ -183,7 +183,7 @@ export declare function hitToUiRecord(r: {
     scope?: string;
     /** 归属工作区路径（仅 scope='workspace' 时非空）。 */
     workspaceId?: string;
-    /** 退场判据:`valid_to` 闭合即已退场(软删)。由 `listL1`/`getByIds` 透传。 */
+    /** 退场判据:与库侧同源（门1 解耦后 marker 单源，`isRetired`）。由 `listL1`/`getByIds` 透传。 */
     validTo?: number;
 }, extra?: {
     agingWeight?: number | null;