dsh-layered-memory 0.8.3 → 0.8.5

package/dist/bench-control.d.ts

@@ -0,0 +1,35 @@
+/**
+ * bench 控制服务（config `benchControl` 门控，默认关）：为同进程的基准驱动插件
+ * （dsh-bench-runner 的 lifecycle 赛道）提供进程内控制面。
+ *
+ * 为什么不走 RPC：宿主侧 connection.rpc 只有 handle/intercept、没有 call()，
+ * 基准驱动包在 dsh 宿主进程内无法调用插件的 loopback RPC 端点；cordis 服务
+ * （ctx.provide / ctx.get）是唯一干净的进程内通道。生产部署不开启该配置，
+ * 服务不注册、零表面积；即便开启，暴露的也只是既有公开 API 的薄包装，
+ * 不引入新逻辑：
+ *   - RebuildController.start()/getStatus()（重建触发与状态轮询）；
+ *   - SessionModeStore.set()/get()（会话档位——capture/recall 每轮读 Map，
+ *     agent 建好后、首条消息前设档即可生效，且走 onModeChange 回调的
+ *     pending 落袋/挂起语义，不是裸改 Map）。
+ */
+import type { Context } from '@deepseek-ai/cordis';
+import type { MemoryLogger, MemoryMode } from './types.js';
+import type { RebuildController, RebuildStatus } from './pipeline/rebuild.js';
+import type { SessionModeStore } from './store/session-modes.js';
+import type { DistillUsageSnapshot } from './llm-usage.js';
+/** 服务名（消费方：bench/harness/dsh-bench-runner 的 lifecycle 赛道）。 */
+export declare const BENCH_CONTROL_SERVICE = "dsh-memory-bench";
+export interface BenchControlSurface {
+    /** 触发全量重建（从 L0 重导派生层）；前置条件不满足时抛错（调用方捕获）。 */
+    rebuildStart(): RebuildStatus;
+    /** 重建状态快照（phase/running/recordsBuilt/…，轮询至 done/failed/cancelled）。 */
+    rebuildStatus(): RebuildStatus;
+    /** 设置会话档位（chat/work/off/auto）；对全新会话应在首条消息前设置。 */
+    setSessionMode(sessionId: string, mode: MemoryMode): void;
+    /** 查询会话档位（未设过的会话返回部署默认档）。 */
+    getSessionMode(sessionId: string): MemoryMode;
+    /** 蒸馏用量快照（按层累计的调用数/输入字符/输出 token——「记忆开销」记账）。 */
+    getDistillUsage(): DistillUsageSnapshot;
+}
+/** 注册控制服务，返回注销函数（调用方在插件 dispose 时执行）。 */
+export declare function registerBenchControl(ctx: Context, rebuild: RebuildController, modes: SessionModeStore, logger: MemoryLogger): () => void;

package/dist/bench-control.js

@@ -0,0 +1,16 @@
+import { snapshotDistillUsage } from './llm-usage.js';
+/** 服务名（消费方：bench/harness/dsh-bench-runner 的 lifecycle 赛道）。 */
+export const BENCH_CONTROL_SERVICE = 'dsh-memory-bench';
+/** 注册控制服务，返回注销函数（调用方在插件 dispose 时执行）。 */
+export function registerBenchControl(ctx, rebuild, modes, logger) {
+    const surface = {
+        rebuildStart: () => rebuild.start(),
+        rebuildStatus: () => rebuild.getStatus(),
+        setSessionMode: (sessionId, mode) => modes.set(sessionId, mode),
+        getSessionMode: (sessionId) => modes.get(sessionId),
+        getDistillUsage: () => snapshotDistillUsage(),
+    };
+    const dispose = ctx.provide(BENCH_CONTROL_SERVICE, surface);
+    logger.info('[memory] bench 控制服务已提供（dsh-memory-bench，仅基准/调试部署）');
+    return dispose;
+}

package/dist/client.js

@@ -244,6 +244,23 @@ window.__ModuleLoader__.load({
       }
     }
 
