dsh-prime-memory 0.26.5 → 0.26.9

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 节):结构化蒸馏用不到总闸级预算,逐层设护栏;
@@ -45,11 +46,28 @@ export const HIGH_EFFORT_TIERS = ['high', 'xhigh', 'max'];
 export function layerMaxTokens(base, reasoningEffort) {
     return HIGH_EFFORT_TIERS.includes(reasoningEffort) ? base * 4 : base;
 }
+/** 无可用蒸馏路由(显式一线/二线/链皆缺且 requireExplicitRoute=true)：
+ *  runner 据此 skip+顺延、不记退避——区别于"模型慢/超时"(那才退避)。R4。 */
+export class NoDistillRouteError extends Error {
+    constructor(msg = '无可用蒸馏路由:已开启 llm.requireExplicitRoute,但未显式配置一线/二线/回退链') {
+        super(msg);
+        this.name = 'NoDistillRouteError';
+    }
+}
 /** 解析蒸馏用的 provider/model:配置优先,其次当前默认选择。 */
 export async function resolveModelRoute(ctx, cfg) {
     if (cfg.llm.provider && cfg.llm.model) {
         return { provider: cfg.llm.provider, model: cfg.llm.model };
     }
+    // R4 fail-closed:开了 requireExplicitRoute 且二线/回退链都未配 → 不蹭宿主默认模型,
+    // 抛专用错误(runner 侧 skip+顺延、不记退避——"没配路由"≠"模型慢")。关时逐字走旧路径。
+    if (cfg.llm.requireExplicitRoute === true) {
+        const sec = cfg.llm.secondary;
+        const hasSecondary = !!(sec && sec.provider && sec.model);
+        const hasChain = (cfg.llm.fallbacks?.length ?? 0) > 0;
+        if (!hasSecondary && !hasChain)
+            throw new NoDistillRouteError();
+    }
     // agentDefaultModel 是可选服务,缺失时不得抛错。
     const defaults = ctx.get('agentDefaultModel');
     const sel = defaults?.currentSelection?.();
@@ -58,6 +76,19 @@ export async function resolveModelRoute(ctx, cfg) {
     }
     throw new Error('无法解析蒸馏模型路由:请在插件 config 中配置 llm.provider / llm.model,或确保存在默认模型选择');
 }
