dsh-layered-memory 0.8.7 → 0.8.9

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/dist/util/context-occupancy.d.ts

@@ -0,0 +1,68 @@
+/**
+ * 上下文占用账本：插件注入内容在当前会话上下文窗口中的启发式 token 存量。
+ *
+ * 本模块是全部占用数字的**唯一算术来源**（host 记账与 client 渲染共用，esbuild
+ * 将其内联进 client bundle），任何一侧不得另写算法。口径与官方
+ * @deepseek-ai/dsh-token-meter/estimate 的固定密度启发式同式：
+ *
+ *   - text 块 = ceil(chars / 4) + 4（块开销）；
+ *   - 整条 user 消息（召回注入体的形态）再叠加 role overhead 4；
+ *   - 系统提示里的稳定区**子片**计入时不加任何 overhead——那 +8 是官方对整段
+ *     消息/整体系统提示的结构成本，切片重复计会与官方总数对不上；
+ *   - 字符数一律 JS `.length`（UTF-16 单元），与官方产出严格可比。
+ */
+/** 固定文本密度：每 4 字符记 1 token（官方 CHARS_PER_TOKEN 同值）。 */
+export declare const CHARS_PER_TOKEN = 4;
+/** 召回注入体（单 text 块 user message）的启发式 token 数。 */
+export declare function estimateInjectedMessageTokens(chars: number): number;
+/** 稳定区子片的启发式 token 数（不加结构开销，见模块头注释）。 */
+export declare function estimateStableSectionTokens(chars: number): number;
+/**
+ * 单会话占用账本（权威账本只存在于 host 侧；client 仅消费展示）。
+ * stockTokens = recallTokens + profileTokens 恒等式由三个迁移函数共同维护。
+ */
+export interface OccupancyLedger {
+    /** 当前估算仍在上下文窗口内的记忆存量（token）。 */
+    stockTokens: number;
+    /** 累计召回注入存留份额。 */
+    recallTokens: number;
+    /** 系统提示稳定区当前份额（OFF 使 text() 返回空时即时清零）。 */
+    profileTokens: number;
+    /** 最近一轮召回注入的增量（悬浮卡/面板"最近一次"语义）。 */
+    lastInjectTokens: number;
+    updatedAt: number;
+}
+export declare function emptyOccupancyLedger(now?: number): OccupancyLedger;
+/** 召回注入成功后的入账（失败跳过的轮次不调用——账目零扰动）。 */
+export declare function recordRecallInjection(l: OccupancyLedger, chars: number, now?: number): void;
+/**
+ * 稳定区份额随每次实际组进的文本同步（含切回非 OFF 的重新计入）：
+ * 增量记账保证重复调用不双算，清零后重设即可净额回补。
+ */
+export declare function recordProfileShare(l: OccupancyLedger, chars: number, now?: number): void;
+/** OFF 边界：稳定区随下一次请求组装物理离场，账目同边界清零（宁低勿高）。 */
+export declare function clearProfileShare(l: OccupancyLedger, now?: number): void;
+/**
+ * compaction 复位：v1 采用"清零重新累积"的低估近似——被压缩掉的注入以整数轮粒度
+ * 退出账本，幸存的摘要行不重复认领（已知限制，方向宁低勿高；事件级精确对齐留待 v2）。
+ */
+export declare function resetForCompaction(l: OccupancyLedger, now?: number): void;
+/**
+ * 官方上下文环周长：viewBox 14 内 r=5.5 圆（2π×5.5 ≈ 34.55751918948772），
+ * 与真机反推的官方 fill dasharray 分母逐字一致。
+ */
+export declare const CONTEXT_METER_CIRCUMFERENCE = 34.55751918948772;
+/**
+ * 光晕弧 stroke-dasharray：形状沿用官方 fill（len + 全周长 gap）。
+ * @param occupancyRatio 占窗口比 0..1（越界钳制）。
+ * @param minLen 最小可见弧长（单位=-viewBox 坐标；14px 渲染下 <1 单位即亚像素不可见，
+ *  真实占比常低至 0.6%≈0.2 单位——指示灯语义需要"存在即可见"，精确数字归面板）。
+ */
+export declare function haloDashArray(occupancyRatio: number, circumference?: number, minLen?: number): string;
+/** 官方环触发按钮的结构签名（locale 无关定位依据；见组件设计 C1 锚点节）。 */
+export interface ContextMeterAnchorSignature {
+    ariaHasPopup?: string | null;
+    viewBox?: string | null;
+    circleRadii?: ReadonlyArray<number>;
+}
+export declare function isContextMeterAnchor(sig: ContextMeterAnchorSignature): boolean;

package/dist/util/context-occupancy.js

