dsh-layered-memory 0.8.7 → 0.8.8

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,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, 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,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,
@@ -211,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;
@@ -234,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,
@@ -268,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)
@@ -278,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）——此前此处漏扩词表，
@@ -322,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 ?? {});
@@ -338,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': {
             // 两族拼接展示（浏览器保持混合视图；路径冲突时后写入的族覆盖显示名，读取仍各自独立）
@@ -381,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': {
@@ -407,6 +427,7 @@ async function handleEndpoint(endpoint, payload, deps) {
         // ── 蒸馏模型选择器（用户已配置的供应商路由） ──
         case 'dsh-memory/llm-providers': {
             // 供应商目录（已注册适配器的活动路由）+ 默认选择 + 当前覆盖与实际生效路由
+            // ——蒸馏路由链编辑器的数据源（供应商下拉/默认模型展示/链状态 chain 块）
             let providers = [];
             try {
                 providers = deps.ctx.llm.listProviders();
@@ -425,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,
@@ -442,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 ?? {});
@@ -456,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 [];
+        }
+    }
+}

package/dist/store/download-queue.d.ts

@@ -1,24 +1,7 @@
 import type { MemoryLogger } from '../types.js';
 import { type CatalogEntry } from './model-catalog.js';
-export type DownloadPhase = 'downloading' | 'verifying' | 'done' | 'cancelled' | 'error';
-export interface DownloadProgress {
-    modelId: string;
-    phase: DownloadPhase;
-    /** 当前文件序号（1-based）。 */
-    fileIndex: number;
-    fileCount: number;
-    /** 当前文件已收字节（含续传基线）。 */
-    fileReceived: number;
-    fileTotal: number;
-    /** 整模型累计字节（含已完成文件；分母 = 目录总大小）。 */
-    overallReceived: number;
-    overallTotal: number;
-    /** EMA 平滑速度（字节/秒）。 */
-    speedBps: number;
-    startedAt: number;
-    /** phase=error 时的原因。 */
-    error?: string;
-}
+import type { DownloadProgress } from '../contract.js';
+export type { DownloadPhase, DownloadProgress } from '../contract.js';
 export interface ModelStatus {
     id: string;
     /** none=未下载；partial=有断点/不完整；downloaded=全部文件就位且尺寸吻合。 */
@@ -104,4 +87,3 @@ export declare function resolveProxyUrl(setting: string | undefined, host: strin
 /** 代理 URL 日志脱敏：剥掉 userinfo（内网代理常带 user:pass 凭据），只留 scheme//host；
  *  解析失败的串原样也可能是凭据形态，返回占位符。 */
 export declare function maskProxyUrl(proxy: string): string;
-export {};

package/dist/store/embedding-source.d.ts

@@ -7,7 +7,8 @@ import { LocalEmbeddingService } from './local-embedding.js';
 import { ModelDownloadQueue } from './download-queue.js';
 import { RuntimeInstaller } from './runtime-installer.js';
 import type { MemoryDb } from './sqlite.js';
-export type EmbeddingSourceKind = 'remote' | 'local' | 'off';
+import type { EmbeddingSourceKind, EmbeddingStateView } from '../contract.js';
+export type { ApplyPhase, EmbeddingSourceKind, EmbeddingStateView, ReindexProgressState } from '../contract.js';
 export interface EmbeddingSourceState {
     source: EmbeddingSourceKind;
     /** source=local 时启用的目录模型 id。 */
@@ -38,17 +39,6 @@ export declare function resolveInitialEmbedding(cfg: MemoryConfig, sourceStore:
 /** 本地服务构造工厂（index.ts 的初始解析与 Manager 共用一份实现，防漂移）。
  *  推理在 worker 线程（见 local-embedding.ts）；此处只传 runtime 目录与模型目录。 */
 export declare function makeLocalServiceFactory(installer: RuntimeInstaller, downloader: ModelDownloadQueue, logger?: MemoryLogger, maxInputChars?: number): (modelId: string) => LocalEmbeddingService | null;
-export type ApplyPhase = 'idle' | 'installing-runtime' | 'warming' | 'switching' | 'reindexing' | 'done' | 'error';
-export interface ReindexProgressState {
-    running: boolean;
-    l1Done: number;
-    l1Total: number;
-    l0Done: number;
-    l0Total: number;
-    startedAt: number;
-    cancelled: boolean;
-    error?: string;
-}
 export interface EmbeddingManagerDeps {
     dataDir: string;
     cfg: MemoryConfig;
@@ -119,43 +109,3 @@ export declare class EmbeddingManager {
     /** RPC 快照（设置页嵌入区块数据源；client 忙时 1s 轮询）。 */
     snapshot(): Promise<EmbeddingStateView>;
 }
-export interface EmbeddingStateView {
-    source: EmbeddingSourceKind;
-    activeModel: string | null;
-    ceilings: {
-        remote: boolean;
-        local: boolean;
-    };
-    runtime: {
-        targetVersion: string;
-        phase: 'idle' | 'installing' | 'ready' | 'error' | 'cancelled';
-        installedVersion: string | null;
-        elapsedMs: number;
-        lastLines: string[];
-        error?: string;
-    };
-    models: Array<{
-        id: string;
-        name: string;
-        dims: number;
-        contextTokens: number;
-        tags: string[];
-        description: string;
-        totalBytes: number;
-        bytesOnDisk: number;
-        state: 'none' | 'partial' | 'downloaded';
-    }>;
-    download: ReturnType<ModelDownloadQueue['getProgress']>;
-    apply: {
-        phase: ApplyPhase;
-        message: string;
-        startedAt: number;
-        busy: boolean;
-    };
-    local: {
-        state: 'idle' | 'loading' | 'ready' | 'failed' | 'terminated';
-        error: string | null;
-    } | null;
-    reindex: ReindexProgressState;
-    activeNote?: string;
-}

package/dist/store/runtime-installer.d.ts

@@ -1,19 +1,8 @@
 import type { MemoryLogger } from '../types.js';
 /** 钉死的 transformers.js 版本（D8：精确版本，升级插件时在此变更并重装运行时）。 */
 export declare const PINNED_TRANSFORMERS_VERSION = "4.2.0";
-export interface RuntimeProgress {
-    phase: 'idle' | 'installing' | 'ready' | 'error' | 'cancelled';
-    /** 插件钉死的目标版本。 */
-    targetVersion: string;
-    /** runtime 里实际就位的版本（未安装为 null）。 */
-    installedVersion: string | null;
-    startedAt: number;
-    /** 已运行毫秒（读时计算）。 */
-    elapsedMs: number;
-    /** npm 输出尾行（最近 5 行，让用户看到 npm 在干什么）。 */
-    lastLines: string[];
-    error?: string;
-}
+import type { RuntimeProgress } from '../contract.js';
+export type { RuntimeProgress } from '../contract.js';
 /** 子进程抽象（测试注入缝）：注册输出行回调 + 终止 + 终态。 */
 export interface SpawnedProcess {
     onStdout(cb: (line: string) => void): void;