dsh-prime-memory 0.26.5 → 0.26.9

package/dist/embedding-child.cjs

@@ -0,0 +1,192 @@
+/**
+ * 本地嵌入子进程(fix #11):transformers.js 的模型加载与推理在 fork 出的独立
+ * 子进程执行,主线程只投递文本、收回向量。取代 worker_threads 的原因:
+ * 插件 runtime 的 sharp/libvips 与宿主 Electron 的 sharp/libvips 在同一进程内
+ * 加载会撞 libvips-42.dll 名字(OS LoadLibrary 层冲突,同名不同路径行为未定义)
+ * ——worker_thread 与主线程同进程,撞名前提仍在;子进程自带独立 DLL 表,物理隔离。
+ *
+ * 推理队列语义与 embedding-worker.cjs 完全一致(单线程串行、priority 插队、
+ * 条间 setImmediate 让路),只有 IPC 传输层不同:
+ *
+ * 协议(与 src/store/local-embedding.ts 的 RealChildChannel 配对;自增 id):
+ * - 启动配置:env DSH_EMBED_CFG(JSON 字符串:{runtimeDir,modelDir,pooling,dtype,
+ *   maxInputChars}——fork 的 env 只收标量,嵌套对象经序列化传递);
+ * - 入向:{id,type:'ping'} | {id,type:'warmup'} | {id,type:'embed',texts,priority}
+ * - 出向:{id,ok:true,type:'pong'|'ready'|'embedded',vectors?}(vectors 为
+ *   number[][],fork IPC 默认 JSON 序列化不支持 TypedArray,主线程侧重建
+ *   Float32Array;512d×32 条 ≈64KB,序列化 <5ms,瓶颈在推理不在传输)
+ *   | {id,ok:false,stage:'load'|'infer',error} | {type:'fatal',error}
+ *
+ * 信任边界(沿 AGENTS.md 审查记录):runtime/ 目录在数据目录信任边界内,
+ * 本进程按其 package.json createRequire 加载 transformers——对数据目录有写
+ * 权限的进程理论上可植入恶意模块;模型文件逐文件 sha256 锁定,运行时代码
+ * 无同级防护,完整修复需安装指纹设计,暂以文档化假设为准。
+ */
+'use strict';
+
+const path = require('node:path');
+const { createRequire } = require('node:module');
+
+// 必须由 fork 启动(需要 IPC channel);裸 node 执行时静默退出,不报 SyntaxError、不永挂。
+if (typeof process.send !== 'function') {
+  console.error('[embedding-child] 未经 fork 启动,无 IPC 通道,退出');
+  process.exit(0);
+}
+
+/** 错误消息归一化(Error 取 message,其余 String 化)。 */
+function errMsg(err) {
+  return err && err.message ? err.message : String(err);
+}
+
+const cfg = JSON.parse(process.env.DSH_EMBED_CFG || '{}');
+const RUNTIME_DIR = typeof cfg.runtimeDir === 'string' ? cfg.runtimeDir : '';
+const MODEL_DIR = typeof cfg.modelDir === 'string' ? cfg.modelDir : '';
+const POOLING = cfg.pooling === 'cls' ? 'cls' : 'mean';
+const DTYPE = typeof cfg.dtype === 'string' ? cfg.dtype : 'q8';
+const MAX_INPUT_CHARS = cfg.maxInputChars > 0 ? cfg.maxInputChars : 5000;
+
+let extractor = null; // pipeline('feature-extraction', …)
+let loadState = 'idle'; // idle | loading | ready | failed
+let loadPromise = null;
+let loadError = null;
+
+// ── 模型懒加载(首请求触发;失败后经 warmup 可重试,embed 请求失败快返回) ──
+function ensureLoaded() {
+  if (loadState === 'ready') return Promise.resolve();
+  if (loadState === 'loading' && loadPromise) return loadPromise;
+  loadState = 'loading';
+  loadError = null;
+  loadPromise = (async () => {
+    try {
+      if (!RUNTIME_DIR || !MODEL_DIR) throw new Error('DSH_EMBED_CFG 缺少 runtimeDir/modelDir');
+      const req = createRequire(path.join(RUNTIME_DIR, 'package.json'));
+      const mod = req('@huggingface/transformers');
+      if (mod.env) {
+        mod.env.allowRemoteModels = false;
+        if (mod.env.allowLocalModels !== undefined) mod.env.allowLocalModels = true;
+      }
+      extractor = await mod.pipeline('feature-extraction', MODEL_DIR, { dtype: DTYPE });
+      loadState = 'ready';
+    } catch (err) {
+      loadState = 'failed';
+      loadError = errMsg(err);
+      loadPromise = null; // 失败后下一次 warmup 重新走加载
+      throw err;
+    }
+  })();
+  return loadPromise;
+}
+
+// ── 推理队列(逐条 job;priority 插队;条间让路) ──
+const queue = []; // [{ request, index, text }]
+let pumping = false;
+
+function postReply(msg) {
+  // 通道已断(父进程退出/正在终止)时 send 抛错——静默即可,父进程侧有 exit 兜底
+  try {
+    process.send(msg);
+  } catch {
+    /* IPC 已关闭,回复无处可去 */
+  }
+}
+
+/** 请求全部条目完成 → 回执(Float32Array → number[] 序列化,IPC JSON 通道不支持 TypedArray)。 */
+function settle(request) {
+  if (request.failed || request.remaining !== 0) return;
+  postReply({
+    id: request.id,
+    ok: true,
+    type: 'embedded',
+    vectors: request.vectors.map((v) => Array.from(v)),
+  });
+}
+
+/** 首个失败即回执错误,并移除该请求尚未开跑的条目(正在跑的至多 1 条,算完即弃)。 */
+function failRequest(request, error, stage) {
+  if (request.failed) return;
+  request.failed = true;
+  for (let i = queue.length - 1; i >= 0; i--) {
+    if (queue[i].request === request) queue.splice(i, 1);
+  }
+  postReply({ id: request.id, ok: false, stage: stage, error: errMsg(error) });
+}
+
+async function pump() {
+  if (pumping) return;
+  pumping = true;
+  try {
+    while (queue.length > 0) {
+      const job = queue.shift();
+      if (job.request.failed) continue;
+      try {
+        const result = await extractor([job.text.slice(0, MAX_INPUT_CHARS)], { pooling: POOLING, normalize: true });
+        const data = result[0] && result[0].data;
+        job.request.vectors[job.index] = data instanceof Float32Array ? data : new Float32Array(data);
+        job.request.remaining -= 1;
+        settle(job.request);
+      } catch (err) {
+        failRequest(job.request, err, 'infer');
+      }
+      // 条间让路:交还本进程事件循环,新消息(含 priority 插队)可在批间被处理
+      await new Promise((resolve) => setImmediate(resolve));
+    }
+  } finally {
+    pumping = false;
+  }
+}
+
+function handleEmbed(msg) {
+  const texts = Array.isArray(msg.texts) ? msg.texts : [];
+  if (texts.length === 0) {
+    postReply({ id: msg.id, ok: true, type: 'embedded', vectors: [] });
+    return;
+  }
+  const request = { id: msg.id, vectors: new Array(texts.length), remaining: texts.length, failed: false };
+  // 单条请求(召回 query)插队到队首;批次追加到队尾(批内条目间仍会被后来的插队)
+  const priority = msg.priority === true && texts.length === 1;
+  for (let i = 0; i < texts.length; i++) {
+    const job = { request: request, index: i, text: String(texts[i] == null ? '' : texts[i]) };
+    if (priority) queue.unshift(job);
+    else queue.push(job);
+  }
+  void pump();
+}
+
+process.on('message', (msg) => {
+  if (!msg || typeof msg.id !== 'number' || typeof msg.type !== 'string') return;
+  if (msg.type === 'ping') {
+    postReply({ id: msg.id, ok: true, type: 'pong' });
+    return;
+  }
+  if (msg.type === 'warmup') {
+    ensureLoaded().then(
+      () => postReply({ id: msg.id, ok: true, type: 'ready' }),
+      () => postReply({ id: msg.id, ok: false, stage: 'load', error: loadError ?? '模型加载失败' }),
+    );
+    return;
+  }
+  if (msg.type === 'embed') {
+    void (async () => {
+      try {
+        await ensureLoaded();
+      } catch {
+        postReply({ id: msg.id, ok: false, stage: 'load', error: loadError ?? '模型加载失败' });
+        return;
+      }
+      handleEmbed(msg);
+    })();
+    return;
+  }
+});
+
+// 父进程disconnect(通道被主动关闭,如宿主优雅退出/RealChildChannel 前置断开):
+// 模型与 onnxruntime 都只服务于这条通道,留着就是孤儿常驻——直接退出。
+// taskkill /T /F 兜底覆盖"父进程被硬杀、无 disconnect"的路径。
+process.on('disconnect', () => process.exit(0));
+
+// 未捕获异常:尽力通知父进程后强制退出(父进程的 exit 处理会拒绝全部 pending
+// 并转入 failed 态)。不保持半死状态——半死的子进程只会让调用方挂到超时。
+process.on('uncaughtException', (err) => {
+  postReply({ type: 'fatal', error: errMsg(err) });
+  setTimeout(() => process.exit(1), 50);
+});

