dsh-memory-tiers 0.3.0 → 0.5.0

package/ARCHITECTURE.md

@@ -834,10 +834,24 @@ dsh 有两套注入接口，语义完全不同：
 
 系统提示词因此变成逐字节不变 → 首轮之后全量命中缓存。
 
-**② L1 不再注入（`injectHot: false`）**
+**② L1 默认不注入（`injectHot: false`）—— 但这条理由后来被更正了**
 
-L1 存的是当前会话的对话原文，模型在历史里已经看过。把它再塞进注入块，
-唯一效果就是让注入块每轮都变、缓存每轮都断。跨会话恢复靠 L2/L3（沉淀过的）+ `memory_search`（按需检索）。
+> **⚠️ 2026-11-01 更正**：这里原先写的是「L1 每轮都变 → 注入块每轮变化 → **打掉缓存**」。
+> 那个结论只在 `section()` 时代成立。改用 `context()` 之后，记忆块是**追加**的 user 快照，
+> 位置在末尾，**前面历史缓存完全不受影响**。用户当场指出了这点，是对的。
+>
+> 真实成本只剩下「每轮多追加一条快照」，而 L1 通常只有几百到一千多字 —— 很小。
+> 所以 `injectHot` 该不该开，取决于下面的**配套关系**，不是缓存问题。
+
+`injectHot` 和 `compactKeepTurns` 必须配套：
+
+| 组合 | 模型能看到最近对话吗 | 说明 |
+|---|---|---|
+| `keepTurns=1` + `injectHot=false` | 能（靠 dsh 历史） | 默认。快照稳定、不重复付费；代价是历史留 1 轮原文 |
+| **`keepTurns=0` + `injectHot=true`** | 能（**只能靠 L1 快照**） | 彻底接管：dsh 历史一条不留，最近原话由 L1 提供 |
+| `keepTurns=0` + `injectHot=false` | **不能，完全失忆** | 禁用组合 |
+
+跨会话恢复始终靠 L2/L3（沉淀过的）+ `memory_search`（按需检索）。
 
 **③ 节流（`refreshMinMs`，默认 5 分钟）**
 
@@ -1384,3 +1398,216 @@ link 安装的插件 **import 不到** dsh 自己的包，三个解法：
 **`memory5.mjs` 一行都不用改**——它只依赖 `{ text, speaker, channel, at }` 这种纯数据。
 `compaction.mjs` 只依赖 `session.surface.nodes` / `eventAt` / `append` 三个方法，
 适配层写个小 shim 就能复用。
