dsh-prime-memory 0.26.5-beta.0 → 0.26.6

package/dist/llm.js

@@ -1,5 +1,6 @@
 import { createUserMessage, ReasoningEffortId } from '@deepseek-ai/dsh-llm';
 import { errDetail } from './util/filelog.js';
+import { parseJsonTolerant } from './util/json-repair.js';
 import { recordDistillCall } from './llm-usage.js';
 import { recordCostCall } from './token-cost.js';
 // ── 分层输出预算(规格 C 节):结构化蒸馏用不到总闸级预算,逐层设护栏;
@@ -499,35 +500,26 @@ async function callRoute(ctx, cfg, opts, route) {
     opts.logger?.info(`[memory] LLM 调用 ${provider}/${model}:输入 ${user.length} 字符 → 输出 ${out.length} 字符(${((Date.now() - startedAt) / 1000).toFixed(1)}s,finish=${finishKind || '无'})`);
     return out;
 }
-/** 带诊断日志的 parseJson:解析失败时记录原始输出摘录(模型输出异常排查的关键信息)。 */
+/** 带诊断日志的 parseJson:解析失败时记录原始输出摘录(模型输出异常排查的关键信息);修复/救援命中时 warn 一行。 */
 export function parseJsonLogged(raw, what, logger) {
     try {
-        return parseJson(raw);
+        const { value, level, notes } = parseJsonTolerant(raw);
+        if (level !== 'strict') {
+            logger?.warn(`[memory] ${what} JSON 已容错处理(${level}: ${notes.join('、') || '无动作'}),原文 ${raw.length} 字符`);
+        }
+        return value;
     }
     catch (err) {
         logger?.error(`[memory] ${what} JSON 解析失败(${errDetail(err)}),原始输出前 400 字符: ${raw.slice(0, 400)}`);
         throw new Error(`${what} 输出无法解析为 JSON`);
     }
 }
-/** 容错地解析 LLM 输出的 JSON(剥掉可能的 ```json 围栏)。 */
+/**
+ * 容错地解析 LLM 输出的 JSON。
+ *
+ * 旧版行为：剥 ```json``` 围栏 + 切到首个 `[`/`{` 到末尾 `]`/`}`,一次 JSON.parse。
+ * 新版同路径 + 三级容错(strict → repaired → salvaged),内部实现见 util/json-repair.ts。
+ */
 export function parseJson(raw) {
-    let s = raw.trim();
-    if (s.startsWith('```')) {
-        s = s.replace(/^```[a-zA-Z]*\n?/, '').replace(/```$/, '').trim();
-    }
-    const start = s.indexOf('[');
-    const brace = s.indexOf('{');
-    let begin;
-    if (start === -1)
-        begin = brace;
-    else if (brace === -1)
-        begin = start;
-    else
-        begin = Math.min(start, brace);
-    if (begin > 0)
-        s = s.slice(begin);
-    const end = s.lastIndexOf(']') > s.lastIndexOf('}') ? s.lastIndexOf(']') + 1 : s.lastIndexOf('}') + 1;
-    if (end > 0)
-        s = s.slice(0, end);
-    return JSON.parse(s);
+    return parseJsonTolerant(raw).value;
 }

package/dist/pipeline/graph.d.ts

@@ -25,11 +25,36 @@ export declare const GRAPH_CONTEXT_EDGE_LIMIT = 120;
 export declare function selectContextNodes(records: readonly MemoryRecord[], nodes: readonly GraphNode[], limit?: number): GraphNode[];
 /** 选择进入上下文的边:两端都入选节点的 active 边,按更新时间新→旧,≤120。 */
 export declare function selectContextEdges(nodes: readonly GraphNode[], edges: readonly GraphEdge[], limit?: number): GraphEdge[];