+    /** 相对时间（悬浮卡摘要行用）：刚刚 / N 分钟前 / N 小时前 / N 天前；无效返回 null。 */
+    function fmtAgo(iso) {
+      if (!iso) return null;
+      try {
+        var t = new Date(iso).getTime();
+        if (!t) return null;
+        var s = Math.floor((Date.now() - t) / 1000);
+        if (s < 0) s = 0;
+        if (s < 45) return "刚刚";
+        if (s < 3600) return Math.floor(s / 60) + " 分钟前";
+        if (s < 86400) return Math.floor(s / 3600) + " 小时前";
+        return Math.floor(s / 86400) + " 天前";
+      } catch (e) {
+        return null;
+      }
+    }
+
     // ── Switch 组件 ──
     function Switch(props) {
       var on = !!props.checked;
@@ -673,6 +690,151 @@ window.__ModuleLoader__.load({
           props.error
             ? react.createElement("div", { style: { fontSize: 11, color: "var(--dsh-mem-danger)", marginTop: 10, whiteSpace: "nowrap" } }, props.error)
             : null,
+          // 会话信息区（分隔线 + 2×2 指标 + 状态行）：session-stats 热路径端点，
+          // 宿主不支持 / 数据缺失时整体不渲染（best-effort 增强，不占位）
+          props.rpc && props.sessionId
+            ? react.createElement(SessionInfoArea, { rpc: props.rpc, sessionId: props.sessionId })
+            : null,
+        ),
+      );
+    }
+
+    // ── 会话信息区：悬浮卡下半部（召回命中 / 攒批进度 / 会话产出 / 会话消息） ──
+    // 数据通道 dsh-memory/session-stats（宿主侧零文件 I/O：内存注册表 + 索引 COUNT，
+    // 见 slider-spec 数据策略节）；自适应轮询：忙时（攒批/挂起/全局待蒸馏）2s，静默 5s，
+    // 浮层卸载即停（ModeSlider 只在 pill 展开期间挂载）。
+    function sinfoCell(val, label, title) {
+      return react.createElement(
+        "div",
+        { title: title || null },
+        react.createElement("div", { className: "dsh-mem-sinfo-val" }, val),
+        react.createElement("div", { className: "dsh-mem-sinfo-label" }, label),
+      );
+    }
+
+    function SessionInfoArea(props) {
+      var rpc = props.rpc;
+      var sessionId = props.sessionId;
+      // undefined=首帧加载中；null=宿主不支持（整体隐藏）；对象=最新快照
+      var stState = react.useState(undefined);
+      var stats = stState[0];
+      var setStats = stState[1];
+      var busyRef = react.useRef(false);
+
+      react.useEffect(function () {
+        if (!rpc || !sessionId) return undefined;
+        var alive = true;
+        var timer = null;
+        var seq = 0;
+        var tick = function () {
+          var token = ++seq;
+          rpc("dsh-memory/session-stats", { sessionId: sessionId })
+            .then(function (r) {
+              if (!alive || token !== seq) return;
+              if (r && r.ok && r.value && r.value.supported === false) {
+                setStats(null); // 宿主无数据源：整体隐藏
+              } else if (r && r.ok && r.value) {
+                setStats(r.value);
+                var d = r.value.distill || {};
+                var g = r.value.global || {};
+                busyRef.current = (d.pendingSlice || 0) > 0 || (d.parkedSlices || 0) > 0 || (g.pendingTotal || 0) > 0;
+              }
+              // RPC 失败：保持旧快照（信息区不因瞬时错误闪没）
+            })
+            .catch(function () {})
+            .then(function () {
+              if (alive) timer = setTimeout(tick, busyRef.current ? 2000 : 5000);
+            });
+        };
+        tick();
+        return function () {
+          alive = false;
+          if (timer) clearTimeout(timer);
+        };
+      }, [rpc, sessionId]);
+
+      // 首帧占位骨架（防内容跳变）；宿主不支持则整体隐藏
+      if (stats === null) return null;
+      if (stats === undefined) {
+        return react.createElement(
+          "div",
+          { className: "dsh-mem-sinfo" },
+          react.createElement(
+            "div",
+            { className: "dsh-mem-sinfo-grid" },
+            sinfoCell("…", "召回命中"),
+            sinfoCell("…", "攒批进度"),
+            sinfoCell("…", "本会话记忆"),
+            sinfoCell("…", "会话消息"),
+          ),
+        );
+      }
+
+      var rc = stats.recall || {};
+      var di = stats.distill || {};
+      var gl = stats.global || {};
+      var isOff = stats.mode === "off";
+
+      // 召回命中：口径是"注入统计"（命中轮次/检索轮次），停用时显示状态而非误导性 0/0
+      var rcVal;
+      var rcLabel;
+      var rcTitle;
+      if (rc.enabled === false) {
+        rcVal = "停用";
+        rcLabel = "召回命中";
+        rcTitle = "召回已停用（开关关闭 / 档位关闭 / 部署未启用）";
+      } else {
+        rcVal = (rc.hitTurns || 0) + "/" + (rc.injectedTurns || 0);
+        rcLabel = "召回命中 · " + (rc.totalHits || 0) + " 条";
+        rcTitle =
+          "最近一轮命中 " + (rc.lastHits || 0) + " 条，耗时 " + (rc.lastDurationMs || 0) + "ms" +
+          ((rc.timeouts || 0) > 0 ? "，超时跳过 " + rc.timeouts + " 次" : "");
+      }
+
+      // 攒批进度（x/生效阈值，含 warmup 爬坡）；off 档显示挂起切片数
+      var dVal;
+      var dLabel;
+      var dTitle;
+      if (isOff) {
+        dVal = String(di.parkedSlices || 0);
+        dLabel = "挂起切片";
+        dTitle = "档位关闭：未蒸馏切片挂起，切回档位后继续";
+      } else {
+        dVal = (di.pendingSlice || 0) + "/" + (di.threshold != null ? di.threshold : "-");
+        dLabel = (di.parkedSlices || 0) > 0 ? "攒批 · 挂起 " + di.parkedSlices : "攒批进度";
+        dTitle = "达到阈值后自动蒸馏（阈值随使用渐进爬坡到稳态）";
+      }
+
+      var pTitle = di.lastDistillAt ? "最近蒸馏 " + fmtTime(di.lastDistillAt) : "本会话尚未蒸馏";
+      var warn = gl.degraded ? "⚠ 存储不可用，记忆功能已停用" : null;
+      var note = null;
+      if (!gl.degraded) {
+        if (stats.retrieval === "keyword" && !isOff) note = "检索降级：纯关键词（向量不可用）";
+        else if (stats.retrieval === "none") note = "检索不可用（FTS 与向量均失效）";
+      }
+      var ago = fmtAgo(gl.lastExtractAt);
+
+      return react.createElement(
+        "div",
+        { className: "dsh-mem-sinfo" },
+        warn
+          ? react.createElement("div", { className: "dsh-mem-sinfo-warn" }, warn)
+          : null,
+        react.createElement(
+          "div",
+          { className: "dsh-mem-sinfo-grid" },
+          sinfoCell(rcVal, rcLabel, rcTitle),
+          sinfoCell(dVal, dLabel, dTitle),
+          sinfoCell(String(di.producedRecords || 0), "本会话记忆", pTitle),
+          sinfoCell(stats.l0Count != null ? String(stats.l0Count) : "…", "会话消息"),
+        ),
+        note
+          ? react.createElement("div", { className: "dsh-mem-sinfo-note" }, note)
+          : null,
+        react.createElement(
+          "div",
+          { className: "dsh-mem-sinfo-sum" },
+          "待蒸馏 " + (gl.pendingTotal || 0) + " · 上次蒸馏 " + (ago || "尚未蒸馏"),
         ),
       );
     }