+
+---
+
+## 20. 设置页：DSH「设置 → 记忆」（2026-11-01，v0.4.0）
+
+> 之前只能在 `~/.dsh/storages/memory-v5/config.json` 里手改，改错一个逗号插件就起不来。
+> 现在有了图形界面，12 个字段分 5 组，外加只读运行状态。
+
+### 为什么手写界面，不用 schemastery
+
+dsh 的自动表单要 `@deepseek-ai/schemastery` 声明 schema，**link 安装的插件 import 不到**
+（同 `defineTool` / `CompactionEngine` 那个坑，见 19.5）。所以走「自己开 HTTP 接口 + 自己写 React 组件」：
+
+```
+package.json
+  "dsh": { "client": { "platform": "web", "inject": [] } }
+  "exports": { "./client": "./client.mjs" }
+
+client.mjs    浏览器端：React section
+settings.mjs  服务端：/dsh-memory/api/*
+```
+
+### 客户端：三个关键点
+
+```js
+window.__ModuleLoader__.load({
+  id: 'dsh-memory-tiers',
+  factory: (require) => {
+    const React = require('react')            // 宿主提供的 react
+    const { createElement: h } = React
+    // ...组件...
+    exports.apply = apply
+    return module.exports
+  },
+})
+
+const inject = ['slots']
+function apply(ctx) {
+  ctx.effect(() => ctx.slots.inject('settings.section', () =>
+    ctx.slots.register(
+      { name: 'settings.section', id: 'memory-tiers', order: 7, label: () => '记忆' },
+      MemoryTiersSection,
+    )))
+}
+```
+
+- 模块不是标准 ESM，是 **`window.__ModuleLoader__.load({id, factory})`**（照抄 dsh-bili-whale）
+- `require('react')` 由宿主注入，**不需要打包工具**（手写 47KB 也能跑，没有 devDependencies）
+- CSS 通过 `<style data-dmt=…>` 注入，颜色用 `--dsw-alias-*` 变量，深浅色主题自适应
+
+`order: 7` 排在养鱼（6）后面。`label()` 是函数，支持后续改文案不用重载。
+
+### 服务端：一个路径只能注册一个 handler
+
+```js
+ctx.webServer.register({ kind: 'exact', path: '/dsh-memory/api/settings', handler })
+```
+
+> ⚠️ **踩过的坑**：读和写注册成两个 handler（同一路径两次），宿主「首个匹配即终止」，
+> 结果 GET 200 而 POST 405。必须**合成一个 handler，内部按 `req.method` 分派**。
+> 这个坑 dsh-bili-whale 的源码注释里提过，我们还是踩了一遍。
+
+字段写入走**白名单**（`WRITABLE` 表），前端传 `dir`、`evil` 都会被忽略——
+配置目录不能让前端改，否则等于开了任意路径写文件。
+
+### 界面结构
+
+| 分组 | 字段 |
+|---|---|
+| 运行状态（只读） | L1/L2/L3/DL3 条数、向量数、数据目录、语义检索开关 |
+| 模型连接 | `apiKey`（密码框）、`apiBase` |
+| 三层容量 | `memoryCfg.hotMaxChars` / `consolidateMaxChars` / `longMaxChars` |
+| 上下文注入 | `injectHot`、`refreshMinMs` |
+| 历史压缩 | `autoCompact`、`compactKeepTurns`、`compactArchiveChars` |
+| 写入捕获 | `userCaptureChars`、`toolCaptureChars` |
+| 底部 | `capture.log` 最后 15 行（每轮的归档与压缩记录） |
+
+### 改配置需要重启
+
+保存只写 `config.json`，运行中的 `mem` 实例不会重建。面板上明确写了「重启 dsh 后生效」。
+
+要做热重载的话，得在保存接口里 dispose 旧 `mem` 再 `createMemory5` 一遍，
+但内存里的分层状态、队列、定时器都要跟着重建，风险大于收益——**现阶段就要求重启**。
+
+### 验证
+
+```
+注册的路由: /dsh-memory/api/settings:exact, /dsh-memory/api/log:exact
+
+GET  → HTTP 200, config: apiKey/bootMaxChars/injectHot/memoryCfg
+       live: {counts:{L1:0,L2:0,L3:0,DL1:0,DL2:0,DL3:0}, vectors:0, semantic:true}
+POST → HTTP 200, applied: ["apiKey","injectHot","memoryCfg.hotMaxChars","memoryCfg.longMaxChars"]
+       ignored: []  needRestart: true
+       落盘正确；传 dir / evil 被白名单挡住
+
+客户端: 模块加载 → 导出 apply/inject/MemoryTiersSection/FIELDS
+        12 个字段 / 5 个分组
+        slots.register({name:'settings.section', id:'memory-tiers', order:7, label:'记忆'})
+```
+
+### 21:00 补充：`compactKeepTurns: 0` 是受支持的显式选项（2026-11-01）
+
+用户要的是「dsh 历史一条不留，全部交给记忆」。实测**能做**：
+
+```
+第 1 轮压缩: removed=2 | surface 剩 2 条
+第 2 轮压缩: removed=3 | surface 剩 2 条
+第 3 轮压缩: removed=3 | surface 剩 2 条
+第 4 轮压缩: removed=3 | surface 剩 2 条
+
+最终 surface：
+  system/message: sys
+  user/message: （此前 1 轮对话已归档到长期记忆，需要细节可以让我检索）
+```
+
+聊多少轮，dsh 侧都只剩 **system + 一条占位**。
+
+**以前这段是靠巧合工作的**：`userIdx[length - 0]` 得到 `undefined`，`slice(first, undefined)`
+恰好等于「取到末尾」。虽然结果对，但纯属运气——已改成显式分支：
+
+```js
+const keepStart = keepTurns === 0 ? nodes.length : userIdx[userIdx.length - keepTurns]
+```
+
+**必须同时开 `injectHot: true`**，否则模型完全看不见上一句问了什么（见第 16 节的配套表）。
+
+注入块对照（真实库）：
+
+| 配置 | 注入块 | 构成 |
+|---|---|---|
+| `injectHot: false` | 4625 字 ≈ 3083 token | L3 4150 + L2 458 |
+| `injectHot: true` | 6088 字 ≈ 4059 token | L3 4150 + L2 458 + L1 1455 |
+
+每轮多约 1000 token（追加新快照，全价）——相对于「dsh 历史归零」这点代价可以接受。
+
+配置改动落在 `~/.dsh/storages/memory-v5/config.json`：
+
+```json
+{ "injectHot": true, "compactKeepTurns": 0 }
+```
+
+---
+
+## 21. 模型分阶段配置（2026-11-01，v0.5.0）
+
+> 背景：原来四个模型角色（向量 / 重排 / 轻任务 / 摘要）**共用一套 `apiKey` + `apiBase`**，
+> 设置页也没暴露，等于绑死在硅基流动上。现在每个阶段都能单独指定 `{ base, apiKey, model }`。
+
+### 四个阶段
+
+| 阶段 | 干什么 | 调用频率 | 默认模型 |
+|---|---|---|---|
+| `embed` | 向量化，检索和入库判重的基础 | 每条记忆 1 次 | `Qwen/Qwen3-Embedding-0.6B` |
+| `rerank` | 检索结果精排 | 每次检索 | `Qwen/Qwen3-Reranker-0.6B` |
+| `chat` | 判重、判矛盾、分类等高频小任务 | 很频繁 | `inclusionAI/Ling-mini-2.0` |
+| `summary` | 把一批对话压成摘要 | 低频但重 | `deepseek-ai/DeepSeek-V4.1-Flash` |
+
+### 解析规则
+
+```js
+function stage(name) {
+  const over = cfg.models[name] || {}
+  const base   = over.base   || cfg.base       // 没覆盖就用顶层
+  const apiKey = over.apiKey || cfg.apiKey
+  const model  = over.model  || cfg[name + 'Model']   // 再退到默认模型名
+  return { base, apiKey, model, chat: base + '/chat/completions', embed: …, rerank: … }
+}
+```
+
+**优先级：`models[stage].x` > 顶层 `cfg.x` > 该阶段默认模型名。**
+空字符串是「删除这条覆盖、回落到顶层」，不是「设成空值」——这样前端不用区分“没填过”和“清空了”。
+
+配置示例（摘要单独走 DeepSeek 官方，其余留硅基流动）：
+
+```json
+{
+  "apiKey": "sk-siliconflow",
+  "apiBase": "https://api.siliconflow.cn/v1",
+  "models": {
+    "summary": {
+      "base": "https://api.deepseek.com",
+      "apiKey": "sk-deepseek",
+      "model": "deepseek-chat"
+    }
+  }
+}
+```
+
+### 实现要点
+
+- `chat()` 多了一个 `stage` 参数，内部用该阶段的 url 和 key 发请求——**摘要能挂到另一家**
+- `embed` / `rerank` 各自调 `stage('embed')` / `stage('rerank')`，不再直接用全局 `cfg.apiKey`
+- key 检查放宽：`cfg.apiKey || 任一 models[s].apiKey`，否则只配了摘要一家时会被误判为"没配"
+- `silicon.resolveStage(name)` 和 `silicon.stages()` 暴露给设置页，显示**实际生效**的值（覆盖已合并）
+
+### 验证
+
+```
+顶层硅基流动 + summary 单独挂 deepseek + embed 换 bge-m3：
+embed    {"base":"…siliconflow.cn/v1","model":"BAAI/bge-m3","hasKey":true}
+rerank   {"base":"…siliconflow.cn/v1","model":"Qwen/Qwen3-Reranker-0.6B","hasKey":true}
+chat     {"base":"…siliconflow.cn/v1","model":"inclusionAI/Ling-mini-2.0","hasKey":true}
+summary  {"base":"https://api.deepseek.com","model":"deepseek-chat","hasKey":true}
+
+设置页写入 → applied: ["models.summary.base","models.summary.apiKey","models.summary.model"]
+清空 base → 该键被删除，回落顶层（不是留一个空字符串）
+全空 → 抛「缺少 apiKey（顶层或某个阶段的 models[s].apiKey）」
+```
+
+### 一个提醒
+
+换 `embed` 模型会导致**向量维度变化**，旧库的向量全部作废。真要换得清空 `vectors-part-*.json` 并重建，
+否则检索结果会乱。设置页的提示里写了这条。

package/client.mjs