+/**
+ * 瞬态失败判据(与永久错误分流,由 GraphStore.fail 选不同重试封顶)。
+ *
+ * 真机归因(2026-10-20 审计):14 个 dead 全是 `llm aborted: Request was aborted` ×13 +
+ * `llm error: terminated` ×1——零校验类失败,全部是网关负载/超时把在飞请求掉断。
+ * 这类错误与 prompt/数据无关,退避后重试即可恢复,不该和“模型真的产坏了”同封顶。
+ * 匹配串源自 callLLM/callRoute/callDirect 的实际抛出形态(小写子串包含)。
+ */
+export declare function isTransientGraphFailure(msg: string): boolean;
+/**
+ * 节点向量化的嵌入文本(单一形态定义,读写两侧共用):
+ * 实体名 + 别名 + 当前状态串。读侧种子查询用用户 query 的文本向量,
+ * 两边同嵌入源同空间即可——不追求"同一句话",追求"同一语义面"。
+ */
+export declare function nodeEmbedText(node: GraphNode): string;
+/**
+ * 投影收尾的节点向量补写(G-vec 缺陷修:此前 upsertNodeVectors 生产零调用点,
+ * 嵌入开着时 graph_node_vec 永远是 0 行,"向量种子"读路结构性空转)。
+ *
+ * 失败隔离:嵌入失败/未就绪只 warn——向量是召回增益,缺了它图谱词法路照常,
+ * 绝不能把一个旁路补算弄挂投影主流程(与 L1 侧 restore 的向量纪律同向)。
+ */
+export declare function writeNodeVectorsAfterComplete(graphs: GraphStore, touched: readonly GraphNode[], embed: ((text: string) => Promise<Float32Array | undefined>) | undefined, logger: MemoryLogger): Promise<number>;
 /**
  * 执行一次图谱投影(claim 一个 job → LLM → 校验落库;无 job 时静默返回)。
  * 返回是否实际认领了任务(泵据此决定是否续排)。失败转 fail(退避/封顶由
  * GraphStore 管),不向 runner 上抛。
  */
-export declare function runGraphProjection(ctx: Context, cfg: MemoryConfig, graphs: GraphStore, logger: MemoryLogger): Promise<boolean>;
+export declare function runGraphProjection(ctx: Context, cfg: MemoryConfig, graphs: GraphStore, logger: MemoryLogger, 
+/** 节点向量补算的嵌入缝(runner 接 stores.l1.embedText;缺席/未就绪 = 不补)。 */
+embedNode?: (text: string) => Promise<Float32Array | undefined>): Promise<boolean>;
 /** 投影输出解析与形状归一:非对象/缺数组字段回空结构(校验侧再逐条把关)。 */
 export declare function parseProjection(raw: string, logger?: MemoryLogger): GraphProjectionResult;

package/dist/pipeline/graph.js

@@ -2,6 +2,7 @@ import { callLLM, parseJsonLogged, resolveLayerTokens } from '../llm.js';
 import { buildGraphProjectionPrompt, getGraphProjectionSystemPrompt, } from '../prompts/graph-projection.js';
 import { normalizeEntityName } from '../graph/apply.js';
 import { tokenize } from '../util/text.js';
+import { GRAPH_PROJECTION_CALL_TIMEOUT_MS } from '../graph/types.js';
 import { errDetail } from '../util/filelog.js';
 /** claim 上下文装配的节点上限(词法相关 + 最近更新,总量封顶)。 */
 export const GRAPH_CONTEXT_NODE_LIMIT = 80;
@@ -64,12 +65,73 @@ export function selectContextEdges(nodes, edges, limit = GRAPH_CONTEXT_EDGE_LIMI
         .sort((a, b) => (a.updatedAt < b.updatedAt ? 1 : a.updatedAt > b.updatedAt ? -1 : 0))
         .slice(0, limit);
 }