@@ -930,6 +1092,15 @@ window.__ModuleLoader__.load({
         "  box-shadow: 0 16px 48px rgba(0,0,0,0.24); }",
         "body[data-ds-dark-theme] .dsh-mem-rb-modal { box-shadow: 0 16px 48px rgba(0,0,0,0.6); }",
         ".dsh-mem-rb-muted { font-size: 12px; color: var(--dsh-mem-text-3); }",
+        // ── 会话信息区（悬浮卡下半部）：分隔线 + 2×2 指标 + 状态行；纯静态 DOM，
+        // 不进粒子层 rAF 循环，轮询数据到达才触发本组件小树 re-render ──
+        ".dsh-mem-sinfo { margin-top: 12px; padding-top: 10px; border-top: 1px solid var(--dsh-mem-border); }",
+        ".dsh-mem-sinfo-grid { display: grid; grid-template-columns: 1fr 1fr; gap: 8px 10px; }",
+        ".dsh-mem-sinfo-val { font-size: 13px; font-weight: 600; color: var(--dsh-mem-text-1); line-height: 18px; font-variant-numeric: tabular-nums; }",
+        ".dsh-mem-sinfo-label { font-size: 11px; color: var(--dsh-mem-text-3); line-height: 15px; white-space: nowrap; overflow: hidden; text-overflow: ellipsis; }",
+        ".dsh-mem-sinfo-warn { font-size: 11px; color: var(--dsh-mem-danger); line-height: 16px; margin-bottom: 6px; }",
+        ".dsh-mem-sinfo-note { font-size: 11px; color: var(--dsh-mem-text-3); line-height: 16px; margin-top: 8px; }",
+        ".dsh-mem-sinfo-sum { font-size: 11px; color: var(--dsh-mem-text-3); line-height: 16px; margin-top: 8px; }",
         // reduced-motion 兜底放样式表末尾：同特异性下后置声明才能压过上面的组件类
         "@media (prefers-reduced-motion: reduce) {",
         "  .dsh-mem-root, .dsh-mem-root *, .dsh-mem-btn, .dsh-mem-input, .dsh-mem-select, .dsh-mem-rb-fill, .dsh-mem-scene-chev, .dsh-mem-sel-chev { transition: none; }",
@@ -1066,6 +1237,8 @@ window.__ModuleLoader__.load({
               mode: mode || "auto",
               onCommit: commit,
               error: error,
+              rpc: rpc,
+              sessionId: sessionId,
             })
           : null,
       );
@@ -2044,7 +2217,7 @@ window.__ModuleLoader__.load({
               "div", { style: S.switchDesc },
               "各蒸馏层单次输出的 token 上限（抽取/去重/L2/L3）；留空或 0 = 跟随默认（当前生效 " +
                 layers.map(function (l) { return eff[l[0]] || "?"; }).join(" / ") +
-                "）；思考档 high/max 时实际限额自动 ×4",
+                "）；思考档 high/xhigh/max 时实际限额自动 ×4",
             )),
         ),
         react.createElement(
@@ -2197,34 +2370,37 @@ window.__ModuleLoader__.load({
                 // 分组：蒸馏参数（模型路由 / 思考档位 / 输出预算）
                 react.createElement("div", { style: S.panelLabel }, "蒸馏参数"),
                 settingsData.effort
-                  ? react.createElement(
-                      "div",
-                      { style: S.switchRow },
-                      react.createElement(Segmented, {
-                        // 档位表来自当前生效模型的能力声明（settings-get 的 effort.options；
-                        // 空声明 → 只显示 high）。''（自动）或档位不在表里时高亮实际生效值。
-                        value: (function () {
-                          var opts = settingsData.effort.options && settingsData.effort.options.length
-                            ? settingsData.effort.options : ["high"];
-                          if (opts.indexOf(settingsData.effort.current) >= 0) return settingsData.effort.current;
-                          return opts.indexOf(settingsData.effort.effective) >= 0
-                            ? settingsData.effort.effective : "high";
-                        })(),
-                        options: (settingsData.effort.options && settingsData.effort.options.length
-                          ? settingsData.effort.options : ["high"]
-                        ).map(function (k) { return { key: k, label: k }; }),
-                        disabled: !master,
-                        onChange: function (v) { toggle("reasoningEffort", v); },
-                      }),
-                      react.createElement("div", null,
-                        react.createElement("div", { style: S.switchLabel }, "蒸馏思考"),
-                        react.createElement(
-                          "div",
-                          { style: S.switchDesc },
-                          "当前生效 " + (settingsData.effort.effective || "（不传，跟随模型默认）") +
-                            (settingsData.effort.current ? "" : "（自动）"),
-                        )),
-                    )
+                  ? (function () {
+                      // 档位表来自当前生效模型的能力声明（settings-get 的 effort.options；
+                      // 空声明 → 只显示 high）。首项固定「自动」（key=''，点击回写空串=
+                      // 按模型能力解析），选过显式档位后仍可回到自动；失效档位高亮实际生效值。
+                      var f = settingsData.effort;
+                      var opts = f.options && f.options.length ? f.options : ["high"];
+                      var segOptions = [{ key: "", label: "自动" }].concat(
+                        opts.map(function (k) { return { key: k, label: k }; })
+                      );
+                      var segValue = f.current === "" || opts.indexOf(f.current) >= 0
+                        ? f.current
+                        : opts.indexOf(f.effective) >= 0 ? f.effective : "high";
+                      return react.createElement(
+                        "div",
+                        { style: S.switchRow },
+                        react.createElement(Segmented, {
+                          value: segValue,
+                          options: segOptions,
+                          disabled: !master,
+                          onChange: function (v) { toggle("reasoningEffort", v); },
+                        }),
+                        react.createElement("div", null,
+                          react.createElement("div", { style: S.switchLabel }, "蒸馏思考"),
+                          react.createElement(
+                            "div",
+                            { style: S.switchDesc },
+                            "当前生效 " + (f.effective || "（不传，跟随模型默认）") +
+                              (f.current ? "" : "（自动）"),
+                          )),
+                      );
+                    })()
                   : null,
                 react.createElement(LlmModelRow, { rpc: rpc, disabled: !master }),
                 react.createElement(BudgetInputs, {

package/dist/config.d.ts

@@ -5,6 +5,13 @@
  */
 import Schema from '@deepseek-ai/schemastery';
 import type { ExtractMode } from './types.js';
+/**
+ * 蒸馏思考档位全词汇表（唯一事实源）：'' = 自动（模型默认档 → high），
+ * 其余为各适配器通用档位词汇表（deepseek 认 'off'，OpenAI 系是 'none'）。
+ * schema（config/settings）、运行时解析（settings.resolveSettings）与 RPC
+ * 写入门（stats.settings-set）共用，勿在别处再抄字面量表。
+ */
+export declare const EFFORT_CHOICES: readonly ["", "off", "none", "minimal", "low", "medium", "high", "xhigh", "max"];
 export interface MemoryConfig {
     /** 数据目录；留空则用 $DSH_HOME/memory。 */
     dataDir: string;
@@ -106,6 +113,9 @@ export interface MemoryConfig {
     };
     /** 是否注册模型可调用的记忆工具。 */
     tools: boolean;
+    /** 注册 bench 控制服务（dsh-memory-bench，进程内 rebuild 触发面）。
+     *  仅供基准/调试部署（bench profile 的 lifecycle 赛道），默认关——生产零表面积。 */
+    benchControl: boolean;
 }
 export declare const memorySchema: Schema<Schemastery.ObjectS<{
     dataDir: Schema<string, string>;
@@ -212,6 +222,7 @@ export declare const memorySchema: Schema<Schemastery.ObjectS<{
         timeoutMs: Schema<number, number>;
     }>>;
     tools: Schema<boolean, boolean>;
+    benchControl: Schema<boolean, boolean>;
 }>, Schemastery.ObjectT<{
     dataDir: Schema<string, string>;
     family: Schema<"chat" | "work" | "auto", "chat" | "work" | "auto">;
@@ -317,5 +328,6 @@ export declare const memorySchema: Schema<Schemastery.ObjectS<{
         timeoutMs: Schema<number, number>;
     }>>;
     tools: Schema<boolean, boolean>;
+    benchControl: Schema<boolean, boolean>;
 }>>;
 export declare function resolveDataDir(cfg: MemoryConfig): string;

package/dist/config.js

@@ -5,6 +5,13 @@
  */
 import Schema from '@deepseek-ai/schemastery';
 import { dshHomePath } from '@deepseek-ai/dsh-home-paths';
+/**
+ * 蒸馏思考档位全词汇表（唯一事实源）：'' = 自动（模型默认档 → high），
+ * 其余为各适配器通用档位词汇表（deepseek 认 'off'，OpenAI 系是 'none'）。
+ * schema（config/settings）、运行时解析（settings.resolveSettings）与 RPC
+ * 写入门（stats.settings-set）共用，勿在别处再抄字面量表。
+ */
+export const EFFORT_CHOICES = ['', 'off', 'none', 'minimal', 'low', 'medium', 'high', 'xhigh', 'max'];
 export const memorySchema = Schema.object({
     dataDir: Schema.string().default(''),
     family: Schema.union(['auto', 'chat', 'work']).default('auto'),
@@ -64,13 +71,14 @@ export const memorySchema = Schema.object({
         // 蒸馏思考档位：'' = 自动（按模型能力解析：模型默认档 → high，见 llm.ts decideSendableEffort）；
         // 显式值仅在该模型声明支持时发送（跨供应商 effort 词汇表不同：deepseek 认 'off'，
         // openai 系是 'none'，未声明档位的模型不传）。旧默认 'off' 在非 deepseek 模型上必炸（400/本地拒绝）
-        reasoningEffort: Schema.union(['', 'off', 'none', 'minimal', 'low', 'medium', 'high', 'xhigh', 'max']).default(''),
+        reasoningEffort: Schema.union([...EFFORT_CHOICES]).default(''),
         temperature: Schema.number().min(0).max(2).default(0.3),
         // 模型上下文 1M token，日常压到 ~700k 使用（中文按 1 字≈1 token 保守折算）
         maxInputChars: Schema.number().min(1000).max(1_000_000).default(700_000),
         timeoutMs: Schema.number().min(1000).max(600_000).default(120_000),
     }),
     tools: Schema.boolean().default(true),
+    benchControl: Schema.boolean().default(false),
 });
 export function resolveDataDir(cfg) {
     if (cfg.dataDir)

package/dist/hooks/recall.d.ts

@@ -30,9 +30,32 @@ import type { MemoryLogger } from '../types.js';
 export declare function buildRecallQuery(messages: Array<{
     content: unknown;
 }>, tailMessages?: number, maxChars?: number): string;
+/** 单会话召回统计（悬浮卡信息区数据源；每轮 O(1) 记账，agent/disposed 清理）。
+ *  口径声明：这是"注入统计"而非 bench 的离线 recall@k——运行时没有 ground truth，
+ *  命中率 = hitTurns / injectedTurns（发生过检索的轮次中命中 ≥1 条的占比）。 */
+export interface RecallSessionStats {
+    /** 发生过召回检索的轮次数（含零命中与超时）。 */
+    injectedTurns: number;
+    /** 命中（≥1 条）轮次数。 */
+    hitTurns: number;
+    /** 累计命中条数（预算截断前）。 */
+    totalHits: number;
+    /** 总预算超时跳过次数。 */
+    timeouts: number;
+    /** 最近一轮命中条数（0 = 零命中/超时；工具指南门控沿用此信号）。 */
+    lastHits: number;
+    /** 最近一轮检索耗时 ms。 */
+    lastDurationMs: number;
+    /** 最近一次记账时间（LRU 清理依据）。 */
+    updatedAt: number;
+}
+/** 新建零值统计（首次出现的会话）。 */
+export declare function emptyRecallStats(now?: number): RecallSessionStats;
 export interface RecallHooks {
     /** 管线更新后调用：画像/场景缓存立即失效并异步刷新。 */
     invalidateProfile(): void;
+    /** 会话召回统计只读视图（未发生过检索的会话返回 undefined）。 */
+    stats(sessionId: string): RecallSessionStats | undefined;
 }
 export declare function registerRecall(ctx: Context, cfg: MemoryConfig, stores: {
     l1: L1Store;

package/dist/hooks/recall.js

@@ -35,9 +35,21 @@ const MEMORY_TOOLS_GUIDE = `<memory-tools-guide>
 注：若当前环境限制直接调用工具（如仅允许代码执行入口），请经由该环境的工具调用机制
 （如 run_code 程序内）使用以上记忆工具。
 </memory-tools-guide>`;
+/** 新建零值统计（首次出现的会话）。 */
+export function emptyRecallStats(now = Date.now()) {
+    return { injectedTurns: 0, hitTurns: 0, totalHits: 0, timeouts: 0, lastHits: 0, lastDurationMs: 0, updatedAt: now };
+}
 export function registerRecall(ctx, cfg, stores, logger, live, modes) {
-    /** 每 agent 最近一次注入的命中条数（工具指南门控的"本轮召回命中"信号）。 */
-    const recallHits = new Map();
+    /** 每 agent 召回统计（工具指南门控读 lastHits；悬浮卡信息区读全量计数）。 */
+    const recallStats = new Map();
+    const statFor = (id) => {
+        let s = recallStats.get(id);
+        if (!s) {
+            s = emptyRecallStats();
+            recallStats.set(id, s);
+        }
+        return s;
+    };
     // 画像/场景导航按族缓存（分族隔离：注入时按会话档位选族）
     const profileCache = {
         chat: { persona: '', nav: '' },
@@ -65,9 +77,9 @@ export function registerRecall(ctx, cfg, stores, logger, live, modes) {
     const invalidateProfile = () => {
         void refreshProfile();
     };
-    // agent 销毁时清掉召回信号槽
+    // agent 销毁时清掉召回统计槽
     ctx.on('agent/disposed', (payload) => {
-        recallHits.delete(payload.agent.id);
+        recallStats.delete(payload.agent.id);
     });
     // ── 1. pre-step 消息侧注入：记忆先行于每一条新的用户输入（ADR-0001） ──
     // prepend 注册 + 先 next() 再改写：不劫持其他监听器（dsh-time-context 官方范式）。
@@ -86,20 +98,35 @@ export function registerRecall(ctx, cfg, stores, logger, live, modes) {
                 if (!hasNewUserMessage)
                     return decision;
                 const query = buildRecallQuery(payload.messages);
-                recallHits.set(payload.agent.id, 0);
-                if (!query)
+                // 空查询是退化轮（无用户文本），重置命中信号但不计入统计
+                if (!query) {
+                    const degenerate = statFor(payload.agent.id);
+                    degenerate.lastHits = 0;
                     return decision;
+                }
+                const st = statFor(payload.agent.id);
+                st.injectedTurns++;
+                st.lastHits = 0;
+                st.updatedAt = Date.now();
+                const searchStart = Date.now();
                 const hits = await raceRecallTimeout(stores.l1.search(query, cfg.recall.maxResults, {
                     scoreThreshold: cfg.recall.scoreThreshold,
                     family: mode === 'auto' ? undefined : mode,
                     // 远程嵌入 fetch 内层钳制：给 FTS 降级留出总预算内的时间（本地推理不钳）
                     embeddingTimeoutMs: RECALL_EMBED_CAP_MS,
                 }), cfg.recall.timeoutMs);
+                st.updatedAt = Date.now();
                 if (hits === undefined) {
+                    st.timeouts++;
                     logger.warn('[memory] 召回超时，跳过本轮注入（不阻塞对话）');
                     return decision;
                 }
-                recallHits.set(payload.agent.id, hits.length);
+                st.lastDurationMs = Date.now() - searchStart;
+                st.lastHits = hits.length;
+                if (hits.length > 0) {
+                    st.hitTurns++;
+                    st.totalHits += hits.length;
+                }
                 if (hits.length === 0)
                     return decision;
                 const lines = applyRecallBudget(hits.map((h) => `- [${h.scene_name ? `${h.type}|${h.scene_name}` : h.type}] ${h.content}`), { maxCharsPerMemory: cfg.recall.maxCharsPerMemory, maxTotalRecallChars: cfg.recall.maxTotalRecallChars });
@@ -156,7 +183,7 @@ export function registerRecall(ctx, cfg, stores, logger, live, modes) {
                     const body = mode === 'auto'
                         ? formatProfileAuto(profileCache.chat, profileCache.work)
                         : formatProfileSingle(profileCache[mode]);
-                    const hasRecallHit = (recallHits.get(agent.id) ?? 0) > 0;
+                    const hasRecallHit = (recallStats.get(agent.id)?.lastHits ?? 0) > 0;
                     // 指南三条件门控：工具已注册（cfg.tools）&&（稳定内容 ∥ 本轮召回命中）——
                     // 空库用户与关闭工具的用户不付这份固定 token（原版 auto-recall 同款语义）
                     if (!cfg.tools)
@@ -189,7 +216,7 @@ export function registerRecall(ctx, cfg, stores, logger, live, modes) {
             }
         }
     });
-    return { invalidateProfile };
+    return { invalidateProfile, stats: (id) => recallStats.get(id) };
 }
 /** auto 档 <user-persona> 内的域说明：让模型理解分块结构与两域的独立性。 */
 const DOMAIN_HINT = '以下内容按记忆域分块：chat=用户个人画像（User Narrative Profile），work=团队工作准则（Team Operating Doctrine）。' +

package/dist/index.d.ts

@@ -113,6 +113,7 @@ export declare const Config: import("@deepseek-ai/schemastery").default<Schemast
         timeoutMs: import("@deepseek-ai/schemastery").default<number, number>;
     }>>;
     tools: import("@deepseek-ai/schemastery").default<boolean, boolean>;
+    benchControl: import("@deepseek-ai/schemastery").default<boolean, boolean>;
 }>, Schemastery.ObjectT<{
     dataDir: import("@deepseek-ai/schemastery").default<string, string>;
     family: import("@deepseek-ai/schemastery").default<"chat" | "work" | "auto", "chat" | "work" | "auto">;
@@ -218,5 +219,6 @@ export declare const Config: import("@deepseek-ai/schemastery").default<Schemast
         timeoutMs: import("@deepseek-ai/schemastery").default<number, number>;
     }>>;
     tools: import("@deepseek-ai/schemastery").default<boolean, boolean>;
+    benchControl: import("@deepseek-ai/schemastery").default<boolean, boolean>;
 }>>;
 export declare function apply(ctx: Context, config: MemoryConfig): Promise<void>;

package/dist/index.js

@@ -18,6 +18,7 @@
  */
 import * as path from 'node:path';
 import { memorySchema, resolveDataDir } from './config.js';
+import { registerBenchControl } from './bench-control.js';
 import { registerCapture } from './hooks/capture.js';
 import { registerRecall } from './hooks/recall.js';
 import { MemoryRunner } from './pipeline/runner.js';
@@ -297,7 +298,21 @@ export async function apply(ctx, config) {
     registerMemoryRpc(ctx, config, stores, logger, {
         degraded: () => !storageOk || db.isDegraded(),
         pending: () => runner.pendingCount,
-    }, live, modes, dataDir, rebuild, embedManager);
+    }, live, modes, dataDir, rebuild, embedManager, 
+    // 悬浮卡信息区数据源（session-stats 热路径端点；全部内存读 + 索引 COUNT，零文件 I/O）
+    {
+        recallStats: (sid) => recall.stats(sid),
+        runnerView: (sid, mode) => runner.sessionView(sid, mode),
+        l0Count: (sid) => stores.l0.countBySession(sid),
+        capabilities: () => db.getCapabilities(),
+    });
+    // bench 控制服务（config.benchControl 门控，默认关）：仅基准/调试部署注册，
+    // 供同进程的 bench-runner lifecycle 赛道触发 rebuild / 设置会话档位
+    // （宿主侧 RPC 无 call()，见 bench-control.ts）
+    if (config.benchControl && rebuild) {
+        const disposeBench = registerBenchControl(ctx, rebuild, modes, logger);
+        ctx.effect(() => () => disposeBench());
+    }
     logger.info(`[memory] L0~L3 分层蒸馏记忆插件就绪（L1 记忆 ${storageOk ? stores.l1.size : 0} 条 | 捕获=${storageOk && config.capture.enabled} | 蒸馏=${storageOk && config.extract.enabled} | 召回=${config.recall.enabled}）`);
     // 停机顺序（M7）：置停机标志（后台 embeddings 不再发起）→ 停蒸馏取新任务 →
     // 冲刷 L0 串行链（排队消息先落盘）→ 关库。cordis disposer 为 LIFO 逐个 await，

package/dist/llm-usage.d.ts

@@ -0,0 +1,27 @@
+/**
+ * 蒸馏用量追踪（进程内累计计数器，常开——纯内存累加，无 IO）：
+ * callLLM 按层（l1-extract/l1-dedup/l2/l3）累计调用数、输入字符、输出/思考 token。
+ *
+ * 用途：基准的「记忆开销」记账（效率三角之一）——L1/L2/L3 蒸馏消耗摊到每条
+ * 捕获消息，与工作流赛道已测的"记忆节省"（B 组重新探索的 token）配成完整 ROI。
+ * 暴露面：bench 控制服务 getDistillUsage()（config.benchControl 门控）。
+ *
+ * 输入侧说明：dsh llm 流的 usage 块只携带 output/reasoning token，输入 token
+ * 拿不到——按仓库既有口径记输入**字符**（中文 1 字 ≈ 1 token 保守折算，
+ * 见 config.ts maxInputChars 注释），报告侧如实标注。
+ */
+export type DistillLayer = 'l1-extract' | 'l1-dedup' | 'l2' | 'l3';
+export interface DistillLayerUsage {
+    calls: number;
+    failures: number;
+    inputChars: number;
+    outputTokens: number;
+    reasoningTokens: number;
+}
+export interface DistillUsageSnapshot {
+    layers: Record<string, DistillLayerUsage>;
+}
+/** 单次调用用量累计（callLLM 出口调用；inputChars 为实际发送的用户 prompt 字符）。 */
+export declare function recordDistillCall(layer: DistillLayer, inputChars: number, outputTokens: number, reasoningTokens: number, failed: boolean): void;
+/** 深拷贝快照（消费方拿到后不受后续累计影响）。 */
+export declare function snapshotDistillUsage(): DistillUsageSnapshot;

package/dist/llm-usage.js

@@ -0,0 +1,39 @@
+/**
+ * 蒸馏用量追踪（进程内累计计数器，常开——纯内存累加，无 IO）：
+ * callLLM 按层（l1-extract/l1-dedup/l2/l3）累计调用数、输入字符、输出/思考 token。
+ *
+ * 用途：基准的「记忆开销」记账（效率三角之一）——L1/L2/L3 蒸馏消耗摊到每条
+ * 捕获消息，与工作流赛道已测的"记忆节省"（B 组重新探索的 token）配成完整 ROI。
+ * 暴露面：bench 控制服务 getDistillUsage()（config.benchControl 门控）。
+ *
+ * 输入侧说明：dsh llm 流的 usage 块只携带 output/reasoning token，输入 token
+ * 拿不到——按仓库既有口径记输入**字符**（中文 1 字 ≈ 1 token 保守折算，
+ * 见 config.ts maxInputChars 注释），报告侧如实标注。
+ */
+const counters = new Map();
+function bucketOf(layer) {
+    let b = counters.get(layer);
+    if (!b) {
+        b = { calls: 0, failures: 0, inputChars: 0, outputTokens: 0, reasoningTokens: 0 };
+        counters.set(layer, b);
+    }
+    return b;
+}
+/** 单次调用用量累计（callLLM 出口调用；inputChars 为实际发送的用户 prompt 字符）。 */
+export function recordDistillCall(layer, inputChars, outputTokens, reasoningTokens, failed) {
+    const b = bucketOf(layer);
+    b.calls++;
+    if (failed)
+        b.failures++;
+    b.inputChars += Math.max(0, Math.round(inputChars));
+    b.outputTokens += Math.max(0, Math.round(outputTokens));
+    b.reasoningTokens += Math.max(0, Math.round(reasoningTokens));
+}
+/** 深拷贝快照（消费方拿到后不受后续累计影响）。 */
+export function snapshotDistillUsage() {
+    const layers = {};
+    for (const [layer, b] of counters) {
+        layers[layer] = { ...b };
+    }
+    return { layers };
+}