dsh-layered-memory 0.8.6 → 0.8.8

package/dist/settings.js

@@ -1,6 +1,61 @@
 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 = 通过）。 */
+export function validateDistillChain(chain) {
+    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 ((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,6 +65,7 @@ const ALWAYS_ON = {
     reasoningEffort: '',
     distillProvider: '',
     distillModel: '',
+    distillChain: [],
     distillBudgets: { extract: 0, dedup: 0, l2: 0, l3: 0 },
     distillMaxInputChars: 0,
 };
@@ -40,6 +96,11 @@ 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([]),
         distillBudgets: Schema.object({
             extract: budget(),
             dedup: budget(),
@@ -153,10 +214,28 @@ 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 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,
+        });
+    }
     return {
         enabled: v.enabled !== false,
         capture: v.capture !== false,
@@ -167,6 +246,7 @@ function resolveSettings(value) {
             : '',
         distillProvider: typeof v.distillProvider === 'string' ? v.distillProvider : '',
         distillModel: typeof v.distillModel === 'string' ? v.distillModel : '',
+        distillChain: chain,
         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';
@@ -44,31 +44,7 @@ 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;
-    };
-}
+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,8 +12,10 @@ 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, 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);
 export const PLUGIN_VERSION = require('../package.json').version;
 /** 注册状态 RPC（web 侧 connection 服务可选，缺失时跳过，不影响插件主体）。 */
@@ -148,12 +150,23 @@ async function handleEndpoint(endpoint, payload, deps) {
     switch (endpoint) {
         case 'dsh-memory/stats':
             return buildStats(cfg, stores, status);
+        case 'dsh-memory/token-cost': {
+            const p = (payload ?? {});
+            const granularity = p.granularity === 'week' || p.granularity === 'month' ? p.granularity : 'day';
+            // rangeDays 须为正整数且不超过明细保留期（tokenCost.retentionDays，0=永久保留则放行 1~3650），否则回退默认窗口
+            const retention = cfg.tokenCost.retentionDays;
+            const upper = retention > 0 ? retention : 3650;
+            const rawDays = p.rangeDays;
+            const rangeDays = typeof rawDays === 'number' && Number.isInteger(rawDays) && rawDays > 0 && rawDays <= upper ? rawDays : 0;
+            return snapshotTokenCost(granularity, rangeDays);
+        }
         case 'dsh-memory/session-mode-get': {
             if (!modes)
                 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)
@@ -166,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': {
@@ -185,7 +199,7 @@ 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 {
+            const v = {
                 supported: true,
                 sessionId,
                 mode,
@@ -200,13 +214,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;
@@ -223,17 +240,18 @@ 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,
                 },
                 // 静态部署上限（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,
@@ -257,6 +275,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)
@@ -267,6 +286,13 @@ 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;
+            }
             if (patch.reasoningEffort !== undefined) {
                 const v = String(patch.reasoningEffort);
                 // 白名单与 schema/settings 同源（config.ts EFFORT_CHOICES）——此前此处漏扩词表，
@@ -311,7 +337,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 ?? {});
@@ -327,22 +354,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': {
             // 两族拼接展示（浏览器保持混合视图；路径冲突时后写入的族覆盖显示名，读取仍各自独立）
@@ -370,8 +399,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': {
@@ -396,6 +427,7 @@ async function handleEndpoint(endpoint, payload, deps) {
         // ── 蒸馏模型选择器（用户已配置的供应商路由） ──
         case 'dsh-memory/llm-providers': {
             // 供应商目录（已注册适配器的活动路由）+ 默认选择 + 当前覆盖与实际生效路由
+            // ——蒸馏路由链编辑器的数据源（供应商下拉/默认模型展示/链状态 chain 块）
             let providers = [];
             try {
                 providers = deps.ctx.llm.listProviders();
@@ -414,14 +446,21 @@ 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;
             try {
-                effective = await resolveModelRoute(deps.ctx, effectiveCfg(cfg, live));
+                const 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 resp = {
                 supported: true,
                 providers,
                 default: def,
@@ -431,7 +470,14 @@ async function handleEndpoint(endpoint, payload, deps) {
                 // 所选供应商是否仍在已注册路由中（用户删掉供应商后提示回退）
                 currentRegistered: current.provider === '' || providers.some((p) => p.id === current.provider),
                 effective,
+                chain: {
+                    current: chainCurrent,
+                    static: cfg.llm.fallbacks ?? [],
+                    effectiveChain,
+                    source: chainCurrent.length ? 'runtime' : 'static',
+                },
             };
+            return resp;
         }
         case 'dsh-memory/llm-models': {
             const p = (payload ?? {});
@@ -445,16 +491,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[];
+}

package/dist/store/cost-ledger.js

@@ -0,0 +1,173 @@
+function emptyCostAggregate() {
+    return { calls: 0, inputChars: 0, outputTokens: 0, reasoningTokens: 0, avgOutputTokens: 0, medianOutputTokens: 0 };
+}
+/** 已排序序列的中位数（偶数个取中间两者平均；空返回 0）。 */
+function medianOf(sorted) {
+    const n = sorted.length;
+    if (n === 0)
+        return 0;
+    const mid = Math.floor(n / 2);
+    return n % 2 ? sorted[mid] : (sorted[mid - 1] + sorted[mid]) / 2;
+}
+export class CostLedger {
+    db = null;
+    logger;
+    stmtInsert = null;
+    stmtDelete = null;
+    /** init 是否成功（未就绪 = 宿主库降级，方法全部返回零值不抛错）。 */
+    get ready() {
+        return this.stmtInsert !== null;
+    }
+    /** 建表 + 迁移 + 语句缓存（MemoryDb.initSchema 内调用；失败冒泡触发库级降级）。 */
+    init(db, logger) {
+        this.db = db;
+        this.logger = logger;
+        db.exec(`
+      CREATE TABLE IF NOT EXISTS token_cost (
+        ts INTEGER NOT NULL,
+        provider TEXT NOT NULL,
+        model TEXT NOT NULL,
+        layer TEXT NOT NULL,
+        input_chars INTEGER NOT NULL DEFAULT 0,
+        output_tokens INTEGER NOT NULL DEFAULT 0,
+        reasoning_tokens INTEGER NOT NULL DEFAULT 0
+      )
+    `);
+        // 迁移：provider/model 复合键引入前的旧表补 provider 列（历史行回填 unknown）
+        const cols = db.prepare('PRAGMA table_info(token_cost)').all();
+        if (!cols.some((c) => c.name === 'provider')) {
+            db.exec("ALTER TABLE token_cost ADD COLUMN provider TEXT NOT NULL DEFAULT 'unknown'");
+        }
+        db.exec('CREATE INDEX IF NOT EXISTS idx_token_cost_ts ON token_cost(ts)');
+        this.stmtInsert = db.prepare('INSERT INTO token_cost (ts, provider, model, layer, input_chars, output_tokens, reasoning_tokens) VALUES (?, ?, ?, ?, ?, ?, ?)');
+        this.stmtDelete = db.prepare('DELETE FROM token_cost WHERE ts < ?');
+    }
+    /**
+     * 记录一次蒸馏调用成本（明细表，写入时按 retentionDays 滚动清理；0 = 永久保留）。
+     * 失败/成功都记（token 照烧）；记账失败记 warn 但不阻断蒸馏（成本看板是增强能力）。
+     */
+    insertCostCall(provider, model, layer, inputChars, outputTokens, reasoningTokens, retentionDays) {
+        if (!this.db || !this.stmtInsert || !this.stmtDelete)
+            return;
+        try {
+            this.stmtInsert.run(Date.now(), provider, model, layer, Math.max(0, Math.round(inputChars)), Math.max(0, Math.round(outputTokens)), Math.max(0, Math.round(reasoningTokens)));
+            if (retentionDays > 0)
+                this.stmtDelete.run(Date.now() - retentionDays * 24 * 3600_000);
+        }
+        catch (err) {
+            this.logger?.warn(`[memory][sqlite] token_cost 记账失败: ${err instanceof Error ? err.message : String(err)}`);
+        }
+    }
+    /**
+     * 查询 token_cost 单窗口聚合（成本看板用；since 为毫秒起点，0 = 全量）。
+     * 输入口径：inputChars 是字符（llm 流拿不到输入 token，沿用 llm-usage 的字符折算口径）。
+     * median 需取 output_tokens 序列在 JS 侧算（SQLite 无内置 median 函数）。
+     */
+    aggregateCost(since) {
+        if (!this.ready || !this.db)
+            return { total: emptyCostAggregate(), byModel: [] };
+        try {
+            const total = this.db
+                .prepare(`SELECT COUNT(*) AS calls,
+                  COALESCE(SUM(input_chars), 0) AS inputChars,
+                  COALESCE(SUM(output_tokens), 0) AS outputTokens,
+                  COALESCE(SUM(reasoning_tokens), 0) AS reasoningTokens,
+                  COALESCE(AVG(output_tokens), 0) AS avgOutputTokens
+             FROM token_cost WHERE ts >= ?`)
+                .get(since);
+            const tokenRows = this.db
+                .prepare('SELECT output_tokens FROM token_cost WHERE ts >= ? ORDER BY output_tokens')
+                .all(since);
+            const byModel = this.db
+                .prepare(`SELECT provider, model, COUNT(*) AS calls,
+                  COALESCE(SUM(input_chars), 0) AS inputChars,
+                  COALESCE(SUM(output_tokens), 0) AS outputTokens,
+                  COALESCE(SUM(reasoning_tokens), 0) AS reasoningTokens
+             FROM token_cost WHERE ts >= ? GROUP BY provider, model ORDER BY outputTokens DESC`)
+                .all(since);
+            return {
+                total: {
+                    calls: total.calls,
+                    inputChars: total.inputChars,
+                    outputTokens: total.outputTokens,
+                    reasoningTokens: total.reasoningTokens,
+                    avgOutputTokens: total.avgOutputTokens,
+                    medianOutputTokens: medianOf(tokenRows.map((r) => r.output_tokens)),
+                },
+                byModel,
+            };
+        }
+        catch {
+            return { total: emptyCostAggregate(), byModel: [] };
+        }
+    }
+    /**
+     * 按层级归并聚合（l1 = l1-extract + l1-dedup；成本看板层级表格用）。
+     * 降级/异常返回空数组，不抛错。
+     */
+    aggregateCostByLayer(since) {
+        if (!this.ready || !this.db)
+            return [];
+        try {
+            const rows = this.db
+                .prepare(`SELECT CASE WHEN layer IN ('l1-extract','l1-dedup') THEN 'l1' ELSE layer END AS layer,
+                  COUNT(*) AS calls,
+                  COALESCE(SUM(input_chars), 0) AS inputChars,
+                  COALESCE(SUM(output_tokens), 0) AS outputTokens,
+                  COALESCE(SUM(reasoning_tokens), 0) AS reasoningTokens,
+                  COALESCE(AVG(output_tokens), 0) AS avgOutputTokens
+             FROM token_cost WHERE ts >= ? GROUP BY layer ORDER BY layer`)
+                .all(since);
+            // 中位数需取 output_tokens 序列在 JS 侧算（SQLite 无内置 median）
+            const tokenRows = this.db
+                .prepare(`SELECT CASE WHEN layer IN ('l1-extract','l1-dedup') THEN 'l1' ELSE layer END AS layer,
+                  output_tokens
+             FROM token_cost WHERE ts >= ? ORDER BY layer, output_tokens`)
+                .all(since);
+            const medianByLayer = new Map();
+            for (const r of tokenRows) {
+                const arr = medianByLayer.get(r.layer);
+                if (arr)
+                    arr.push(r.output_tokens);
+                else
+                    medianByLayer.set(r.layer, [r.output_tokens]);
+            }
+            return rows.map((r) => ({
+                ...r,
+                medianOutputTokens: medianOf(medianByLayer.get(r.layer) ?? []),
+            }));
+        }
+        catch {
+            return [];
+        }
+    }
+    /**
+     * 按时间桶（bucketMs 毫秒）+ model 聚合，返回扁平行。
+     * offsetMs 把桶边界对齐本地时区；layer 为空=全部，'l1' 归并 extract/dedup，其余精确匹配。
+     * 趋势图与「日均/周均/月均 + 中位数」统计共用：JS 侧按不同 bucketMs 调三次再聚合。
+     */
+    aggregateByBucket(bucketMs, offsetMs, since, layer) {
+        if (!this.ready || !this.db)
+            return [];
+        try {
+            let sql = `SELECT CAST((ts + ?) / ? AS INTEGER) AS bucket, provider, model,
+                COUNT(*) AS calls,
+                COALESCE(SUM(output_tokens), 0) AS outputTokens,
+                COALESCE(SUM(reasoning_tokens), 0) AS reasoningTokens
+           FROM token_cost WHERE ts >= ?`;
+            const params = [offsetMs, bucketMs, since];
+            if (layer === 'l1') {
+                sql += ` AND layer IN ('l1-extract','l1-dedup')`;
+            }
+            else if (layer) {
+                sql += ` AND layer = ?`;
+                params.push(layer);
+            }
+            sql += ` GROUP BY bucket, provider, model ORDER BY bucket, provider, model`;
+            return this.db.prepare(sql).all(...params);
+        }
+        catch {
+            return [];
+        }
+    }
+}