dsh-layered-memory 0.5.3 → 0.6.0

package/README.en.md

@@ -0,0 +1,211 @@
+[简体中文](README.md) | **English**
+
+<p align="center">
+  <img src="./assets/readme/hero.svg" width="100%"
+       alt="dsh-layered-memory: conversations are automatically distilled into layered memories and injected before every model step (L0 raw conversation → L1 atomic memories → L2 scene blocks → L3 core persona)">
+</p>
+
+# dsh-layered-memory
+
+A **layered distillation memory plugin** for DeepSeek Harness (persistent composition
+plugin): conversations are processed in the background through L0 capture → L1 atomic
+memories → L2 scene consolidation → L3 persona distillation, and relevant memories are
+automatically injected into context before every model step — neither the user nor the
+model needs to do anything. Ported from the pipeline design of
+[MemoryCore](https://github.com/TencentDB-Agent-Memory) (TencentDB Agent Memory):
+prompts are kept as-is; only the L2/L3 "LLM manipulates files" flow is adapted to
+"LLM outputs, engineering side executes".
+
+## Core Capabilities
+
+### Layered Memory (L0–L3)
+
+| Layer | Content | Storage |
+| --- | --- | --- |
+| L0 | Per-turn user/assistant messages (cleaned, code blocks and injected tags stripped) | `conversations/YYYY-MM-DD.jsonl` + SQLite |
+| L1 | Scene segmentation + memory extraction (chat: persona/episodic/instruction; work: work_fact/work_task/work_method/work_artifact) + conflict-detection dedup & merge, each record family-tagged | `records/YYYY-MM-DD.jsonl` + SQLite (FTS5 + optional vectors, family column) |
+| L2 | New memories consolidated into Markdown scene documents (META blocks, heat management, merge caps), consolidated per family | `scenes/chat/*.md`, `scenes/work/*.md` |
+| L3 | Persona distilled from changed scenes (chat: user persona ≤2000 chars; work: Team Operating Doctrine ≤1200 chars), one per family | `persona-chat.md`, `persona-work.md` |
+
+Pipeline principles: all distillation calls reuse DSH's own `ctx.llm`; any stage
+failure is logged only and never blocks the agent loop; recall injection is wrapped
+in tags that are automatically stripped on the capture side, preventing feedback loops.
+
+### Per-Session Memory Modes
+
+Each session can independently choose a memory mode — **write and recall share the
+same mode**:
+
+| Mode | Distillation (write) | Recall (injection) |
+| --- | --- | --- |
+| `Auto` (default) | Single extraction with a merged-vocabulary prompt, all personal 3 + work 4 types enabled, family tag assigned by type prefix | Both families recalled; persona/scene navigation grouped by category and injected with structured `<domain>` blocks |
+| `chat` | Narrow prompt with personal 3 types only, chat family only | chat memories only + chat persona/scene navigation |
+| `work` | Narrow prompt with work 4 types only, work family only | work memories only + work persona/scene navigation |
+| `Off` | No L0 writes, no distillation | No recall; the three memory tools return a "cloaked" notice |
+
+- **Control**: the pill next to the mode selector in the input bar (`Memory · Auto`);
+  clicking opens a macOS-style sliding picker above — release to snap to the nearest
+  mode;
+- **Default mode** = config `family` (`auto|chat|work`, default `auto`); each session's
+  choice is persisted by sessionId to `session-modes.json`, surviving restarts/session
+  restore; switching mid-session takes effect next turn, already-extracted memories
+  stay in their original family;
+- Stacks with the global switches (global is the master gate); L2/L3 are fully
+  family-isolated — content never leaks across families.
+
+### Memory Browser (Settings → Memory)
+
+Multi-tab page with a mixed view of both families: **Overview** (per-layer counts +
+memory mode switch panel, auto-refresh every 5s), **Memories** (L1 card list with
+keyword/type/scene filters), **Scenes** (L2 full text), **Persona** (L3 full text),
+**Log** (last 200 lines of `memory.log`). Switches go through the official settings
+service (namespace `dsh-memory`, effective immediately, persisted across restarts);
+effective rule = **static config (deployment ceiling) AND runtime switch**; data
+channel is loopback RPC (`dsh-memory/*`).
+
+## Getting Started
+
+Requires Node ≥ 22.16. Two invocation styles — the `npx` prefix can replace `dsh` in
+any command below:
+
+```bash
+# Option 1: run the official CLI directly via npx (no pre-installed dsh; version can be pinned, e.g. dsh-layered-memory@0.5.4)
+npx -y @deepseek-ai/dsh plugin --profile web add dsh-layered-memory
+
+# Option 2: with the dsh CLI installed (dsh is a pnpm forwarder; npm i -g pnpm first if missing)
+dsh plugin --profile web add dsh-layered-memory
+
+# Alternative sources: GitHub repo / local path (dev & debugging, link: points at the repo; npm run build + restart dsh to apply)
+dsh plugin --profile web add https://github.com/JunNanLYS/dsh-layered-memory
+dsh plugin --profile web add /path/to/dsh-layered-memory
+```
+
+This package declares a `dsh.bundle` composition layer (`cordis.patch.yml`); after
+installation the **plugin entry is mounted automatically** — no need to hand-edit
+`$DSH_HOME/profiles/web/cordis.patch.yml`. Then restart DeepSeek Harness and verify:
+the appearance of `conversations/ records/ scenes/` and `memory.db` under
+`~/.dsh/memory/` means the plugin applied successfully; the "Memory" page in settings
+and the mode pill in the input bar mean the client half is ready.
+
+> ⚠️ **Security note**: installing a plugin = running third-party code with your
+> privileges. This plugin reads session content, writes files in its data directory,
+> and calls the LLM/embedding services you configured; if that concerns you, review
+> the source first (`src/`).
+
+**Uninstall**: `dsh plugin --profile web remove dsh-layered-memory` + restart. Data
+stays in `~/.dsh/memory/`; delete the whole directory manually if you don't need it.
+
+### Development from Source
+
+```bash
+git clone https://github.com/JunNanLYS/dsh-layered-memory
+cd dsh-layered-memory
+npm install && npm run build
+dsh plugin --profile web add .        # link: install; after code changes, npm run build + restart dsh
+npm run smoke                         # smoke test (rebuild first: see command below)
+npx tsc src/smoke.ts --outDir dist-smoke --module nodenext --moduleResolution nodenext --target es2022 --strict --skipLibCheck --esModuleInterop
+```
+
+## Configuration
+
+Override configs go into the profile's own `cordis.patch.yml` as a **top-level bare
+patch entry** (direct `id:`, not wrapped in `insert:` — an insert with the same id as
+the bundle layer appends and causes `duplicate loader entry id` startup failure):
+
+```yaml
+- id: dsh-memory
+  name: dsh-layered-memory
+  config:                    # keys replace whole lines (no deep merge); write out all keys you want to keep
+    family: auto             # default mode for new sessions: auto | chat | work
+    llm:                     # distillation model route (falls back to the current default model if empty)
+      provider: ''
+      model: ''
+```
+
+| Field | Default | Description |
+| --- | --- | --- |
+| `family` | `auto` | Default memory mode for new sessions: `auto` (both families) \| `chat` (personal) \| `work` (work); switchable per session via the input-bar control |
+| `dataDir` | `$DSH_HOME/memory` | Data directory |
+| `capture.enabled` | `true` | L0 capture |
+| `capture.stripCodeBlocks` | `true` | Strip code blocks from assistant messages |
+| `capture.maxMessageChars` | `4000` | Max characters per message |
+| `extract.enabled` | `true` | L1 extraction |
+| `extract.minMessages` | `1` | Run L1 extraction after N new messages accumulate |
+| `extract.backgroundMessages` | `10` | Background messages attached to extraction |
+| `extract.candidatePool` | `5` | Dedup candidate pool size |
+| `l2.enabled` | `true` | L2 scene consolidation |
+| `l2.minNewMemories` | `5` | New-memory threshold since last L2 consolidation |
+| `l2.maxScenes` | `12` | Scene block count cap |
+| `l2.sceneContextLimit` | `3` | Max similar-scene full texts attached to the L2 prompt |
+| `l3.enabled` | `true` | L3 persona distillation |
+| `l3.interval` | `20` | L3 distillation interval (new-memory count) |
+| `recall.enabled` | `true` | Auto recall |
+| `recall.maxResults` | `5` | L1 records injected per step |
+| `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) |
+| `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 |
+| `embedding.model` | empty | embedding model name |
+| `embedding.dimensions` | `0` | Vector dimensions (required when enabled; must match model output) |
+| `llm.provider/model` | empty | Distillation model override (defaults to current selection) |
+| `llm.maxTokens` | `20000` | Output token cap per distillation call (unified across stages; a reasoning model's reasoning shares this budget — too low gets fully consumed by thinking, leaving 0 chars of text) |
+| `llm.temperature` | `0.3` | Distillation temperature |
+| `llm.maxInputChars` | `700000` | Input character budget per distillation call (over-budget L1 inputs are chunked automatically) |
+| `tools` | `true` | Whether to register model-callable memory tools |
+
+## Storage Layout
+
+Aligned with MemoryCore's official dual-write architecture: append-only JSONL files
+(`conversations/`, `records/` sharded by day) are the source of truth for
+backup/restore and are **never rewritten**; `memory.db` (node:sqlite + WAL + FTS5
+BM25 + sqlite-vec cosine vectors) is the primary retrieval engine — updates/deletes
+from dedup merges touch the retrieval DB only.
+
+- **Three retrieval strategies** (`recall.strategy`): `keyword` (FTS5 BM25) /
+  `embedding` (vec0 cosine KNN) / `hybrid` (both lanes in parallel + RRF k=60
+  fusion, default); `conversation_search` (L0) uses the same fusion;
+- **Vectors optional**: off by default (pure FTS). DSH's `ctx.llm` has no embeddings
+  endpoint; enabling requires any OpenAI-compatible `/embeddings` service (configure
+  `embedding.*`); config changes automatically drop the vector table and re-embed
+  everything in the background;
+- **Degradation chain**: sqlite-vec load failure → pure FTS; embedding call failure
+  → degrade to FTS for that call with a one-time warning; retrieval DB init failure
+  → memory features disabled entirely but dsh itself starts normally;
+- **Replacement seam**: `L1Store.search()` is the single retrieval entry point.
+
+```
+memory/
+├── memory.db              # SQLite retrieval DB (L0/L1 metadata + FTS5 + optional vectors; L1 has a family column)
+├── conversations/2026-01-01.jsonl  # L0 raw conversation source of truth (one file per day, append-only; not family-split)
+├── records/2026-01-01.jsonl        # L1 atomic memory source of truth (one file per day, append-only; family field included)
+├── scenes/chat/*.md       # L2 scene blocks (chat family)
+├── scenes/work/*.md       # L2 scene blocks (work family)
+├── persona-chat.md        # L3 persona (chat family: user persona)
+├── persona-work.md        # L3 persona (work family: Team Operating Doctrine)
+├── state.json             # pipeline checkpoint (v2 family-split: families.chat / families.work)
+├── session-modes.json     # session mode map (sessionId → mode, auto-pruned after >90 days)
+└── memory.log             # diagnostic log (info+, rotates to memory.log.1 beyond 2MB)
+```
+
+## Logging & Troubleshooting
+
+The dsh host prints plugin logs to the console; the plugin mirrors info and above to
+`memory.log` in its data directory. The typical log path of one conversation turn:
+`L0 捕获 turn=N …条` → `L0 落盘 N 条` → `蒸馏管线开始（…待重试 M 条）` →
+`LLM 调用 provider/model：输入 x → 输出 y 字符（z s）` → `L1 抽取完成（…新增 Y 条）` →
+`蒸馏管线结束`; the next turn shows `召回命中 N 条 L1`. Empty LLM output carries full
+diagnostics (finish reason / token counts / reasoning excerpt); JSON parse failures
+include the first 400 characters of the raw model output; all failure warns carry the
+first stack frame.
+
+## Differences from MemoryCore
+
+- The full pipeline is embedded (no external Gateway); distillation reuses DSH's own LLM;
+- L2/L3 changed from "LLM manipulates file tools" to "LLM outputs operation JSON / full documents, engineering side executes";
+- Recall injection happens at `agent/pre-step` + agent-scoped `systemPrompt.context` (DSH-native events/services);
+- Storage/retrieval is a single-machine slimmed version of the official sqlite backend (drops multi-tenant isolation columns, TCVDB cloud backend, audit tables; tokenization uses a bundled CJK bigram instead of jieba, keeping zero native dependencies — sqlite-vec is the only native extension, auto-degrading on load failure).
+
+## License
+
+[MIT](LICENSE)

package/README.md

@@ -1,3 +1,5 @@
+**简体中文** | [English](README.en.md)
+
 <p align="center">
   <img src="./assets/readme/hero.svg" width="100%"
        alt="dsh-layered-memory：对话自动分层蒸馏成记忆，模型每步前自动召回注入（L0 原始对话 → L1 原子记忆 → L2 场景块 → L3 核心画像）">
@@ -44,24 +46,26 @@ Agent 循环；召回注入用标签包裹、捕获侧自动剥离，防止反
 
 ### 记忆浏览器（设置页 → 记忆）
 
-多 Tab 页面，两族混合视图：**概览**（各层计数 + 记忆模式开关面板，5 秒自动刷新）、
+多 Tab 页面，两族混合视图：**概览**（各层计数 + 记忆模式开关面板 + 蒸馏思考档位选择器，5 秒自动刷新）、
 **记忆**（L1 卡片列表，关键词/类型/情境筛选）、**场景**（L2 全文）、**画像**（L3 全文）、
-**日志**（`memory.log` 尾部 200 行）。开关走官方 settings 服务（命名空间 `dsh-memory`，
-实时生效、重启保留）；生效规则 = **静态 config（部署上限）AND 运行时开关**，
+**日志**（`memory.log` 尾部 200 行）。开关与思考档位走官方 settings 服务（命名空间 `dsh-memory`，
+实时生效、重启保留）；开关生效规则 = **静态 config（部署上限）AND 运行时开关**；
+思考档位为运行时覆盖（选择器选"跟随配置"则用部署配置 `llm.reasoningEffort` 作默认），
 数据通道为 loopback RPC（`dsh-memory/*`）。
 
 ## 快速开始
 
-需要 Node ≥ 22.16 与已安装的 dsh CLI（dsh 是 pnpm 转发器，未装 pnpm 时先 `npm i -g pnpm`）。
+需要 Node ≥ 22.16。两种调用方式任选（`npx` 前缀可替换下面任何 `dsh` 命令）：
 
 ```bash
-# 从 npm 安装（推荐；可 pin 版本，如 @0.5.3）
+# 方式一：npx 直接跑官方 CLI（无需预装 dsh；可 pin 版本，如 dsh-layered-memory@0.5.4）
+npx -y @deepseek-ai/dsh plugin --profile web add dsh-layered-memory
+
+# 方式二：已装 dsh CLI（dsh 是 pnpm 转发器，未装 pnpm 时先 npm i -g pnpm）
 dsh plugin --profile web add dsh-layered-memory
 
-# 或从 GitHub 仓库安装
+# 包源备选：GitHub 仓库 / 本地路径（开发调试，link: 指向仓库，npm run build + 重启 dsh 即生效）
 dsh plugin --profile web add https://github.com/JunNanLYS/dsh-layered-memory
-
-# 或从本地路径安装（开发/调试，link: 指向仓库，npm run build + 重启 dsh 即生效）
 dsh plugin --profile web add /path/to/dsh-layered-memory
 ```
 
@@ -131,6 +135,7 @@ npx tsc src/smoke.ts --outDir dist-smoke --module nodenext --moduleResolution no
 | `embedding.dimensions` | `0` | 向量维度（启用时必填，须与模型输出一致） |
 | `llm.provider/model` | 空 | 蒸馏模型覆盖（默认用当前默认选择） |
 | `llm.maxTokens` | `20000` | 单次蒸馏输出 token 上限（全阶段统一；推理模型的 reasoning 与正文共享该预算，过低会被思考吃光导致正文 0 字符） |
+| `llm.reasoningEffort` | `off` | 蒸馏思考档位（部署默认）：`off` / `high` / `max`，空串不传（跟随模型默认）。蒸馏是结构化抽取任务，默认关思考——推理模型（如 v4-flash）默认 high 档的思考可把任意输出预算全部吃光导致正文 0 字符；非推理模型不认识 effort 时需设为空串。运行时可在设置页 → 记忆 → 概览临时切换（选"跟随配置"即回退本值） |
 | `llm.temperature` | `0.3` | 蒸馏温度 |
 | `llm.maxInputChars` | `700000` | 单次蒸馏输入字符预算（超限的 L1 输入自动分块抽取） |
 | `tools` | `true` | 是否注册模型可调用的记忆工具 |

package/dist/client.js

@@ -160,6 +160,31 @@ window.__ModuleLoader__.load({
         padding: "4px 12px",
         marginBottom: 14,
       },
+      seg: {
+        display: "inline-flex",
+        border: "1px solid var(--dsw-alias-border-secondary, #e5e5e5)",
+        borderRadius: 8,
+        overflow: "hidden",
+        flexShrink: 0,
+      },
+      segBtn: {
+        padding: "4px 12px",
+        fontSize: 12,
+        lineHeight: "16px",
+        cursor: "pointer",
+        background: "transparent",
+        color: "inherit",
+        border: "none",
+        borderRight: "1px solid var(--dsw-alias-border-secondary, #e5e5e5)",
+      },
+      segBtnOn: {
+        background: "var(--dsw-alias-interactive-bg-primary, #1a7f37)",
+        color: "#fff",
+        fontWeight: 600,
+      },
+      segBtnOff: {
+        background: "var(--dsw-alias-bg-secondary, #f6f8fa)",
+      },
       flexRow: { display: "flex", alignItems: "center", gap: 8, flexWrap: "wrap" },
       grow: { flex: 1 },
       sceneHead: { display: "flex", alignItems: "baseline", gap: 10, marginBottom: 6, flexWrap: "wrap" },
@@ -228,6 +253,36 @@ window.__ModuleLoader__.load({
       );
     }
 
+    // ── Segmented 组件：分段选择器（记忆设置页的蒸馏思考档位等单选项） ──
+    function Segmented(props) {
+      var value = props.value;
+      var disabled = !!props.disabled;
+      return react.createElement(
+        "div",
+        { style: Object.assign({}, S.seg, disabled ? S.switchDisabled : null) },
+        props.options.map(function (opt, i) {
+          var on = opt.key === value;
+          return react.createElement(
+            "span",
+            {
+              key: opt.key,
+              style: Object.assign(
+                {},
+                S.segBtn,
+                on ? S.segBtnOn : S.segBtnOff,
+                i === props.options.length - 1 ? { borderRight: "none" } : null,
+                disabled ? { cursor: "not-allowed" } : null,
+              ),
+              onClick: function () {
+                if (!disabled && !on && props.onChange) props.onChange(opt.key);
+              },
+            },
+            opt.label,
+          );
+        }),
+      );
+    }
+
     // ── 会话记忆档位控件（输入栏 pill + macOS 风格滑动选择器） ──
     // 档位顺序即滑轨顺序：关闭 → chat → work → 自动（默认档"自动"居右）
     var MODES = [
@@ -257,40 +312,54 @@ window.__ModuleLoader__.load({
       return 3;
     }
 
-    /** 滑动选择器浮层（参考 macOS 滑动器：拖拽圆头 + 松手吸附最近档；当前档由下方标签高亮指示）。 */
+    /** 滑动选择器浮层（参考 macOS 滑动器：拖拽圆头 1:1 连续跟手，松手按动量投影吸附最近档）。 */
     function ModeSlider(props) {
+      ensureFlowStyle(); // 玻璃材质 class 与流光共用同一张注入样式表
       var trackRef = react.useRef(null);
+      // 拖拽状态：{ x: 圆头连续位置 px, lastX: 上次指针 clientX, t: 时间戳, v: 速度 px/ms（EMA 平滑） }
       var dragState = react.useState(null);
-      var dragIdx = dragState[0];
-      var setDragIdx = dragState[1];
-
-      var activeIdx = dragIdx === null ? modeIndex(props.mode) : dragIdx;
+      var drag = dragState[0];
+      var setDrag = dragState[1];
 
-      var idxFromClientX = function (clientX) {
+      var clampX = function (x) {
+        if (x < 0) return 0;
+        if (x > INNER_W) return INNER_W;
+        return x;
+      };
+      var xFromClientX = function (clientX) {
         var rect = trackRef.current.getBoundingClientRect();
-        var x = clientX - rect.left - THUMB / 2;
-        if (x < 0) x = 0;
-        if (x > INNER_W) x = INNER_W;
-        return Math.round((x / INNER_W) * (MODES.length - 1));
+        return clampX(clientX - rect.left - THUMB / 2);
       };
 
       var onPointerDown = function (e) {
         e.preventDefault();
         e.currentTarget.setPointerCapture(e.pointerId);
-        setDragIdx(idxFromClientX(e.clientX));
+        setDrag({ x: xFromClientX(e.clientX), lastX: e.clientX, t: e.timeStamp, v: 0 });
       };
       var onPointerMove = function (e) {
-        if (dragIdx === null) return;
-        setDragIdx(idxFromClientX(e.clientX));
+        if (drag === null) return;
+        var dt = e.timeStamp - drag.t;
+        var instV = dt > 0 ? (e.clientX - drag.lastX) / dt : drag.v;
+        setDrag({
+          x: xFromClientX(e.clientX),
+          lastX: e.clientX,
+          t: e.timeStamp,
+          v: drag.v * 0.7 + instV * 0.3, // EMA：瞬时抖动不放大，松手投影用
+        });
       };
       var onPointerUp = function (e) {
-        if (dragIdx === null) return;
-        var idx = idxFromClientX(e.clientX);
-        setDragIdx(null);
+        if (drag === null) return;
+        // 动量投影（Designing Fluid Interfaces）：按松手速度前瞻落点就近吸附；
+        // 投影量 clamp 到半档（±30px）——甩动最多把边界推到相邻档，绝不会跳两档
+        var projected = xFromClientX(e.clientX) + Math.max(-30, Math.min(30, drag.v * 120));
+        var idx = Math.round((clampX(projected) / INNER_W) * (MODES.length - 1));
+        setDrag(null);
         props.onCommit(MODES[idx].key);
       };
 
-      var thumbLeft = (activeIdx / (MODES.length - 1)) * INNER_W;
+      // 拖拽中圆头 1:1 跟指针（连续位置，不吸附）；静止时停在档位中心
+      var thumbLeft = drag !== null ? drag.x : (modeIndex(props.mode) / (MODES.length - 1)) * INNER_W;
+      var activeIdx = Math.min(MODES.length - 1, Math.max(0, Math.round((thumbLeft / INNER_W) * (MODES.length - 1))));
       var info = MODES[activeIdx];
 
       var stops = [];
@@ -310,7 +379,8 @@ window.__ModuleLoader__.load({
                   width: 6,
                   height: 6,
                   borderRadius: "50%",
-                  background: active ? MODES[i].color : "#c6cbd1",
+                  background: active ? MODES[i].color : "rgba(128,140,150,0.55)",
+                  zIndex: 2,
                 },
               },
             ),
@@ -331,9 +401,10 @@ window.__ModuleLoader__.load({
                   cursor: "pointer",
                   whiteSpace: "nowrap",
                   fontWeight: active ? 600 : 400,
-                  color: active ? MODES[i].color : "var(--dsw-alias-label-tertiary, #888)",
+                  // 未激活标签走主题 caption 令牌（浅色 #400 灰蓝 / 暗色 #600），玻璃面上保持可读
+                  color: active ? MODES[i].color : "var(--dsw-alias-label-caption, #888)",
                 },
-                onClick: function () { if (dragIdx === null) props.onCommit(MODES[i].key); },
+                onClick: function () { if (drag === null) props.onCommit(MODES[i].key); },
               },
               MODES[i].label,
             ),
@@ -344,6 +415,8 @@ window.__ModuleLoader__.load({
       return react.createElement(
         "div",
         {
+          // 外壳只负责定位（带 transform 居中）；玻璃材质拆到内层独立元素——
+          // Chromium 中 transform 元素上的 backdrop-filter 采样异常，玻璃会失效
           style: {
             position: "absolute",
             bottom: "calc(100% + 8px)",
@@ -351,67 +424,134 @@ window.__ModuleLoader__.load({
             left: "50%",
             transform: "translateX(-50%)",
             zIndex: 1000,
-            background: "var(--dsw-alias-bg-primary, #fff)",
-            border: "1px solid var(--dsw-alias-border-secondary, #e0e0e0)",
-            borderRadius: 10,
-            boxShadow: "0 8px 24px rgba(0,0,0,0.16)",
-            padding: "12px 16px 30px",
           },
         },
+        react.createElement("div", {
+          className: "dsh-mem-glass",
+          style: { position: "absolute", top: 0, left: 0, right: 0, bottom: 0, pointerEvents: "none" },
+        }),
         react.createElement(
           "div",
-          {
-            ref: trackRef,
-            style: {
-              position: "relative",
-              width: TRACK_W + THUMB,
-              height: 16,
-              touchAction: "none",
-              cursor: dragIdx === null ? "pointer" : "grabbing",
+          { style: { position: "relative", padding: "12px 16px 30px" } },
+          react.createElement(
+            "div",
+            {
+              ref: trackRef,
+              style: {
+                position: "relative",
+                // 容器宽 = thumb 活动范围（0..INNER_W + THUMB），点击映射与视觉两端严格对齐
+                width: TRACK_W,
+                height: 16,
+                touchAction: "none",
+                cursor: drag === null ? "pointer" : "grabbing",
             },
             onPointerDown: onPointerDown,
             onPointerMove: onPointerMove,
             onPointerUp: onPointerUp,
             onPointerCancel: onPointerUp,
           },
-          // 圆球先画、线条后画（叠在球面上）——线条从圆球中心穿过；
-          // 线两端延伸到两端球的边缘（对称穿过首尾停点的中心）；
-          // 当前档由下方标签高亮指示（上方不放文字）
+          // 线条（底层）：只连首尾停点的中心，两端不再露出停点外；
+          // thumb（当前档定位球）压最上层，不再被线条与停点穿过。
+          // 中性半透明灰在玻璃材质上深浅主题都可辨
           react.createElement("div", {
             style: {
               position: "absolute",
-              left: thumbLeft,
-              top: 1,
-              width: THUMB,
-              height: THUMB,
-              borderRadius: "50%",
-              background: "#fff",
-              border: "1px solid " + info.color,
-              boxShadow: "0 1px 4px rgba(0,0,0,0.3)",
+              left: THUMB / 2,
+              width: INNER_W,
+              top: 7,
+              height: 4,
+              borderRadius: 999,
+              background: "rgba(128,140,150,0.32)",
               pointerEvents: "none",
-              transition: dragIdx === null ? "left 120ms ease" : "none",
+              zIndex: 1,
             },
           }),
+          stops,
           react.createElement("div", {
             style: {
               position: "absolute",
-              left: 0,
-              width: TRACK_W,
-              top: 7,
-              height: 4,
-              borderRadius: 999,
-              background: "var(--dsw-alias-border-secondary, #e1e4e8)",
+              left: thumbLeft,
+              top: 1,
+              width: THUMB,
+              height: THUMB,
+              borderRadius: "50%",
+              // 微透白 + 上缘高光：与浮层玻璃材质同语言
+              background: "rgba(255,255,255,0.94)",
+              border: "1px solid " + info.color,
+              boxShadow: "0 1px 4px rgba(0,0,0,0.28), inset 0 1px 0 rgba(255,255,255,0.9)",
               pointerEvents: "none",
+              transition: drag === null ? "left 120ms ease" : "none",
+              zIndex: 3,
             },
           }),
-          stops,
+          ),
+          props.error
+            ? react.createElement("div", { style: { fontSize: 11, color: "#cf222e", marginTop: 20, whiteSpace: "nowrap" } }, props.error)
+            : null,
         ),
-        props.error
-          ? react.createElement("div", { style: { fontSize: 11, color: "#cf222e", marginTop: 20, whiteSpace: "nowrap" } }, props.error)
-          : null,
       );
     }
 
+    // ── auto 档边缘流光 + 浮层玻璃材质：inline style 放不了 @keyframes/@property/媒体查询，
+    // 惰性注入一次性样式表（id 防重复）。dsw 主题变量参考其前端令牌：暗色走 body[data-ds-dark-theme]。 ──
+    var FLOW_STYLE_ID = "dsh-mem-flow-style";
+    function ensureFlowStyle() {
+      if (document.getElementById(FLOW_STYLE_ID)) return;
+      var el = document.createElement("style");
+      el.id = FLOW_STYLE_ID;
+      el.textContent = [
+        // conic 角度动画需要 @property 注册才能插值；不支持的浏览器优雅降级为静态渐变边框
+        "@property --dsh-mem-angle { syntax: '<angle>'; initial-value: 0deg; inherits: false; }",
+        "@keyframes dshMemFlow { to { --dsh-mem-angle: 360deg; } }",
+        // 边缘流光（双层背景）：border 区画旋转 conic 冷蓝光带；内部必须是【不透明】底色盖住
+        // 光带（半透明内层会让 conic 透进按钮内部，文字被光斑干扰——实测事故）。
+        // 不透明底 = 主题底混 12% 冷蓝（color-mix 出来 alpha=1），静态、随主题
+        ".dsh-mem-flow {",
+        "  border: 1px solid transparent;",
+        "  background:",
+        "    linear-gradient(",
+        "      color-mix(in srgb, var(--dsw-alias-bg-layer-2, #ffffff) 88%, #3b82f6),",
+        "      color-mix(in srgb, var(--dsw-alias-bg-layer-2, #ffffff) 88%, #3b82f6)",
+        "    ) padding-box,",
+        "    conic-gradient(from var(--dsh-mem-angle),",
+        "      rgba(8,145,178,0.9), rgba(59,130,246,0.9), rgba(125,211,252,1),",
+        "      rgba(99,102,241,0.9), rgba(8,145,178,0.9)) border-box;",
+        "  animation: dshMemFlow 3s linear infinite;",
+        "  color: #0284c7;",
+        "}",
+        "body[data-ds-dark-theme] .dsh-mem-flow { color: #7dd3fc; }",
+        "@media (prefers-reduced-motion: reduce) { .dsh-mem-flow { animation: none; } }",
+        // 浮层玻璃材质（Apple 菜单配方）：材质层必须是【无 transform 的独立元素】——
+        // Chromium 中 transform 元素上的 backdrop-filter 采样异常（玻璃失效，实测）。
+        // 低不透明度基底让底下内容透出 + 顶部光泽渐变 + blur/saturate + 亮缘 + 分主题阴影
+        ".dsh-mem-glass {",
+        "  border-radius: 12px;",
+        "  background:",
+        "    linear-gradient(rgba(255,255,255,0.34), rgba(255,255,255,0.05)),",
+        "    rgba(248,249,251,0.55);",
+        "  -webkit-backdrop-filter: blur(32px) saturate(180%);",
+        "  backdrop-filter: blur(32px) saturate(180%);",
+        "  border: 1px solid rgba(255,255,255,0.55);",
+        "  box-shadow:",
+        "    0 12px 40px rgba(0,0,0,0.16), 0 2px 8px rgba(0,0,0,0.07),",
+        "    inset 0 1px 0 rgba(255,255,255,0.55), inset 0 -1px 0 rgba(0,0,0,0.03);",
+        "}",
+        "body[data-ds-dark-theme] .dsh-mem-glass {",
+        "  background:",
+        "    linear-gradient(rgba(255,255,255,0.09), rgba(255,255,255,0.015)),",
+        "    rgba(30,32,40,0.55);",
+        "  border-color: rgba(255,255,255,0.14);",
+        "  box-shadow:",
+        "    0 16px 48px rgba(0,0,0,0.55), 0 3px 12px rgba(0,0,0,0.35),",
+        "    inset 0 1px 0 rgba(255,255,255,0.12);",
+        "}",
+        "@media (prefers-reduced-transparency: reduce) {",
+        "  .dsh-mem-glass { background: var(--dsw-alias-bg-layer-2, #ffffff); backdrop-filter: none; -webkit-backdrop-filter: none; }",
+        "}",
+      ].join("\n");
+      document.head.appendChild(el);
+    }
+
     /** 输入栏 pill：点击展开滑动选择器；props 来自 conversation.input.left 的 zone 注入。 */
     function MemoryModePill(props) {
       var rpc = props.rpc;
@@ -474,6 +614,31 @@ window.__ModuleLoader__.load({
       if (!sessionId || !rpc) return null;
       var info = modeInfo(mode);
       var loaded = mode !== null;
+      var isAuto = loaded && mode === "auto";
+
+      if (isAuto) ensureFlowStyle();
+
+      // auto 档的边框/背景/文字色均由 .dsh-mem-flow 提供（双层背景画流光边 + 分主题文字），
+      // inline 不能设置这些——inline 优先级会盖掉 class 里的流光
+      var pillStyle = {
+        display: "inline-flex",
+        alignItems: "center",
+        gap: 4,
+        height: 24,
+        padding: "0 10px",
+        borderRadius: 999,
+        fontSize: 12,
+        fontWeight: 500,
+        lineHeight: "20px",
+        cursor: "pointer",
+      };
+      if (isAuto) {
+        pillStyle.boxShadow = "0 0 12px rgba(56,189,248,0.30)";
+      } else {
+        pillStyle.border = "1px solid " + (loaded ? info.color + "66" : "var(--dsw-alias-border-secondary, #ccc)");
+        pillStyle.background = loaded ? info.color + "14" : "var(--dsw-alias-bg-secondary, #f6f8fa)";
+        pillStyle.color = loaded ? info.color : "var(--dsh-alias-label-tertiary, #888)";
+      }
 
       return react.createElement(
         "div",
@@ -484,21 +649,8 @@ window.__ModuleLoader__.load({
             type: "button",
             title: "本会话记忆档位（点击切换）",
             onClick: function () { setOpen(!open); },
-            style: {
-              display: "inline-flex",
-              alignItems: "center",
-              gap: 4,
-              height: 24,
-              padding: "0 10px",
-              borderRadius: 999,
-              fontSize: 12,
-              fontWeight: 500,
-              lineHeight: "20px",
-              cursor: "pointer",
-              border: "1px solid " + (loaded ? info.color + "66" : "var(--dsw-alias-border-secondary, #ccc)"),
-              background: loaded ? info.color + "14" : "var(--dsw-alias-bg-secondary, #f6f8fa)",
-              color: loaded ? info.color : "var(--dsh-alias-label-tertiary, #888)",
-            },
+            className: isAuto ? "dsh-mem-flow" : null,
+            style: pillStyle,
           },
           "记忆·",
           react.createElement("span", null, loaded ? info.label : "…"),
@@ -630,6 +782,31 @@ window.__ModuleLoader__.load({
                   disabled: !master,
                   onChange: function (v) { toggle("recall", v); },
                 }),
+                settingsData.effort
+                  ? react.createElement(
+                      "div",
+                      { style: S.switchRow },
+                      react.createElement(Segmented, {
+                        value: settingsData.effort.current,
+                        options: [
+                          { key: "", label: "跟随配置" },
+                          { key: "off", label: "off" },
+                          { key: "high", label: "high" },
+                          { key: "max", label: "max" },
+                        ],
+                        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 ? "" : "（来自部署配置 llm.reasoningEffort）"),
+                        )),
+                    )
+                  : null,
                 ceilingNote
                   ? react.createElement("p", { style: S.hint }, ceilingNote)
                   : null,

package/dist/config.d.ts

@@ -72,6 +72,8 @@ export interface MemoryConfig {
         model: string;
         /** 单次蒸馏调用的输出 token 上限（推理模型的 reasoning 与正文共享该预算）。 */
         maxTokens: number;
+        /** 蒸馏调用的思考档位；空串不传（跟随模型默认）。 */
+        reasoningEffort: string;
         temperature: number;
         /** 单次蒸馏调用的用户 prompt 字符预算（≈token 数，按中文 1 字≈1 token 保守估算）。 */
         maxInputChars: number;
@@ -158,6 +160,7 @@ export declare const memorySchema: Schema<Schemastery.ObjectS<{
         provider: Schema<string, string>;
         model: Schema<string, string>;
         maxTokens: Schema<number, number>;
+        reasoningEffort: Schema<"" | "off" | "high" | "max", "" | "off" | "high" | "max">;
         temperature: Schema<number, number>;
         maxInputChars: Schema<number, number>;
         timeoutMs: Schema<number, number>;
@@ -165,6 +168,7 @@ export declare const memorySchema: Schema<Schemastery.ObjectS<{
         provider: Schema<string, string>;
         model: Schema<string, string>;
         maxTokens: Schema<number, number>;
+        reasoningEffort: Schema<"" | "off" | "high" | "max", "" | "off" | "high" | "max">;
         temperature: Schema<number, number>;
         maxInputChars: Schema<number, number>;
         timeoutMs: Schema<number, number>;
@@ -247,6 +251,7 @@ export declare const memorySchema: Schema<Schemastery.ObjectS<{
         provider: Schema<string, string>;
         model: Schema<string, string>;
         maxTokens: Schema<number, number>;
+        reasoningEffort: Schema<"" | "off" | "high" | "max", "" | "off" | "high" | "max">;
         temperature: Schema<number, number>;
         maxInputChars: Schema<number, number>;
         timeoutMs: Schema<number, number>;
@@ -254,6 +259,7 @@ export declare const memorySchema: Schema<Schemastery.ObjectS<{
         provider: Schema<string, string>;
         model: Schema<string, string>;
         maxTokens: Schema<number, number>;
+        reasoningEffort: Schema<"" | "off" | "high" | "max", "" | "off" | "high" | "max">;
         temperature: Schema<number, number>;
         maxInputChars: Schema<number, number>;
         timeoutMs: Schema<number, number>;

package/dist/config.js

@@ -51,6 +51,9 @@ export const memorySchema = Schema.object({
         model: Schema.string().default(''),
         // 推理模型（如 v4-flash）的 reasoning 计入输出预算：预算不足会被思考吃光导致正文 0 字符
         maxTokens: Schema.number().default(20_000),
+        // 蒸馏是结构化抽取任务，默认关思考（off）：v4-flash 默认 high 档的思考可把任意 maxTokens
+        // 预算全部吃光导致正文 0 字符；非推理模型不认识 effort 时会报 UNSUPPORTED_REASONING_EFFORT，设空串跳过
+        reasoningEffort: Schema.union(['', 'off', 'high', 'max']).default('off'),
         temperature: Schema.number().default(0.3),
         // 模型上下文 1M token，日常压到 ~700k 使用（中文按 1 字≈1 token 保守折算）
         maxInputChars: Schema.number().default(700_000),

package/dist/index.d.ts

@@ -85,6 +85,7 @@ export declare const Config: import("@deepseek-ai/schemastery").default<Schemast
         provider: import("@deepseek-ai/schemastery").default<string, string>;
         model: import("@deepseek-ai/schemastery").default<string, string>;
         maxTokens: import("@deepseek-ai/schemastery").default<number, number>;
+        reasoningEffort: import("@deepseek-ai/schemastery").default<"" | "off" | "high" | "max", "" | "off" | "high" | "max">;
         temperature: import("@deepseek-ai/schemastery").default<number, number>;
         maxInputChars: import("@deepseek-ai/schemastery").default<number, number>;
         timeoutMs: import("@deepseek-ai/schemastery").default<number, number>;
@@ -92,6 +93,7 @@ export declare const Config: import("@deepseek-ai/schemastery").default<Schemast
         provider: import("@deepseek-ai/schemastery").default<string, string>;
         model: import("@deepseek-ai/schemastery").default<string, string>;
         maxTokens: import("@deepseek-ai/schemastery").default<number, number>;
+        reasoningEffort: import("@deepseek-ai/schemastery").default<"" | "off" | "high" | "max", "" | "off" | "high" | "max">;
         temperature: import("@deepseek-ai/schemastery").default<number, number>;
         maxInputChars: import("@deepseek-ai/schemastery").default<number, number>;
         timeoutMs: import("@deepseek-ai/schemastery").default<number, number>;
@@ -174,6 +176,7 @@ export declare const Config: import("@deepseek-ai/schemastery").default<Schemast
         provider: import("@deepseek-ai/schemastery").default<string, string>;
         model: import("@deepseek-ai/schemastery").default<string, string>;
         maxTokens: import("@deepseek-ai/schemastery").default<number, number>;
+        reasoningEffort: import("@deepseek-ai/schemastery").default<"" | "off" | "high" | "max", "" | "off" | "high" | "max">;
         temperature: import("@deepseek-ai/schemastery").default<number, number>;
         maxInputChars: import("@deepseek-ai/schemastery").default<number, number>;
         timeoutMs: import("@deepseek-ai/schemastery").default<number, number>;
@@ -181,6 +184,7 @@ export declare const Config: import("@deepseek-ai/schemastery").default<Schemast
         provider: import("@deepseek-ai/schemastery").default<string, string>;
         model: import("@deepseek-ai/schemastery").default<string, string>;
         maxTokens: import("@deepseek-ai/schemastery").default<number, number>;
+        reasoningEffort: import("@deepseek-ai/schemastery").default<"" | "off" | "high" | "max", "" | "off" | "high" | "max">;
         temperature: import("@deepseek-ai/schemastery").default<number, number>;
         maxInputChars: import("@deepseek-ai/schemastery").default<number, number>;
         timeoutMs: import("@deepseek-ai/schemastery").default<number, number>;

package/dist/llm.js

@@ -1,4 +1,4 @@
-import { createUserMessage } from '@deepseek-ai/dsh-llm';
+import { createUserMessage, ReasoningEffortId } from '@deepseek-ai/dsh-llm';
 import { errDetail } from './util/filelog.js';
 /** 解析蒸馏用的 provider/model：配置优先，其次当前默认选择。 */
 export async function resolveModelRoute(ctx, cfg) {
@@ -35,6 +35,10 @@ export async function callLLM(ctx, cfg, opts) {
         messages: [createUserMessage({ content: [{ type: 'text', text: user }], source: { kind: 'user' } })],
         temperature: opts.temperature ?? cfg.llm.temperature,
         maxTokens: opts.maxTokens ?? cfg.llm.maxTokens,
+        // 默认 off：蒸馏是结构化抽取，high 思考可吃光全部输出预算致正文 0 字符；空串不传（非推理模型）
+        ...(cfg.llm.reasoningEffort
+            ? { reasoningEffort: ReasoningEffortId(cfg.llm.reasoningEffort) }
+            : {}),
         signal,
     });
     const startedAt = Date.now();

package/dist/pipeline/runner.js

@@ -51,20 +51,26 @@ export class MemoryRunner {
         const turnStart = Date.now();
         this.logger.info(`[memory] 蒸馏管线开始（session=${sessionId}，mode=${mode}，本轮 ${messages.length} 条消息，待重试 ${this.pendingCount} 条）`);
         // ── L0：原始对话已由 capture 在 turn/end 即时落盘（不排蒸馏队列，防慢 LLM 阻塞/退出丢消息） ──
+        // ── 运行时调参视图：UI 选择器可临时覆盖蒸馏思考档位（空串回退静态 config 默认）。
+        // 浅拷贝只覆盖 llm 一层，其余键与 this.cfg 共享只读引用；pipeline 全链继续收 cfg，无需感知。 ──
+        const liveNow = this.live.get();
+        const cfg = liveNow.reasoningEffort
+            ? { ...this.cfg, llm: { ...this.cfg.llm, reasoningEffort: liveNow.reasoningEffort } }
+            : this.cfg;
         // ── L1：抽取 + 去重（按档分桶，失败按桶保留待重试） ──
         let newRecords = [];
-        const distillOn = this.live.get().enabled && this.live.get().distill;
-        if (this.cfg.extract.enabled && distillOn) {
+        const distillOn = liveNow.enabled && liveNow.distill;
+        if (cfg.extract.enabled && distillOn) {
             const bucket = this.pending[mode];
             bucket.push(...messages);
             if (bucket.length > 200)
                 bucket.splice(0, bucket.length - 200);
             try {
                 const t = Date.now();
-                const result = await runExtraction(this.ctx, this.cfg, this.stores.l1, this.states, bucket, this.background, this.logger, mode);
+                const result = await runExtraction(this.ctx, cfg, this.stores.l1, this.states, bucket, this.background, this.logger, mode);
                 if (!result.skipped)
                     this.pending[mode] = [];
-                this.background = [...this.background.slice(-this.cfg.extract.backgroundMessages), ...messages];
+                this.background = [...this.background.slice(-cfg.extract.backgroundMessages), ...messages];
                 newRecords = result.newRecords;
                 this.logger.info(`[memory] L1 阶段完成（${Date.now() - t}ms）`);
             }
@@ -84,16 +90,16 @@ export class MemoryRunner {
             }
         }
         // ── L2/L3：按记录族各自判定与执行 ──
-        if (this.cfg.l2.enabled && distillOn) {
+        if (cfg.l2.enabled && distillOn) {
             for (const family of ['chat', 'work']) {
                 const familyRecords = newRecords.filter((r) => (r.family ?? 'chat') === family);
                 if (familyRecords.length === 0)
                     continue;
                 const fstate = this.states[family];
-                if (fstate.newMemoriesSinceL2 >= this.cfg.l2.minNewMemories) {
+                if (fstate.newMemoriesSinceL2 >= cfg.l2.minNewMemories) {
                     try {
                         const t = Date.now();
-                        const result = await runSceneConsolidation(this.ctx, this.cfg, this.stores.scenes[family], familyRecords, this.logger, family);
+                        const result = await runSceneConsolidation(this.ctx, cfg, this.stores.scenes[family], familyRecords, this.logger, family);
                         fstate.lastL2At = Date.now();
                         fstate.newMemoriesSinceL2 = 0;
                         if (result.personaRequestedReason)
@@ -105,14 +111,14 @@ export class MemoryRunner {
                     }
                 }
                 else {
-                    this.logger.debug?.(`[memory] L2 跳过（family=${family}，本族新增 ${familyRecords.length} 条，累计未整合 ${fstate.newMemoriesSinceL2}/${this.cfg.l2.minNewMemories}）`);
+                    this.logger.debug?.(`[memory] L2 跳过（family=${family}，本族新增 ${familyRecords.length} 条，累计未整合 ${fstate.newMemoriesSinceL2}/${cfg.l2.minNewMemories}）`);
                 }
             }
         }
-        if (this.cfg.l3.enabled && distillOn) {
+        if (cfg.l3.enabled && distillOn) {
             for (const family of ['chat', 'work']) {
                 try {
-                    await runPersona(this.ctx, this.cfg, this.stores.scenes[family], this.stores.persona[family], this.states[family], this.logger, family);
+                    await runPersona(this.ctx, cfg, this.stores.scenes[family], this.stores.persona[family], this.states[family], this.logger, family);
                 }
                 catch (err) {
                     this.logger.warn(`[memory] L3 画像蒸馏失败（family=${family}）: ${errDetail(err)}`);

package/dist/settings.d.ts

@@ -6,6 +6,8 @@
 import type { Context } from '@deepseek-ai/cordis';
 import Schema from '@deepseek-ai/schemastery';
 import type { MemoryLogger } from './types.js';
+/** 蒸馏思考档位可选项：'' = 跟随静态 config（部署默认）。 */
+export type EffortChoice = '' | 'off' | 'high' | 'max';
 export interface MemoryLiveSettings {
     /** 总开关：关 = 捕获/蒸馏/召回注入全停（数据保留） */
     enabled: boolean;
@@ -15,6 +17,8 @@ export interface MemoryLiveSettings {
     distill: boolean;
     /** 召回注入（画像/记忆上下文） */
     recall: boolean;
+    /** 蒸馏思考档位运行时覆盖：'' = 跟随静态 config（llm.reasoningEffort） */
+    reasoningEffort: EffortChoice;
 }
 export interface LiveSettingsHandle {
     /** settings 服务是否可用（不可用时 UI 侧隐藏开关面板） */

package/dist/settings.js

@@ -1,13 +1,14 @@
 import Schema from '@deepseek-ai/schemastery';
 import { settingsNamespace } from '@deepseek-ai/dsh-settings';
 const NS = settingsNamespace('dsh-memory');
-const ALWAYS_ON = { enabled: true, capture: true, distill: true, recall: true };
+const ALWAYS_ON = { enabled: true, capture: true, distill: true, recall: true, reasoningEffort: '' };
 export function liveSettingsSchema() {
     return Schema.object({
         enabled: Schema.boolean().default(true),
         capture: Schema.boolean().default(true),
         distill: Schema.boolean().default(true),
         recall: Schema.boolean().default(true),
+        reasoningEffort: Schema.union(['', 'off', 'high', 'max']).default(''),
     });
 }
 export function registerLiveSettings(ctx, logger) {
@@ -27,7 +28,8 @@ export function registerLiveSettings(ctx, logger) {
             scope.watch((next) => {
                 const prev = current;
                 current = resolveSettings(next);
-                logger.info(`[memory] 记忆模式开关更新：总=${current.enabled} 捕获=${current.capture} 蒸馏=${current.distill} 召回=${current.recall}（此前 总=${prev.enabled}）`);
+                logger.info(`[memory] 记忆模式开关更新：总=${current.enabled} 捕获=${current.capture} 蒸馏=${current.distill} 召回=${current.recall}` +
+                    `，蒸馏思考=${current.reasoningEffort || '跟随配置'}（此前 总=${prev.enabled}）`);
             });
             inner = {
                 supported: true,
@@ -36,7 +38,8 @@ export function registerLiveSettings(ctx, logger) {
                     await scope.update(patch);
                 },
             };
-            logger.info(`[memory] 记忆模式开关就绪（settings 命名空间 dsh-memory，当前：总=${current.enabled} 捕获=${current.capture} 蒸馏=${current.distill} 召回=${current.recall}）`);
+            logger.info(`[memory] 记忆模式开关就绪（settings 命名空间 dsh-memory，当前：总=${current.enabled} 捕获=${current.capture} 蒸馏=${current.distill} 召回=${current.recall}` +
+                `，蒸馏思考=${current.reasoningEffort || '跟随配置'}）`);
             return true;
         }
         catch (err) {
@@ -64,10 +67,14 @@ function resolveSettings(value) {
     if (!value || typeof value !== 'object')
         return { ...ALWAYS_ON };
     const v = value;
+    const efforts = ['', 'off', 'high', 'max'];
     return {
         enabled: v.enabled !== false,
         capture: v.capture !== false,
         distill: v.distill !== false,
         recall: v.recall !== false,
+        reasoningEffort: typeof v.reasoningEffort === 'string' && efforts.includes(v.reasoningEffort)
+            ? v.reasoningEffort
+            : '',
     };
 }

package/dist/stats.js

@@ -130,26 +130,41 @@ async function handleEndpoint(endpoint, payload, deps) {
             deps.logger.info(`[memory] 会话档位设置 session=${p.sessionId} mode=${p.mode}`);
             return { sessionId: p.sessionId, mode: p.mode };
         }
-        case 'dsh-memory/settings-get':
+        case 'dsh-memory/settings-get': {
+            const s = live?.get();
             return {
                 supported: live?.supported ?? false,
-                settings: live?.get() ?? { enabled: true, capture: true, distill: true, recall: true },
+                settings: s ?? { enabled: true, capture: true, distill: true, recall: true, reasoningEffort: '' },
                 // 静态部署上限（cordis.patch.yml）：运行时开关与它取 AND
                 ceilings: { capture: cfg.capture.enabled, distill: cfg.extract.enabled, recall: cfg.recall.enabled },
+                // 蒸馏思考档位：current 是运行时覆盖（'' = 跟随配置），effective 是实际生效值
+                effort: {
+                    current: s?.reasoningEffort ?? '',
+                    effective: s?.reasoningEffort || cfg.llm.reasoningEffort,
+                    fallback: cfg.llm.reasoningEffort,
+                },
             };
+        }
         case 'dsh-memory/settings-set': {
             if (!live)
                 throw new Error('开关通道未初始化');
             const patch = (payload ?? {});
-            const allowed = ['enabled', 'capture', 'distill', 'recall'];
             const clean = {};
-            for (const key of allowed) {
+            for (const key of ['enabled', 'capture', 'distill', 'recall']) {
                 if (typeof patch[key] === 'boolean')
                     clean[key] = patch[key];
             }
+            if (patch.reasoningEffort !== undefined) {
+                const v = String(patch.reasoningEffort);
+                if (!['', 'off', 'high', 'max'].includes(v)) {
+                    throw new Error(`非法思考档位: ${v}（允许 ''/off/high/max）`);
+                }
+                clean.reasoningEffort = v;
+            }
             if (Object.keys(clean).length === 0)
                 throw new Error('开关更新载荷为空');
             await live.update(clean);
+            deps.logger.info(`[memory] 设置更新：${JSON.stringify(clean)}`);
             return { ok: true, settings: live.get() };
         }
         case 'dsh-memory/list-records': {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "dsh-layered-memory",
-  "version": "0.5.3",
+  "version": "0.6.0",
   "description": "L0~L3 分层蒸馏记忆插件 for DeepSeek Harness：自动捕获对话（L0）、抽取原子记忆（L1）、整合场景块（L2）、蒸馏核心画像/团队方法论（L3），并在模型步骤前自动召回注入。移植自 MemoryCore (TencentDB Agent Memory) 的管线设计。",
   "type": "module",
   "main": "dist/index.js",