+/**
+ * 二线(大容量兜底)选路(R3)：单次调用输入字符 ≥ triggerChars 且二线已配 → 返回二线路由，
+ * 否则 null（走一线/链）。二线未配（provider/model 任一空）→ 永不命中，不隐式改选任意模型。
+ */
+export function pickSecondary(cfg, inputChars) {
+    const sec = cfg.llm.secondary;
+    if (!sec || !sec.provider || !sec.model)
+        return null;
+    const trigger = sec.triggerChars > 0 ? sec.triggerChars : Number.POSITIVE_INFINITY;
+    if (!(inputChars >= trigger))
+        return null;
+    return { provider: sec.provider, model: sec.model, ...(sec.reasoningEffort ? { reasoningEffort: sec.reasoningEffort } : {}) };
+}
 /**
  * 组装蒸馏路由链(纯决策,决策表缝):主路由在前、回退条目按配置顺序在后。
  * provider/model 缺失的条目剔除;与主路由或先前条目完全相同(provider+model)的
@@ -369,8 +400,17 @@ export async function callLLM(ctx, cfg, opts) {
     // 宿主路由链:opts.layer 配了层链的层走层链完整替换,其余走全局解析;
     // direct 模式下这一段充当付费/默认模型的兜底安全网。
     const routes = await resolveLayerRoutes(ctx, cfg, opts.layer);
-    for (let i = 0; i < routes.length; i++) {
-        const route = routes[i];
+    // R3 二线(大容量兜底)：输入 ≥ triggerChars 且二线已配 → 前置二线，让肥调用先走大容量档；
+    // 二线未配时 sec=null → 链逐字不变（零漂移）。已在链里的同路由去重。
+    const sec = pickSecondary(cfg, opts.user.length);
+    const chain = sec
+        ? [
+            { provider: sec.provider, model: sec.model, effort: sec.reasoningEffort ?? '' },
+            ...routes.filter((r) => !(r.provider === sec.provider && r.model === sec.model)),
+        ]
+        : routes;
+    for (let i = 0; i < chain.length; i++) {
+        const route = chain[i];
         try {
             return await callRoute(ctx, cfg, opts, route);
         }
@@ -380,7 +420,7 @@ export async function callLLM(ctx, cfg, opts) {
                 throw err;
             lastErr = err;
             warnRouteDeadOnce(route, opts.logger);
-            const next = routes[i + 1];
+            const next = chain[i + 1];
             if (next) {
                 opts.logger?.info(`[memory] 蒸馏路由降级 ${route.provider}/${route.model} → ${next.provider}/${next.model}(${errDetail(err)})`);
             }
@@ -499,35 +539,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

@@ -34,11 +34,27 @@ export declare function selectContextEdges(nodes: readonly GraphNode[], edges: r
  * 匹配串源自 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

@@ -86,12 +86,52 @@ export function isTransientGraphFailure(msg) {
         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;
@@ -110,7 +150,10 @@ export async function runGraphProjection(ctx, cfg, graphs, logger) {
             // 实测 ~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) {
         const detail = errDetail(err);

package/dist/pipeline/l1.d.ts

@@ -1,8 +1,15 @@
 import type { Context } from '@deepseek-ai/cordis';
 import type { MemoryConfig } from '../config.js';
+import type { RouteHealthStore } from '../store/route-health.js';
 import type { L1Store } from '../store/l1.js';
 import type { MemoryState } from '../store/state.js';
 import type { ConversationAnchor, ConversationMessage, ExtractedMemory, ExtractMode, MemoryFamily, MemoryLogger, MemoryRecord, MemoryScope } from '../types.js';
+/**
+ * L2 场景整合单块字符硬顶（R1）：与抽取同精神——旧版一次把整族 backlog 塞单调用，
+ * 库越大越必撞超时（实测 work-L2 >60s abort）。砍到 24k 后逐块整合，失败半径从
+ * “整族 backlog”缩到“一块”。默认对齐 MAX_EXTRACT_CHUNK_CHARS。
+ */
+export declare const MAX_SCENE_CHUNK_CHARS = 24000;
 export interface ExtractionResult {
     stored: number;
     skipped: boolean;
@@ -12,6 +19,8 @@ export interface ExtractionResult {
     runId?: string;
     /** §F 追踪捎带:六值决策词表聚合;早退分支缺省。 */
     byKind?: Record<string, number>;
+    /** R1′ 抽取块级失败的消息：调用方应留桶下轮重投(部分消费，不整批回滚)。 */
+    failedMessages?: ConversationMessage[];
 }
 /** 分族 checkpoint 桶(活引用,改动由调用方 save 落盘)。 */
 export type FamilyStates = Record<MemoryFamily, MemoryState>;
@@ -55,7 +64,9 @@ export declare function toStoreRecord(m: PendingMemory, now: number, ts: number,
  * 按字符预算把消息切成多块(保持顺序,单条超预算独占一块,由 callLLM 兜底截断)。
  * 每条消息按 content 长度 + 64 字符脚手架开销(id/时间戳行)计。
  */
-export declare function chunkByCharBudget(messages: ConversationMessage[], budgetChars: number): ConversationMessage[][];
+export declare function chunkByCharBudget<T extends {
+    content: string;
+}>(messages: readonly T[], budgetChars: number): T[][];
 export declare function runExtraction(ctx: Context, cfg: MemoryConfig, store: L1Store, states: FamilyStates, pending: ConversationMessage[], background: ConversationMessage[], logger: MemoryLogger, mode: ExtractMode, 
 /**
  * §E 当前工作区标识(由调用方经 `sessionWorkspaceIdOf` 解析;拿不到传 undefined)。
@@ -74,4 +85,6 @@ anchorMap?: ReadonlyMap<string, ConversationAnchor>,
  * 另两个 sidecar 里，而 merge 每次新铸 id——不搬就等于每次合并把这条记忆的
  * `used`/人工打分清零，它会被当成“没用过”而沉底。缺省不搬（行为与改动前一致）。
  */
-mergeRekey?: (oldId: string, newId: string) => void): Promise<ExtractionResult>;
+mergeRekey?: (oldId: string, newId: string) => void, 
+/** R9 路由健康学习（可选）：读已学到的跑通块长收紧 perChunk，成功块回记。未传=不启用。 */
+routeHealth?: RouteHealthStore): Promise<ExtractionResult>;

package/dist/pipeline/l1.js

@@ -8,7 +8,7 @@
  */
 import { randomBytes } from 'node:crypto';
 import { normWingEnabled } from '../config.js';
-import { callLLM, parseJsonLogged, resolveLayerTokens } from '../llm.js';
+import { callLLM, parseJsonLogged, resolveLayerTokens, resolveModelRoute } from '../llm.js';
 import { buildReceipts, newRunId, persistReceiptsSafely } from '../store/receipts.js';
 import { buildConflictPair, conflictRejectId, DEFER_MAX, normalizeClaimKey, normalizeConflictType, occupiesConflictQuota, pendingHardTotal, validateConflictPair, } from '../store/conflicts.js';
 import { formatExtractionPrompt, getExtractMemoriesSystemPrompt } from '../prompts/l1-extraction.js';
@@ -16,9 +16,35 @@ 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 调用输入闸门」(默认 200k),被复用为
+ * 分块预算时算出 658k/块——一次输出须在同一 JSON 数组写完全部抽出记忆,块越大字符串越多,
+ * 任一处长中文里未转义 ASCII `"` 即整批 parse 失败、该块记忆全丢;慢模型更直接撞 120s 超时。
+ * 砍到 24k 后输出 ≈2–4k tokens,仍远低于 LAYER_MAX_TOKENS_EXTRACT(16k),不会引入截断,
+ * 单块失败半径从「几百条」缩到「几十条」。代价是多几次小调用,但每次 5–15s 完成。
+ */
+const MAX_EXTRACT_CHUNK_CHARS = 24_000;
+/**
+ * L2 场景整合单块字符硬顶（R1）：与抽取同精神——旧版一次把整族 backlog 塞单调用，
+ * 库越大越必撞超时（实测 work-L2 >60s abort）。砍到 24k 后逐块整合，失败半径从
+ * “整族 backlog”缩到“一块”。默认对齐 MAX_EXTRACT_CHUNK_CHARS。
+ */
+export const MAX_SCENE_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 +55,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 +189,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 +219,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')}`;
@@ -227,7 +272,9 @@ anchorMap,
  * 另两个 sidecar 里，而 merge 每次新铸 id——不搬就等于每次合并把这条记忆的
  * `used`/人工打分清零，它会被当成“没用过”而沉底。缺省不搬（行为与改动前一致）。
  */
-mergeRekey) {
+mergeRekey, 
+/** R9 路由健康学习（可选）：读已学到的跑通块长收紧 perChunk，成功块回记。未传=不启用。 */
+routeHealth) {
     if (!cfg.extract.enabled)
         return { stored: 0, skipped: true, sceneName: chainHead(states, mode), newRecords: [] };
     // 触发阈值(渐进爬坡 + 按会话切片计数)由 runner 判定(trigger.ts);
@@ -274,12 +321,32 @@ 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 注释);若配置更小则跟随配置
+    let perChunk = Math.min(MAX_EXTRACT_CHUNK_CHARS, Math.max(20_000, cfg.llm.maxInputChars - 42_000));
+    // R5: 尊重模型真实输入上限（若声明），避免 700k 盲值撞本地模型硬限
+    if (cfg.llm.modelMaxInputChars && cfg.llm.modelMaxInputChars > 0) {
+        perChunk = Math.min(perChunk, Math.max(20_000, cfg.llm.modelMaxInputChars - 42_000));
+    }
+    // R9: 用该路由已学到的跑通块长再收紧 perChunk（best-effort；路由解析失败则跳过）
+    let rhKey;
+    if (routeHealth) {
+        try {
+            rhKey = await resolveModelRoute(ctx, cfg);
+            const lg = routeHealth.lastGoodChunkChars(rhKey.provider, rhKey.model);
+            if (lg > 0)
+                perChunk = Math.min(perChunk, Math.max(20_000, lg));
+        }
+        catch {
+            rhKey = undefined;
+        }
+    }
     const chunks = chunkByCharBudget(pending, perChunk);
     if (chunks.length > 1) {
         logger.info(`[memory] L1 输入超预算(${pending.length} 条消息),分 ${chunks.length} 块抽取(每块 ≤${perChunk} 字符)`);
     }
     const extracted = [];
