dsh-layered-memory 0.8.7 → 0.8.9

package/dist/settings.js

@@ -1,6 +1,68 @@
 import Schema from '@deepseek-ai/schemastery';
 import { settingsNamespace } from '@deepseek-ai/dsh-settings';
 import { EFFORT_CHOICES } from './config.js';
+/**
+ * 运行时统一路由链条目：[0] = 主路由（provider/model 双空 = 跟随默认模型），
+ * [1..] = 回退链（按序降级）；reasoningEffort 为该路由的档位覆盖（'' = 跟随部署全局）。
+ */
+/** 运行时路由链上限（写入门与 UI 同限，防误粘贴巨数组撑爆 settings 存储）。 */
+export const DISTILL_CHAIN_MAX = 8;
+/**
+ * 运行时统一路由链的**展示投影**（llm-providers 的 chain.current 数据源）：
+ * distillChain 非空即原样返回；为空时投影旧运行时键（distillProvider/distillModel
+ * 成对 → 单行主路由，旧档位 reasoningEffort 作为该主路由的档位——旧语义里它
+ * 作用的就是当时唯一的路由）。注意：生效逻辑（effectiveCfg）只认显式
+ * distillChain、不走本投影——旧键路径在未配链时按旧语义原样生效。
+ */
+export function projectDistillChain(s) {
+    if (s?.distillChain?.length)
+        return s.distillChain;
+    if (s?.distillProvider && s?.distillModel) {
+        return [{ provider: s.distillProvider, model: s.distillModel, reasoningEffort: s.reasoningEffort || '' }];
+    }
+    return [];
+}
+/**
+ * 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)
+        return `路由链最多 ${DISTILL_CHAIN_MAX} 条`;
+    const seen = new Set();
+    for (let i = 0; i < chain.length; i++) {
+        if (!chain[i] || typeof chain[i] !== 'object')
+            return `第 ${i + 1} 行须为对象`;
+        const e = chain[i];
+        const p = typeof e.provider === 'string' ? e.provider : '';
+        const m = typeof e.model === 'string' ? e.model : '';
+        const eff = typeof e.reasoningEffort === 'string' ? e.reasoningEffort : '';
+        if (p.length > 200 || m.length > 200)
+            return `第 ${i + 1} 行 provider/model 过长（≤200 字符）`;
+        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 须成对（双空 = 跟随默认模型）';
+        }
+        else if (!p || !m) {
+            return `第 ${i + 1} 行回退路由必须显式选择供应商与模型`;
+        }
+        if (p && m) {
+            const key = `${p}::${m}`;
+            if (seen.has(key))
+                return `第 ${i + 1} 行与前面的路由重复（${p}/${m}）`;
+            seen.add(key);
+        }
+    }
+    return null;
+}
 const NS = settingsNamespace('dsh-memory');
 const ALWAYS_ON = {
     enabled: true,
@@ -10,8 +72,10 @@ const ALWAYS_ON = {
     reasoningEffort: '',
     distillProvider: '',
     distillModel: '',
+    distillChain: [],
     distillBudgets: { extract: 0, dedup: 0, l2: 0, l3: 0 },
     distillMaxInputChars: 0,
+    distillLayerChains: { l1: [], l2: [], l3: [] },
 };
 /**
  * 进程内 scope 复用（fiber 重启重挂）。
@@ -32,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),
@@ -40,6 +111,12 @@ export function liveSettingsSchema() {
         reasoningEffort: Schema.union([...EFFORT_CHOICES]).default(''),
         distillProvider: Schema.string().default(''),
         distillModel: Schema.string().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(),
@@ -153,10 +230,33 @@ export function registerLiveSettings(ctx, logger) {
 /** scope.get() 的防御性解析：异常值回退全开（宁可多记不可静默停摆）。 */
 function resolveSettings(value) {
     if (!value || typeof value !== 'object')
-        return { ...ALWAYS_ON };
+        return { ...ALWAYS_ON, distillChain: [] };
     const v = value;
     const num = (x) => (typeof x === 'number' && Number.isFinite(x) && x >= 0 ? Math.floor(x) : 0);
     const rawBudgets = (v.distillBudgets ?? {});
+    // 路由链逐条防御：非对象条目剔除、超长截断、非法档位归空、超限截断到上限
+    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,
@@ -167,6 +267,12 @@ function resolveSettings(value) {
             : '',
         distillProvider: typeof v.distillProvider === 'string' ? v.distillProvider : '',
         distillModel: typeof v.distillModel === 'string' ? v.distillModel : '',
+        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

@@ -2,7 +2,7 @@ import type { Context } from '@deepseek-ai/cordis';
 import { type MemoryConfig } from './config.js';
 import { type RecallSessionStats } from './hooks/recall.js';
 import type { RebuildController } from './pipeline/rebuild.js';
-import type { LiveSettingsHandle } from './settings.js';
+import { type LiveSettingsHandle } from './settings.js';
 import type { L0Store } from './store/l0.js';
 import type { L1Store } from './store/l1.js';
 import type { PersonaStore } from './store/persona.js';
@@ -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,31 +50,8 @@ export interface SessionInfoSource {
         vectorSearch: boolean;
     };
 }
-export interface MemoryStats {
-    ok: boolean;
-    dataDir: string;
-    /** 新会话默认记忆档位（auto/chat/work）。 */
-    family: string;
-    version: string;
-    l0Today: number;
-    l1Count: number;
-    l1TotalExtracted: number;
-    sceneCount: number;
-    personaChars: number;
-    hasPersona: boolean;
-    lastExtractAt: string | null;
-    lastL2At: string | null;
-    lastL3At: string | null;
-    memoriesSinceL2: number;
-    memoriesSinceL3: number;
-    pendingExtract: number;
-    message: string;
-    /** 实际生效的阈值（概览进度分母用，避免 UI 硬编码与部署配置脱节）。 */
-    thresholds: {
-        l2MinNewMemories: number;
-        l3Interval: number;
-    };
-}
+import type { MemoryOccupancy } from './contract.js';
+export type { MemoryStats } from './contract.js';
 /** 注册状态 RPC（web 侧 connection 服务可选，缺失时跳过，不影响插件主体）。 */
 export declare function registerMemoryRpc(ctx: Context, cfg: MemoryConfig, stores: {
     l0: L0Store;

package/dist/stats.js

@@ -12,7 +12,8 @@ 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 { 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';
 const require = createRequire(import.meta.url);
@@ -164,7 +165,8 @@ async function handleEndpoint(endpoint, payload, deps) {
                 throw new Error('档位存储未初始化');
             const p = (payload ?? {});
             const sessionId = expectSessionId(p.sessionId);
-            return { sessionId, mode: modes.get(sessionId), defaultMode: modes.default };
+            const v = { sessionId, mode: modes.get(sessionId), defaultMode: modes.default };
+            return v;
         }
         case 'dsh-memory/session-mode-set': {
             if (!modes)
@@ -177,7 +179,8 @@ async function handleEndpoint(endpoint, payload, deps) {
             }
             modes.set(sessionId, p.mode);
             deps.logger.info(`[memory] 会话档位设置 session=${sessionId} mode=${p.mode}`);
-            return { sessionId, mode: p.mode };
+            const v = { sessionId, mode: p.mode };
+            return v;
         }
         // ── 会话级统计（悬浮卡信息区；热路径端点，见 SessionInfoSource 的零 I/O 硬规则） ──
         case 'dsh-memory/session-stats': {
@@ -196,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);
-            return {
+            // 主对话模型的官方声明窗口（占用指示器分母；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',
@@ -211,13 +238,16 @@ async function handleEndpoint(endpoint, payload, deps) {
                     lastExtractAt: lastAt ? new Date(lastAt).toISOString() : null,
                 },
             };
+            return v;
         }
         case 'dsh-memory/settings-get': {
             const s = live?.get();
             const budgets = s?.distillBudgets ?? { extract: 0, dedup: 0, l2: 0, l3: 0 };
             // 蒸馏思考档位：current 是运行时值（'' = 自动）；effective 是能力探询后实际发送值
             // （'' = 不传，跟随模型默认）；options 是当前生效模型声明的档位表（空声明 → 只显示
-            // high，用户规则：无声明默认 high），供蒸馏思考选择器渲染；fallback 是静态部署值
+            // high，用户规则：无声明默认 high），fallback 是静态部署值。注：旧「蒸馏思考」
+            // 选择器已删，本块保留给旧 client 版本与 smoke 兼容；新 UI（路由链编辑器）
+            // 的逐行档位词表走 llm-models 的 efforts 字段
             let effortEffective = s?.reasoningEffort || cfg.llm.reasoningEffort;
             let effortOptions = ['high'];
             let effortRoute = null;
@@ -234,17 +264,19 @@ async function handleEndpoint(endpoint, payload, deps) {
             catch {
                 /* 路由解析/探询失败保持占位（effective 用运行时||静态值） */
             }
-            return {
+            const resp = {
                 supported: live?.supported ?? false,
                 settings: s ?? {
                     enabled: true, capture: true, distill: true, recall: true,
-                    reasoningEffort: '', distillProvider: '', distillModel: '',
+                    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 },
                 effort: {
                     current: s?.reasoningEffort ?? '',
+                    // 静态 schema 与 settings-set 写入门都以 EFFORT_CHOICES 白名单校验，这里断言回窄类型
                     effective: effortEffective,
                     fallback: cfg.llm.reasoningEffort,
                     options: effortOptions,
@@ -268,6 +300,7 @@ async function handleEndpoint(endpoint, payload, deps) {
                     effective: s && s.distillMaxInputChars > 0 ? s.distillMaxInputChars : cfg.llm.maxInputChars,
                 },
             };
+            return resp;
         }
         case 'dsh-memory/settings-set': {
             if (!live)
@@ -278,6 +311,34 @@ async function handleEndpoint(endpoint, payload, deps) {
                 if (typeof patch[key] === 'boolean')
                     clean[key] = patch[key];
             }
+            // 运行时统一路由链：结构校验后整体写入（空数组 = 回到跟随部署配置）
+            if (patch.distillChain !== undefined) {
+                const err = validateDistillChain(patch.distillChain);
+                if (err)
+                    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）——此前此处漏扩词表，
@@ -322,7 +383,8 @@ async function handleEndpoint(endpoint, payload, deps) {
                 throw new Error('开关更新载荷为空');
             await live.update(clean);
             deps.logger.info(`[memory] 设置更新：${JSON.stringify(clean)}`);
-            return { ok: true, settings: live.get() };
+            const v = { ok: true, settings: live.get() };
+            return v;
         }
         case 'dsh-memory/list-records': {
             const p = (payload ?? {});
@@ -338,22 +400,24 @@ async function handleEndpoint(endpoint, payload, deps) {
                 const wanted = offset + limit + 1;
                 const hits = await stores.l1.search(p.query, Math.min(wanted, SEARCH_CAP), { type: p.type || undefined });
                 const filtered = p.scene ? hits.filter((h) => h.scene_name === p.scene) : hits;
-                return {
+                const resp = {
                     items: filtered.slice(offset, offset + limit).map(hitToUiRecord),
                     hasMore: filtered.length > offset + limit,
                     total: null,
                     truncated: wanted > SEARCH_CAP,
                     scenes: offset === 0 ? stores.l1.distinctScenes() : undefined,
                 };
+                return resp;
             }
             const { items, total } = stores.l1.list({ type: p.type || undefined, scene: p.scene || undefined, limit, offset });
-            return {
+            const resp = {
                 items: items.map(hitToUiRecord),
                 hasMore: offset + items.length < total,
                 total,
                 truncated: false,
                 scenes: offset === 0 ? stores.l1.distinctScenes() : undefined,
             };
+            return resp;
         }
         case 'dsh-memory/scenes': {
             // 两族拼接展示（浏览器保持混合视图；路径冲突时后写入的族覆盖显示名，读取仍各自独立）
@@ -381,8 +445,10 @@ async function handleEndpoint(endpoint, payload, deps) {
             return { lines: readLogTail(join(dataDir, 'memory.log'), Math.min(Math.max(Number(p.lines) || 200, 1), 1000)) };
         }
         case 'dsh-memory/rebuild-status': {
-            if (!rebuild)
-                return { supported: false, running: false, phase: 'idle' };
+            if (!rebuild) {
+                const v = { supported: false, running: false, phase: 'idle' };
+                return v;
+            }
             return rebuild.getStatus();
         }
         case 'dsh-memory/rebuild-start': {
@@ -407,6 +473,7 @@ async function handleEndpoint(endpoint, payload, deps) {
         // ── 蒸馏模型选择器（用户已配置的供应商路由） ──
         case 'dsh-memory/llm-providers': {
             // 供应商目录（已注册适配器的活动路由）+ 默认选择 + 当前覆盖与实际生效路由
+            // ——蒸馏路由链编辑器的数据源（供应商下拉/默认模型展示/链状态 chain 块）
             let providers = [];
             try {
                 providers = deps.ctx.llm.listProviders();
@@ -425,24 +492,60 @@ async function handleEndpoint(endpoint, payload, deps) {
             }
             const s = live?.get();
             const current = { provider: s?.distillProvider ?? '', model: s?.distillModel ?? '' };
+            // 统一路由链块：current = 运行时链（含旧键投影）；static = 部署静态回退链；
+            // effective = buildRouteChain 语义的实际链（主路由 + 有效条目去重，每条带档位候选）；
+            // source 标记当前链来自运行时还是部署静态（UI 的跟随态/接管态判定）
+            const chainCurrent = projectDistillChain(s);
+            let effectiveChain = [];
             let effective = null;
+            let cfgView = cfg;
             try {
-                effective = await resolveModelRoute(deps.ctx, 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 显示占位
             }
-            return {
+            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),
                 effective,
+                chain: {
+                    current: chainCurrent,
+                    static: cfg.llm.fallbacks ?? [],
+                    effectiveChain,
+                    source: chainCurrent.length ? 'runtime' : 'static',
+                },
+                // 按层层链（#34）：source 三态与解析真值同径（layerChainOrNull）——pinned 下
+                // 运行时层链不生效（与 effectiveCfg 注入条件一致），存量照实返回供 UI 展示
+                layerChains: {
+                    l1: mkLayerView('l1'),
+                    l2: mkLayerView('l2'),
+                    l3: mkLayerView('l3'),
+                },
             };
+            return resp;
         }
         case 'dsh-memory/llm-models': {
             const p = (payload ?? {});
@@ -456,16 +559,40 @@ async function handleEndpoint(endpoint, payload, deps) {
                 deps.ctx.llm.listModels(p.provider),
                 new Promise((_, reject) => setTimeout(() => reject(new Error('模型列表查询超时')), 8000)),
             ]);
-            return {
-                provider: p.provider,
-                models: models.map((m) => ({ id: m.id, name: m.name, description: m.description ?? null })),
-            };
+            // 每个模型附思考档位能力表（resolveModelInfo 复用 effortCache，本地快照不触
+            // 网）：统一路由链编辑器的逐行档位下拉数据源。整体限时限流——第三方适配器的
+            // resolveModelInfo 若为远端查询会拖死端点（client 5s 轮询放大），超时降级空表
+            // （探询失败/未声明同样 → 空表，UI 只显示「跟随部署配置」）
+            const baseModels = models.map((m) => ({ id: m.id, name: m.name, description: m.description ?? null, efforts: [] }));
+            const providerId = p.provider;
+            const withEfforts = await Promise.race([
+                (async () => {
+                    const out = [];
+                    for (const m of models) {
+                        let efforts = [];
+                        try {
+                            efforts = (await resolveModelEfforts(deps.ctx, providerId, m.id))?.efforts ?? [];
+                        }
+                        catch {
+                            efforts = [];
+                        }
+                        out.push({ id: m.id, name: m.name, description: m.description ?? null, efforts });
+                    }
+                    return out;
+                })(),
+                new Promise((resolve) => setTimeout(() => resolve(baseModels), 4000)),
+            ]);
+            const resp = { provider: p.provider, models: withEfforts };
+            return resp;
         }
         // ── 嵌入源（远程/本地/关闭 三态）与模型管理 ──
         case 'dsh-memory/embedding-state-get': {
-            if (!embedManager)
-                return { supported: false };
-            return { supported: true, ...(await embedManager.snapshot()) };
+            if (!embedManager) {
+                const v = { supported: false };
+                return v;
+            }
+            const v = { supported: true, ...(await embedManager.snapshot()) };
+            return v;
         }
         case 'dsh-memory/embedding-source-set': {
             if (!embedManager)

package/dist/store/cost-ledger.d.ts

@@ -0,0 +1,78 @@
+/**
+ * 蒸馏成本账本（token_cost 明细表）：从 sqlite.ts 巨石拆出的第一刀（体检 P1）。
+ *
+ * 职责：明细写入（写入时按保留期滚动清理）+ 四路聚合查询（单窗口总览 / 按模型 /
+ * 按层级归并 / 按时间桶）。与检索引擎零关系——唯一的耦合是共享同一个
+ * node:sqlite 连接。成本看板是增强能力：降级/异常一律返回零值，不向上抛错。
+ *
+ * 接口策略：MemoryDb 的四个同名公开方法保持原签名做一行委托（"拆文件不拆接口"），
+ * 既有调用方（token-cost.ts / smoke）零改动。
+ */
+import type { DatabaseSync } from 'node:sqlite';
+import type { CostByModel } from '../contract.js';
+import type { MemoryLogger } from '../types.js';
+/** token_cost 单窗口成本聚合（成本看板用）。 */
+export interface CostAggregate {
+    calls: number;
+    inputChars: number;
+    outputTokens: number;
+    reasoningTokens: number;
+    /** 单次调用输出 token 均值（无数据为 0）。 */
+    avgOutputTokens: number;
+    /** 单次调用输出 token 中位数（无数据为 0）。 */
+    medianOutputTokens: number;
+}
+/** 按层级（l1/l2/l3 归并）分组的成本行。 */
+export interface CostByLayer {
+    layer: string;
+    calls: number;
+    inputChars: number;
+    outputTokens: number;
+    reasoningTokens: number;
+    avgOutputTokens: number;
+    medianOutputTokens: number;
+}
+/** 按时间桶 + provider/model 聚合的扁平行（趋势图与日均/周均/月均 + 中位数统计共用）。 */
+export interface BucketRow {
+    bucket: number;
+    provider: string;
+    model: string;
+    calls: number;
+    outputTokens: number;
+    reasoningTokens: number;
+}
+export declare class CostLedger {
+    private db;
+    private logger;
+    private stmtInsert;
+    private stmtDelete;
+    /** init 是否成功（未就绪 = 宿主库降级，方法全部返回零值不抛错）。 */
+    get ready(): boolean;
+    /** 建表 + 迁移 + 语句缓存（MemoryDb.initSchema 内调用；失败冒泡触发库级降级）。 */
+    init(db: DatabaseSync, logger?: MemoryLogger): void;
+    /**
+     * 记录一次蒸馏调用成本（明细表，写入时按 retentionDays 滚动清理；0 = 永久保留）。
+     * 失败/成功都记（token 照烧）；记账失败记 warn 但不阻断蒸馏（成本看板是增强能力）。
+     */
+    insertCostCall(provider: string, model: string, layer: string, inputChars: number, outputTokens: number, reasoningTokens: number, retentionDays: number): void;
+    /**
+     * 查询 token_cost 单窗口聚合（成本看板用；since 为毫秒起点，0 = 全量）。
+     * 输入口径：inputChars 是字符（llm 流拿不到输入 token，沿用 llm-usage 的字符折算口径）。
+     * median 需取 output_tokens 序列在 JS 侧算（SQLite 无内置 median 函数）。
+     */
+    aggregateCost(since: number): {
+        total: CostAggregate;
+        byModel: CostByModel[];
+    };
+    /**
+     * 按层级归并聚合（l1 = l1-extract + l1-dedup；成本看板层级表格用）。
+     * 降级/异常返回空数组，不抛错。
+     */
+    aggregateCostByLayer(since: number): CostByLayer[];
+    /**
+     * 按时间桶（bucketMs 毫秒）+ model 聚合，返回扁平行。
+     * offsetMs 把桶边界对齐本地时区；layer 为空=全部，'l1' 归并 extract/dedup，其余精确匹配。
+     * 趋势图与「日均/周均/月均 + 中位数」统计共用：JS 侧按不同 bucketMs 调三次再聚合。
+     */
+    aggregateByBucket(bucketMs: number, offsetMs: number, since: number, layer: string): BucketRow[];
+}