dsh-layered-memory 0.8.8 → 0.8.9

package/dist/llm.js

@@ -22,11 +22,13 @@ export const LAYER_DEFAULT_BUDGETS = {
 /**
  * 解析某蒸馏层的生效输出预算：运行时覆盖（cfg.llm.budgets，由 effectiveCfg 从
  * 设置页 distillBudgets 注入，0/缺省 = 跟随）→ 内置默认 → 思考档放大
- * （high/xhigh/max ×4，reasoning 计入输出预算的历史事故防线）。
+ * （high/xhigh/max ×4，reasoning 计入输出预算的历史事故防线）。放大触发档位
+ * 跟层走（#34 D8）：层链头档位候选 > 全局主路由档位候选（primaryEffort > 静态全局）。
  */
 export function resolveLayerTokens(cfg, layer) {
     const override = cfg.llm.budgets?.[layer];
-    return layerMaxTokens(override && override > 0 ? override : LAYER_DEFAULT_BUDGETS[layer], cfg.llm.reasoningEffort);
+    const key = layer === 'l2' ? 'l2' : layer === 'l3' ? 'l3' : 'l1';
+    return layerMaxTokens(override && override > 0 ? override : LAYER_DEFAULT_BUDGETS[layer], layerEffortTrigger(cfg, key));
 }
 /**
  * 高思考档集合（输出预算 ×4 的档位）：阶段侧 layerMaxTokens 与 callLLM 的
@@ -74,6 +76,60 @@ export function buildRouteChain(primary, fallbacks, globalEffort) {
     }
     return routes;
 }
+// ── 按层独立路由（#34 / ADR-0005）：层内三级 运行时层链 > 静态层链 > 全局解析 ──
+// 层链非空即完整替换该层解析（该层主路由与回退都归层链管，全局链对该层不参与）；
+// 档位是全局偏好轴：层链空档位条目/头行仍回退全局档位（primaryEffort 之后的
+// cfg.llm.reasoningEffort 语义照旧）。pin 只废运行时侧（effectiveCfg 不注入），
+// 静态层链天然穿透——与回退链"静态配置不构成 pin 绕过"先例同源。
+/** DistillLayer（调用点四键）→ 路由层键（三键）：l1-extract/l1-dedup 同属 l1。 */
+export function layerKeyFor(layer) {
+    return layer === 'l2' ? 'l2' : layer === 'l3' ? 'l3' : 'l1';
+}
+/**
+ * 取某层的生效层链（运行时优先）。头行残缺（provider/model 缺失——手写 YAML 错误
+ * 或防御性解析后的空链头）视为该层未配置、回退全局解析：路由配置错误不致该层
+ * 蒸馏失产，与回退链"条目缺失剔除"同一防御姿态。
+ */
+function layerChainOf(cfg, key) {
+    const rt = cfg.llm.layerChainsRuntime?.[key];
+    if (rt?.length && rt[0].provider && rt[0].model)
+        return rt;
+    const st = cfg.llm.layerRoutes?.[key];
+    if (st?.length && st[0].provider && st[0].model)
+        return st;
+    return undefined;
+}
+/** 该层的预算放大触发档位（D8）：层链头档位候选 > 全局主路由档位候选（primaryEffort > 静态全局）。 */
+export function layerEffortTrigger(cfg, key) {
+    const chain = layerChainOf(cfg, key);
+    return chain
+        ? chain[0].reasoningEffort || cfg.llm.primaryEffort || cfg.llm.reasoningEffort
+        : cfg.llm.primaryEffort || cfg.llm.reasoningEffort;
+}
+/**
+ * 解析某次蒸馏调用的实际路由链（callLLM 入口）：有层标签且该层配了层链 → 层链
+ * 完整替换（buildRouteChain 复用：头行在前、条目去重、档位三级候选）；否则现行
+ * 全局解析（主路由既有优先级 + fallbacks，语义一个比特不动）。layer 缺省
+ * （bench/测试缝）= 全局解析。
+ */
+export async function resolveLayerRoutes(ctx, cfg, layer) {
+    const key = layer ? layerKeyFor(layer) : undefined;
+    const lr = key ? layerChainOrNull(cfg, key) : null;
+    if (lr)
+        return lr;
+    const primary = await resolveModelRoute(ctx, cfg);
+    return buildRouteChain(
+    // 主路由显式档位来自运行时统一链（primaryEffort，'' = 跟随全局静态）
+    { provider: primary.provider, model: primary.model, effort: cfg.llm.primaryEffort || '' }, cfg.llm.fallbacks, cfg.llm.reasoningEffort);
+}
+/** 层链解析的同步半边（llm-providers 视图与 resolveLayerRoutes 共用一条真值路径）：
+ *  该层配了有效层链 → 完整链；null = 该层跟随全局解析。 */
+export function layerChainOrNull(cfg, key) {
+    const chain = layerChainOf(cfg, key);
+    if (!chain)
+        return null;
+    return buildRouteChain({ provider: chain[0].provider, model: chain[0].model, effort: chain[0].reasoningEffort || '' }, chain.slice(1), cfg.llm.reasoningEffort);
+}
 /** 单路由持续失败的一次性告警去重表（effortWarned 同款；拓扑变化随能力缓存一起失效）。 */
 const routeDeadWarned = new Set();
 function warnRouteDeadOnce(route, logger) {
@@ -89,6 +145,7 @@ const effortCache = new Map();
 /** 清空能力缓存（llm/adapters-updated 时调用：供应商增删/改配置后重新探询）。 */
 export function invalidateEffortCache() {
     effortCache.clear();
+    contextWindowCache.clear();
     effortWarned.clear();
     routeDeadWarned.clear();
 }
@@ -116,6 +173,30 @@ export async function resolveModelEfforts(ctx, provider, model) {
         return null; // 不缓存失败：路由尚未注册等瞬时态，下次调用重试
     }
 }
+/** (provider, model) → 上下文窗口 token 数；advisory，未声明/失败为 null。 */
+const contextWindowCache = new Map();
+/**
+ * 探询某模型的上下文窗口容量（adapter 声明的 provider-owned capacity）。
+ * 与 effortCache 同源同失效策略（invalidateEffortCache 一并清空）；
+ * 仅用于占用指示器的分母展示——分母必须与官方环同源（模型声明值），禁止 client 自估。
+ */
+export async function resolveModelContextWindow(ctx, provider, model) {
+    const key = `${provider}::${model}`;
+    if (contextWindowCache.has(key))
+        return contextWindowCache.get(key) ?? null;
+    try {
+        if (typeof ctx.llm?.resolveModelInfo !== 'function')
+            return null;
+        const info = await ctx.llm.resolveModelInfo(provider, model);
+        const win = info.context?.contextWindow;
+        const val = typeof win === 'number' && Number.isFinite(win) && win > 0 ? Math.floor(win) : null;
+        contextWindowCache.set(key, val);
+        return val;
+    }
+    catch {
+        return null; // 不缓存失败：下次调用重试
+    }
+}
 /** 纯决策：配置档位 + 模型能力 → 实际发送值（callLLM 与 settings-get 共用）。 */
 export function decideSendableEffort(cap, cfgEffort) {
     if (!cap)
@@ -165,10 +246,8 @@ export async function planDistillEffort(ctx, provider, model, cfgEffort, logger)
  * 适配器异常地没有发 block-end 时兜底。两者都累计会把输出翻倍。
  */
 export async function callLLM(ctx, cfg, opts) {
-    const primary = await resolveModelRoute(ctx, cfg);
-    const routes = buildRouteChain(
-    // 主路由显式档位来自运行时统一链（primaryEffort，'' = 跟随全局静态）
-    { provider: primary.provider, model: primary.model, effort: cfg.llm.primaryEffort || '' }, cfg.llm.fallbacks, cfg.llm.reasoningEffort);
+    // 按层路由（#34）：opts.layer 配了层链的层走层链完整替换，其余走全局解析
+    const routes = await resolveLayerRoutes(ctx, cfg, opts.layer);
     let lastErr;
     for (let i = 0; i < routes.length; i++) {
         const route = routes[i];
@@ -201,12 +280,16 @@ async function callRoute(ctx, cfg, opts, route) {
     const user = opts.user.length > cfg.llm.maxInputChars
         ? `${opts.user.slice(0, cfg.llm.maxInputChars)}\n\n[输入超出 ${cfg.llm.maxInputChars} 字符预算，已截断]`
         : opts.user;
-    // 输出预算 ×4 防线跟随【实际发送】的档位：阶段侧已按原始配置的高档位
-    // （HIGH_EFFORT_TIERS）放大过，这里只补自动档（'' → 模型默认/高档）解析出
-    // 高档时的欠放大缺口——两侧共用一张表，配置本身就是高档时不再放大（防 ×16 双乘）
+    // 输出预算 ×4 防线跟随【实际发送】的档位：阶段侧已按该层放大触发档位
+    // （layerEffortTrigger：层链头候选 > 全局主路由候选）放大过，这里只补自动档
+    // （'' → 模型默认/高档）解析出高档时的欠放大缺口——两侧共用一张表与同一触发值，
+    // 配置本身就是高档时不再放大（防 ×16 双乘）
     const baseMaxTokens = opts.maxTokens ?? cfg.llm.maxTokens;
     const highTiers = HIGH_EFFORT_TIERS;
-    const maxTokens = highTiers.includes(effort.effort) && !highTiers.includes(cfg.llm.reasoningEffort)
+    const triggerEffort = opts.layer
+        ? layerEffortTrigger(cfg, layerKeyFor(opts.layer))
+        : cfg.llm.primaryEffort || cfg.llm.reasoningEffort;
+    const maxTokens = highTiers.includes(effort.effort) && !highTiers.includes(triggerEffort)
         ? layerMaxTokens(baseMaxTokens, 'high')
         : baseMaxTokens;
     const stream = ctx.llm.stream({

package/dist/pipeline/runner.js

@@ -60,6 +60,19 @@ export function effectiveCfg(cfg, live) {
             ...(b.l3 > 0 ? { l3: b.l3 } : {}),
         }
         : null;
+    // 运行时按层路由链（#34）：非空层链逐层注入 layerChainsRuntime（解析侧层内第一
+    // 优先级）；pinned = 部署锁，运行时层链与运行时全局链一并失效（同 chainMode 的
+    // pinned 处理）；全部层为空 = 无注入（返回引用不变路径不受影响）。层键逐个
+    // ?.length 容忍部分键缺失（旧存量 settings / 手写覆盖可能只带部分层）
+    const lc = s?.distillLayerChains;
+    const layerPick = lc && !pinned
+        ? {
+            ...(lc.l1?.length ? { l1: lc.l1 } : {}),
+            ...(lc.l2?.length ? { l2: lc.l2 } : {}),
+            ...(lc.l3?.length ? { l3: lc.l3 } : {}),
+        }
+        : null;
+    const layerChains = layerPick && Object.keys(layerPick).length ? layerPick : null;
     const maxInput = s && s.distillMaxInputChars > 0 ? s.distillMaxInputChars : null;
     // 旧档位键的全局接管（含给静态回退条目盖章）：仅非链模式保留（旧存量值兼容）
     const fallbacksTakeover = !chainMode && eff && cfg.llm?.fallbacks?.length
@@ -70,7 +83,7 @@ export function effectiveCfg(cfg, live) {
     const effortInject = live && !chainMode && (eff !== '' || Boolean(cfg.llm?.reasoningEffort))
         ? { reasoningEffort: eff }
         : null;
-    if (!override && !budgets && !maxInput && !fallbacksTakeover && !chainEffort && !chainFallbacks && !effortInject)
+    if (!override && !budgets && !maxInput && !fallbacksTakeover && !chainEffort && !chainFallbacks && !effortInject && !layerChains)
         return cfg;
     return {
         ...cfg,
@@ -83,6 +96,7 @@ export function effectiveCfg(cfg, live) {
             ...(fallbacksTakeover ? { fallbacks: fallbacksTakeover } : {}),
             ...(chainEffort ? { primaryEffort: chainEffort } : {}),
             ...(chainFallbacks ? { fallbacks: chainFallbacks } : {}),
+            ...(layerChains ? { layerChainsRuntime: layerChains } : {}),
         },
     };
 }

package/dist/settings.d.ts

@@ -22,8 +22,15 @@ export declare const DISTILL_CHAIN_MAX = 8;
  * distillChain、不走本投影——旧键路径在未配链时按旧语义原样生效。
  */
 export declare function projectDistillChain(s: Partial<MemoryLiveSettings> | undefined): DistillChainEntry[];
-/** settings-set 写入门校验：返回错误文案（null = 通过）。 */
-export declare function validateDistillChain(chain: unknown): string | null;
+/**
+ * settings-set 写入门校验：返回错误文案（null = 通过）。
+ * opts.requireExplicitHead（#34 层链用）：头行必须 provider+model 双显式——层键出现
+ * 即意图覆盖；"双空 = 跟随默认模型"是全局链独有语义（"默认模型 + 自定义回退"的
+ * 诉求由全局 llm.fallbacks 承担），层链禁掉双空头，消除"层链头跟随哪套全局解析"的歧义。
+ */
+export declare function validateDistillChain(chain: unknown, opts?: {
+    requireExplicitHead?: boolean;
+}): string | null;
 export interface LiveSettingsHandle {
     /** settings 服务是否可用（不可用时 UI 侧隐藏开关面板） */
     supported: boolean;

package/dist/settings.js

@@ -22,8 +22,13 @@ export function projectDistillChain(s) {
     }
     return [];
 }
-/** settings-set 写入门校验：返回错误文案（null = 通过）。 */
-export function validateDistillChain(chain) {
+/**
+ * settings-set 写入门校验：返回错误文案（null = 通过）。
+ * opts.requireExplicitHead（#34 层链用）：头行必须 provider+model 双显式——层键出现
+ * 即意图覆盖；"双空 = 跟随默认模型"是全局链独有语义（"默认模型 + 自定义回退"的
+ * 诉求由全局 llm.fallbacks 承担），层链禁掉双空头，消除"层链头跟随哪套全局解析"的歧义。
+ */
+export function validateDistillChain(chain, opts) {
     if (!Array.isArray(chain))
         return 'distillChain 须为数组';
     if (chain.length > DISTILL_CHAIN_MAX)
@@ -41,6 +46,8 @@ export function validateDistillChain(chain) {
         if (!EFFORT_CHOICES.includes(eff))
             return `第 ${i + 1} 行思考档位非法: ${eff || '(空)'}`;
         if (i === 0) {
+            if (opts?.requireExplicitHead && (!p || !m))
+                return '主路由行必须显式选择供应商与模型（层链不支持跟随默认模型）';
             if ((p && !m) || (!p && m))
                 return '主路由行 provider 与 model 须成对（双空 = 跟随默认模型）';
         }
@@ -68,6 +75,7 @@ const ALWAYS_ON = {
     distillChain: [],
     distillBudgets: { extract: 0, dedup: 0, l2: 0, l3: 0 },
     distillMaxInputChars: 0,
+    distillLayerChains: { l1: [], l2: [], l3: [] },
 };
 /**
  * 进程内 scope 复用（fiber 重启重挂）。
@@ -88,6 +96,13 @@ let cachedUnwatch;
 let cachedSvc;
 export function liveSettingsSchema() {
     const budget = () => Schema.number().min(0).max(1_000_000).default(0);
+    // 层链条目形状与 distillChain 相同（档位必填、'' = 跟随）；写入校验另在
+    // settings-set 门做逐层 requireExplicitHead（schema 层只管形状默认，语义门在 host）
+    const chainEntry = () => Schema.object({
+        provider: Schema.string().default(''),
+        model: Schema.string().default(''),
+        reasoningEffort: Schema.union([...EFFORT_CHOICES]).default(''),
+    });
     return Schema.object({
         enabled: Schema.boolean().default(true),
         capture: Schema.boolean().default(true),
@@ -96,11 +111,12 @@ export function liveSettingsSchema() {
         reasoningEffort: Schema.union([...EFFORT_CHOICES]).default(''),
         distillProvider: Schema.string().default(''),
         distillModel: Schema.string().default(''),
-        distillChain: Schema.array(Schema.object({
-            provider: Schema.string().default(''),
-            model: Schema.string().default(''),
-            reasoningEffort: Schema.union([...EFFORT_CHOICES]).default(''),
-        })).default([]),
+        distillChain: Schema.array(chainEntry()).default([]),
+        distillLayerChains: Schema.object({
+            l1: Schema.array(chainEntry()).default([]),
+            l2: Schema.array(chainEntry()).default([]),
+            l3: Schema.array(chainEntry()).default([]),
+        }).default({ l1: [], l2: [], l3: [] }),
         distillBudgets: Schema.object({
             extract: budget(),
             dedup: budget(),
@@ -219,23 +235,28 @@ function resolveSettings(value) {
     const num = (x) => (typeof x === 'number' && Number.isFinite(x) && x >= 0 ? Math.floor(x) : 0);
     const rawBudgets = (v.distillBudgets ?? {});
     // 路由链逐条防御：非对象条目剔除、超长截断、非法档位归空、超限截断到上限
-    const rawChain = Array.isArray(v.distillChain) ? v.distillChain : [];
-    const chain = [];
-    for (const item of rawChain) {
-        if (chain.length >= DISTILL_CHAIN_MAX)
-            break;
-        if (!item || typeof item !== 'object')
-            continue;
-        const e = item;
-        const eff = typeof e.reasoningEffort === 'string' && EFFORT_CHOICES.includes(e.reasoningEffort)
-            ? e.reasoningEffort
-            : '';
-        chain.push({
-            provider: typeof e.provider === 'string' ? e.provider.slice(0, 200) : '',
-            model: typeof e.model === 'string' ? e.model.slice(0, 200) : '',
-            reasoningEffort: eff,
-        });
-    }
+    const defuseChain = (raw) => {
+        const out = [];
+        if (!Array.isArray(raw))
+            return out;
+        for (const item of raw) {
+            if (out.length >= DISTILL_CHAIN_MAX)
+                break;
+            if (!item || typeof item !== 'object')
+                continue;
+            const e = item;
+            const eff = typeof e.reasoningEffort === 'string' && EFFORT_CHOICES.includes(e.reasoningEffort)
+                ? e.reasoningEffort
+                : '';
+            out.push({
+                provider: typeof e.provider === 'string' ? e.provider.slice(0, 200) : '',
+                model: typeof e.model === 'string' ? e.model.slice(0, 200) : '',
+                reasoningEffort: eff,
+            });
+        }
+        return out;
+    };
+    const rawLayer = (v.distillLayerChains ?? {});
     return {
         enabled: v.enabled !== false,
         capture: v.capture !== false,
@@ -246,7 +267,12 @@ function resolveSettings(value) {
             : '',
         distillProvider: typeof v.distillProvider === 'string' ? v.distillProvider : '',
         distillModel: typeof v.distillModel === 'string' ? v.distillModel : '',
-        distillChain: chain,
+        distillChain: defuseChain(v.distillChain),
+        distillLayerChains: {
+            l1: defuseChain(rawLayer.l1),
+            l2: defuseChain(rawLayer.l2),
+            l3: defuseChain(rawLayer.l3),
+        },
         distillBudgets: {
             extract: num(rawBudgets.extract),
             dedup: num(rawBudgets.dedup),

package/dist/stats.d.ts

@@ -28,6 +28,12 @@ export interface MemoryStatusSource {
 export interface SessionInfoSource {
     /** 召回统计（recall.ts 注册表；未发生检索的会话返回 undefined）。 */
     recallStats(sessionId: string): RecallSessionStats | undefined;
+    /** 记忆上下文占用账本（context-occupancy 唯一权威实例；未注入过的会话返回 null）。 */
+    memoryOccupancy(sessionId: string): MemoryOccupancy | null;
+    /** 稳定区份额估算（旧会话回填用；缺省 = 装配未提供，回填隐藏）。 */
+    profileEstimate?(sessionId: string): number;
+    /** 召回份额回填（live surface 现扫，miss 读盘上日志；缺省 = null）。 */
+    recallEstimate?(sessionId: string): Promise<number | null> | number | null;
     /** 蒸馏管线会话视图（runner：攒批进度/挂起切片/会话产出）。 */
     runnerView(sessionId: string, mode: string): {
         pendingSlice: number;
@@ -44,6 +50,7 @@ export interface SessionInfoSource {
         vectorSearch: boolean;
     };
 }
+import type { MemoryOccupancy } from './contract.js';
 export type { MemoryStats } from './contract.js';
 /** 注册状态 RPC（web 侧 connection 服务可选，缺失时跳过，不影响插件主体）。 */
 export declare function registerMemoryRpc(ctx: Context, cfg: MemoryConfig, stores: {

package/dist/stats.js

@@ -12,7 +12,7 @@ import { join } from 'node:path';
 import { EFFORT_CHOICES, resolveDataDir } from './config.js';
 import { effectiveCfg } from './pipeline/runner.js';
 import { emptyRecallStats } from './hooks/recall.js';
-import { buildRouteChain, decideSendableEffort, LAYER_DEFAULT_BUDGETS, resolveModelEfforts, resolveModelRoute } from './llm.js';
+import { buildRouteChain, decideSendableEffort, LAYER_DEFAULT_BUDGETS, layerChainOrNull, resolveModelContextWindow, resolveModelEfforts, resolveModelRoute } from './llm.js';
 import { projectDistillChain, validateDistillChain } from './settings.js';
 import { errDetail } from './util/filelog.js';
 import { snapshotTokenCost } from './token-cost.js';
@@ -199,12 +199,36 @@ async function handleEndpoint(endpoint, payload, deps) {
             const chat = stores.state.forFamily('chat');
             const work = stores.state.forFamily('work');
             const lastAt = Math.max(chat.lastExtractAt, work.lastExtractAt);
+            // 主对话模型的官方声明窗口（占用指示器分母；advisory 查询读本地快照且有缓存，
+            // 轮询热路径下稳态为 Map 命中——遵守本端点"只许内存注册表读取"的硬规则口径。
+            // race 封顶防第三方适配器 resolveModelInfo 挂起拖死轮询——llm-models 端点同款先例）
+            let contextWindowTokens = null;
+            try {
+                const sel = deps.ctx.get('agentDefaultModel')?.currentSelection?.();
+                if (sel?.provider && sel?.model) {
+                    contextWindowTokens = await Promise.race([
+                        resolveModelContextWindow(deps.ctx, sel.provider, sel.model),
+                        new Promise((resolve) => setTimeout(() => resolve(null), 3_000)),
+                    ]);
+                }
+            }
+            catch {
+                /* 可选服务缺失/解析失败 = 分母未知，UI 降级 */
+            }
             const v = {
                 supported: true,
                 sessionId,
                 mode,
                 defaultMode: modes?.default ?? cfg.family,
                 recall: { enabled: recallOn, ...(sessionInfo.recallStats(sessionId) ?? emptyRecallStats()) },
+                memoryOccupancy: sessionInfo.memoryOccupancy(sessionId),
+                occupancyBackfill: sessionInfo.profileEstimate
+                    ? {
+                        recallTokens: sessionInfo.recallEstimate ? await sessionInfo.recallEstimate(sessionId) : null,
+                        profileTokens: sessionInfo.profileEstimate(sessionId),
+                    }
+                    : null,
+                contextWindowTokens,
                 distill: distillView,
                 l0Count,
                 retrieval: caps.vectorSearch ? (caps.ftsSearch ? 'hybrid' : 'vector') : caps.ftsSearch ? 'keyword' : 'none',
@@ -246,6 +270,7 @@ async function handleEndpoint(endpoint, payload, deps) {
                     enabled: true, capture: true, distill: true, recall: true,
                     reasoningEffort: '', distillProvider: '', distillModel: '', distillChain: [],
                     distillBudgets: { extract: 0, dedup: 0, l2: 0, l3: 0 }, distillMaxInputChars: 0,
+                    distillLayerChains: { l1: [], l2: [], l3: [] },
                 },
                 // 静态部署上限（cordis.patch.yml）：运行时开关与它取 AND
                 ceilings: { capture: cfg.capture.enabled, distill: cfg.extract.enabled, recall: cfg.recall.enabled },
@@ -293,6 +318,27 @@ async function handleEndpoint(endpoint, payload, deps) {
                     throw new Error(err);
                 clean.distillChain = patch.distillChain;
             }
+            // 运行时按层路由链（#34）：逐层校验（头行必须显式——层覆盖不支持跟随默认模型）；
+            // patch 语义只带要改的层，写入侧与存量层合并后落盘（空数组 = 该层回到跟随）
+            if (patch.distillLayerChains !== undefined) {
+                const rawLC = (patch.distillLayerChains ?? {});
+                // 与存量层合并后落全三键 Record（settings 视图类型是全量；缺层 = 清空该层跟随）
+                const prev = (live.get().distillLayerChains ?? {});
+                const merged = {
+                    l1: prev.l1 ?? [],
+                    l2: prev.l2 ?? [],
+                    l3: prev.l3 ?? [],
+                };
+                for (const key of ['l1', 'l2', 'l3']) {
+                    if (rawLC[key] === undefined)
+                        continue;
+                    const err = validateDistillChain(rawLC[key], { requireExplicitHead: true });
+                    if (err)
+                        throw new Error(`层路由 ${key}：${err}`);
+                    merged[key] = rawLC[key];
+                }
+                clean.distillLayerChains = merged;
+            }
             if (patch.reasoningEffort !== undefined) {
                 const v = String(patch.reasoningEffort);
                 // 白名单与 schema/settings 同源（config.ts EFFORT_CHOICES）——此前此处漏扩词表，
@@ -452,20 +498,35 @@ async function handleEndpoint(endpoint, payload, deps) {
             const chainCurrent = projectDistillChain(s);
             let effectiveChain = [];
             let effective = null;
+            let cfgView = cfg;
             try {
-                const cfgView = effectiveCfg(cfg, live);
+                cfgView = effectiveCfg(cfg, live);
                 effective = await resolveModelRoute(deps.ctx, cfgView);
                 effectiveChain = buildRouteChain({ provider: effective.provider, model: effective.model, effort: cfgView.llm.primaryEffort || '' }, cfgView.llm.fallbacks, cfgView.llm.reasoningEffort);
             }
             catch {
                 effective = null; // 无法解析（无默认选择且未覆盖）时 UI 显示占位
             }
+            const pinned = Boolean(cfg.llm.provider && cfg.llm.model);
+            // 按层层链视图：与解析真值同径（layerChainOrNull 吃 effectiveCfg 之后的 cfgView，
+            // pinned 时运行时层链未注入、静态层链胜出；跟随层直接复用全局 effectiveChain）
+            const mkLayerView = (key) => {
+                const rt = s?.distillLayerChains?.[key] ?? [];
+                const lr = layerChainOrNull(cfgView, key);
+                const rtLive = !pinned && rt.length > 0 && !!rt[0].provider && !!rt[0].model;
+                return {
+                    runtime: rt,
+                    static: cfg.llm.layerRoutes?.[key] ?? [],
+                    effectiveChain: lr ?? effectiveChain,
+                    source: rtLive ? 'runtime' : lr ? 'static' : 'global',
+                };
+            };
             const resp = {
                 supported: true,
                 providers,
                 default: def,
                 // 部署静态 pin（provider+model 双字段）优先于运行时选择，UI 据此禁用选择器
-                pinned: Boolean(cfg.llm.provider && cfg.llm.model),
+                pinned,
                 current,
                 // 所选供应商是否仍在已注册路由中（用户删掉供应商后提示回退）
                 currentRegistered: current.provider === '' || providers.some((p) => p.id === current.provider),
@@ -476,6 +537,13 @@ async function handleEndpoint(endpoint, payload, deps) {
                     effectiveChain,
                     source: chainCurrent.length ? 'runtime' : 'static',
                 },
+                // 按层层链（#34）：source 三态与解析真值同径（layerChainOrNull）——pinned 下
+                // 运行时层链不生效（与 effectiveCfg 注入条件一致），存量照实返回供 UI 展示
+                layerChains: {
+                    l1: mkLayerView('l1'),
+                    l2: mkLayerView('l2'),
+                    l3: mkLayerView('l3'),
+                },
             };
             return resp;
         }

package/dist/store/occupancy.d.ts

@@ -0,0 +1,30 @@
+import type { MemoryLogger } from '../types.js';
+import type { OccupancyLedger } from '../util/context-occupancy.js';
+/** 会话条目上限（按 updatedAt 淘汰最旧；防文件无限增长）。 */
+export declare const OCCUPANCY_SESSION_CAP = 200;
+export declare class OccupancyStore {
+    private readonly logger?;
+    private readonly file;
+    private readonly entries;
+    private persistFailed;
+    /** 串行化持久化写（避免并发原子写撞临时文件名）；init 链最前（先载入再落盘，防丢更新）。 */
+    private writeChain;
+    constructor(dataDir: string, logger?: MemoryLogger | undefined);
+    /** 载入持久化账目（合并进内存——构造与载入之间发生的 save 不丢）；失败降级内存态。 */
+    private init;
+    /**
+     * 该会话的持久化账目（热路径同步读；从未注入/已复位返回 null）。
+     * 返回**浅拷贝**——调用方（ledgerFor 复生）会在其上做迁移；若交出内部引用，
+     * 原地修改会让 save() 的 prev/ledger 恒等比较误判“数值未变”而跳过写穿（实测踩坑）。
+     */
+    load(sessionId: string): OccupancyLedger | null;
+    /**
+     * 迁移后写穿。数值未变只刷新内存时间戳不落盘（profile 稳定区每次请求组装都
+     * 触发迁移，但内容不变时不应产生文件写）；stock 归零即删除条目。
+     */
+    save(sessionId: string, ledger: OccupancyLedger): void;
+    /** 等待在途持久化写完成（测试/停机用）。 */
+    flush(): Promise<void>;
+    private persist;
+    private serialize;
+}

package/dist/store/occupancy.js

@@ -0,0 +1,134 @@
+/**
+ * 记忆占用流水存储：sessionId → OccupancyLedger 的持久化映射。
+ *
+ * 动机（2026-08-27 票07）：占用账本是进程内存态，dsh 重启后历史会话"窗口里明明
+ * 有记忆、账面却为零"，指示器对重启前注入的存量失明。本存储让账目跨进程复生：
+ * - 每次账本迁移后写穿（recall-dedupe 同款：串行化原子写 + 失败降级内存态）；
+ * - 查询热路径仍是同步内存读——文件只在迁移时刻与启动载入时触碰；
+ * - stock 归零的条目不落盘（compaction 复位即天然删除）；
+ * - agent 销毁不删记录（持久化语义与召回去重一致：会话恢复后账目继续）；
+ * - 90 天未更新过期清理 + 会话条目上限（session-modes/dedupe 同款量级）。
+ */
+import * as path from 'node:path';
+import { errDetail } from '../util/filelog.js';
+import { atomicWriteJson, ensureDir, readJsonIfExists } from './io.js';
+/** 会话条目上限（按 updatedAt 淘汰最旧；防文件无限增长）。 */
+export const OCCUPANCY_SESSION_CAP = 200;
+/** 条目过期清理（90 天未更新即丢弃，与 session-modes/dedupe 同款量级）。 */
+const PRUNE_MS = 90 * 24 * 3600_000;
+export class OccupancyStore {
+    logger;
+    file;
+    entries = new Map();
+    persistFailed = false;
+    /** 串行化持久化写（避免并发原子写撞临时文件名）；init 链最前（先载入再落盘，防丢更新）。 */
+    writeChain;
+    constructor(dataDir, logger) {
+        this.logger = logger;
+        this.file = path.join(dataDir, 'occupancy.json');
+        this.writeChain = this.init();
+    }
+    /** 载入持久化账目（合并进内存——构造与载入之间发生的 save 不丢）；失败降级内存态。 */
+    async init() {
+        const data = await readJsonIfExists(this.file);
+        if (!data?.sessions || typeof data.sessions !== 'object')
+            return;
+        const now = Date.now();
+        let count = 0;
+        for (const [sid, entry] of Object.entries(data.sessions)) {
+            if (typeof entry?.stockTokens !== 'number')
+                continue;
+            if (now - (entry.updatedAt ?? 0) > PRUNE_MS)
+                continue;
+            const existing = this.entries.get(sid);
+            if (existing) {
+                if (entry.updatedAt > existing.updatedAt)
+                    this.entries.set(sid, { ...entry });
+            }
+            else {
+                this.entries.set(sid, { ...entry });
+            }
+            count++;
+        }
+        if (count > 0)
+            this.logger?.info(`[memory] 记忆占用账目载入 ${count} 个会话`);
+    }
+    /**
+     * 该会话的持久化账目（热路径同步读；从未注入/已复位返回 null）。
+     * 返回**浅拷贝**——调用方（ledgerFor 复生）会在其上做迁移；若交出内部引用，
+     * 原地修改会让 save() 的 prev/ledger 恒等比较误判“数值未变”而跳过写穿（实测踩坑）。
+     */
+    load(sessionId) {
+        const e = this.entries.get(sessionId);
+        return e ? { ...e } : null;
+    }
+    /**
+     * 迁移后写穿。数值未变只刷新内存时间戳不落盘（profile 稳定区每次请求组装都
+     * 触发迁移，但内容不变时不应产生文件写）；stock 归零即删除条目。
+     */
+    save(sessionId, ledger) {
+        const prev = this.entries.get(sessionId);
+        const sameNumbers = prev !== undefined &&
+            prev.stockTokens === ledger.stockTokens &&
+            prev.recallTokens === ledger.recallTokens &&
+            prev.profileTokens === ledger.profileTokens &&
+            prev.lastInjectTokens === ledger.lastInjectTokens;
+        if (sameNumbers) {
+            prev.updatedAt = ledger.updatedAt;
+            return;
+        }
+        if (ledger.stockTokens <= 0) {
+            if (prev === undefined)
+                return;
+            this.entries.delete(sessionId);
+        }
+        else {
+            this.entries.set(sessionId, { ...ledger });
+        }
+        this.writeChain = this.writeChain.then(() => this.persist());
+    }
+    /** 等待在途持久化写完成（测试/停机用）。 */
+    flush() {
+        return this.writeChain;
+    }
+    async persist() {
+        try {
+            await ensureDir(path.dirname(this.file));
+            await atomicWriteJson(this.file, this.serialize());
+            this.persistFailed = false;
+        }
+        catch (err) {
+            if (!this.persistFailed) {
+                this.persistFailed = true;
+                this.logger?.warn(`[memory] 记忆占用持久化失败（降级内存态）: ${errDetail(err)}`);
+            }
+        }
+    }
+    serialize() {
+        const now = Date.now();
+        for (const [sid, e] of this.entries) {
+            if (now - e.updatedAt > PRUNE_MS && e.updatedAt > 0)
+                this.entries.delete(sid);
+        }
+        while (this.entries.size > OCCUPANCY_SESSION_CAP) {
+            let oldest;
+            let oldestAt = Infinity;
+            for (const [sid, e] of this.entries) {
+                if (e.updatedAt > 0 && e.updatedAt < oldestAt) {
+                    oldest = sid;
+                    oldestAt = e.updatedAt;
+                }
+            }
+            if (oldest === undefined)
+                break;
+            this.entries.delete(oldest);
+        }
+        const sessions = {};
+        for (const [sid, e] of this.entries) {
+            if (e.stockTokens <= 0)
+                continue; // 归零条目不落盘
+            sessions[sid] = { ...e };
+        }
+        return { version: 1, sessions };
+    }
+}