@@ -0,0 +1,92 @@
+/**
+ * 上下文占用账本：插件注入内容在当前会话上下文窗口中的启发式 token 存量。
+ *
+ * 本模块是全部占用数字的**唯一算术来源**（host 记账与 client 渲染共用，esbuild
+ * 将其内联进 client bundle），任何一侧不得另写算法。口径与官方
+ * @deepseek-ai/dsh-token-meter/estimate 的固定密度启发式同式：
+ *
+ *   - text 块 = ceil(chars / 4) + 4（块开销）；
+ *   - 整条 user 消息（召回注入体的形态）再叠加 role overhead 4；
+ *   - 系统提示里的稳定区**子片**计入时不加任何 overhead——那 +8 是官方对整段
+ *     消息/整体系统提示的结构成本，切片重复计会与官方总数对不上；
+ *   - 字符数一律 JS `.length`（UTF-16 单元），与官方产出严格可比。
+ */
+/** 固定文本密度：每 4 字符记 1 token（官方 CHARS_PER_TOKEN 同值）。 */
+export const CHARS_PER_TOKEN = 4;
+const BLOCK_OVERHEAD = 4;
+const ROLE_OVERHEAD = 4;
+/** 召回注入体（单 text 块 user message）的启发式 token 数。 */
+export function estimateInjectedMessageTokens(chars) {
+    return Math.ceil(chars / CHARS_PER_TOKEN) + BLOCK_OVERHEAD + ROLE_OVERHEAD;
+}
+/** 稳定区子片的启发式 token 数（不加结构开销，见模块头注释）。 */
+export function estimateStableSectionTokens(chars) {
+    return Math.ceil(chars / CHARS_PER_TOKEN);
+}
+export function emptyOccupancyLedger(now = Date.now()) {
+    return { stockTokens: 0, recallTokens: 0, profileTokens: 0, lastInjectTokens: 0, updatedAt: now };
+}
+/** 召回注入成功后的入账（失败跳过的轮次不调用——账目零扰动）。 */
+export function recordRecallInjection(l, chars, now = Date.now()) {
+    const tokens = estimateInjectedMessageTokens(chars);
+    l.recallTokens += tokens;
+    l.stockTokens += tokens;
+    l.lastInjectTokens = tokens;
+    l.updatedAt = now;
+}
+/**
+ * 稳定区份额随每次实际组进的文本同步（含切回非 OFF 的重新计入）：
+ * 增量记账保证重复调用不双算，清零后重设即可净额回补。
+ */
+export function recordProfileShare(l, chars, now = Date.now()) {
+    const tokens = estimateStableSectionTokens(chars);
+    l.stockTokens += tokens - l.profileTokens;
+    l.profileTokens = tokens;
+    l.updatedAt = now;
+}
+/** OFF 边界：稳定区随下一次请求组装物理离场，账目同边界清零（宁低勿高）。 */
+export function clearProfileShare(l, now = Date.now()) {
+    l.stockTokens -= l.profileTokens;
+    l.profileTokens = 0;
+    l.updatedAt = now;
+}
+/**
+ * compaction 复位：v1 采用"清零重新累积"的低估近似——被压缩掉的注入以整数轮粒度
+ * 退出账本，幸存的摘要行不重复认领（已知限制，方向宁低勿高；事件级精确对齐留待 v2）。
+ */
+export function resetForCompaction(l, now = Date.now()) {
+    l.stockTokens = 0;
+    l.recallTokens = 0;
+    l.profileTokens = 0;
+    l.lastInjectTokens = 0;
+    l.updatedAt = now;
+}
+/* ── 渲染侧纯函数（client 寄生组件用；宿主 smoke 一并断言，数字唯一来源在此） ── */
+/**
+ * 官方上下文环周长：viewBox 14 内 r=5.5 圆（2π×5.5 ≈ 34.55751918948772），
+ * 与真机反推的官方 fill dasharray 分母逐字一致。
+ */
+export const CONTEXT_METER_CIRCUMFERENCE = 34.55751918948772;
+/**
+ * 光晕弧 stroke-dasharray：形状沿用官方 fill（len + 全周长 gap）。
+ * @param occupancyRatio 占窗口比 0..1（越界钳制）。
+ * @param minLen 最小可见弧长（单位=-viewBox 坐标；14px 渲染下 <1 单位即亚像素不可见，
+ *  真实占比常低至 0.6%≈0.2 单位——指示灯语义需要"存在即可见"，精确数字归面板）。
+ */
+export function haloDashArray(occupancyRatio, circumference = CONTEXT_METER_CIRCUMFERENCE, minLen = 0) {
+    const clamped = Number.isFinite(occupancyRatio) ? Math.min(1, Math.max(0, occupancyRatio)) : 0;
+    const len = Math.max(clamped * circumference, clamped > 0 ? minLen : 0);
+    return `${len} ${circumference}`;
+}
+/** 半径比对容差：吞掉渲染库对属性值的无害浮点噪声。 */
+const RADIUS_EPSILON = 1e-6;
+export function isContextMeterAnchor(sig) {
+    if (sig.ariaHasPopup !== 'dialog')
+        return false;
+    if (sig.viewBox !== '0 0 14 14')
+        return false;
+    const radii = sig.circleRadii;
+    if (!Array.isArray(radii) || radii.length !== 2)
+        return false;
+    return radii.every((r) => Math.abs(r - 5.5) < RADIUS_EPSILON);
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "dsh-layered-memory",
-  "version": "0.8.7",
+  "version": "0.8.9",
   "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"
   }
 }