@@ -0,0 +1,425 @@
+/**
+ * dsh-memory-tiers —— 客户端半边：DSH「设置」里的 **记忆** section。
+ *
+ * 宿主提供的运行时：window.__ModuleLoader__.load({ id, factory }) + require('react')。
+ * 挂载点：ctx.slots.register('settings.section', { id, order, label }, Component)。
+ * 数据来源：本插件服务端的 /dsh-memory/api/*（settings.mjs）。
+ *
+ * 为什么不用 schemastery 声明 schema 让 dsh 自动生成表单：
+ * link 安装的插件 import 不到 @deepseek-ai/*（见 ARCHITECTURE 19.5），拿不到那个包。
+ * 手写反而能把「只读运行状态」「三层容量对照」「重启提示」排在一起。
+ */
+window.__ModuleLoader__.load({
+  id: 'dsh-memory-tiers',
+  factory: (require) => {
+    const module = { exports: {} }
+    const exports = module.exports
+    Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' })
+
+    const React = require('react')
+    const { createElement: h, useCallback, useEffect, useState } = React
+
+    const API = '/dsh-memory/api'
+    const CSS_TAG = 'dsh-memory-tiers/section.css'
+    const CSS = [
+      '.dmt{max-width:760px;color:var(--dsw-alias-label-primary);display:flex;flex-direction:column;gap:6px}',
+      '.dmt-title{margin:0;font-size:16px;font-weight:500;line-height:24px}',
+      '.dmt-intro{color:var(--dsw-alias-label-tertiary);margin:0 0 4px;font-size:13px;line-height:20px}',
+      '.dmt-group{margin-top:16px;font-size:13px;font-weight:500;line-height:20px}',
+      '.dmt-rows{display:flex;flex-direction:column}',
+      '.dmt-row{display:flex;justify-content:space-between;align-items:flex-start;gap:12px 20px;padding:10px 0;border-bottom:.5px solid var(--dsw-alias-border-l2);flex-wrap:wrap}',
+      '.dmt-row:last-child{border-bottom:none}',
+      '.dmt-row>div:first-child{flex:1;min-width:190px}',
+      '.dmt-label{font-size:13px;line-height:19px}',
+      '.dmt-hint{color:var(--dsw-alias-label-tertiary);margin-top:3px;font-size:11.5px;line-height:17px}',
+      '.dmt-input,.dmt-select{background:transparent;border:1px solid var(--dsw-alias-border-l2);border-radius:6px;color:var(--dsw-alias-label-primary);font-size:12.5px;height:28px;padding:0 8px;min-width:180px;outline:none}',
+      '.dmt-input:focus-visible{border-color:var(--dsw-alias-brand-primary)}',
+      '.dmt-input.dmt-wide{min-width:280px}',
+      '.dmt-check{width:16px;height:16px;accent-color:var(--dsw-alias-brand-primary)}',
+      '.dmt-actions{display:flex;gap:8px;align-items:center;flex-wrap:wrap;margin-top:16px;padding-top:12px;border-top:.5px solid var(--dsw-alias-border-l2)}',
+      '.dmt-btn{height:28px;padding:0 14px;border-radius:6px;border:1px solid var(--dsw-alias-border-l2);background:transparent;color:var(--dsw-alias-label-primary);font-size:12.5px;cursor:pointer}',
+      '.dmt-btn:hover{border-color:var(--dsw-alias-border-l1)}',
+      '.dmt-btn.dmt-primary{background:var(--dsw-alias-brand-primary);border-color:var(--dsw-alias-brand-primary);color:var(--dsw-alias-label-primary-foreground,#fff)}',
+      '.dmt-btn:disabled{opacity:.5;cursor:default}',
+      '.dmt-msg{font-size:12.5px;line-height:18px}',
+      '.dmt-msg.dmt-ok{color:var(--dsw-alias-label-success,#3b6d11)}',
+      '.dmt-msg.dmt-err{color:var(--dsw-alias-label-danger,#a32d2d)}',
+      '.dmt-stats{display:flex;gap:18px;flex-wrap:wrap;margin-top:8px}',
+      '.dmt-stat{min-width:92px}',
+      '.dmt-stat b{display:block;font-size:15px;font-weight:500;line-height:22px}',
+      '.dmt-stat span{color:var(--dsw-alias-label-tertiary);font-size:11.5px}',
+      '.dmt-log{margin-top:8px;padding:8px 10px;border-radius:6px;background:var(--dsw-alias-bg-secondary,rgba(127,127,127,.06));font-family:var(--dsw-font-mono,ui-monospace,monospace);font-size:11px;line-height:16px;white-space:pre-wrap;word-break:break-all;max-height:200px;overflow:auto}',
+      '.dmt-mono{font-family:var(--dsw-font-mono,ui-monospace,monospace);font-size:11.5px;word-break:break-all}',
+    ].join('\n')
+
+    function ensureCss() {
+      if (typeof document === 'undefined') return
+      if (document.querySelector('style[data-dmt="' + CSS_TAG + '"]')) return
+      const el = document.createElement('style')
+      el.dataset.dmt = CSS_TAG
+      el.textContent = CSS
+      document.head.appendChild(el)
+    }
+
+    const getPath = (obj, path) => path.reduce((o, k) => (o == null ? undefined : o[k]), obj)
+    const setPath = (obj, path, value) => {
+      const next = { ...obj }
+      let cur = next
+      for (let i = 0; i < path.length - 1; i++) {
+        const k = path[i]
+        cur[k] = { ...(cur[k] || {}) }
+        cur = cur[k]
+      }
+      cur[path[path.length - 1]] = value
+      return next
+    }
+
+    // ── 字段定义：改这里就能增减配置项（服务端白名单见 settings.mjs 的 WRITABLE） ──
+    const FIELDS = [
+      {
+        group: '模型连接',
+        path: ['apiKey'],
+        label: 'API Key',
+        type: 'password',
+        wide: true,
+        hint: '硅基流动的 key。留空则用本地哈希向量——能跑，但语义检索会弱很多。改完需重启。',
+      },
+      {
+        group: '模型连接',
+        path: ['apiBase'],
+        label: 'API 地址',
+        type: 'text',
+        wide: true,
+        hint: '默认 https://api.siliconflow.cn/v1。换别家兼容 OpenAI 接口的服务时改这里。',
+      },
+
+      {
+        group: '模型（每个阶段可分开指定，留空走默认）',
+        path: ['models', 'summary', 'model'],
+        label: '摘要模型',
+        type: 'text',
+        wide: true,
+        hint: '把一批对话压成摘要用哪个。留空 = deepseek-ai/DeepSeek-V4.1-Flash。摘要量最大，想单独走一家便宜的就填这里，并配上下面两项地址和 key。',
+      },
+      {
+        group: '模型（每个阶段可分开指定，留空走默认）',
+        path: ['models', 'summary', 'base'],
+        label: '摘要 API 地址',
+        type: 'text',
+        wide: true,
+        hint: '留空 = 用上面「模型连接」里的 API 地址。例：https://api.deepseek.com',
+      },
+      {
+        group: '模型（每个阶段可分开指定，留空走默认）',
+        path: ['models', 'summary', 'apiKey'],
+        label: '摘要 API Key',
+        type: 'password',
+        wide: true,
+        hint: '留空 = 用上面的 API Key。填了就表示摘要单独走另一家。',
+      },
+      {
+        group: '模型（每个阶段可分开指定，留空走默认）',
+        path: ['models', 'chat', 'model'],
+        label: '轻任务模型',
+        type: 'text',
+        wide: true,
+        hint: '判重、判矛盾、分类这些高频小任务，选快而便宜的。留空 = inclusionAI/Ling-mini-2.0。',
+      },
+      {
+        group: '模型（每个阶段可分开指定，留空走默认）',
+        path: ['models', 'embed', 'model'],
+        label: '向量模型',
+        type: 'text',
+        wide: true,
+        hint: '检索和入库判重都靠它。留空 = Qwen/Qwen3-Embedding-0.6B。换模型后向量维度不同，旧库要重建。',
+      },
+      {
+        group: '模型（每个阶段可分开指定，留空走默认）',
+        path: ['models', 'rerank', 'model'],
+        label: '重排模型',
+        type: 'text',
+        wide: true,
+        hint: '检索结果精排。留空 = Qwen/Qwen3-Reranker-0.6B。',
+      },
+
+      {
+        group: '三层容量（决定每轮注入多少字）',
+        path: ['memoryCfg', 'hotMaxChars'],
+        label: 'L1 即时层',
+        type: 'number',
+        hint: '按时间保存的原文。满了取最老一半分流沉淀。默认 2000。',
+      },
+      {
+        group: '三层容量（决定每轮注入多少字）',
+        path: ['memoryCfg', 'consolidateMaxChars'],
+        label: 'L2 巩固层',
+        type: 'number',
+        hint: '较重要的原话。默认 2500。',
+      },
+      {
+        group: '三层容量（决定每轮注入多少字）',
+        path: ['memoryCfg', 'longMaxChars'],
+        label: 'L3 长期层',
+        type: 'number',
+        hint: '摘要。这个值直接决定每轮注入块的大小，默认 2000，调大更全但也更贵。',
+      },
+
+      {
+        group: '上下文注入',
+        path: ['injectHot'],
+        label: '把 L1 也注入上下文',
+        type: 'boolean',
+        hint: '默认关。当前会话的对话本来就在历史里，重复注入会让注入块每轮变化、打掉 prompt cache。',
+      },
+      {
+        group: '上下文注入',
+        path: ['refreshMinMs'],
+        label: '记忆块刷新间隔（毫秒）',
+        type: 'number',
+        hint: '默认 1800000（30 分钟）。内容变了也要等过节流窗口才刷新，保护缓存。',
+      },
+
+      {
+        group: '历史压缩',
+        path: ['autoCompact'],
+        label: '自动压缩历史',
+        type: 'boolean',
+        hint: '每轮结束把宿主的会话历史压成一条占位，原文归档进记忆，不调用模型。',
+      },
+      {
+        group: '历史压缩',
+        path: ['compactKeepTurns'],
+        label: '保留最近几轮原文',
+        type: 'number',
+        hint: '默认 1。设 0 会让模型完全看不见上一句问了什么，不建议。',
+      },
+      {
+        group: '历史压缩',
+        path: ['compactArchiveChars'],
+        label: '单次归档字数上限',
+        type: 'number',
+        hint: '默认 1200。超出的部分截断收录，不会整段丢。',
+      },
+
+      {
+        group: '写入捕获',
+        path: ['userCaptureChars'],
+        label: '单条用户消息上限',
+        type: 'number',
+        hint: '默认 2000 字。超长消息只记前这么多。',
+      },
+      {
+        group: '写入捕获',
+        path: ['toolCaptureChars'],
+        label: '工具输出上限',
+        type: 'number',
+        hint: '默认 500 字。bash 一次能吐几万字，L1 才 2000 字。',
+      },
+    ]
+
+    const GROUPS = []
+    for (const f of FIELDS) if (!GROUPS.includes(f.group)) GROUPS.push(f.group)
+
+    async function api(path, init) {
+      const res = await fetch(API + path, {
+        credentials: 'same-origin',
+        headers: { 'content-type': 'application/json' },
+        ...init,
+      })
+      const text = await res.text()
+      let data
+      try { data = JSON.parse(text) } catch { data = { ok: false, error: text.slice(0, 200) } }
+      if (!res.ok || data.ok === false) throw new Error(data.error || 'HTTP ' + res.status)
+      return data
+    }
+
+    function Field({ field, value, onChange }) {
+      const kind = field.type
+      const id = 'dmt-' + field.path.join('-')
+      let control
+      if (kind === 'boolean') {
+        control = h('input', {
+          id,
+          className: 'dmt-check',
+          type: 'checkbox',
+          checked: value === true,
+          onChange: (e) => onChange(e.target.checked),
+        })
+      } else {
+        control = h('input', {
+          id,
+          className: 'dmt-input' + (field.wide ? ' dmt-wide' : ''),
+          type: kind === 'number' ? 'number' : kind === 'password' ? 'password' : 'text',
+          value: value === undefined || value === null ? '' : String(value),
+          placeholder: kind === 'password' ? '留空则用本地哈希向量' : '',
+          onChange: (e) => onChange(kind === 'number' ? (e.target.value === '' ? '' : Number(e.target.value)) : e.target.value),
+        })
+      }
+      return h('div', { className: 'dmt-row' },
+        h('div', null,
+          h('label', { className: 'dmt-label', htmlFor: id }, field.label),
+          field.hint ? h('div', { className: 'dmt-hint' }, field.hint) : null,
+        ),
+        control,
+      )
+    }
+
+    function MemoryTiersSection() {
+      const [cfg, setCfg] = useState(null)
+      const [live, setLive] = useState(null)
+      const [logs, setLogs] = useState([])
+      const [busy, setBusy] = useState(false)
+      const [msg, setMsg] = useState(null)
+      const [err, setErr] = useState(null)
+
+      const load = useCallback(async () => {
+        try {
+          const d = await api('/settings')
+          setCfg(d.config || {})
+          setLive(d.live || null)
+          const l = await api('/log').catch(() => ({ lines: [] }))
+          setLogs(l.lines || [])
+          setErr(null)
+        } catch (e) {
+          setErr(String(e.message || e))
+        }
+      }, [])
+
+      useEffect(() => { ensureCss(); load() }, [load])
+
+      const setField = (path, value) => {
+        setCfg((cur) => setPath(cur || {}, path, value))
+        setMsg(null)
+      }
+
+      const save = async () => {
+        setBusy(true)
+        setMsg(null)
+        setErr(null)
+        try {
+          const r = await api('/settings', { method: 'POST', body: JSON.stringify({ config: cfg }) })
+          const applied = r.applied?.length ?? 0
+          setMsg(applied > 0
+            ? '已保存 ' + applied + ' 项。重启 dsh 后生效。'
+            : '没有可保存的改动。')
+          await load()
+        } catch (e) {
+          setErr('保存失败：' + String(e.message || e))
+        } finally {
+          setBusy(false)
+        }
+      }
+
+      if (err && !cfg) {
+        return h('div', { className: 'dmt' },
+          h('h3', { className: 'dmt-title' }, '记忆'),
+          h('div', { className: 'dmt-msg dmt-err' }, '读取配置失败：' + err),
+          h('div', { className: 'dmt-actions' }, h('button', { className: 'dmt-btn', onClick: load }, '重试')),
+        )
+      }
+
+      if (!cfg) return h('div', { className: 'dmt' }, h('div', { className: 'dmt-hint' }, '加载中…'))
+
+      const c = live?.counts || {}
+
+      return h('div', { className: 'dmt' },
+        h('h3', { className: 'dmt-title' }, '记忆'),
+        h('p', { className: 'dmt-intro' },
+          '六层记忆 + 零 LLM 历史压缩。同一会话里记忆负责「记得住」，压缩负责「上下文不涨」。改完需要重启 dsh 生效。'),
+
+        // ── 运行状态（只读） ──
+        h('div', { className: 'dmt-group' }, '运行状态'),
+        h('div', { className: 'dmt-stats' },
+          h('div', { className: 'dmt-stat' }, h('b', null, String(c.L1 ?? '-')), h('span', null, 'L1 即时')),
+          h('div', { className: 'dmt-stat' }, h('b', null, String(c.L2 ?? '-')), h('span', null, 'L2 巩固')),
+          h('div', { className: 'dmt-stat' }, h('b', null, String(c.L3 ?? '-')), h('span', null, 'L3 长期')),
+          h('div', { className: 'dmt-stat' }, h('b', null, String(c.DL3 ?? '-')), h('span', null, 'DL3 摘要库')),
+          h('div', { className: 'dmt-stat' }, h('b', null, String(live?.vectors ?? '-')), h('span', null, '向量')),
+        ),
+        h('div', { className: 'dmt-row' },
+          h('div', null,
+            h('div', { className: 'dmt-label' }, '数据目录'),
+            h('div', { className: 'dmt-hint' }, '整个目录是自包含的，拷走即可备份或迁移；用环境变量 MEMORY_TIERS_DIR 可换位置。'),
+          ),
+          h('div', { className: 'dmt-mono' }, live?.dir || '-'),
+        ),
+        h('div', { className: 'dmt-row' },
+          h('div', null,
+            h('div', { className: 'dmt-label' }, '语义检索'),
+            h('div', { className: 'dmt-hint' }, live?.semantic ? '已接真模型' : '未配置 key，当前用本地哈希向量，关键词匹配为主'),
+          ),
+          h('div', { className: 'dmt-msg ' + (live?.semantic ? 'dmt-ok' : '') }, live?.semantic ? '开' : '关'),
+        ),
+        live?.models
+          ? h('div', { className: 'dmt-row' },
+              h('div', null,
+                h('div', { className: 'dmt-label' }, '实际生效的模型'),
+                h('div', { className: 'dmt-hint' }, '留空的项已回落到顶层配置或默认值。改完需重启才会重新解析。'),
+              ),
+              h('div', {
+                className: 'dmt-mono',
+                style: { whiteSpace: 'pre-line', textAlign: 'right' },
+              }, Object.entries(live.models)
+                .map(([k, v]) => k + ': ' + (v.model || '?') + ' @ ' + String(v.base || '').replace(/^https?:\/\//, ''))
+                .join('\n')),
+            )
+          : null,
+
+        // ── 配置字段 ──
+        ...GROUPS.map((g) =>
+          h('div', { key: g },
+            h('div', { className: 'dmt-group' }, g),
+            h('div', { className: 'dmt-rows' },
+              FIELDS.filter((f) => f.group === g).map((f) =>
+                h(Field, {
+                  key: f.path.join('.'),
+                  field: f,
+                  value: getPath(cfg, f.path),
+                  onChange: (v) => setField(f.path, v),
+                }),
+              ),
+            ),
+          ),
+        ),
+
+        // ── 操作 ──
+        h('div', { className: 'dmt-actions' },
+          h('button', { className: 'dmt-btn dmt-primary', onClick: save, disabled: busy }, busy ? '保存中…' : '保存'),
+          h('button', { className: 'dmt-btn', onClick: load, disabled: busy }, '重新读取'),
+          msg ? h('span', { className: 'dmt-msg dmt-ok' }, msg) : null,
+          err ? h('span', { className: 'dmt-msg dmt-err' }, err) : null,
+        ),
+
+        // ── 最近审计 ──
+        h('div', { className: 'dmt-group' }, '最近归档 / 压缩（capture.log 末尾）'),
+        logs.length
+          ? h('div', { className: 'dmt-log' }, logs.join('\n'))
+          : h('div', { className: 'dmt-hint' }, '还没有记录。聊几轮后这里会出现每轮的归档与压缩行。'),
+      )
+    }
+
+    const inject = ['slots']
+    const NS = 'memory-tiers'
+    const NAMES = { nav: '记忆' }
+
+    function apply(ctx) {
+      ctx.effect(
+        () =>
+          ctx.slots.inject('settings.section', () =>
+            ctx.slots.register(
+              { name: 'settings.section', id: NS, order: 7, label: () => NAMES.nav },
+              MemoryTiersSection,
+            ),
+            'memory-tiers: settings section',
+          ),
+        'memory-tiers: settings section',
+      )
+    }
+
+    exports.apply = apply
+    exports.inject = inject
+    exports.MemoryTiersSection = MemoryTiersSection
+    exports.FIELDS = FIELDS
+    return module.exports
+  },
+})

package/compaction.mjs

@@ -93,7 +93,11 @@ export async function compactSurface(session, mem, opts = {}) {
   }
 
   // 选区 = [first, keepStart)，keepStart 是「保留的第一轮」的 user 位置
-  const keepStart = userIdx[userIdx.length - keepTurns]
+  // ★ keepTurns === 0 是**受支持的显式选项**：整段历史全压成占位，dsh 侧一条原文不留。
+  //   以前靠 `userIdx[length - 0] === undefined` + `slice(first, undefined)` 恰好取到末尾
+  //   才"能用"，纯属巧合；这里写死，免得以后重构踩空。
+  //   ⚠️ 用 0 时必须同时开 injectHot（注入 L1），否则模型完全看不见刚才聊了什么。
+  const keepStart = keepTurns === 0 ? nodes.length : userIdx[userIdx.length - keepTurns]
   if (keepStart <= first) {
     return { compacted: false, removed: 0, archived: 0, reason: 'nothing-to-compact' }
   }

package/index.mjs

@@ -20,6 +20,7 @@ import { join } from 'node:path'
 import { createMemory5, LAYER, DEFAULTS as MEM_DEFAULTS } from './memory5.mjs'
 import { createSilicon, keyFromAstrbot } from './silicon.mjs'
 import { compactSurface } from './compaction.mjs'
+import { installSettingsApi } from './settings.mjs'
 
 export const name = 'memory-tiers'
 export const inject = ['tools']
@@ -211,6 +212,10 @@ export function apply(ctx, config = {}) {
         compactKeepTurns: 1,
         compactArchiveChars: 1200,
         memoryCfg: { longMaxChars: 4000 },
+        // 每个模型阶段可单独覆盖 { base, apiKey, model }；留空继承顶层 apiKey/apiBase。
+        // 例：想让它摘要走 DeepSeek 官方而不走硅基流动
+        //   models: { summary: { base: 'https://api.deepseek.com', apiKey: 'sk-...', model: 'deepseek-chat' } }
+        models: {},
         _说明: [
           'apiKey 填硅基流动的 key（也可以设环境变量 SILICONFLOW_API_KEY）；',
           '留空则用本地哈希向量，语义检索会变弱。改完重启 dsh 生效。',
@@ -231,7 +236,13 @@ export function apply(ctx, config = {}) {
   let silicon = null
   if (auth) {
     try {
-      silicon = createSilicon({ apiKey: auth.apiKey, base: auth.base, budgetTokens: cfg.budgetTokens })
+      silicon = createSilicon({
+        apiKey: auth.apiKey,
+        base: auth.base,
+        budgetTokens: cfg.budgetTokens,
+        // 每个阶段可单独指定 { base, apiKey, model }；留空继承上面的 apiKey/base
+        models: cfg.models || {},
+      })
     } catch (err) {
       log.warn?.('[memory-tiers] silicon 初始化失败：%s', err?.message ?? err)
     }
@@ -549,6 +560,29 @@ export function apply(ctx, config = {}) {
       toolCount, !!silicon, cfg.autoCapture !== false)
   })
 
+  // ── 设置页的服务端接口：读写 config.json（前端见 client.mjs） ──
+  //    webServer 可能比插件晚就绪，用 inject 等它，而不是直接读 ctx.webServer。
+  ctx.inject(['webServer'], (c) => {
+    const off = installSettingsApi(c, {
+      dir,
+      getCfg: () => cfg,
+      log,
+      mem,
+      getModels: () => {
+        if (!silicon?.resolveStage) return null
+        const out = {}
+        for (const st of silicon.stages()) out[st] = silicon.resolveStage(st)
+        return out
+      },
+    })
+    if (typeof off === 'function') {
+      try { c.effect(() => off, 'memory-tiers: settings api') } catch { /* 老版本没有 effect 也不影响接口可用 */ }
+    } else {
+      log.warn?.('[memory-tiers] webServer 不可用，设置页接口没挂上')
+    }
+    log.info?.('[memory-tiers] 设置页接口已挂：/dsh-memory/api/settings')
+  })
+
   // ── 斜杠命令：手动查看/维护入口 ──
   ctx.inject(['commands'], (c) => {
     c.commands.register({

package/package.json

@@ -1,11 +1,17 @@
 {
   "name": "dsh-memory-tiers",
-  "version": "0.3.0",
+  "version": "0.5.0",
   "description": "六层记忆插件：L1/L2/L3 活跃层 + DL1/DL2/DL3 深层，自动捕获写入、摘要沉淀、按需召回，并接管历史压缩（零 LLM）。",
   "type": "module",
   "main": "index.mjs",
   "license": "MIT",
-  "keywords": ["dsh", "dsh-plugin", "memory", "compaction", "context"],
+  "keywords": [
+    "dsh",
+    "dsh-plugin",
+    "memory",
+    "compaction",
+    "context"
+  ],
   "repository": {
     "type": "git",
     "url": "git+https://github.com/1129742588/dsh-memory-tiers.git"
@@ -17,10 +23,15 @@
   "dsh": {
     "bundle": {
       "patch": "./cordis.patch.yml"
+    },
+    "client": {
+      "inject": [],
+      "platform": "web"
     }
   },
   "exports": {
     ".": "./index.mjs",
+    "./client": "./client.mjs",
     "./compaction.mjs": "./compaction.mjs",
     "./memory5.mjs": "./memory5.mjs",
     "./cordis.patch.yml": "./cordis.patch.yml",
@@ -28,6 +39,8 @@
   },
   "files": [
     "index.mjs",
+    "client.mjs",
+    "settings.mjs",
     "compaction.mjs",
     "memory5.mjs",
     "silicon.mjs",

package/settings.mjs

@@ -0,0 +1,241 @@
+/**
+ * 设置页的服务端半边：读写 config.json + 暴露运行状态。
+ *
+ * 为什么要自己写 HTTP 接口而不是用 schemastery 声明 schema：
+ * link 安装的插件 import 不到 @deepseek-ai/*，拿不到 dsh 的 schema 包（见 ARCHITECTURE 19.5）。
+ * 走 webServer + 自己的 React 组件反而更可控——字段说明、分组、只读状态都能自己排版。
+ */
+import { readFileSync, writeFileSync, existsSync, mkdirSync } from 'node:fs'
+import { join } from 'node:path'
+import { isIP } from 'node:net'
+
+/** 可写字段白名单：只管运行参数，dir 和 _说明 不让前端改 */
+const WRITABLE = {
+  apiKey: 'string',
+  apiBase: 'string',
+  bootMaxChars: 'number',
+  injectHot: 'boolean',
+  refreshMinMs: 'number',
+  autoCompact: 'boolean',
+  compactKeepTurns: 'number',
+  compactArchiveChars: 'number',
+  userCaptureChars: 'number',
+  toolCaptureChars: 'number',
+  budgetTokens: 'number',
+  flushEveryMs: 'number',
+  sweepEveryMs: 'number',
+}
+
+/** 三层容量在 memoryCfg 里，单独处理 */
+const MEMORY_CFG_WRITABLE = {
+  hotMaxChars: 'number',
+  consolidateMaxChars: 'number',
+  longMaxChars: 'number',
+  dl2MaxChars: 'number',
+}
+
+/** 每个模型阶段可单独覆盖的连接参数；留空字符串 = 清除覆盖、回落到顶层 */
+const STAGES = ['embed', 'rerank', 'chat', 'summary']
+const STAGE_FIELDS = { base: 'string', apiKey: 'string', model: 'string' }
+
+function json(res, code, obj) {
+  const body = JSON.stringify(obj)
+  res.statusCode = code
+  res.setHeader('content-type', 'application/json; charset=utf-8')
+  res.setHeader('cache-control', 'no-store')
+  res.end(body)
+}
+
+function readBody(req) {
+  return new Promise((resolve, reject) => {
+    let buf = ''
+    req.on('data', (c) => {
+      buf += c
+      if (buf.length > 1 << 20) reject(new Error('body too large'))
+    })
+    req.on('end', () => resolve(buf))
+    req.on('error', reject)
+  })
+}
+
+/** 只信任本机回环；远程连接交给 dsh 的 connection 服务判定 */
+function isTrustedReq(ctx, req) {
+  const addr = req.socket?.remoteAddress || ''
+  const bare = addr.replace(/^::ffff:/, '')
+  if (isIP(bare) && (bare === '127.0.0.1' || bare === '::1')) return true
+  try {
+    const conn = ctx.get?.('connection') || ctx.connection
+    if (conn && typeof conn.isTrusted === 'function') return conn.isTrusted(req) === true
+  } catch { /* 栅栏不可用按不信任处理 */ }
+  return false
+}
+
+function coerce(kind, value) {
+  if (kind === 'boolean') {
+    if (typeof value === 'boolean') return value
+    if (value === 'true') return true
+    if (value === 'false') return false
+    return undefined
+  }
+  if (kind === 'number') {
+    const n = Number(value)
+    return Number.isFinite(n) ? n : undefined
+  }
+  if (kind === 'string') return typeof value === 'string' ? value : undefined
+  return undefined
+}
+
+/**
+ * 挂上 /dsh-memory/api/*。
+ * @returns {() => void} disposer；webServer 不可用时返回 null
+ */
+export function installSettingsApi(ctx, opts) {
+  const { dir, getCfg, log, mem, getModels } = opts
+  const webServer = ctx.webServer
+  if (!webServer?.register) return null
+
+  const cfgPath = join(dir, 'config.json')
+  const disposers = []
+
+  const readCfgFile = () => {
+    try {
+      if (!existsSync(cfgPath)) return {}
+      return JSON.parse(readFileSync(cfgPath, 'utf8'))
+    } catch (err) {
+      log?.warn?.('[memory-tiers] 读 config.json 失败：%s', err?.message ?? err)
+      return {}
+    }
+  }
+
+  function route(path, handler) {
+    const off = webServer.register({
+      kind: 'exact',
+      path,
+      handler: async (req, res) => {
+        if (!isTrustedReq(ctx, req)) { json(res, 403, { ok: false, error: '不受信任的访问来源' }); return }
+        try { await handler(req, res) } catch (err) {
+          log?.warn?.('[memory-tiers] 设置接口出错：%s', err?.message ?? err)
+          json(res, 500, { ok: false, error: String(err?.message ?? err) })
+        }
+      },
+    })
+    if (typeof off === 'function') disposers.push(off)
+  }
+
+  // ── settings：读和写必须**合成一个 handler** ──
+  //   踩过的坑：同一路径注册两次，若宿主「首个匹配即终止」，后注册的永远收不到请求。
+  //   实测表现是 GET 正常、POST 405（或反之），排查半天。
+  route('/dsh-memory/api/settings', async (req, res) => {
+    if (req.method === 'GET') {
+      const file = readCfgFile()
+      const live = getCfg() || {}
+      const stats = (() => {
+        try { return mem?.stats?.() ?? null } catch { return null }
+      })()
+      json(res, 200, {
+        ok: true,
+        config: {
+          ...file,
+          memoryCfg: { ...(file.memoryCfg || {}) },
+        },
+        live: {
+          dir,
+          counts: stats?.count ?? null,
+          vectors: stats?.vectors ?? null,
+          semantic: !!(live.apiKey || process.env.SILICONFLOW_API_KEY ||
+            Object.values(live.models || {}).some((m) => m?.apiKey)),
+          autoCompact: live.autoCompact !== false,
+          // 各阶段最终解析成什么（覆盖已合并），设置页拿来显示"实际生效"
+          models: (() => {
+            try { return getModels?.() ?? null } catch { return null }
+          })(),
+        },
+        configPath: cfgPath,
+      })
+      return
+    }
+
+    if (req.method !== 'POST') { json(res, 405, { ok: false, error: '只接受 GET / POST' }); return }
+
+    const raw = await readBody(req)
+    let body
+    try { body = JSON.parse(raw || '{}') } catch { json(res, 400, { ok: false, error: 'JSON 解析失败' }); return }
+
+    // 兼容 { config: {...} } 和直接 {...} 两种写法（踩过：只认一种会「保存成功但没变」）
+    const incoming = (body && typeof body.config === 'object' && body.config) || body || {}
+
+    const cur = readCfgFile()
+    const next = { ...cur }
+    const applied = []
+    const ignored = []
+
+    for (const [k, kind] of Object.entries(WRITABLE)) {
+      if (!(k in incoming)) continue
+      const v = coerce(kind, incoming[k])
+      if (v === undefined) { ignored.push(k); continue }
+      next[k] = v
+      applied.push(k)
+    }
+
+    if (incoming.memoryCfg && typeof incoming.memoryCfg === 'object') {
+      const mc = { ...(cur.memoryCfg || {}) }
+      for (const [k, kind] of Object.entries(MEMORY_CFG_WRITABLE)) {
+        if (!(k in incoming.memoryCfg)) continue
+        const v = coerce(kind, incoming.memoryCfg[k])
+        if (v === undefined) { ignored.push('memoryCfg.' + k); continue }
+        mc[k] = v
+        applied.push('memoryCfg.' + k)
+      }
+      next.memoryCfg = mc
+    }
+
+    // ── 每阶段模型覆盖 ──
+    // 语义：填了就覆盖，留空（空字符串）= 删掉这条覆盖，回落到顶层的 apiKey/apiBase 和默认模型名。
+    // 这样「全走一家」和「摘要单独挂别家」都能表达，不用区分"没填过"和"清空了"。
+    if (incoming.models && typeof incoming.models === 'object') {
+      const mm = { ...(cur.models || {}) }
+      for (const st of STAGES) {
+        const src = incoming.models[st]
+        if (!src || typeof src !== 'object') continue
+        const dst = { ...(mm[st] || {}) }
+        for (const [k, kind] of Object.entries(STAGE_FIELDS)) {
+          if (!(k in src)) continue
+          const v = coerce(kind, src[k])
+          if (v === undefined) { ignored.push(`models.${st}.${k}`); continue }
+          if (v === '') delete dst[k]
+          else dst[k] = v
+          applied.push(`models.${st}.${k}`)
+        }
+        if (Object.keys(dst).length) mm[st] = dst
+        else delete mm[st]
+      }
+      next.models = mm
+    }
+
+    try {
+      mkdirSync(dir, { recursive: true })
+      writeFileSync(cfgPath, JSON.stringify(next, null, 2), 'utf8')
+    } catch (err) {
+      json(res, 500, { ok: false, error: '写入失败：' + String(err?.message ?? err) })
+      return
+    }
+    log?.info?.('[memory-tiers] 设置已更新：%s 项，重启 dsh 生效', applied.length)
+    json(res, 200, { ok: true, applied, ignored, needRestart: true })
+  })
+
+  // ── 最近归档/压缩审计（设置页底部展示） ──
+  route('/dsh-memory/api/log', async (req, res) => {
+    if (req.method !== 'GET') { json(res, 405, { ok: false }); return }
+    let lines = []
+    try {
+      const p = join(dir, 'capture.log')
+      if (existsSync(p)) {
+        const all = readFileSync(p, 'utf8').trim().split('\n')
+        lines = all.slice(-15)
+      }
+    } catch { /* 读不到就当空 */ }
+    json(res, 200, { ok: true, lines })
+  })
+
+  return () => { for (const off of disposers) { try { off() } catch { /* 已卸 */ } } }
+}

package/silicon.mjs

@@ -319,7 +319,34 @@ const RESULT_PATTERNS = /(跑通|改完|部署|提交|补完|删掉|清理|扩
 
 export function createSilicon(options = {}) {
   const cfg = { ...DEFAULTS, ...options }
-  if (!cfg.apiKey) throw new Error('[silicon] 缺少 apiKey')
+  // models 段允许每个阶段单独覆盖 { base, apiKey, model }，留空则继承顶层的 base/apiKey
+  if (!cfg.models || typeof cfg.models !== 'object') cfg.models = {}
+
+  const STAGES = ['embed', 'rerank', 'chat', 'summary']
+
+  /**
+   * 解析某个阶段的最终连接参数。
+   * 优先级：models[stage].xxx > 顶层 cfg.xxx > 该阶段的默认模型名。
+   * 这样既能"全部走硅基流动"，也能"摘要单独挂 DeepSeek 官方、向量走本地服务"。
+   */
+  function stage(name) {
+    const over = cfg.models[name] || {}
+    const base = String(over.base || cfg.base || '').replace(/\/+$/, '')
+    const apiKey = over.apiKey || cfg.apiKey || ''
+    const model = over.model || cfg[name + 'Model'] || ''
+    return {
+      base,
+      apiKey,
+      model,
+      chat: base + '/chat/completions',
+      embed: base + '/embeddings',
+      rerank: base + '/rerank',
+    }
+  }
+
+  // 只要任意一个阶段拿到了 key 就能跑；全部为空才认为没配（由调用方降级到本地哈希向量）
+  const anyKey = cfg.apiKey || STAGES.some((s) => cfg.models?.[s]?.apiKey)
+  if (!anyKey) throw new Error('[silicon] 缺少 apiKey（顶层或某个阶段的 models[s].apiKey）')
 
   const chatUrl = `${cfg.base.replace(/\/+$/, '')}/chat/completions`
   const embedUrl = `${cfg.base.replace(/\/+$/, '')}/embeddings`
@@ -404,21 +431,26 @@ export function createSilicon(options = {}) {
     const {
       maxTokens = 400,
       temperature = 0,
-      model = cfg.chatModel,
+      stage: stageName = 'chat',
+      model,
       timeout = cfg.timeoutMs,
       thinking = false,
     } = opts
 
+    const st = stage(stageName)
+    const useModel = model || st.model
+
     const body = {
-      model,
+      model: useModel,
       messages: [{ role: 'system', content: system }, { role: 'user', content: user }],
       max_tokens: maxTokens,
       temperature,
     }
     if (thinking === false) body.enable_thinking = false
 
-    const d = await post(chatUrl, cfg.apiKey, body, timeout, cfg.retries, cfg.maxConcurrent, cfg.rateLimitRetries, cfg.rateLimitBaseMs, guard)
-    note('chat', d.usage?.total_tokens, model)
+    // ★ 用该阶段自己的 url / key：摘要可以挂到另一家 provider 上
+    const d = await post(st.chat, st.apiKey, body, timeout, cfg.retries, cfg.maxConcurrent, cfg.rateLimitRetries, cfg.rateLimitBaseMs, guard)
+    note(stageName, d.usage?.total_tokens, useModel)
     return (d.choices?.[0]?.message?.content || '').trim()
   }
 
@@ -429,7 +461,8 @@ export function createSilicon(options = {}) {
     const list = (Array.isArray(texts) ? texts : [texts]).map((t) => String(t || '').trim()).filter(Boolean)
     if (!list.length) return null
     try {
-      const d = await post(embedUrl, cfg.apiKey, { model: cfg.embedModel, input: list }, cfg.timeoutMs, cfg.retries, cfg.maxConcurrent, cfg.rateLimitRetries, cfg.rateLimitBaseMs, guard)
+      const es = stage('embed')
+      const d = await post(es.embed, es.apiKey, { model: es.model, input: list }, cfg.timeoutMs, cfg.retries, cfg.maxConcurrent, cfg.rateLimitRetries, cfg.rateLimitBaseMs, guard)
       note('embed', d.usage?.total_tokens || d.meta?.tokens?.input_tokens)
       const vecs = (d.data || []).map((x) => x.embedding)
       return vecs.length === list.length ? vecs : null
@@ -443,9 +476,10 @@ export function createSilicon(options = {}) {
     const list = (docs || []).map((t) => String(t || ''))
     if (!list.length) return null
     try {
-      const body = { model: cfg.rerankModel, query: String(query || ''), documents: list }
+      const rs = stage('rerank')
+      const body = { model: rs.model, query: String(query || ''), documents: list }
       if (topN > 0) body.top_n = Math.min(topN, list.length)
-      const d = await post(rerankUrl, cfg.apiKey, body, cfg.timeoutMs, cfg.retries, cfg.maxConcurrent, cfg.rateLimitRetries, cfg.rateLimitBaseMs, guard)
+      const d = await post(rs.rerank, rs.apiKey, body, cfg.timeoutMs, cfg.retries, cfg.maxConcurrent, cfg.rateLimitRetries, cfg.rateLimitBaseMs, guard)
       note('rerank', d.meta?.tokens?.input_tokens)
       return (d.results || []).map((x) => ({ index: x.index, score: Number(x.relevance_score) }))
     } catch {
@@ -524,7 +558,7 @@ export function createSilicon(options = {}) {
         // 再留 250 给"多写一行"的余量。上限 4000 是模型的安全区。
         maxTokens: Math.min(250 + 10 * list.length, 4000),
         temperature: 0.2,
-        model: cfg.summaryModel,
+        stage: 'summary',
         timeout: cfg.summaryTimeoutMs,
         // ★ 必须显式关掉推理。
         //   这里原来传的是 null，而 chat() 里只处理 `thinking === false`，
@@ -656,7 +690,7 @@ export function createSilicon(options = {}) {
       const out = await chat(sys, user, {
         maxTokens: Math.min(300 + 12 * list.length, 4000),
         temperature: 0.2,
-        model: cfg.summaryModel,
+        stage: 'summary',
         timeout: cfg.summaryTimeoutMs,
         thinking: false,
       })
@@ -869,15 +903,31 @@ export function createSilicon(options = {}) {
       ms: Date.now() - t0,
       dim: v[0].length,
       models: {
-        embed: cfg.embedModel,
-        rerank: cfg.rerankModel,
-        chat: cfg.chatModel,
-        summary: cfg.summaryModel,
+        // 显示**实际生效**的值（阶段覆盖已合并），而不是原始配置
+        embed: stage('embed').model,
+        rerank: stage('rerank').model,
+        chat: stage('chat').model,
+        summary: stage('summary').model,
+      },
+      endpoints: {
+        embed: stage('embed').base,
+        rerank: stage('rerank').base,
+        chat: stage('chat').base,
+        summary: stage('summary').base,
       },
     }
   }
 
-  return { embed, rerank, summarize, summarizeWithSources, classify, classifyBatch, sameEvent, relation, ping, cos, config: cfg, usage, resetUsage, budget }
+  return {
+    embed, rerank, summarize, summarizeWithSources, classify, classifyBatch, sameEvent, relation, ping, cos,
+    config: cfg, usage, resetUsage, budget,
+    /** 给设置页/诊断用：某阶段最终解析成什么 */
+    resolveStage: (name) => {
+      const st = stage(name)
+      return { base: st.base, model: st.model, hasKey: !!st.apiKey }
+    },
+    stages: () => STAGES,
+  }
 }
 
 /** 从 AstrBot 的 cmd_config.json 里取 siliconflow 的 key，省去手抄 */