package/dist/embedding-worker.cjs

@@ -1,3 +1,5 @@
+// DEPRECATED: use embedding-child.cjs (subprocess isolation, fix #11)
+// 保留一版兼容(opts.useWorker 逃生门),下版删除。不再主动修改。
 /**
  * 本地嵌入 worker:transformers.js 的模型加载与推理在本线程执行,主线程只
  * 投递文本、收回向量。onnxruntime-node 的 run/loadModel 是 setImmediate 回调里

package/dist/graph/apply.d.ts

@@ -31,7 +31,16 @@ export declare function normalizeEntityName(name: string): string;
  * validTo → validFrom(时间增强列,新写入路径)→ metadata.activity_end_time →
  * metadata.activity_start_time(列迁移前的存量数据)→ timestamps 最新 → createdAt。
  * 全部无证据才用 fallback(now),绝不猜测。
+ *
+ * task_2.6(expiry-tiering):兜底 now 分支回传 `'fallback_now'` 证据等级——供图谱侧
+ * 同口径读时派生使用(落到 now 的 validFrom **不是**时间证据,与 activity_* 链的
+ * 'evidence' 必须可区分;否则假过期与真过期同形)。
  */
+export declare function anchorTimeFromRecordsDetailed(records: readonly MemoryRecord[], fallbackIso: string): {
+    iso: string;
+    source: 'evidence' | 'fallback_now';
+};
+/** {@link anchorTimeFromRecordsDetailed} 的旧签名封装(调用方只要时刻时的零改动通道)。 */
 export declare function anchorTimeFromRecords(records: readonly MemoryRecord[], fallbackIso: string): string;
 /** 应用一次投影提案(硬校验 + 消歧 + supersede + 状态重建)。 */
 export declare function applyGraphProjection(options: ApplyGraphProjectionOptions): ApplyGraphProjectionOutcome;