+/**
+ * 瞬态失败判据(与永久错误分流,由 GraphStore.fail 选不同重试封顶)。
+ *
+ * 真机归因(2026-10-20 审计):14 个 dead 全是 `llm aborted: Request was aborted` ×13 +
+ * `llm error: terminated` ×1——零校验类失败,全部是网关负载/超时把在飞请求掉断。
+ * 这类错误与 prompt/数据无关,退避后重试即可恢复,不该和“模型真的产坏了”同封顶。
+ * 匹配串源自 callLLM/callRoute/callDirect 的实际抛出形态(小写子串包含)。
+ */
+export function isTransientGraphFailure(msg) {
+    const low = msg.toLowerCase();
+    return (low.includes('aborted') ||
+        low.includes('timeout') ||
+        low.includes('timed out') ||
+        low.includes('terminated') ||
+        low.includes('empty output') ||
+        low.includes('econn') ||
+        low.includes('etimedout') ||
+        low.includes('fetch failed') ||
+        low.includes('socket hang') ||
+        low.includes('network'));
+}
+/**
+ * 节点向量化的嵌入文本(单一形态定义,读写两侧共用):
+ * 实体名 + 别名 + 当前状态串。读侧种子查询用用户 query 的文本向量,
+ * 两边同嵌入源同空间即可——不追求"同一句话",追求"同一语义面"。
+ */
+export function nodeEmbedText(node) {
+    return [node.name, ...node.aliases, node.currentState].filter((s) => s && s.trim()).join(' ');
+}
+/**
+ * 投影收尾的节点向量补写(G-vec 缺陷修:此前 upsertNodeVectors 生产零调用点,
+ * 嵌入开着时 graph_node_vec 永远是 0 行,"向量种子"读路结构性空转)。
+ *
+ * 失败隔离:嵌入失败/未就绪只 warn——向量是召回增益,缺了它图谱词法路照常,
+ * 绝不能把一个旁路补算弄挂投影主流程(与 L1 侧 restore 的向量纪律同向)。
+ */
+export async function writeNodeVectorsAfterComplete(graphs, touched, embed, logger) {
+    if (!graphs.nodeVecReady || !embed || touched.length === 0)
+        return 0;
+    const rows = [];
+    for (const n of touched) {
+        if (n.status !== 'active' && n.status !== 'disputed')
+            continue;
+        try {
+            const v = await embed(nodeEmbedText(n));
+            if (v && v.length > 0)
+                rows.push({ nodeId: n.id, embedding: v, updatedAt: n.updatedAt });
+        }
+        catch (err) {
+            logger.warn(`[memory] 节点向量计算失败(该节点跳过,词法路不受影响): ${err instanceof Error ? err.message : String(err)}`);
+        }
+    }
+    if (rows.length === 0)
+        return 0;
+    const written = graphs.upsertNodeVectors(rows);
+    if (written > 0)
+        logger.debug?.(`[memory] 节点向量随投影写入 ${written} 条`);
+    return written;
+}
 /**
  * 执行一次图谱投影(claim 一个 job → LLM → 校验落库;无 job 时静默返回)。
  * 返回是否实际认领了任务(泵据此决定是否续排)。失败转 fail(退避/封顶由
  * GraphStore 管),不向 runner 上抛。
  */
-export async function runGraphProjection(ctx, cfg, graphs, logger) {
+export async function runGraphProjection(ctx, cfg, graphs, logger, 
+/** 节点向量补算的嵌入缝(runner 接 stores.l1.embedText;缺席/未就绪 = 不补)。 */
+embedNode) {
     const claim = graphs.claimNext();
     if (!claim)
         return false;
@@ -84,12 +146,20 @@ export async function runGraphProjection(ctx, cfg, graphs, logger) {
             maxTokens: resolveLayerTokens(cfg, 'graph'),
             layer: 'graph',
             logger,
+            // 自带宽超时信号:不传则沿用 cfg.llm.timeoutMs(120s)——图谱批 prompt 在本地网关上
+            // 实测 ~2min/job,正好撞线(14 dead 根因);照 backfill callTimeoutMs 先例给 240s。
+            signal: AbortSignal.timeout(GRAPH_PROJECTION_CALL_TIMEOUT_MS),
         });
-        graphs.complete(job.id, parseProjection(raw, logger), { now: new Date().toISOString() });
+        const touched = graphs.complete(job.id, parseProjection(raw, logger), { now: new Date().toISOString() });
+        // 投影落库后的向量收尾(G-vec 缺陷修):事务外做——嵌入是网络/推理调用,
+        // LLM 与嵌入永不进事务缝是本文件头注释写死的既有纪律。
+        await writeNodeVectorsAfterComplete(graphs, touched, embedNode, logger);
     }
     catch (err) {
-        logger.warn(`[memory] 图谱投影失败(job=${job.id},attempts=${job.attempts}): ${errDetail(err)}`);
-        graphs.fail(job.id, errDetail(err));
+        const detail = errDetail(err);
+        logger.warn(`[memory] 图谱投影失败(job=${job.id},attempts=${job.attempts}): ${detail}`);
+        // 瞬态(网关掉断/超时/空输出)与永久(校验/解析)分档——前者多给 3 次退避重试机会。
+        graphs.fail(job.id, detail, { transient: isTransientGraphFailure(detail) });
     }
     return true;
 }

package/dist/pipeline/l1.js

@@ -16,9 +16,29 @@ import { normTags, normUsageScenario, readCognitiveHall, readWing } from '../met
 import { acceptTitle } from '../util/md-name.js';
 import { formatBatchConflictPrompt, getConflictDetectionSystemPrompt } from '../prompts/l1-dedup.js';
 import { resolveSourceAnchors, withSourceAnchors } from './anchors.js';
