dsh-layered-memory 0.8.7 → 0.8.8

package/dist/store/sqlite.d.ts

@@ -9,45 +9,10 @@ export interface StoreCapabilities {
     ftsSearch: boolean;
     vectorSearch: boolean;
 }
-/** token_cost 单窗口成本聚合（成本看板用）。 */
-export interface CostAggregate {
-    calls: number;
-    inputChars: number;
-    outputTokens: number;
-    reasoningTokens: number;
-    /** 单次调用输出 token 均值（无数据为 0）。 */
-    avgOutputTokens: number;
-    /** 单次调用输出 token 中位数（无数据为 0）。 */
-    medianOutputTokens: number;
-}
-/** 按 model 分组的成本行（成本看板用）。 */
-export interface CostByModel {
-    provider: string;
-    model: string;
-    calls: number;
-    inputChars: number;
-    outputTokens: number;
-    reasoningTokens: 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;
-}
+import { CostLedger } from './cost-ledger.js';
+import type { BucketRow, CostAggregate, CostByLayer } from './cost-ledger.js';
+export type { BucketRow, CostAggregate, CostByLayer } from './cost-ledger.js';
+import type { CostByModel } from '../contract.js';
 /** L1 检索命中（含 BM25/余弦归一分数）。 */
 export interface L1SearchHit {
     id: string;
@@ -62,6 +27,7 @@ export interface L1SearchHit {
 export interface L0SearchHit extends L0MessageRecord {
     score: number;
 }
+/** 已排序序列的中位数（偶数个取中间两者平均；空返回 0）。 */
 export declare class MemoryDb {
     private db;
     private degraded;
@@ -83,9 +49,8 @@ export declare class MemoryDb {
     private stmtL1FtsDelete;
     private stmtL1FtsSearch;
     private stmtL1FtsSearchFamily;
-    /** token_cost 明细写入 / 滚动清理语句（构造期 prepare 缓存）。 */
-    private stmtInsertCost;
-    private stmtDeleteCost;
+    /** 成本账本（token_cost 表族；init 内初始化，未就绪时方法返回零值）。 */
+    readonly costLedger: CostLedger;
     private stmtUpsertL0;
     private stmtGetL0;
     /** 主表存在性点查（同 L1：防御性 FTS 删除的前置判断）。 */
@@ -187,31 +152,16 @@ export declare class MemoryDb {
     searchL1Vector(embedding: Float32Array, topK: number, family?: string): L1SearchHit[];
     /** 批量 upsert L0 消息（元数据 + FTS；embeddings 与 records 等长，可省略）。 */
     upsertL0Batch(records: L0MessageRecord[], embeddings?: Array<Float32Array | undefined>): boolean;
-    /**
-     * 记录一次蒸馏调用成本（明细表，写入时按 retentionDays 滚动清理；0 = 永久保留）。
-     * 失败/成功都记（token 照烧）；记账失败记 warn 但不阻断蒸馏（成本看板是增强能力）。
-     */
+    /** 记录一次蒸馏调用成本（委托 cost-ledger；语义见 CostLedger.insertCostCall）。 */
     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 函数）。
-     */
+    /** 查询 token_cost 单窗口聚合（委托 cost-ledger；降级/异常返回零值）。 */
     aggregateCost(since: number): {
         total: CostAggregate;
         byModel: CostByModel[];
     };
-    /**
-     * 按层级归并聚合（l1 = l1-extract + l1-dedup；成本看板层级表格用）。
-     * 降级/异常返回空数组，不抛错。
-     */
+    /** 按层级归并聚合（委托 cost-ledger；降级/异常返回空数组）。 */
     aggregateCostByLayer(since: number): CostByLayer[];
-    /**
-     * 按时间桶（bucketMs 毫秒）+ model 聚合，返回扁平行。
-     * offsetMs 把桶边界对齐本地时区；layer 为空=全部，'l1' 归并 extract/dedup，其余精确匹配。
-     * 趋势图与「日均/周均/月均 + 中位数」统计共用：JS 侧按不同 bucketMs 调三次再聚合。
-     */
+    /** 按时间桶 + model 聚合（委托 cost-ledger；趋势图与日均/周均/月均共用）。 */
     aggregateByBucket(bucketMs: number, offsetMs: number, since: number, layer: string): BucketRow[];
     countL0(): number;
     /** 统计 recorded_at >= iso 的消息数（状态面板"今日捕获"用）。 */

package/dist/store/sqlite.js

@@ -22,6 +22,9 @@ import { bm25RankToScore, buildFtsQuery, tokenizeForFts } from './search-utils.j
 import { describeTokenizer, ensureTokenizer, tokenizerStamp } from '../util/tokenizer.js';
 const require = createRequire(import.meta.url);
 const TAG = '[memory][sqlite]';
+// 成本账本（token_cost 表族：类型 + 实现）已整体迁出到 ./cost-ledger.ts——与检索引擎
+// 零关系的独立职责；此处 re-export 不断裂既有引用，MemoryDb 四个公开方法改为一行委托。
+import { CostLedger } from './cost-ledger.js';
 /** vec0 KNN 对遗留零向量的补偿缓冲（官方同款）。 */
 const ZERO_VEC_BUFFER = 10;
 /** IN 查询/删除的分块大小（保守避开 SQLite 变量数上限：现代构建 32766，老版 999）。 */
@@ -39,13 +42,6 @@ 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 === 1 ? sorted[mid] : (sorted[mid - 1] + sorted[mid]) / 2;
-}
 export class MemoryDb {
     db;
     degraded = false;
@@ -67,9 +63,8 @@ export class MemoryDb {
     stmtL1FtsDelete;
     stmtL1FtsSearch;
     stmtL1FtsSearchFamily;
-    /** token_cost 明细写入 / 滚动清理语句（构造期 prepare 缓存）。 */
-    stmtInsertCost;
-    stmtDeleteCost;
+    /** 成本账本（token_cost 表族；init 内初始化，未就绪时方法返回零值）。 */
+    costLedger = new CostLedger();
     stmtUpsertL0;
     stmtGetL0;
     /** 主表存在性点查（同 L1：防御性 FTS 删除的前置判断）。 */
@@ -339,25 +334,8 @@ export class MemoryDb {
         this.stmtGetL0 = this.db.prepare('SELECT session_id, role, message_text, recorded_at, timestamp FROM l0_conversations WHERE record_id = ?');
         this.stmtL0Exists = this.db.prepare('SELECT 1 FROM l0_conversations WHERE record_id = ?');
         this.prepareL0VecStatements();
-        // ── token_cost：蒸馏成本明细表（成本看板用；保留期经 retentionDays 滚动清理） ──
-        this.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）
-        if (this.tableExists('token_cost') && !this.hasColumn('token_cost', 'provider')) {
-            this.db.exec("ALTER TABLE token_cost ADD COLUMN provider TEXT NOT NULL DEFAULT 'unknown'");
-        }
-        this.db.exec('CREATE INDEX IF NOT EXISTS idx_token_cost_ts ON token_cost(ts)');
-        this.stmtInsertCost = this.db.prepare('INSERT INTO token_cost (ts, provider, model, layer, input_chars, output_tokens, reasoning_tokens) VALUES (?, ?, ?, ?, ?, ?, ?)');
-        this.stmtDeleteCost = this.db.prepare('DELETE FROM token_cost WHERE ts < ?');
+        // ── token_cost：蒸馏成本明细表（成本账本自治；见 cost-ledger.ts） ──
+        this.costLedger.init(this.db, this.logger);
         // ── FTS5 全文索引（建表失败仅停用 FTS，不降级整个库） ──
         try {
             // 索引重建判据（FTS5 无法 ALTER，只能 drop 后从源表全量回灌）：
@@ -1011,134 +989,21 @@ export class MemoryDb {
             return false;
         }
     }
-    /**
-     * 记录一次蒸馏调用成本（明细表，写入时按 retentionDays 滚动清理；0 = 永久保留）。
-     * 失败/成功都记（token 照烧）；记账失败记 warn 但不阻断蒸馏（成本看板是增强能力）。
-     */
+    /** 记录一次蒸馏调用成本（委托 cost-ledger；语义见 CostLedger.insertCostCall）。 */
     insertCostCall(provider, model, layer, inputChars, outputTokens, reasoningTokens, retentionDays) {
-        if (this.degraded)
-            return;
-        try {
-            this.stmtInsertCost.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.stmtDeleteCost.run(Date.now() - retentionDays * 24 * 3600_000);
-        }
-        catch (err) {
-            this.logger?.warn(`${TAG} token_cost 记账失败: ${err instanceof Error ? err.message : String(err)}`);
-        }
+        this.costLedger.insertCostCall(provider, model, layer, inputChars, outputTokens, reasoningTokens, retentionDays);
     }
-    /**
-     * 查询 token_cost 单窗口聚合（成本看板用；since 为毫秒起点，0 = 全量）。
-     * 输入口径：inputChars 是字符（llm 流拿不到输入 token，沿用 llm-usage 的字符折算口径）。
-     * 成本看板是增强能力：降级态/查询异常一律返回零值，不向上抛错。
-     * median 需取 output_tokens 序列在 JS 侧算（SQLite 无内置 median 函数）。
-     */
+    /** 查询 token_cost 单窗口聚合（委托 cost-ledger；降级/异常返回零值）。 */
     aggregateCost(since) {
-        if (this.degraded)
-            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: [] };
-        }
+        return this.costLedger.aggregateCost(since);
     }
-    /**
-     * 按层级归并聚合（l1 = l1-extract + l1-dedup；成本看板层级表格用）。
-     * 降级/异常返回空数组，不抛错。
-     */
+    /** 按层级归并聚合（委托 cost-ledger；降级/异常返回空数组）。 */
     aggregateCostByLayer(since) {
-        if (this.degraded)
-            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 [];
-        }
+        return this.costLedger.aggregateCostByLayer(since);
     }
-    /**
-     * 按时间桶（bucketMs 毫秒）+ model 聚合，返回扁平行。
-     * offsetMs 把桶边界对齐本地时区；layer 为空=全部，'l1' 归并 extract/dedup，其余精确匹配。
-     * 趋势图与「日均/周均/月均 + 中位数」统计共用：JS 侧按不同 bucketMs 调三次再聚合。
-     */
+    /** 按时间桶 + model 聚合（委托 cost-ledger；趋势图与日均/周均/月均共用）。 */
     aggregateByBucket(bucketMs, offsetMs, since, layer) {
-        if (this.degraded)
-            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 [];
-        }
+        return this.costLedger.aggregateByBucket(bucketMs, offsetMs, since, layer);
     }
     countL0() {
         if (this.degraded)

package/dist/token-cost.d.ts

@@ -7,84 +7,15 @@
  * 与作者 llm-usage.ts 的关系：作者是"按 layer 累计的纯内存计数器"（给 bench 用）；
  * 本模块补上三个缺口——按 model 分组、持久化（保留期可配置，默认 365 天）、面向 UI 成本看板。
  */
+import type { CostSnapshot, Granularity } from './contract.js';
 import type { DistillLayer } from './llm-usage.js';
-import type { CostByModel, MemoryDb } from './store/sqlite.js';
+import type { MemoryDb } from './store/sqlite.js';
+export type { CostWindow, Granularity, ModelMetrics, LayerMetrics, LayerWindow, LayerCost, TrendBucket, TrendSnapshot, CostSnapshot, } from './contract.js';
 /** 插件启动时注入 db 与明细保留期（index.ts 调用；retentionDays 0 = 永久保留）。 */
 export declare function initTokenCost(d: MemoryDb, retention: number): void;
 /** 插件卸载时清空 db 引用（index.ts 的 ctx.effect 清理里调用，防悬空引用）。 */
 export declare function resetTokenCost(): void;
 /** 记录一次蒸馏调用成本（callLLM 出口调用；provider/model 由调用方传入）。 */
 export declare function recordCostCall(provider: string, model: string, layer: DistillLayer, inputChars: number, outputTokens: number, reasoningTokens: number): void;
-/** 成本看板单个时间窗口（day/week/month/all）。 */
-export interface CostWindow {
-    range: 'day' | 'week' | 'month' | 'all';
-    /** 窗口起点（毫秒；all 为 0）。 */
-    since: number;
-    calls: number;
-    inputChars: number;
-    outputTokens: number;
-    reasoningTokens: number;
-    avgOutputTokens: number;
-    medianOutputTokens: number;
-}
-/** 成本看板时间粒度（趋势图 + 统计口径共用）。 */
-export type Granularity = 'day' | 'week' | 'month';
-/** 每模型统计指标（层级表格行；均值/中位数按 since=0 全量历史的活跃桶口径，非「最近窗口」）。 */
-export interface ModelMetrics {
-    model: string;
-    dayCalls: number;
-    weekCalls: number;
-    monthCalls: number;
-    dayOutput: number;
-    dayMedian: number;
-    weekOutput: number;
-    weekMedian: number;
-    monthOutput: number;
-    monthMedian: number;
-}
-/** 每层级（l1/l2/l3）的模型统计（层级表格）。 */
-export interface LayerMetrics {
-    layer: 'l1' | 'l2' | 'l3';
-    models: ModelMetrics[];
-}
-/** 层级 × 窗口矩阵里的单个窗口格子。 */
-export interface LayerWindow {
-    range: 'day' | 'week' | 'month' | 'all';
-    calls: number;
-    inputChars: number;
-    outputTokens: number;
-    reasoningTokens: number;
-    avgOutputTokens: number;
-    medianOutputTokens: number;
-}
-/** 单个层级在四个窗口的聚合（层级×窗口表格行）。 */
-export interface LayerCost {
-    layer: 'l1' | 'l2' | 'l3';
-    windows: LayerWindow[];
-}
-/** 趋势单桶。 */
-export interface TrendBucket {
-    ts: number;
-    total: number;
-    byModel: Record<string, number>;
-}
-/** 趋势快照：三个层级各一份连续桶序列。 */
-export interface TrendSnapshot {
-    granularity: Granularity;
-    byLayer: Record<'l1' | 'l2' | 'l3', TrendBucket[]>;
-}
-/** 成本看板快照（dsh-memory/token-cost 端点返回值）。 */
-export interface CostSnapshot {
-    /** day/week/month/all 四窗口聚合。 */
-    windows: CostWindow[];
-    /** 全量窗口（all）按 model 分组。 */
-    byModel: CostByModel[];
-    /** 按层级（l1/l2/l3 归并）在四个窗口的聚合（层级×窗口表格）。 */
-    byLayer: LayerCost[];
-    /** 每层级的模型统计指标（层级表格）。 */
-    byLayerStats: LayerMetrics[];
-    /** 趋势图数据。 */
-    trend: TrendSnapshot;
-}
 /** 读成本看板快照（db 未注入/降级时返回全零结构，不抛错；rangeDays>0 = 趋势展示近 N 天）。 */
 export declare function snapshotTokenCost(granularity: Granularity, rangeDays: number): CostSnapshot;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "dsh-layered-memory",
-  "version": "0.8.7",
+  "version": "0.8.8",
   "description": "L0~L3 分层蒸馏记忆插件 for DeepSeek Harness：自动捕获对话（L0）、抽取原子记忆（L1）、整合场景块（L2）、蒸馏核心画像/团队方法论（L3），并在模型步骤前自动召回注入。移植自 MemoryCore (TencentDB Agent Memory) 的管线设计。",
   "type": "module",
   "main": "dist/index.js",
@@ -31,9 +31,11 @@
     "cordis.patch.yml"
   ],
   "scripts": {
-    "build": "tsc -p tsconfig.json && node scripts/copy-client.mjs",
-    "smoke": "node dist-smoke/smoke.js",
-    "verify-catalog": "npm run build && node scripts/verify-catalog.mjs"
+    "build": "tsc -p tsconfig.json && node scripts/build-client.mjs && node scripts/copy-client.mjs",
+    "smoke": "npm run build:smoke && node dist-smoke/smoke.js",
+    "verify-catalog": "npm run build && node scripts/verify-catalog.mjs",
+    "typecheck": "tsc -p tsconfig.json --noEmit && tsc -p tsconfig.client.json --noEmit",
+    "build:smoke": "tsc src/smoke.ts --outDir dist-smoke --module nodenext --moduleResolution nodenext --target es2022 --strict --skipLibCheck --esModuleInterop"
   },
   "engines": {
     "node": ">=22.16.0"
@@ -78,6 +80,8 @@
     "@deepseek-ai/dsh-system-prompt": "0.1.1-rc.2",
     "@deepseek-ai/dsh-tools": "0.1.1-rc.2",
     "@types/node": "^22.0.0",
+    "@types/react": "^19.2.18",
+    "esbuild": "^0.28.2",
     "typescript": "^5.6.0"
   }
 }