package/dist/graph/apply.js

@@ -66,8 +66,12 @@ function recordFamily(r) {
  * validTo → validFrom(时间增强列,新写入路径)→ metadata.activity_end_time →
  * metadata.activity_start_time(列迁移前的存量数据)→ timestamps 最新 → createdAt。
  * 全部无证据才用 fallback(now),绝不猜测。
+ *
+ * task_2.6(expiry-tiering):兜底 now 分支回传 `'fallback_now'` 证据等级——供图谱侧
+ * 同口径读时派生使用(落到 now 的 validFrom **不是**时间证据,与 activity_* 链的
+ * 'evidence' 必须可区分;否则假过期与真过期同形)。
  */
-export function anchorTimeFromRecords(records, fallbackIso) {
+export function anchorTimeFromRecordsDetailed(records, fallbackIso) {
     let latest = Number.NaN;
     const consider = (raw) => {
         const t = typeof raw === 'number' ? raw : typeof raw === 'string' ? Date.parse(raw) : Number.NaN;
@@ -85,7 +89,13 @@ export function anchorTimeFromRecords(records, fallbackIso) {
             consider(t);
         consider(r.createdAt);
     }
-    return Number.isNaN(latest) ? fallbackIso : new Date(latest).toISOString();
+    return Number.isNaN(latest)
+        ? { iso: fallbackIso, source: 'fallback_now' }
+        : { iso: new Date(latest).toISOString(), source: 'evidence' };
+}
+/** {@link anchorTimeFromRecordsDetailed} 的旧签名封装(调用方只要时刻时的零改动通道)。 */
+export function anchorTimeFromRecords(records, fallbackIso) {
+    return anchorTimeFromRecordsDetailed(records, fallbackIso).iso;
 }
 /** 来源集并集封顶(保最新:新引用追加在尾部,溢出丢头部最老引用)。 */
 function unionSourcesCapped(old, add) {

package/dist/graph/search.d.ts

@@ -9,6 +9,15 @@ export declare const GRAPH_FIELD_WEIGHTS: {
     readonly relations: 3;
     readonly type: 2;
 };
+/**
+ * as-of 回放可选参数(expiry-tiering Phase 5:图谱读时派生,不加冻结列)。
+ * 默认(缺席)= 当前态检索,行为与改前逐字一致。
+ */
+export interface GraphAsOfOptions {
+    /** ISO 8601 时刻:把"当时成立"的 superseded fact/边也纳入检索与回链;
+     *  archived 仍排除(那是删除传播的墓碑，来源已不在，回放也不该复活)。 */
+    asOf?: string;
+}
 /**
  * 图谱命中 → L1 记录 id 序列(§D 第 3 路 RRF 的输入;纯函数,无 I/O)。
  *
@@ -35,7 +44,7 @@ export declare const GRAPH_FIELD_WEIGHTS: {
  * 见文件头演进阶梯)。族过滤不在本函数:邻居节点可跨族,兜底在 graphLane 尾部的
  * 记录级 family/scope 双闸(宁可漏不可串落在记录上)。
  */
-export declare function expandHitRecordIds(hits: readonly GraphNodeSearchResult[], nodes: readonly GraphNode[], edges: readonly GraphEdge[]): string[];
+export declare function expandHitRecordIds(hits: readonly GraphNodeSearchResult[], nodes: readonly GraphNode[], edges: readonly GraphEdge[], opts?: GraphAsOfOptions): string[];
 /**
  * 直连段回链(无 hop)——保留 task_9 的原语义形状(既有测试继续钉住);
  * 生产链路一律走 expandHitRecordIds(向量种子并集 + 1-hop)。
@@ -45,4 +54,4 @@ export declare function graphHitRecordIds(hits: readonly GraphNodeSearchResult[]
  * 图谱节点检索:返回按 score 降序的命中(最多 limit 条;limit 钳制 1~20)。
  * 候选节点 = active | disputed(superseded/archived 不进检索)。
  */
-export declare function searchGraphNodes(nodes: readonly GraphNode[], edges: readonly GraphEdge[], query: string, limit: number): GraphNodeSearchResult[];
+export declare function searchGraphNodes(nodes: readonly GraphNode[], edges: readonly GraphEdge[], query: string, limit: number, opts?: GraphAsOfOptions): GraphNodeSearchResult[];

package/dist/graph/search.js

@@ -60,6 +60,22 @@ const FIELD_ORDER = ['name', 'aliases', 'tags', 'currentState', 'facts', 'relati
 function factValueText(value) {
     return Array.isArray(value) ? value.join(' ') : value;
 }
+/** ISO 字符串区间覆盖判定(字典序=时间序;空串视作未闭合)。 */
+function coversInterval(from, to, asOf) {
+    if (from && from > asOf)
+        return false;
+    if (to && asOf >= to)
+        return false;
+    return true;
+}
+/** fact 在回放时刻是否成立(active 恒成立;superseded 看区间)。archived/disputed 不含。 */
+function factValidAtAsOf(f, asOf) {
+    if (f.status === 'active')
+        return true;
+    if (f.status === 'superseded')
+        return coversInterval(f.validFrom, f.validTo, asOf);
+    return false;
+}
 /** 节点新度序(updatedAt 新→旧,同值按 id 升序——与检索结果排序同式)。 */
 function byNodeRecency(a, b) {
     return a.updatedAt < b.updatedAt ? 1 : a.updatedAt > b.updatedAt ? -1 : a.id < b.id ? -1 : 1;
@@ -90,7 +106,8 @@ function byNodeRecency(a, b) {
  * 见文件头演进阶梯)。族过滤不在本函数:邻居节点可跨族,兜底在 graphLane 尾部的
  * 记录级 family/scope 双闸(宁可漏不可串落在记录上)。
  */
-export function expandHitRecordIds(hits, nodes, edges) {
+export function expandHitRecordIds(hits, nodes, edges, opts) {
+    const asOf = typeof opts?.asOf === 'string' && opts.asOf.length > 0 ? opts.asOf : undefined;
     const seen = new Set();
     const out = [];
     const take = (id) => {
@@ -99,12 +116,13 @@ export function expandHitRecordIds(hits, nodes, edges) {
         seen.add(id);
         out.push(id);
     };
-    // 直连段(节点身份来源在前,active facts 在后)
+    // 直连段(节点身份来源在前,有效 facts 在后;task_5.2:asOf 下额外纳入当时成立的 superseded fact)
     for (const h of hits) {
         for (const id of h.node.sourceRecordIds)
             take(id);
         for (const f of h.node.facts) {
-            if (f.status !== 'active')
+            const ok = asOf === undefined ? f.status === 'active' : factValidAtAsOf(f, asOf);
+            if (!ok)
                 continue;
             for (const id of f.sourceRecordIds ?? [])
                 take(id);
@@ -112,13 +130,17 @@ export function expandHitRecordIds(hits, nodes, edges) {
     }
     if (edges.length === 0)
         return out;
-    // hop 段:active 边的双向邻居 ∉ 命中集,邻居去重,状态需 active|disputed
+    // hop 段:可用边的双向邻居 ∉ 命中集,邻居去重,状态需 active|disputed
+    // (task_5.2:asOf 下"当时成立"的 superseded 边也可回链,邻居同理含当时成立的 superseded 节点)
     const hitNodeIds = new Set(hits.map((h) => h.node.id));
     const nodeById = new Map(nodes.map((n) => [n.id, n]));
+    const edgeUsable = (e) => e.status === 'active' || (asOf !== undefined && e.status === 'superseded' && coversInterval(e.validFrom, e.validTo, asOf));
+    const neighborUsable = (n) => n.status === 'active' || n.status === 'disputed'
+        || (asOf !== undefined && n.status === 'superseded' && coversInterval(n.createdAt, n.updatedAt, asOf));
     const seenNeighbor = new Set();
     const neighbors = [];
     for (const e of edges) {
-        if (e.status !== 'active')
+        if (!edgeUsable(e))
             continue;
         const dirs = [
             [e.fromNodeId, e.toNodeId],
@@ -128,7 +150,7 @@ export function expandHitRecordIds(hits, nodes, edges) {
             if (!hitNodeIds.has(self) || hitNodeIds.has(other) || seenNeighbor.has(other))
                 continue;
             const n = nodeById.get(other);
-            if (!n || (n.status !== 'active' && n.status !== 'disputed'))
+            if (!n || !neighborUsable(n))
                 continue;
             seenNeighbor.add(other);
             neighbors.push(n);
@@ -161,15 +183,18 @@ export function graphHitRecordIds(hits) {
  * 图谱节点检索:返回按 score 降序的命中(最多 limit 条;limit 钳制 1~20)。
  * 候选节点 = active | disputed(superseded/archived 不进检索)。
  */
-export function searchGraphNodes(nodes, edges, query, limit) {
+export function searchGraphNodes(nodes, edges, query, limit, opts) {
+    const asOf = typeof opts?.asOf === 'string' && opts.asOf.length > 0 ? opts.asOf : undefined;
     const tokens = [...new Set(tokenize(query))];
     const cappedLimit = Math.min(Math.max(Math.floor(limit) || 5, 1), GRAPH_SEARCH_LIMIT_MAX);
     if (tokens.length === 0)
         return [];
-    // nodeId → active 关系词 token 集(先建邻接表,防逐节点全量扫边)
+    // nodeId → 可用关系词 token 集(先建邻接表,防逐节点全量扫边;
+    // task_5.1:asOf 下纳入"当时成立"的 superseded 边)
     const relationTokensByNode = new Map();
     for (const edge of edges) {
-        if (edge.status !== 'active')
+        if (edge.status !== 'active'
+            && !(asOf !== undefined && edge.status === 'superseded' && coversInterval(edge.validFrom, edge.validTo, asOf)))
             continue;
         let set = relationTokensByNode.get(edge.fromNodeId);
         if (!set) {
@@ -188,6 +213,9 @@ export function searchGraphNodes(nodes, edges, query, limit) {
     }
     const results = [];
     for (const node of nodes) {
+        // 候选状态闸保持 active|disputed:task_5.1 的放宽面在 **fact/边**("纳入 superseded 且
+        // 区间覆盖 T 的 fact/edge")——GraphNode 没有 valid 区间列,节点主体复活无判据；
+        // 历史实体经"当时成立边"的邻居回链(task_5.2)重新可达,不需要翻状态。
         if (node.status !== 'active' && node.status !== 'disputed')
             continue;
         const fieldTokens = {
@@ -196,7 +224,7 @@ export function searchGraphNodes(nodes, edges, query, limit) {
             tags: new Set((node.tags ?? []).flatMap((t) => tokenize(t))),
             currentState: new Set(tokenize(node.currentState)),
             facts: new Set(node.facts
-                .filter((f) => f.status === 'active')
+                .filter((f) => (asOf === undefined ? f.status === 'active' : factValidAtAsOf(f, asOf)))
                 .flatMap((f) => tokenize(`${f.key} ${factValueText(f.value)}`))),
             relations: relationTokensByNode.get(node.id) ?? new Set(),
             type: new Set(tokenize(node.type)),

package/dist/hooks/recall.js

@@ -1,6 +1,7 @@
 import { createUserMessage } from '@deepseek-ai/dsh-llm';
 import { createHash } from 'node:crypto';
 import { trace } from '../store/trace.js';
+import { filterInjectCandidates } from '../store/validity.js';
 import { RecallDedupeStore } from '../store/recall-dedupe.js';
 import { OccupancyStore } from '../store/occupancy.js';
 import { expirePendingInjections, registerPendingInjection, setInjectionMarker, } from './recall-ack.js';
@@ -459,6 +460,29 @@ usage) {
                         scoped = kept;
                     }
                 }
+                // ── 门2 被动注入硬当前态(expiry-tiering task_3.3/3.4,灰度闸**默认关**):
+                // 开时按 classifyValidity 现算态剔除 `expired`(仍在索引可检,只是不再自动
+                // 浮现进模型上下文);`expired_suspect` 保留并在注入行带"疑似失效"标注;
+                // superseded/retired 由门1 索引层结构性进不到候选(不在本层重复过滤)。
+                // 判据单源 `stateOfRecord`,本层不再写一份 valid_to/marker 比较(计划 §4 约束)。
+                // 关时不进分支零 getByIds——注入逐字与改前一致(零漂移)。
+                let suspectIds = new Set();
+                const tieringOn = cfg.validity?.tieringEnabled === true || live.get().validityTiering === true;
+                if (tieringOn && scoped.length > 0) {
+                    const nowV = Date.now();
+                    const byIdV = new Map(stores.l1.getByIds(scoped.map((h) => h.id)).map((r) => [r.id, r]));
+                    // 主体收敛在 validity.filterInjectCandidates(纯函数可单测,task_3.6)——
+                    // 这里只做数据装配与日志,不内联第二份判据。
+                    const filtered = filterInjectCandidates(scoped, (id) => byIdV.get(id), nowV);
+                    suspectIds = filtered.suspectIds;
+                    if (filtered.exited > 0) {
+                        logger.warn(`[memory] 门2 防御性拦截退场态候选 ${filtered.exited} 条(门1 应已挡住,出现即泄漏信号)`);
+                    }
+                    if (filtered.kept.length !== scoped.length) {
+                        logger.info(`[memory] 门2 时效过滤:剔除 expired ${scoped.length - filtered.kept.length - filtered.exited} 条(agent=${payload.agent.id})`);
+                    }
+                    scoped = filtered.kept;
+                }
                 // 召回去重:同会话已注入过的记录不再重复注入(模型上下文已持有,省 token)。
                 // 纯过滤——剩几条注几条,全量压制(0 条新鲜命中)是正确状态而非未命中。
                 // §E:压缩后增强轮跳过压制(压缩把已注入内容逐出了模型上下文)。
@@ -485,7 +509,10 @@ usage) {
                     usage?.recordAttempt(scoped.map((h) => h.id), []);
                     return decision;
                 }
-                const lines = applyRecallBudget(fresh.map((h) => `- [${h.scene_name ? `${h.type}|${h.scene_name}` : h.type}] ${h.content}`), { maxCharsPerMemory: cfg.recall.maxCharsPerMemory, maxTotalRecallChars: cfg.recall.maxTotalRecallChars });
+                const lines = applyRecallBudget(fresh.map((h) => `- [${h.scene_name ? `${h.type}|${h.scene_name}` : h.type}] ${h.content}` +
+                    // 门2 task_3.4:疑而不隐——valid_to 来源不可信的行保留注入但带标注,
+                    // 人/模型自行裁量。灰度关时 suspectIds 恒空,行形状逐字不变。
+                    (suspectIds.has(h.id) ? '（疑似失效:有效期来源不可信）' : '')), { maxCharsPerMemory: cfg.recall.maxCharsPerMemory, maxTotalRecallChars: cfg.recall.maxTotalRecallChars });
                 if (lines.length === 0) {
                     // §F 追踪:预算清零轮(截断后无完整行)
                     trace({

package/dist/index.js

@@ -34,6 +34,7 @@ import { SceneStore } from './store/scenes.js';
 import { SessionModeStore } from './store/session-modes.js';
 import { StateStore } from './store/state.js';
 import { SlotStore } from './store/slots.js';
+import { RouteHealthStore, routeHealthPathFor } from './store/route-health.js';
 import { registerMemoryTools } from './tools/index.js';
 import { registerSlotTools } from './tools/slots.js';
 import { registerSlotRecall } from './hooks/slot-recall.js';
@@ -207,6 +208,7 @@ export async function apply(ctx, config) {
     };
     const stores = {
         usage: undefined, // 装配于下方(依赖 dataDir 就绪)
+        routeHealth: undefined, // R9 路由健康学习，装配于下方
         // DRSC 客户端(T8.4 读切):蒸馏背景窗 + conversation_search 工具面的历史供给。
         // 硬依赖无本地回退(l0 表退役);trustedHosts 惰性读取(webStartup 可能晚到)。
         drsc: new DrscClient({ trustedHosts: () => readStartupTrustedHosts(ctx) }),
@@ -399,6 +401,8 @@ export async function apply(ctx, config) {
     runner.startIdleTimer();
     // 图谱周期补投影(cfg.graph.enabled 门控;30 分钟一次低速收敛)
     runner.startGraphBackfillTimer();
+    // 时效标注存量回填(expiry-tiering task_6.3:tieringEnabled 门控,低频、让位蒸馏)
+    runner.startValidityBackfillTimer();
     // 重建控制器(存储降级时不建——RPC 端点走 supported=false 分支)
     const rebuild = storageOk && !db.isDegraded()
         ? new RebuildController(ctx, config, stores, db, runner, logger, live)
@@ -432,6 +436,10 @@ export async function apply(ctx, config) {
     const recallUsage = new RecallUsageStore(dataDir, logger);
     await recallUsage.init();
     stores.usage = recallUsage;
+    // R9 路由健康学习：跨进程留存"退避后跑通的最小块长"，供 runExtraction 收紧 perChunk。
+    const routeHealth = new RouteHealthStore(routeHealthPathFor(dataDir));
+    await routeHealth.load();
+    stores.routeHealth = routeHealth;
     // 召回相关度反馈（人在召回卡上打 -1..5）与「已声明过时」待播报队列。
     // 两个都是低频用户动作 → 立即落盘；sidecar 缺席/损坏只降级为只读，不阻断任何读路径。
     const recallFeedback = new RecallFeedbackStore(dataDir, logger);
@@ -468,7 +476,12 @@ export async function apply(ctx, config) {
     stores.l1.setFileSyncHook(fileSync);
     const recall = registerRecall(ctx, config, stores, logger, live, modes, dataDir, recallUsage);
     runner.setAfterRun(recall.invalidateProfile);
-    const toolSeals = registerMemoryTools(ctx, config, stores, logger, modes, live, ruminate, storageOk ? roomRegistry : undefined);
+    const toolSeals = registerMemoryTools(ctx, config, stores, logger, modes, live, ruminate, storageOk ? roomRegistry : undefined, {
+        // 确定性写面钩子(graph-write-plane R2/R3):runner 公开方法直连,工具三路径与
+        // distill 分支共用同一个入队实现,不存在第二套优先级/去重逻辑。
+        enqueueGraph: (ids) => runner.enqueueGraphFor(ids),
+        reprojectGraph: (ids) => runner.reprojectGraph(ids),
+    });
     // 激活槽位(active slot):工具面 + 常驻注入 + 服务端投影(均走 ctx.effect,可撤销)
     registerSlotTools(ctx, config, stores.slots, logger, modes, live, stores.l1);
     const slotRecall = registerSlotRecall(ctx, config, stores.slots, logger, live);

package/dist/llm.d.ts

@@ -71,11 +71,25 @@ export declare const HIGH_EFFORT_TIERS: readonly ["high", "xhigh", "max"];
  * 预算致正文 0 字符)——effort 为 high/xhigh/max 时分层预算 ×4。
  */
 export declare function layerMaxTokens(base: number, reasoningEffort: string): number;
+/** 无可用蒸馏路由(显式一线/二线/链皆缺且 requireExplicitRoute=true)：
+ *  runner 据此 skip+顺延、不记退避——区别于"模型慢/超时"(那才退避)。R4。 */
+export declare class NoDistillRouteError extends Error {
+    constructor(msg?: string);
+}
 /** 解析蒸馏用的 provider/model:配置优先,其次当前默认选择。 */
 export declare function resolveModelRoute(ctx: Context, cfg: MemoryConfig): Promise<{
     provider: string;
     model: string;
 }>;
+/**
+ * 二线(大容量兜底)选路(R3)：单次调用输入字符 ≥ triggerChars 且二线已配 → 返回二线路由，
+ * 否则 null（走一线/链）。二线未配（provider/model 任一空）→ 永不命中，不隐式改选任意模型。
+ */
+export declare function pickSecondary(cfg: MemoryConfig, inputChars: number): {
+    provider: string;
+    model: string;
+    reasoningEffort?: string;
+} | null;
 /** 回退链条目(配置形态;reasoningEffort 为该路由的档位覆盖,'' = 跟随全局)。 */
 export interface FallbackRouteEntry {
     provider: string;
@@ -156,7 +170,12 @@ export declare function planDistillEffort(ctx: Context, provider: string, model:
  * 适配器异常地没有发 block-end 时兜底。两者都累计会把输出翻倍。
  */
 export declare function callLLM(ctx: Context, cfg: MemoryConfig, opts: LlmCallOptions): Promise<string>;
-/** 带诊断日志的 parseJson:解析失败时记录原始输出摘录(模型输出异常排查的关键信息)。 */
+/** 带诊断日志的 parseJson:解析失败时记录原始输出摘录(模型输出异常排查的关键信息);修复/救援命中时 warn 一行。 */
 export declare function parseJsonLogged<T>(raw: string, what: string, logger?: MemoryLogger): T;
-/** 容错地解析 LLM 输出的 JSON(剥掉可能的 ```json 围栏)。 */
+/**
+ * 容错地解析 LLM 输出的 JSON。
+ *
+ * 旧版行为：剥 ```json``` 围栏 + 切到首个 `[`/`{` 到末尾 `]`/`}`,一次 JSON.parse。
+ * 新版同路径 + 三级容错(strict → repaired → salvaged),内部实现见 util/json-repair.ts。
+ */
 export declare function parseJson<T>(raw: string): T;