+import { stampValidity, validToSourceOf } from '../store/validity.js';
 import { familyForType, normPersistence, normScope, resolveRecordFamily, resolveRecordScope, WING_FALLBACK } from '../types.js';
 import { normApplicability, resolveRepoScope } from '../repo-scope.js';
 import { routeWorkspace } from '../workspace-route.js';
+/**
+ * L1 抽取单块字符硬顶(修复 #10 分批过大)
+ *
+ * `cfg.llm.maxInputChars` 的语义是「单次 LLM 调用输入闸门」(默认 700k),被复用为
+ * 分块预算时算出 658k/块——一次输出须在同一 JSON 数组写完全部抽出记忆,块越大字符串越多,
+ * 任一处长中文里未转义 ASCII `"` 即整批 parse 失败、该块记忆全丢;慢模型更直接撞 120s 超时。
+ * 砍到 24k 后输出 ≈2–4k tokens,仍远低于 LAYER_MAX_TOKENS_EXTRACT(16k),不会引入截断,
+ * 单块失败半径从「几百条」缩到「几十条」。代价是多几次小调用,但每次 5–15s 完成。
+ */
+const MAX_EXTRACT_CHUNK_CHARS = 24_000;
+/**
+ * L1 去重单批发起上限(与抽取同精神)
+ *
+ * 旧版一次将整批 extracted[] 丢给 formatBatchConflictPrompt 发单次 LLM 调用,候选召回默认
+ * 每新记忆 10 个 → batch=100 时 prompt 轻松上 500k 字符,同样命中 #10 的失败面。按
+ * 固定条数切块(同族内不跨子集),失败半径缩到 ≤20 条,且每块上下文仍足够。
+ * 上限 20 为工程默认,后续可提到配置。
+ */
+const MAX_DEDUP_BATCH_SIZE = 20;
 /** 解析 ISO/epoch 时间证据,非法或非正值一律 undefined——不猜测。 */
 function parseTimeEvidence(raw) {
     const t = typeof raw === 'string' ? Date.parse(raw) : typeof raw === 'number' ? raw : Number.NaN;
@@ -29,28 +49,39 @@ function parseTimeEvidence(raw) {
  *
  * `activity_start_time`/`activity_end_time` 是这两列的前身(prompt 已在产出),
  * 这里把它们提升为结构化字段;`persistence` 由 prompt 产出,缺省即未判定。
+ * valid_to 源自 activity_* 证据链 → `validToSource='evidence'`(task_2.5 打标)。
  */
 function temporalOf(meta) {
+    const validTo = parseTimeEvidence(meta?.activity_end_time);
     return {
         validFrom: parseTimeEvidence(meta?.activity_start_time),
-        validTo: parseTimeEvidence(meta?.activity_end_time),
+        validTo,
         persistence: normPersistence(meta?.persistence),
+        ...(validTo !== undefined ? { validToSource: 'evidence' } : {}),
     };
 }
 /**
  * 合并(merge/update)时的有效期并集:
  * 起 = 两侧最早;止 = 任一侧未闭合则仍未闭合(undefined),否则取最晚。
  * 持续性以新记忆为准(合并产物描述的是当前认知),新记忆未判定时继承旧记录。
+ * validToSource 随**胜出值**的来源走(task_2.5):最终 valid_to 取自哪一侧,
+ * 证据等级就读哪一侧的(旧行取其 `dsh_validity` 标注,未标注算 'unknown'——
+ * 宁判疑不判死,fail-open 与 classify 同向)。
  */
 function mergeTemporal(self, targets) {
     const froms = [self.validFrom, ...targets.map((r) => r.validFrom)].filter((t) => t !== undefined);
-    const tos = [self.validTo, ...targets.map((r) => r.validTo)];
-    const anyOpen = tos.some((t) => t === undefined);
-    const closed = tos.filter((t) => t !== undefined);
+    const tos = [
+        { v: self.validTo, s: self.validToSource ?? 'unknown' },
+        ...targets.map((r) => ({ v: r.validTo, s: validToSourceOf(r.metadata) })),
+    ];
+    const anyOpen = tos.some((e) => e.v === undefined);
+    const closed = tos.filter((e) => e.v !== undefined);
+    const winner = closed.length > 0 ? closed.reduce((a, b) => (b.v > a.v ? b : a)) : undefined;
     return {
         validFrom: froms.length > 0 ? Math.min(...froms) : undefined,
-        validTo: anyOpen || closed.length === 0 ? undefined : Math.max(...closed),
+        validTo: anyOpen || winner === undefined ? undefined : winner.v,
         persistence: self.persistence ?? targets.find((r) => r.persistence)?.persistence,
+        ...(!anyOpen && winner !== undefined ? { validToSource: winner.s } : {}),
     };
 }
 /**
@@ -152,7 +183,10 @@ export function toStoreRecord(m, now, ts, anchorMap) {
     // 过不了就**不写键**，交给 `L1Store.assignMissingNames`——判据只留一份，
     // 不在这里养第二套“看起来差不多”的名字清洗。
     const titled = m.title === undefined ? undefined : acceptTitle(m.title);
-    return {
+    // 时间轴派生单独算：validToSource 不进记录形状(它不是 MemoryRecord 字段，随展开
+    // 落库会改 JSONL 形状)，只喂给 stampValidity 盖进 dsh_validity(task_2.5/3.2 写侧标注)。
+    const t = temporalOf(m.metadata);
+    const rec = {
         id: m.record_id,
         content: m.content,
         type: m.type,
@@ -179,8 +213,13 @@ export function toStoreRecord(m, now, ts, anchorMap) {
         // 文件身份键不在这里分：**起名只有一个真源**（`L1Store.assignMissingNames`）。
         // 以前这里自己分一份、库里再分一份，两套判据迟早漂移，而漂移的后果是同一个基底
         // 洗出两个名字（文件跳名）或两个记录抢一个名字（整条写不进去）。
-        ...temporalOf(m.metadata),
+        validFrom: t.validFrom,
+        validTo: t.validTo,
+        persistence: t.persistence,
     };
+    // 写侧标注(task_3.2 派生时机之一):管线盖时源头已知 evidence(LLM 直填/工具路径另算)。
+    stampValidity(rec, now, t.validToSource);
+    return rec;
 }
 function newId(prefix) {
     return `${prefix}_${Date.now()}_${randomBytes(3).toString('hex')}`;
@@ -274,7 +313,8 @@ mergeRekey) {
     // ── Step 1: 抽取(输入按 llm.maxInputChars 预算分块,情境链式衔接,不丢消息) ──
     const backgroundMsgs = background.slice(-cfg.extract.backgroundMessages);
     // 预留:背景消息(≤10 条 ×4000 字)+ prompt 脚手架
-    const perChunk = Math.max(20_000, cfg.llm.maxInputChars - 42_000);
+    // 硬顶 24k(见 MAX_EXTRACT_CHUNK_CHARS 注释);若配置更小则跟随配置
+    const perChunk = Math.min(MAX_EXTRACT_CHUNK_CHARS, Math.max(20_000, cfg.llm.maxInputChars - 42_000));
     const chunks = chunkByCharBudget(pending, perChunk);
     if (chunks.length > 1) {
         logger.info(`[memory] L1 输入超预算(${pending.length} 条消息),分 ${chunks.length} 块抽取(每块 ≤${perChunk} 字符)`);
@@ -367,19 +407,32 @@ mergeRekey) {
         newMemory: m,
         candidates: await store.searchCandidates(m.content, cfg.extract.candidatePool, m.family, wsFilter),
     })));
-    const dedupPrompt = formatBatchConflictPrompt(matches, {
-        conflictFreeze: cfg.conflictFreeze.enabled,
-    });
-    const dedupRaw = await callLLM(ctx, cfg, {
-        system: getConflictDetectionSystemPrompt(mode, { conflictFreeze: cfg.conflictFreeze.enabled, title: cfg.naming?.enabled === true }),
-        user: dedupPrompt,
-        maxTokens: resolveLayerTokens(cfg, 'dedup'),
-        layer: 'l1-dedup',
-        logger,
-    });
-    const decisions = parseJsonLogged(dedupRaw, 'L1 去重判定', logger);
+    // 按固定条数切块发送,失败半径与上下文同时可控(#10 去重侧同精)
+    const dedupBatches = [];
+    for (let i = 0; i < matches.length; i += MAX_DEDUP_BATCH_SIZE) {
+        dedupBatches.push(matches.slice(i, i + MAX_DEDUP_BATCH_SIZE));
+    }
+    if (dedupBatches.length > 1) {
+        logger.info(`[memory] L1 去重分为 ${dedupBatches.length} 批发送(每批 ≤${MAX_DEDUP_BATCH_SIZE} 条候选记忆)`);
+    }
+    const decisionsFlat = [];
+    for (const [bi, batch] of dedupBatches.entries()) {
+        const batchPrompt = formatBatchConflictPrompt(batch, {
+            conflictFreeze: cfg.conflictFreeze.enabled,
+        });
+        const batchRaw = await callLLM(ctx, cfg, {
+            system: getConflictDetectionSystemPrompt(mode, { conflictFreeze: cfg.conflictFreeze.enabled, title: cfg.naming?.enabled === true }),
+            user: batchPrompt,
+            maxTokens: resolveLayerTokens(cfg, 'dedup'),
+            layer: 'l1-dedup',
+            logger,
+        });
+        const batchDecisions = parseJsonLogged(batchRaw, `L1 去重判定${dedupBatches.length > 1 ? `(批 ${bi + 1}/${dedupBatches.length})` : ''}`, logger);
+        if (Array.isArray(batchDecisions))
+            decisionsFlat.push(...batchDecisions);
+    }
     const byRecord = new Map();
-    for (const d of Array.isArray(decisions) ? decisions : []) {
+    for (const d of decisionsFlat) {
         if (d && typeof d.record_id === 'string')
             byRecord.set(d.record_id, d);
     }
@@ -601,7 +654,10 @@ mergeRekey) {
         const mergedTitle = mergedName === undefined || mergedName.length === 0
             ? acceptTitle(decision.merged_title)
             : mergedName;
-        added.push({
+        // 合并的有效期取并集:起 = 两侧最早;止 = 任一侧未闭合则仍未闭合(undefined)。
+        // validToSource 随胜出侧走(task_2.5)，同样不进记录形状、只喂标注。
+        const mt = mergeTemporal(temporalOf(m.metadata), targets.map((id) => byId.get(id)).filter((r) => r !== undefined));
+        const mergedRec = {
             id: m.record_id,
             content: mergedContent,
             type: decision.merged_type || m.type,
@@ -628,14 +684,19 @@ mergeRekey) {
             repoKeyName: m.repoKeyName,
             repoKeyOwner: m.repoKeyOwner,
             applicability: m.applicability,
-            // 合并的有效期取并集:起 = 两侧最早;止 = 任一侧未闭合则仍未闭合(undefined)。
-            ...mergeTemporal(temporalOf(m.metadata), targets.map((id) => byId.get(id)).filter((r) => r !== undefined)),
-        });
+            validFrom: mt.validFrom,
+            validTo: mt.validTo,
+            persistence: mt.persistence,
+        };
+        // 写侧标注(task_3.2):merge 产物的证据链随胜出侧透传。
+        stampValidity(mergedRec, now, mt.validToSource);
+        added.push(mergedRec);
     }
     await store.appendNew(added);
     if (supersededBy.size > 0) {
-        // **软删**(取代):不是物理删除——主表行保留 + `valid_to` 闭合 + 取代标记,
-        // FTS/向量撤出检索面。于是"合并错了"也能恢复,而不必去 `records/*.jsonl` 手工捞。
+        // **软删**(取代):不是物理删除——主表行保留 + 取代标记(marker 单源，门1 解耦后
+        // 不再闭合 valid_to)，FTS/向量撤出检索面。于是"合并错了"也能恢复,而不必去
+        // `records/*.jsonl` 手工捞。
         // 按取代者分组落盘(一次事务一组),避免逐条开事务。
         const retiredAt = new Date(now).toISOString();
         const byNewRecord = new Map();

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/runner.d.ts

@@ -158,6 +158,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,6 @@
 import { resolveDataDir } from '../config.js';
 import { GRAPH_PRIORITY_NEW } from '../graph/types.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';
@@ -136,6 +137,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 +150,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 +160,7 @@ export function effectiveCfg(cfg, live) {
         ...(rdOverride ?? {}),
         ...(mdsOverride ?? {}),
         ...(mpOverride ?? {}),
+        ...(vtOverride ?? {}),
         ...(memExportOverride ?? {}),
         ...(backfillOverride ?? {}),
         llm: {
@@ -454,6 +461,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 +544,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();
@@ -572,11 +641,9 @@ export class MemoryRunner {
             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

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 {