+    // R1′ 抽取块级失败的消息(留桶下轮重投，实现部分消费)
+    const failedMessages = [];
     let lastScene = chainState.lastSceneName;
     let sceneCount = 0;
     // 治理归属(ADR-0015 T1.7/T1.9):repoKey=basename(归一 cwd),**进管线时一次算定**
@@ -290,30 +357,52 @@ mergeRekey) {
     const halls = mode === 'auto' && !hallCandidates.includes(WING_FALLBACK)
         ? [...hallCandidates, WING_FALLBACK]
         : hallCandidates;
+    const timeBudgetMs = cfg.llm.extractTimeBudgetMs ?? 0;
+    const extractStart = Date.now();
     for (const chunk of chunks) {
+        // R5 整轮墙钟预算：超预算把本块(及后续块)留 pending 下轮续，防慢模型独占串行泵
+        if (timeBudgetMs > 0 && chunks.length > 1 && Date.now() - extractStart > timeBudgetMs) {
+            failedMessages.push(...chunk);
+            continue;
+        }
         const userPrompt = formatExtractionPrompt({
             newMessages: chunk,
             backgroundMessages: backgroundMsgs,
             previousSceneName: lastScene || '无',
             halls,
         });
-        const raw = await callLLM(ctx, cfg, {
-            system: getExtractMemoriesSystemPrompt(mode, {
-                usageScenario: cfg.usageScenario?.enabled === true,
-                narrative: cfg.narrativeTemplates?.enabled === true,
-                // 名称蒸馏（Phase 3）：示例段只在总开关开着时付（它与 title 是两层成本，
-                // 分开开关才能 A/B）。关着时这份 opts 产出的提示与改动前逐字相同。
-                title: cfg.naming?.enabled === true,
-                fewShot: cfg.naming?.enabled === true && cfg.naming.fewShot === true,
-            }),
-            user: userPrompt,
-            maxTokens: resolveLayerTokens(cfg, 'extract'),
-            layer: 'l1-extract',
-            logger,
-        });
-        const scenes = parseJsonLogged(raw, 'L1 抽取', logger);
-        if (!Array.isArray(scenes))
-            throw new Error('L1 抽取输出不是 JSON 数组');
+        let scenes;
+        try {
+            const raw = await callLLM(ctx, cfg, {
+                system: getExtractMemoriesSystemPrompt(mode, {
+                    usageScenario: cfg.usageScenario?.enabled === true,
+                    narrative: cfg.narrativeTemplates?.enabled === true,
+                    // 名称蒸馏（Phase 3）：示例段只在总开关开着时付（它与 title 是两层成本，
+                    // 分开开关才能 A/B）。关着时这份 opts 产出的提示与改动前逐字相同。
+                    title: cfg.naming?.enabled === true,
+                    fewShot: cfg.naming?.enabled === true && cfg.naming.fewShot === true,
+                }),
+                user: userPrompt,
+                maxTokens: resolveLayerTokens(cfg, 'extract'),
+                layer: 'l1-extract',
+                logger,
+            });
+            const parsed = parseJsonLogged(raw, 'L1 抽取', logger);
+            if (!Array.isArray(parsed))
+                throw new Error('L1 抽取输出不是 JSON 数组');
+            scenes = parsed;
+            // R9: 记录该路由跑通的实际块长（只降不升），供下轮收紧 perChunk
+            if (routeHealth && rhKey) {
+                const chunkChars = chunk.reduce((n, m) => n + m.content.length + 64, 0);
+                routeHealth.recordGood(rhKey.provider, rhKey.model, chunkChars);
+            }
+        }
+        catch (err) {
+            // R1′ 块级容错：单块超时/崩只丢这块、留桶下轮重投，不掀翻整批(旧行为是整抛)
+            failedMessages.push(...chunk);
+            logger.warn(`[memory] L1 抽取块失败(${chunk.length} 条消息留待重投): ${err instanceof Error ? err.message : String(err)}`);
+            continue;
+        }
         for (const scene of scenes) {
             if (!scene || typeof scene.scene_name !== 'string')
                 continue;
@@ -357,29 +446,46 @@ mergeRekey) {
         }
     }
     if (extracted.length === 0) {
+        // 全部块失败：等价旧"整抛"语义——runner catch 会保留整片 + 记退避(不误当零产出成功)
+        if (failedMessages.length > 0) {
+            throw new Error(`L1 抽取全部 ${chunks.length} 块失败(逐块错误见上)`);
+        }
         logger.info(`[memory] L1 抽取完成:无可提取记忆(mode=${mode},${pending.length} 条消息,${sceneCount} 个情境)`);
         // 成功但零产出:同样推进时间戳/场景,与失败(lastExtractAt 保持 0)区分开
         markExtracted(states, mode, lastScene);
-        return { stored: 0, skipped: false, sceneName: lastScene, newRecords: [] };
+        return { stored: 0, skipped: false, sceneName: lastScene, newRecords: [], failedMessages: [] };
     }
     // ── Step 2: 去重(batch 冲突检测;候选只在本族内召回,去重永不跨族) ──
     const matches = await Promise.all(extracted.map(async (m) => ({
         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 +707,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 +737,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();
@@ -712,7 +826,7 @@ mergeRekey) {
     }
     markExtracted(states, mode, lastScene);
     logger.info(`[memory] L1 抽取完成(mode=${mode}):消息 ${pending.length} 条,抽取 ${extracted.length} 条,去重后新增 ${added.length} 条(取代退场 ${supersededBy.size} 条,chat=${addedByFamily.chat}/work=${addedByFamily.work}),累计 chat=${states.chat.totalExtracted}/work=${states.work.totalExtracted}`);
-    return { stored: added.length, skipped: false, sceneName: lastScene, newRecords: added, runId, byKind };
+    return { stored: added.length, skipped: false, sceneName: lastScene, newRecords: added, runId, byKind, failedMessages };
 }
 /** auto 档取最近活跃的族 checkpoint(情境链/计数锚点)。 */
 function activeState(states) {