dsh-layered-memory 0.8.5 → 0.8.7

package/README.en.md

@@ -90,10 +90,28 @@ synthetic message placed right before the user's new message, rendered as a
 **"Context injection · memory"** row in the chat flow (expand to see the hits) — so you
 can see "memory at work" directly. Injected content is bounded by length and
 time budgets — oversized lines are truncated (pointing the model at the memory tools for
-the full text) and a timed-out recall silently skips that turn, never slowing the chat. It
+the full text) and a timed-out recall silently skips that turn, never slowing the chat.
+**Per-session dedupe**: a memory already injected in this session is not injected again
+(the model's context already holds it — follow-up questions on the same topic save
+tokens); the record resets when the context is compacted or cleared, so memories can
+flow back in, and an updated memory (new id after a content change) is never held back
+by the old suppression. **Freshness weighting**: recall ranking applies a soft weight
+`relevance × max(0.5, 0.5^(days since last update / 30))` — among candidates of similar
+relevance the fresh one wins (slots rotate naturally), while a strongly relevant old
+memory still recalls fine (the floor caps its loss at half a ranking score, so
+long-lived facts never sink); tune via `recall.decayHalfLifeDays`, `0` disables. It
 also registers three model-callable memory tools: `memory_search` /
 `conversation_search` / `memory_read_scene`.
 
+**Cost dashboard**: every distillation LLM call (extract / dedup / L2 / L3) writes its
+token cost to a SQLite detail table keyed by `provider/model` (configurable retention,
+default 365 days with rolling cleanup on write; accounting failures only log a warning
+and never block distillation). Visualize it under Settings → Memory → the **Cost** tab:
+per-model trend lines (day/week/month granularity + last-N-days window + L1/L2/L3 layer
+filter), a layer × time-window table (calls / output & reasoning tokens / mean / median),
+and per-model totals — distillation overhead at a glance. Input is counted in characters
+(DSH streaming usage carries no input tokens); output and reasoning in tokens.
+
 In action: the "Context injection · memory" row surfaces relevant memories first, and
 the model then calls `memory_read_scene` directly to read scene blocks before answering
 from memory:
@@ -243,6 +261,7 @@ the bundle layer appends and causes `duplicate loader entry id` startup failure)
 | `recall.includeSceneNav` | `true` | Inject scene navigation into the system prompt (`<scene-navigation>`, stable zone) |
 | `recall.strategy` | `hybrid` | Retrieval strategy: `keyword` / `embedding` / `hybrid` |
 | `recall.scoreThreshold` | `0.3` | Recall score threshold (below is not injected; applies to keyword/embedding only, not pre-fusion hybrid; tool path unfiltered) |
+| `recall.decayHalfLifeDays` | `30` | Freshness-decay half-life for recall ranking (days, 0=off): ranking applies `relevance × max(0.5, 0.5^(days since last update / half-life))` — among similarly relevant candidates the fresh one wins (slots rotate), and an old memory loses at most half its ranking score (floor keeps long-lived facts afloat) |
 | `embedding.enabled` | `false` | Vector retrieval switch; off = pure FTS |
 | `embedding.baseUrl` | empty | OpenAI-compatible /embeddings endpoint (e.g. `https://api.siliconflow.cn/v1`) |
 | `embedding.apiKey` | empty | API key |
@@ -259,6 +278,7 @@ the bundle layer appends and causes `duplicate loader entry id` startup failure)
 | `llm.temperature` | `0.3` | Distillation temperature |
 | `llm.maxInputChars` | `700000` | Input character budget per distillation call (over-budget L1 inputs are chunked automatically); runtime-adjustable in Settings → distillation parameters → input budget (empty/0 = follow this value) |
 | `llm.timeoutMs` | `120000` | Per-call distillation timeout (ms) |
+| `tokenCost.retentionDays` | `365` | Retention (days) for distillation cost details (the `token_cost` table); rows older than this are rolled away on write. `0` = keep forever. Also the upper bound of the cost dashboard's "last N days" window |
 | `tools` | `true` | Whether to register model-callable memory tools |
 | `benchControl` | `false` | Register the in-process bench control service (rebuild trigger / session-mode setting / distillation usage snapshot — used by the benchmark's lifecycle track). Off by default — zero surface in production deployments; do not enable casually |
 
@@ -299,7 +319,10 @@ with per-file sha256; arbitrary repos cannot be downloaded).
   under `models/<id>/` in the data directory, deletable from the settings page at any time;
 - **On-demand runtime**: the inference runtime (transformers.js, ~100–200MB) is
   installed only on first switch to the local tier, into `runtime/` in the data
-  directory — never in the plugin's dependency tree or install directory;
+  directory — never in the plugin's dependency tree or install directory; model
+  loading and inference run on a **dedicated worker thread**, so the host event
+  loop is never frozen (conversations and page interactions stay responsive while
+  text is being embedded);
 - **Live switching**: one click to swap sources — everything is re-embedded in the
   background (visible progress, cancellable; retrieval silently degrades to keywords
   in the meantime, conversations unaffected; a dimension change rebuilds the vector

package/README.md

@@ -74,7 +74,14 @@ npx tsc src/smoke.ts --outDir dist-smoke --module nodenext --moduleResolution no
        alt="dsh-layered-memory 运行时数据流：左侧 User 与 Assistant 的会话事件流入插件（L0 捕获、L1–L3 蒸馏、检索召回、记忆工具），插件经 agent/pre-step 把相关记忆注入右侧 DSH 核心；蒸馏复用核心的 ctx.llm，数据双写 ~/.dsh/memory/">
 </p>
 
-插件挂在 dsh 原生事件上（`session/event` 捕获、`agent/pre-step` 注入），蒸馏调用复用宿主 `ctx.llm`。召回以**消息侧注入**呈现：相关记忆作为一条合成消息排在用户新消息之前，会话流里显示为**"上下文注入 · memory"**行（点开看命中内容）——用户能直接看到"记忆生效了"；注入内容有长度预算与时间预算，超限截断/超时跳过，绝不拖慢对话。
+插件挂在 dsh 原生事件上（`session/event` 捕获、`agent/pre-step` 注入），蒸馏调用复用宿主 `ctx.llm`。召回以**消息侧注入**呈现：相关记忆作为一条合成消息排在用户新消息之前，会话流里显示为**"上下文注入 · memory"**行（点开看命中内容）——用户能直接看到"记忆生效了"；注入内容有长度预算与时间预算，超限截断/超时跳过，绝不拖慢对话。**同会话去重**：已注入过的记忆不再重复注入（模型上下文里已经有了，追问同类问题时省 token）；上下文被 `/compact` 压缩或清空时自动重置，记忆可重新注入；被更新的记忆（内容变化换新 id）不受旧压制。**时效加权**：召回排序按 `相关度 × max(0.5, 0.5^(距上次更新天数/30))` 软加权——相关度相近的候选之间新鲜记忆优先（名额自然轮转），相关度足够高的老记忆照常召回（地板保证最多损失一半排序分，长期事实不沉底）；`recall.decayHalfLifeDays` 可调，0=关闭。
+
+**成本看板**：每次蒸馏 LLM 调用（抽取/去重/L2/L3）的 token 成本按 `provider/model` 写入
+SQLite 明细表（保留期可配置，默认 365 天，写入时滚动清理；记账失败只告警、绝不阻塞蒸馏），
+设置页 → 记忆 → **成本** Tab 可视化：按模型分色的趋势折线（日/周/月粒度 + 近 N 天窗口 +
+L1/L2/L3 层级过滤）、层级 × 时间窗口表格（调用数 / 输出与思考 token / 均值 / 中位数）、
+按模型累计——蒸馏开销一目了然。输入按字符计（dsh 流式 usage 不含输入 token），
+输出与思考按 token 计。
 
 **记忆工具(3):**
 - memory_search
@@ -206,7 +213,8 @@ ONNX 量化 **CPU 推理**——无需 API Key，数据不出本机）。本地
   绕开镜像 CDN 偶发的坏缓存对象），校验失配从零重下、网络错误保留断点续传；
   落盘数据目录 `models/<id>/`，不用了随时在设置页删除；
 - **按需运行时**：首次切换本地档才安装推理运行时（transformers.js，约 100~200MB，
-  装进数据目录 `runtime/`——不进插件依赖树，不碰插件安装目录）；
+  装进数据目录 `runtime/`——不进插件依赖树，不碰插件安装目录）；模型加载与推理在
+  **独立 worker 线程**执行，不冻结宿主事件循环（嵌入计算期间对话与页面交互照常）；
 - **活切换**：一键换源——自动后台全量重嵌（进度可见、可取消，期间检索自动降级
   关键词，不影响对话；维度变化时向量表按新维度重建）；切换失败保持旧源，重启仍按原源运行；
 - **生效规则 = 部署上限 AND 运行时选择**：`embedding.allowLocalModels=false` 可整体
@@ -256,6 +264,7 @@ ONNX 量化 **CPU 推理**——无需 API Key，数据不出本机）。本地
 | `recall.includeSceneNav` | `true` | 系统提示注入场景导航（`<scene-navigation>`，稳定区） |
 | `recall.strategy` | `hybrid` | 检索策略：`keyword` / `embedding` / `hybrid` |
 | `recall.scoreThreshold` | `0.3` | 召回分数阈值（低于不注入；仅 keyword/embedding 策略生效，hybrid 融合前不过滤；工具路径不过滤） |
+| `recall.decayHalfLifeDays` | `30` | 召回时效衰减半衰期（天，0=关）：排序按 `相关度 × max(0.5, 0.5^(距更新天数/半衰期))` 软加权——相关度相近的候选间新鲜记忆优先（名额轮转），老记忆最多损失一半排序分（地板兜底，长期事实不沉底） |
 | `embedding.enabled` | `false` | 向量检索开关；关闭即纯 FTS 运行 |
 | `embedding.baseUrl` | 空 | OpenAI 兼容 /embeddings 地址（如 `https://api.siliconflow.cn/v1`） |
 | `embedding.apiKey` | 空 | API Key |
@@ -272,6 +281,7 @@ ONNX 量化 **CPU 推理**——无需 API Key，数据不出本机）。本地
 | `llm.temperature` | `0.3` | 蒸馏温度 |
 | `llm.maxInputChars` | `700000` | 单次蒸馏输入字符预算（超限的 L1 输入自动分块抽取）；运行时可在设置页 → 蒸馏参数 → 输入预算调整（留空/0 = 跟随本值） |
 | `llm.timeoutMs` | `120000` | 单次蒸馏调用超时（ms） |
+| `tokenCost.retentionDays` | `365` | 蒸馏成本明细（token_cost 表）保留天数，写入时滚动清理更早行；`0` = 永久保留。成本看板「近 N 天」窗口上限同此值 |
 | `tools` | `true` | 是否注册模型可调用的记忆工具 |
 | `benchControl` | `false` | 注册 bench 控制服务（进程内 rebuild 触发/会话档位设置/蒸馏用量快照，供基准 lifecycle 赛道）。默认关——生产部署零表面积，勿随意开启 |
 

package/dist/client.js

@@ -877,6 +877,15 @@ window.__ModuleLoader__.load({
         "  --dsh-mem-text-2: var(--dsw-alias-label-secondary, #61666b);",
         "  --dsh-mem-text-3: var(--dsw-alias-label-tertiary, #6e7781);",
         "  --dsh-mem-danger: var(--dsw-alias-state-error-primary, #d0403f);",
+        // 图表系列（成本折线图）：8 档固定色，PALETTE 只引用 var()；1 档锚品牌蓝，8 档中性"其他"
+        "  --dsh-mem-chart-1: #4d6bfe;",
+        "  --dsh-mem-chart-2: #0e9c8f;",
+        "  --dsh-mem-chart-3: #1f9d55;",
+        "  --dsh-mem-chart-4: #a8821c;",
+        "  --dsh-mem-chart-5: #d97a0d;",
+        "  --dsh-mem-chart-6: #d64570;",
+        "  --dsh-mem-chart-7: #7c5cff;",
+        "  --dsh-mem-chart-8: #61666b;",
         // 档位色 = 灰 → 品牌蓝 的渐变阶（chat/work 过渡蓝 / auto 品牌蓝）；
         // 文字对比度按 pill 真实底色（流光内底 = bg-card 97% + 档位色 3%）复算 AA 达标
         "  --dsh-mem-mode-chat: #5a69b0;",
@@ -908,6 +917,14 @@ window.__ModuleLoader__.load({
         "  --dsh-mem-text-2: var(--dsw-alias-label-secondary, #cfd3d6);",
         "  --dsh-mem-text-3: var(--dsw-alias-label-tertiary, #8892a6);",
         "  --dsh-mem-danger: var(--dsw-alias-state-error-primary, #f4707b);",
+        "  --dsh-mem-chart-1: #6e85ff;",
+        "  --dsh-mem-chart-2: #35c4b5;",
+        "  --dsh-mem-chart-3: #52c98d;",
+        "  --dsh-mem-chart-4: #d9b23e;",
+        "  --dsh-mem-chart-5: #f59e5b;",
+        "  --dsh-mem-chart-6: #f47ba2;",
+        "  --dsh-mem-chart-7: #a78bfa;",
+        "  --dsh-mem-chart-8: #8892a6;",
         "  --dsh-mem-mode-chat: #97a4ff;",
         "  --dsh-mem-mode-work: #8295ff;",
         "  --dsh-mem-mode-auto: #7b90ff;",
@@ -2824,12 +2841,311 @@ window.__ModuleLoader__.load({
       );
     }
 
+    // ── 折线图 helper：把桶序列画成 SVG 多模型折线 ──
+    function renderCostChart(buckets, models, maxY, fmtDate, fmtInt, palette) {
+      var W = 600, H = 200, L = 46, R = 10, T = 10, B = 26;
+      var iw = W - L - R;
+      var ih = H - T - B;
+      var n = buckets.length;
+      var x = function (i) { return L + (n <= 1 ? iw / 2 : (i / (n - 1)) * iw); };
+      var y = function (v) { return T + ih - (v / maxY) * ih; };
+      var yTicks = [0, maxY / 2, maxY];
+      var xIdx = n > 2 ? [0, Math.floor((n - 1) / 2), n - 1] : n === 2 ? [0, 1] : [0];
+      return react.createElement(
+        "svg",
+        { viewBox: "0 0 " + W + " " + H, style: { width: "100%", height: "auto", display: "block" } },
+        react.createElement("line", { x1: L, y1: y(0), x2: W - R, y2: y(0), stroke: "var(--dsh-mem-border)", strokeWidth: 1 }),
+        yTicks.map(function (v) {
+          return react.createElement("text", { key: "yt" + v, x: L - 6, y: y(v) + 4, textAnchor: "end", fontSize: 10, fill: "var(--dsh-mem-text-3)" }, fmtInt(v));
+        }),
+        xIdx.map(function (i) {
+          return react.createElement("text", { key: "xt" + i, x: x(i), y: H - 8, textAnchor: "middle", fontSize: 10, fill: "var(--dsh-mem-text-3)" }, fmtDate(buckets[i] ? buckets[i].ts : 0));
+        }),
+        models.map(function (m, mi) {
+          var pts = buckets.map(function (b, i) { return x(i) + "," + y(b.byModel[m] || 0); }).join(" ");
+          return react.createElement("polyline", { key: "pl" + m, points: pts, fill: "none", stroke: palette[mi % palette.length], strokeWidth: 2, strokeLinejoin: "round", strokeLinecap: "round" });
+        }),
+      );
+    }
+
+    // ── Tab：蒸馏成本看板（折线图 + 层级×窗口表格 + 总览） ──
+    function CostTab(props) {
+      var rpc = props.rpc;
+      var dataState = react.useState(null);
+      var data = dataState[0];
+      var setData = dataState[1];
+      var errState = react.useState(null);
+      var error = errState[0];
+      var setError = errState[1];
+      var granState = react.useState("day");
+      var granularity = granState[0];
+      var setGranularity = granState[1];
+      var layerState = react.useState("");
+      var layer = layerState[0];
+      var setLayer = layerState[1];
+      var rangeState = react.useState(0);
+      var rangeDays = rangeState[0];
+      var setRangeDays = rangeState[1];
+      var rangeOpenState = react.useState(false);
+      var rangeOpen = rangeOpenState[0];
+      var setRangeOpen = rangeOpenState[1];
+
+      var load = react.useCallback(function () {
+        setError(null);
+        rpc("dsh-memory/token-cost", { granularity: granularity, rangeDays: rangeDays })
+          .then(function (r) {
+            if (r && r.ok) setData(r.value);
+            else setError(r && r.error ? r.error.message : "RPC error");
+          })
+          .catch(function (e) { setError(String((e && e.message) || e)); });
+      }, [rpc, granularity, rangeDays]);
+
+      react.useEffect(function () {
+        load();
+        var timer = setInterval(load, 5000);
+        return function () { clearInterval(timer); };
+      }, [load]);
+
+      var fmtInt = function (n) { return String(Math.round(n)).replace(/\B(?=(\d{3})+(?!\d))/g, ","); };
+      var fmtModel = function (p, m) { return p ? p + "/" + m : m; };
+      var fmtDate = function (ts) {
+        try {
+          var d = new Date(ts);
+          // 近 N 天时后端强制日粒度，用 trend 实际粒度（而非用户选的周/月）格式化横轴
+          var g = data && data.trend ? data.trend.granularity : granularity;
+          if (g === "month") return (d.getMonth() + 1) + "月";
+          return (d.getMonth() + 1) + "/" + d.getDate();
+        } catch (e) { return ""; }
+      };
+      var RANGE_LABELS = { day: "今日", week: "本周", month: "本月", all: "累计" };
+      var LAYER_OPTS = [{ key: "", label: "全部" }, { key: "l1", label: "L1" }, { key: "l2", label: "L2" }, { key: "l3", label: "L3" }];
+      var GRAN_OPTS = [{ key: "day", label: "日" }, { key: "week", label: "周" }, { key: "month", label: "月" }];
+      var PALETTE = ["var(--dsh-mem-chart-1)", "var(--dsh-mem-chart-2)", "var(--dsh-mem-chart-3)", "var(--dsh-mem-chart-4)", "var(--dsh-mem-chart-5)", "var(--dsh-mem-chart-6)", "var(--dsh-mem-chart-7)", "var(--dsh-mem-chart-8)"];
+
+      var windows = (data && data.windows) || [];
+      var byModel = (data && data.byModel) || [];
+      var byLayer = (data && data.byLayer) || [];
+      var trend = data && data.trend ? data.trend : null;
+
+      // 趋势桶（按 layer 过滤/合并；全部 = l1+l2+l3 逐桶相加）
+      var buckets = [];
+      if (trend && trend.byLayer) {
+        if (layer === "l1" || layer === "l2" || layer === "l3") {
+          buckets = trend.byLayer[layer] || [];
+        } else {
+          var seqs = [trend.byLayer.l1 || [], trend.byLayer.l2 || [], trend.byLayer.l3 || []];
+          var n = seqs[0].length;
+          for (var i = 0; i < n; i++) {
+            var merged = { ts: 0, total: 0, byModel: {} };
+            for (var s = 0; s < seqs.length; s++) {
+              var seq = seqs[s];
+              if (seq && seq[i]) {
+                if (merged.ts === 0) merged.ts = seq[i].ts;
+                merged.total += seq[i].total;
+                Object.keys(seq[i].byModel).forEach(function (m) {
+                  merged.byModel[m] = (merged.byModel[m] || 0) + seq[i].byModel[m];
+                });
+              }
+            }
+            buckets.push(merged);
+          }
+        }
+      }
+
+      // 折线模型 + maxY
+      var models = [];
+      var seen = {};
+      buckets.forEach(function (b) {
+        Object.keys(b.byModel).forEach(function (m) {
+          if (!seen[m]) { seen[m] = true; models.push(m); }
+        });
+      });
+      models.sort();
+      var maxY = 1;
+      buckets.forEach(function (b) {
+        if (b.total > maxY) maxY = b.total;
+        models.forEach(function (m) { if ((b.byModel[m] || 0) > maxY) maxY = b.byModel[m]; });
+      });
+
+      // 层级×窗口表格数据（layer → {range: 格子}）
+      var layerTable = byLayer.map(function (lc) {
+        var win = {};
+        lc.windows.forEach(function (w) { win[w.range] = w; });
+        return { layer: lc.layer, win: win };
+      });
+
+      var thFirst = { fontSize: 12, fontWeight: 600, color: "var(--dsh-mem-text-3)", textAlign: "left", padding: "4px 10px", borderBottom: "1px solid var(--dsh-mem-border)" };
+      var thStyle = { fontSize: 12, fontWeight: 600, color: "var(--dsh-mem-text-3)", textAlign: "right", padding: "4px 10px", borderBottom: "1px solid var(--dsh-mem-border)" };
+      var tdFirst = { fontSize: 12.5, fontWeight: 600, color: "var(--dsh-mem-text-1)", textAlign: "left", padding: "4px 10px" };
+      var tdStyle = { fontSize: 12.5, color: "var(--dsh-mem-text-1)", textAlign: "right", padding: "4px 10px", fontFamily: "ui-monospace, Consolas, monospace" };
+
+      return react.createElement(
+        "div", null,
+        react.createElement(
+          "div", { style: Object.assign({}, S.flexRow, { marginBottom: 10 }) },
+          react.createElement(Segmented, { value: layer, options: LAYER_OPTS, onChange: setLayer }),
+          react.createElement(Segmented, { value: granularity, options: GRAN_OPTS, onChange: setGranularity }),
+          react.createElement(NButton, { onClick: function () { setRangeOpen(!rangeOpen); } }, rangeDays > 0 ? "近 " + rangeDays + " 天" : "近N天"),
+          react.createElement("div", { style: S.grow }),
+          react.createElement(NButton, { onClick: load }, "刷新"),
+        ),
+        rangeOpen
+          ? react.createElement(
+              "div", { style: Object.assign({}, S.flexRow, { marginBottom: 10 }) },
+              react.createElement("span", { style: S.muted }, "展示近 N 天（正整数，清空=默认窗口；超出保留期后端自动回退）"),
+              react.createElement(NInput, {
+                value: rangeDays === 0 ? "" : String(rangeDays),
+                placeholder: "如 30",
+                style: { width: 90 },
+                onChange: function (e) {
+                  var v = String(e.target.value || "").trim();
+                  if (v === "") { setRangeDays(0); return; }
+                  var n = Number(v);
+                  if (Number.isInteger(n) && n > 0 && n <= 3650) setRangeDays(n);
+                },
+              }),
+            )
+          : null,
+        error
+          ? react.createElement("div", { style: S.error }, "成本读取失败：" + error)
+          : null,
+        react.createElement("div", { style: S.panelLabel }, "成本趋势（按模型）"),
+        buckets.length > 0
+          ? react.createElement(
+              "div", null,
+              renderCostChart(buckets, models, maxY, fmtDate, fmtInt, PALETTE),
+              react.createElement(
+                "div", { style: { display: "flex", flexWrap: "wrap", gap: "4px 12px", margin: "6px 0 14px" } },
+                models.map(function (m, mi) {
+                  return react.createElement(
+                    "span", { key: "lg" + m, style: { display: "inline-flex", alignItems: "center", gap: 4, fontSize: 12, color: "var(--dsh-mem-text-2)" } },
+                    react.createElement("span", { style: { width: 10, height: 10, borderRadius: 4, background: PALETTE[mi % PALETTE.length], display: "inline-block" } }),
+                    m,
+                  );
+                }),
+              ),
+            )
+          : react.createElement("p", { style: S.muted }, data ? "暂无成本数据（触发一次蒸馏后这里会出现趋势）。" : "加载中…"),
+        react.createElement("div", { style: S.panelLabel }, "层级成本（输出 token）"),
+        react.createElement(
+          "table", { style: { width: "100%", borderCollapse: "collapse", marginBottom: 14 } },
+          react.createElement(
+            "thead", null,
+            react.createElement(
+              "tr", null,
+              react.createElement("th", { style: thFirst }, "层级"),
+              ["day", "week", "month", "all"].map(function (r) {
+                return react.createElement("th", { key: r, style: thStyle }, RANGE_LABELS[r]);
+              }),
+            ),
+          ),
+          react.createElement(
+            "tbody", null,
+            layerTable.map(function (lc) {
+              return react.createElement(
+                "tr", { key: lc.layer },
+                react.createElement("td", { style: tdFirst }, lc.layer.toUpperCase()),
+                ["day", "week", "month", "all"].map(function (r) {
+                  var w = lc.win[r];
+                  return react.createElement("td", { key: r, style: tdStyle }, w ? fmtInt(w.outputTokens) : "0");
+                }),
+              );
+            }),
+          ),
+        ),
+        react.createElement("div", { style: S.panelLabel }, "层级成本（单次 avg）"),
+        react.createElement(
+          "table", { style: { width: "100%", borderCollapse: "collapse", marginBottom: 14 } },
+          react.createElement(
+            "thead", null,
+            react.createElement(
+              "tr", null,
+              react.createElement("th", { style: thFirst }, "层级"),
+              ["day", "week", "month", "all"].map(function (r) {
+                return react.createElement("th", { key: r, style: thStyle }, RANGE_LABELS[r] + "-avg");
+              }),
+            ),
+          ),
+          react.createElement(
+            "tbody", null,
+            layerTable.map(function (lc) {
+              return react.createElement(
+                "tr", { key: lc.layer },
+                react.createElement("td", { style: tdFirst }, lc.layer.toUpperCase()),
+                ["day", "week", "month", "all"].map(function (r) {
+                  var w = lc.win[r];
+                  return react.createElement("td", { key: r, style: tdStyle }, w ? fmtInt(w.avgOutputTokens) : "0");
+                }),
+              );
+            }),
+          ),
+        ),
+        react.createElement("div", { style: S.panelLabel }, "层级成本（单次 median）"),
+        react.createElement(
+          "table", { style: { width: "100%", borderCollapse: "collapse", marginBottom: 14 } },
+          react.createElement(
+            "thead", null,
+            react.createElement(
+              "tr", null,
+              react.createElement("th", { style: thFirst }, "层级"),
+              ["day", "week", "month", "all"].map(function (r) {
+                return react.createElement("th", { key: r, style: thStyle }, RANGE_LABELS[r] + "-median");
+              }),
+            ),
+          ),
+          react.createElement(
+            "tbody", null,
+            layerTable.map(function (lc) {
+              return react.createElement(
+                "tr", { key: lc.layer },
+                react.createElement("td", { style: tdFirst }, lc.layer.toUpperCase()),
+                ["day", "week", "month", "all"].map(function (r) {
+                  var w = lc.win[r];
+                  return react.createElement("td", { key: r, style: tdStyle }, w ? fmtInt(w.medianOutputTokens) : "0");
+                }),
+              );
+            }),
+          ),
+        ),
+        react.createElement("div", { style: S.panelLabel }, "时间窗口总览"),
+        react.createElement(
+          "div", { style: S.statGrid },
+          windows.map(function (w) {
+            return react.createElement(
+              "div", { key: w.range, className: "dsh-mem-card", style: S.statTile },
+              react.createElement("div", { style: S.statNum }, fmtInt(w.outputTokens + w.reasoningTokens)),
+              react.createElement("div", { style: S.statLabel }, RANGE_LABELS[w.range] + " · 总输出 token"),
+              react.createElement("div", { style: S.muted }, "文字 " + fmtInt(w.outputTokens) + " · 思考 " + fmtInt(w.reasoningTokens) + " · " + w.calls + " 次调用"),
+            );
+          }),
+        ),
+        byModel.length > 0
+          ? react.createElement(
+              "div", null,
+              react.createElement("div", { style: S.panelLabel }, "按模型（累计）"),
+              byModel.map(function (m) {
+                var label = fmtModel(m.provider, m.model);
+                return react.createElement(
+                  "div", { key: "m-" + label, style: S.infoRow },
+                  react.createElement("span", { style: S.infoKey }, label),
+                  react.createElement("span", { style: S.infoVal }, m.calls + " 次 · 输出 " + fmtInt(m.outputTokens) + " · 思考 " + fmtInt(m.reasoningTokens)),
+                );
+              }),
+            )
+          : null,
+        data
+          ? react.createElement("p", { style: S.hint }, "输入按字符、输出/思考按 token 计；趋势图 Y 轴为输出 token，上方可切换层级与颗粒度。" )
+          : null,
+      );
+    }
+
     // ── 主面板：Tab 框架 ──
     var TABS = [
       ["overview", "概览"],
       ["records", "记忆"],
       ["scenes", "场景"],
       ["persona", "画像"],
+      ["cost", "成本"],
       ["log", "日志"],
     ];
 
@@ -2898,6 +3214,7 @@ window.__ModuleLoader__.load({
       else if (tab === "records") body = react.createElement(RecordsTab, { rpc: rpc });
       else if (tab === "scenes") body = react.createElement(ScenesTab, { rpc: rpc });
       else if (tab === "persona") body = react.createElement(PersonaTab, { rpc: rpc });
+      else if (tab === "cost") body = react.createElement(CostTab, { rpc: rpc });
       else body = react.createElement(LogTab, { rpc: rpc });
 
       return react.createElement(

package/dist/config.d.ts

@@ -66,6 +66,9 @@ export interface MemoryConfig {
         strategy: 'keyword' | 'embedding' | 'hybrid';
         /** 召回路径分数阈值（0~1，低于该分不注入；工具路径不过滤）。 */
         scoreThreshold: number;
+        /** 时效衰减半衰期（天，0=关）：召回排序的 freshness 加权——score × max(0.5, 0.5^(Δ天/半衰期))，
+         *  只影响相关度相近候选间的名次（老记忆最多损失一半排序分，不淘汰）。 */
+        decayHalfLifeDays: number;
     };
     embedding: {
         /** 向量检索总开关；关闭时纯 FTS 运行（官方 provider="none" 同款）。 */
@@ -111,6 +114,10 @@ export interface MemoryConfig {
             l3: number;
         }>;
     };
+    tokenCost: {
+        /** token_cost 明细保留天数；写入时滚动清理更早行。0 = 永久保留。 */
+        retentionDays: number;
+    };
     /** 是否注册模型可调用的记忆工具。 */
     tools: boolean;
     /** 注册 bench 控制服务（dsh-memory-bench，进程内 rebuild 触发面）。
@@ -170,6 +177,7 @@ export declare const memorySchema: Schema<Schemastery.ObjectS<{
         includeSceneNav: Schema<boolean, boolean>;
         strategy: Schema<"keyword" | "embedding" | "hybrid", "keyword" | "embedding" | "hybrid">;
         scoreThreshold: Schema<number, number>;
+        decayHalfLifeDays: Schema<number, number>;
     }>, Schemastery.ObjectT<{
         enabled: Schema<boolean, boolean>;
         maxResults: Schema<number, number>;
@@ -180,6 +188,7 @@ export declare const memorySchema: Schema<Schemastery.ObjectS<{
         includeSceneNav: Schema<boolean, boolean>;
         strategy: Schema<"keyword" | "embedding" | "hybrid", "keyword" | "embedding" | "hybrid">;
         scoreThreshold: Schema<number, number>;
+        decayHalfLifeDays: Schema<number, number>;
     }>>;
     embedding: Schema<Schemastery.ObjectS<{
         enabled: Schema<boolean, boolean>;
@@ -221,6 +230,11 @@ export declare const memorySchema: Schema<Schemastery.ObjectS<{
         maxInputChars: Schema<number, number>;
         timeoutMs: Schema<number, number>;
     }>>;
+    tokenCost: Schema<Schemastery.ObjectS<{
+        retentionDays: Schema<number, number>;
+    }>, Schemastery.ObjectT<{
+        retentionDays: Schema<number, number>;
+    }>>;
     tools: Schema<boolean, boolean>;
     benchControl: Schema<boolean, boolean>;
 }>, Schemastery.ObjectT<{
@@ -276,6 +290,7 @@ export declare const memorySchema: Schema<Schemastery.ObjectS<{
         includeSceneNav: Schema<boolean, boolean>;
         strategy: Schema<"keyword" | "embedding" | "hybrid", "keyword" | "embedding" | "hybrid">;
         scoreThreshold: Schema<number, number>;
+        decayHalfLifeDays: Schema<number, number>;
     }>, Schemastery.ObjectT<{
         enabled: Schema<boolean, boolean>;
         maxResults: Schema<number, number>;
@@ -286,6 +301,7 @@ export declare const memorySchema: Schema<Schemastery.ObjectS<{
         includeSceneNav: Schema<boolean, boolean>;
         strategy: Schema<"keyword" | "embedding" | "hybrid", "keyword" | "embedding" | "hybrid">;
         scoreThreshold: Schema<number, number>;
+        decayHalfLifeDays: Schema<number, number>;
     }>>;
     embedding: Schema<Schemastery.ObjectS<{
         enabled: Schema<boolean, boolean>;
@@ -327,6 +343,11 @@ export declare const memorySchema: Schema<Schemastery.ObjectS<{
         maxInputChars: Schema<number, number>;
         timeoutMs: Schema<number, number>;
     }>>;
+    tokenCost: Schema<Schemastery.ObjectS<{
+        retentionDays: Schema<number, number>;
+    }>, Schemastery.ObjectT<{
+        retentionDays: Schema<number, number>;
+    }>>;
     tools: Schema<boolean, boolean>;
     benchControl: Schema<boolean, boolean>;
 }>>;

package/dist/config.js

@@ -48,6 +48,9 @@ export const memorySchema = Schema.object({
         includeSceneNav: Schema.boolean().default(true),
         strategy: Schema.union(['keyword', 'embedding', 'hybrid']).default('hybrid'),
         scoreThreshold: Schema.number().min(0).max(1).default(0.3),
+        // 时效衰减（#29）：乘法软加权 + 地板 0.5（老记忆最多损失一半排序分），只轮转
+        // 相关度相近候选的名次；0=关（bench 基线可比性可 pin 0）
+        decayHalfLifeDays: Schema.number().min(0).max(3650).default(30),
     }),
     embedding: Schema.object({
         enabled: Schema.boolean().default(false),
@@ -77,6 +80,10 @@ export const memorySchema = Schema.object({
         maxInputChars: Schema.number().min(1000).max(1_000_000).default(700_000),
         timeoutMs: Schema.number().min(1000).max(600_000).default(120_000),
     }),
+    // token_cost 明细保留期（写入时滚动清理；0 = 永久保留）。成本看板的「近 N 天」窗口上限也取此值
+    tokenCost: Schema.object({
+        retentionDays: Schema.number().min(0).max(3650).default(365),
+    }),
     tools: Schema.boolean().default(true),
     benchControl: Schema.boolean().default(false),
 });