@modusensus/dsh-mneme 0.7.25 → 0.7.27

package/README.en.md

@@ -26,13 +26,14 @@ English | [简体中文](README.md)
   - Per-type `committed / failed / pending` receipts; the health endpoint distinguishes `ok / degraded / unknown`
   - State write failures are never silent: sync failures are logged and leave debt behind, converging automatically on restart
 
-### Model Tools (7)
+### Model Tools (8)
 
 | Tool | Function |
 |------|------|
 | `memory_save` | Save a memory (automatic dedup and merge by title) |
 | `memory_search` | Full-text search (Chinese-substring friendly; vector semantic search can be enabled) |
 | `memory_list` | Paginated listing by type (`include_archived=true` to view archived items) |
+| `memory_get` | Read a single memory's full body by id (v0.7.25; read the full text after a search/list hit) |
 | `memory_update` | Modify an existing memory |
 | `memory_delete` | Delete a memory |
 | `memory_forget` | Suppress injection (down-weighted rather than deleted; recoverable) |
@@ -66,14 +67,14 @@ The default `32768` reserves headroom for reasoning models, where reasoning alon
 | Medium (10k–50k chars) | `65536` |
 | Large (>50k chars) | `131072` (cap) |
 
-> With **reasoning models** (e.g. DeepSeek-R1-like), the model may spend the entire budget on reasoning and return an empty body (the log shows `no json array in llm output`). Resolution order: ① set `dreamReasoningEffort` to `low` to suppress reasoning overhead (when the provider rejects the parameter it is stripped automatically and retried once — the rejection reason lands in `llm_audit`); ② if the retry still returns an empty body under the model's default reasoning behavior, raise `dreamMaxTokens` (reasoning and body share this budget) or route `dreamProvider`/`dreamModel` to a non-reasoning model. The sleep side has the corresponding `sleepReasoningEffort`.
+> With **reasoning models** (e.g. DeepSeek-R1-like), the model may spend the entire budget on reasoning and return an empty body (the log shows `no json array in llm output`). Resolution order: ① set `dreamReasoningEffort` to `low` to suppress reasoning overhead (v0.7.26+: if the model doesn't support that tier, `resolveDreamEffort` auto-falls back to the model's default/first supported tier or omits the field — the rejection reason lands in `llm_audit`); ② if the retry still returns an empty body under the model's default reasoning behavior, raise `dreamMaxTokens` (reasoning and body share this budget) or route `dreamProvider`/`dreamModel` to a non-reasoning model. The sleep side has the corresponding `sleepReasoningEffort`.
 
 **Consolidation model classification** (settings panel "consolidation model" = `dreamProvider`/`dreamModel`; sleep side: `sleepProvider`/`sleepModel`):
 
 | Model kind | Examples | Notes |
 |-----------|----------|-------|
 | **Non-reasoning (recommended)** | glm-5-2-class | No reasoning declaration; even if an effort is configured and the harness rejects it, the fallback strips the field and the retry succeeds. Lowest risk of empty-body runs |
-| **Reasoning (test first)** | deepseek-v4-flash-ga and other v4-flash-ga family | Reasons by default and may burn the whole token budget on an empty body; some SKUs (e.g. v4-flash-ga) are additionally declared by the harness as accepting **no reasoning effort at all** — the no-effort retry still gets rejected through the harness `defaultEffort` (`UNSUPPORTED_REASONING_EFFORT`), which the plugin fallback cannot bypass. If you use one, set `dreamReasoningEffort` and test; switch to a non-reasoning model otherwise |
+| **Reasoning (test first)** | deepseek-v4-flash-ga and other v4-flash-ga family | Reasons by default and may burn the whole token budget on an empty body; some SKUs (e.g. v4-flash-ga) are additionally declared by the harness as accepting **no reasoning effort at all** (the no-effort retry gets rejected through the harness `defaultEffort`, `UNSUPPORTED_REASONING_EFFORT`). Fixed in v0.7.26+: `resolveDreamEffort` probes the model's supported effort tiers before streaming — an unsupported configured tier auto-falls back to the model's default/first supported tier, and the field is omitted for models that declare no reasoning capability. If you use one, set `dreamReasoningEffort` and test; switch to a non-reasoning model otherwise |
 
 ### Sleep Mode: System-Level Sleep 💤 (v0.4.0, opt-in)
 
@@ -173,6 +174,9 @@ Every **background LLM call** (autoDream consolidation + summary, autoSummarize
 
 | Version | Highlights |
 |------|------|
+| **v0.7.27** | v0.7.26 endpoint backfill: the v0.7.26 release tree did not include the `fix/dream-effort-trap` branch, so the `GET /api/dsh-mneme/llm-providers` + `POST /api/dsh-mneme/test-model` endpoints announced in its CHANGELOG/Release were absent from the package (the panel's cascading dropdown + connectivity test would 404); this release rebases and merges the branch (PR #100), landing the endpoints — panel connectivity test now works; 733 tests green |
+| **v0.7.26** | Consolidation `UNSUPPORTED_REASONING_EFFORT` root-cause fix + dream/sleep model connectivity test: root-caused the **defaultEffort trap** — the harness injects `reasoning.defaultEffort` when effort is omitted, so if that default tier itself is unsupported, retrying without effort never helps (whatever effort is sent gets rejected); fix: new `resolveDreamEffort` proactively queries `ctx.llm.resolveModelInfo()` for the model's supported effort tiers and sends a supported one — an unsupported configured tier auto-falls back to the model's default/first supported tier, and the field is omitted when the model declares no reasoning capability. Settings panel adds selection hints on 6 dream/sleep model fields (guiding toward non-thinking models so they don't burn the token budget on reasoning). New `GET /api/dsh-mneme/llm-providers` (host-side provider/model discovery; keys never touch the plugin side) + `POST /api/dsh-mneme/test-model` (connectivity test; empty body resolves via the consolidation route and returns `modelId`); 732 tests green |
+| **v0.7.25** | Tool-compat hardening + `memory_get`/render content preview + consolidation-model guide: new `memory_get` tool (8th model tool, read a single memory's full body by id) + `memory_search`/`memory_list` render now embeds title/metadata/body preview (the model reads actual memory content even when the host only forwards render text) + consolidation-model selection guide (config comments/README classification, non-thinking vs thinking). Fixed `memory_get` execute nested inside output crashing with `userExecute is not a function` (previous tests only counted tool names, never executed it) + tool de-dup on live patch reload + Standalone API port-collision retry (EADDRINUSE) + client inject declaration alignment + better-sidebar hardening; 718 tests green |
 | **v0.7.24** | Fixed DSH Desktop plugin-tree load crash (v0.7.23 regression): cordis 4's ctx is a Proxy — accessing a property not declared in `inject` throws `cannot get property "webServer" without inject` (not `undefined`), and removing webServer from inject meant cordis no longer waited for the host service, so Desktop crashed on restart; fix: restored webServer to inject (cordis applies the plugin only after the host service is ready) + apply/register guard switched to `ctx.reflect.get` (inject-free read, returns `undefined` when absent, never throws); verified with a real cordis + dsh-host-webserver plugin (API routes 200, unknown path 404, headless silently inactive); 714 tests green |
 | **v0.7.23** | Root-caused "memory consolidation keeps failing": a legal empty decision array `[]` from consolidation is no longer treated as a failure (CONSOLIDATION_PROMPT explicitly allows "no output when nothing needs changing", so a model with a healthy, non-redundant memory legitimately returns `[]` — yet `validateDecisions` hard-rejected it as `decision list must be a non-empty array`, failing the whole run and flooding the audit with failures; **model-agnostic** — ChatGPT/Claude hit the same trap; fix: empty array short-circuits to `ok:true` no-op instead of tripping the implicit-keep coverage check). Plus: empty-body fix part 2 (`dreamMaxTokens` default 8192→32768 so thinking models don't burn the whole budget on reasoning) + skipInvalid splice residue bug (length equality ≠ content equality, skipped decisions leaked into apply/audit); 712 tests green |
 | **v0.7.22** | Restored the v0.6.9 skipInvalid tolerant-validation path (issue #89 regression, lost in the v0.7.11 rewrite): `dreamSkipInvalid` (default true) skips individual invalid decisions, applies the valid subset, and marks the run degraded; `allowCrossTypeMerge` (default false) explicitly relaxes cross-type merging — weak models (e.g. qwen3.8-flash) with jittery schema compliance no longer fail the whole batch and burn LLM calls. Strict mode and the sleep path behave unchanged; global caps/coverage floors still reject the whole run (running over cap = broken model, not minor schema drift). New `dreamMinIntervalMinutes` (0–10080, default 0 = unlimited) minimum autoDream trigger interval — failed/degraded runs also consume the interval (throttling exists to stop back-to-back failing calls); feature_flags whitelist now 34 keys; 696 tests green |
@@ -230,6 +234,8 @@ Every **background LLM call** (autoDream consolidation + summary, autoSummarize
 | v0.7.20 | ✅ Done | Heat restore + phase-two frontend + better-sidebar fix | Heat model fully restored (issue #87, backported from v0.7.10: power-law decay + TYPE_DECAY + sleep heat-combined dual protection + entity heat projection) + acceptance checklist landed (heatEnabled default OFF / feature_flags 31 keys / lightMode linkage / sleep demotion audit / updated_at⊥last_accessed_at contract) + phase-two frontend (/list heat projection, HeatBadge three-tier, order=heat page-local sort) + better-sidebar fix (issue #88: inner dynamic sub-plugin); 685 tests green |
 | v0.7.21 | ✅ Done | effort-fallback stream fix | Catch-based effort fallback was dead code on the stream path (dsh-llm rc.1 turns adapter failures into a terminal error finish chunk instead of a throw) → `streamText` captures the finish-chunk cause (`describeStreamFailure`) + `withEffortFallback` gains a `getStreamError` accessor (retries without effort when rejected) + `runAuditedLlm` supports `spec.streamError` (real cause in audit); 688 tests green |
 | v0.7.22 | ✅ Done | skipInvalid tolerant-validation restore (issue #89) + autoDream throttle | Restored v0.6.9 skipInvalid dual-track structure (lost in the v0.7.11 rewrite): `dreamSkipInvalid` skips individual invalid decisions + applies the valid subset + marks the run degraded; `allowCrossTypeMerge` explicitly relaxes cross-type merging; weak models (qwen3.8-flash) with jittery schema compliance no longer fail the whole batch. New `dreamMinIntervalMinutes` (0–10080, default 0) minimum trigger interval — failed/degraded runs also consume it. Strict mode / sleep path unchanged; feature_flags whitelist 34 keys; 696 tests green |
+| v0.7.25 | ✅ Done | Tool-compat hardening + content preview + consolidation-model guide | New `memory_get` tool (8th model tool, full-body read by id) + `memory_search`/`memory_list` render embeds title/metadata/body preview + consolidation-model selection guide; fixed `memory_get` execute nested inside output (`userExecute is not a function`) + tool de-dup on live patch reload + Standalone API port-collision retry + client inject alignment + better-sidebar hardening; 718 tests green |
+| **v0.7.26** | ✅ Done | Consolidation effort-trap root fix + LLM connectivity test | `UNSUPPORTED_REASONING_EFFORT` root cause (defaultEffort trap: harness injects `reasoning.defaultEffort` when effort is omitted, so an unsupported default can never be retried) → `resolveDreamEffort` proactively queries `ctx.llm.resolveModelInfo()` for the model's supported effort tiers (unsupported configured tier falls back to the model's default/first supported tier; field omitted when the model declares no reasoning capability); settings panel adds selection hints on 6 dream/sleep model fields; new `GET /api/dsh-mneme/llm-providers` + `POST /api/dsh-mneme/test-model` (connectivity test; empty body resolves via the consolidation route; keys never touch the plugin side); 732 tests green |
 | **v0.8.0** | 🚧 Planned (late Sep) | Graph enhancement | Interest-drift visualization + scope isolation (issue #17) + cross-workspace sharing |
 
 > All new capabilities ship as **toggleable features** (enabled/disabled via configuration), conservatively on by default and never breaking existing behavior. The `failure_memories` table and the autoDream decision engine have already paved the way for future reflective growth.
@@ -301,7 +307,7 @@ It works out of the box with the defaults. To adjust, override in `~/.dsh/profil
 | `dreamDelayMs` | `2000` | Asynchronous consolidation delay (debounce) |
 | `dreamProvider` / `dreamModel` | empty | Explicit dream LLM route — config wins over the agent's default model (config-first, v0.7.16); left empty, the agent's default model is used |
 | `dreamMaxTokens` | `32768` | Maximum tokens per dream LLM call (cap 131072; reasoning and body share this budget on reasoning models — raise it when the body comes back empty, see the tuning guide below) |
-| `dreamReasoningEffort` | `none` | Reasoning-effort passthrough for the dream LLM: `low` / `medium` / `high` / `none` (`none` = omit the field and use the model default; set `low` when a reasoning model exhausts its budget on reasoning and produces an empty body) |
+| `dreamReasoningEffort` | `none` | Reasoning-effort passthrough for the dream LLM: `low` / `medium` / `high` / `none` (`none` = omit the field and use the model default; set `low` when a reasoning model exhausts its budget on reasoning and produces an empty body; v0.7.26+ auto-falls back to the model's default/first supported tier when the configured tier is unsupported, and omits the field for models without reasoning capability) |
 | `apiToken` | empty | Optional API auth token; once set, write operations and key endpoints require `Authorization: Bearer <apiToken>` |
 | `embedProvider` | `openai` | Semantic backend: `openai` (default, v0.1-compatible) / `local` (ONNX offline) / `ollama` |
 | `localEmbedModel` | `Xenova/bge-small-zh-v1.5` | Local ONNX embedding model |
@@ -420,7 +426,7 @@ dsh-mneme config show                                # Show current config (toke
 │  服务层：saveWithDedupe / injectCandidates        │
 │         / mergeHumanEdits / onWrite 钩子          │
 ├─────────────────────────────────────────────────┤
-│  模型接口：7 个工具 + 自动注入 + 会话摘要          │
+│  模型接口：8 个工具 + 自动注入 + 会话摘要          │
 ├─────────────────────────────────────────────────┤
 │  autoDream：阈值调度 → LLM 决策清单               │
 │            → 校验（fail-safe）→ 应用 → 摘要       │
@@ -437,7 +443,7 @@ src/
 ├── mirror.js         # Markdown 镜像（渲染/解析，人工优先）
 ├── service.js        # 领域逻辑（去重合并、注入筛选、写入钩子）
 ├── config.js         # schemastery 配置 schema
-├── tools.js          # 7 个模型工具（defineTool）
+├── tools.js          # 8 个模型工具（defineTool）
 ├── inject.js         # systemPrompt.context 动态注入
 ├── summarize.js      # 会话结束 LLM 摘要
 ├── dream.js          # autoDream 调度 + runDream（LLM 决策 + 摘要）

package/README.md

@@ -49,13 +49,14 @@ dsh web
   - 逐 type 记录 `committed / failed / pending` 回执，健康端点区分 `ok / degraded / unknown`
   - 状态写失败不静默：同步失败落日志并留债务，重启自动收敛
 
-### 模型工具（7 个）
+### 模型工具（8 个）
 
 | 工具 | 功能 |
 |------|------|
 | `memory_save` | 记录一条记忆（自动按标题去重合并） |
 | `memory_search` | 全文搜索（中文子串友好，可启用向量语义搜索） |
 | `memory_list` | 按类型分页列出（`include_archived=true` 可查看已归档） |
+| `memory_get` | 读取单条记忆完整正文（v0.7.25，按 id；memory_search / memory_list 命中后读全文） |
 | `memory_update` | 修改已有记忆 |
 | `memory_delete` | 删除记忆（按记忆 ID 精确删除） |
 | `memory_forget` | 抑制注入（降权不删除，可恢复） |
@@ -89,14 +90,14 @@ dsh web
 | 中等（1 万-5 万字） | `65536` |
 | 大型（5 万字以上） | `131072`（上限） |
 
-> 若使用**思考型模型**（如 deepseek-v4-flash / DeepSeek-R1 类），模型可能把全部预算花在 reasoning 上导致正文为空（日志出现 `no json array in llm output`）。处理顺序：① 把 `dreamReasoningEffort` 设为 `low` 显式压低思考（被方舟拒绝该参数时自动去掉重试一次，拒绝原因会记入 llm_audit）；② 重试走模型默认思考行为后正文仍为空的，调大 `dreamMaxTokens`（reasoning 与正文共享该预算）或配置 `dreamProvider`/`dreamModel` 指向非思考模型。sleep 侧对应 `sleepReasoningEffort`。
+> 若使用**思考型模型**（如 deepseek-v4-flash / DeepSeek-R1 类），模型可能把全部预算花在 reasoning 上导致正文为空（日志出现 `no json array in llm output`）。处理顺序：① 把 `dreamReasoningEffort` 设为 `low` 显式压低思考（v0.7.26+ 若模型不支持该档位，`resolveDreamEffort` 会自动换用模型支持的默认/首个档位或省略字段，拒绝原因会记入 llm_audit）；② 重试走模型默认思考行为后正文仍为空的，调大 `dreamMaxTokens`（reasoning 与正文共享该预算）或配置 `dreamProvider`/`dreamModel` 指向非思考模型。sleep 侧对应 `sleepReasoningEffort`。
 
 **巩固模型分类声明**（settings panel「巩固模型」= `dreamProvider`/`dreamModel`，睡眠侧对应 `sleepProvider`/`sleepModel`）：
 
 | 模型类别 | 例子 | 说明 |
 |---------|------|------|
 | **非思考模型（推荐）** | glm-5-2 类等 | 无 reasoning 声明；即使配了 effort 被 harness 拒绝，fallback 去掉字段重试即成功。空体风险最低 |
-| **思考模型（需实测）** | deepseek-v4-flash-ga 等 v4-flash-ga 系 | 默认开推理，可能烧光 token 预算返回空体；且部分型号（如 v4-flash-ga）在 harness 侧被声明为**不接受任何 reasoning effort** —— 去掉 effort 重试时 harness 的 `defaultEffort` 仍会顶上来再次拒绝（`UNSUPPORTED_REASONING_EFFORT`），插件侧 fallback 无法绕开。选用时建议配 `dreamReasoningEffort` 实测，不行就换非思考模型 |
+| **思考模型（需实测）** | deepseek-v4-flash-ga 等 v4-flash-ga 系 | 默认开推理，可能烧光 token 预算返回空体；部分型号（如 v4-flash-ga）在 harness 侧被声明为**不接受任何 reasoning effort**（去掉 effort 时 harness 的 `defaultEffort` 会顶上来再次拒绝）。v0.7.26+ 已根治：`resolveDreamEffort` 发流前探测模型支持的档位，不支持的配置档位自动换用模型默认/首个支持档位，声明无 reasoning 能力的型号则省略字段。选用时建议配 `dreamReasoningEffort` 实测，不行就换非思考模型 |
 
 ### Sleep Mode 系统级睡眠 💤（v0.4.0，opt-in）
 
@@ -214,6 +215,9 @@ v0.3.0 起新增**记忆基因**层：从记忆里抽取**命名实体**、**带
 
 | 版本 | 亮点 |
 |------|------|
+| **v0.7.27** | v0.7.26 端点遗漏补齐：v0.7.26 发版树未含 `fix/dream-effort-trap` 分支，CHANGELOG/Release 宣告的 `GET /api/dsh-mneme/llm-providers` + `POST /api/dsh-mneme/test-model` 两个端点实际不在包内（面板「级联下拉 + 测试连通性」会 404）；本版将分支 rebase 后合入（PR #100），端点落地，面板连通性测试可用；733 测试全绿 |
+| **v0.7.26** | 记忆巩固 `UNSUPPORTED_REASONING_EFFORT` 根治 + 巩固/睡眠模型连通性测试：根治 **defaultEffort 陷阱**——harness 在 effort 省略时注入 `reasoning.defaultEffort`，若该默认档位本身不被模型支持，则去 effort 重试也无济于事（换什么 effort 都会被拒绝）；修复：新增 `resolveDreamEffort` 经 `ctx.llm.resolveModelInfo()` 主动探测模型支持的档位再发送——配置档位不被支持时自动换用模型支持的默认/首个档位、模型声明无 reasoning 能力则省略字段；设置面板巩固/睡眠 6 字段补选型提示（引导非思考模型，避免再踩思考模型烧光 token 预算）；新增 `GET /api/dsh-mneme/llm-providers`（宿主侧 provider/model 发现，密钥不经插件侧）+ `POST /api/dsh-mneme/test-model`（模型连通性测试，空 body 按巩固路由解析返回 modelId）；732 测试全绿 |
+| **v0.7.25** | 工具兼容性加固 + `memory_get`/render 内容预览 + 巩固模型引导：新增 `memory_get` 工具（第 8 个模型工具，按 id 读单条记忆全文）+ `memory_search`/`memory_list` render 嵌入标题/元数据/正文预览（宿主只透传 render 文本时模型也能直接读到记忆内容）+ 巩固模型选型引导（config 注释/README 分类声明，非思考 vs 思考模型差异）；修复 `memory_get` execute 嵌套进 output 的崩溃（`userExecute is not a function`，此前测试只数工具名从未执行该工具而掩盖）+ 工具重复注册去重（live patch reload）+ Standalone API 端口冲突重试（EADDRINUSE）+ client inject 声明对齐 + better-sidebar 集成加固；718 测试全绿 |
 | **v0.7.24** | 修复 DSH Desktop 插件树加载崩溃（v0.7.23 回归）：cordis 4 的 ctx 是 Proxy，访问未在 inject 声明的 `webServer` 会抛 `cannot get property without inject`（而非返回 undefined），且去掉 inject 后 cordis 不再等待宿主服务 → 桌面端重启即崩；修复：恢复 webServer 到 inject（cordis 等宿主就绪再 apply）+ apply/register 守卫改 `ctx.reflect.get`（免 inject 读取、未提供返回 undefined 不抛错）；真实 cordis + dsh-host-webserver 插件实测；714 测试全绿 |
 | **v0.7.23** | 记忆沉淀「反复失败」根治：consolidation 合法空数组 `[]` 不再误判 failed（CONSOLIDATION_PROMPT 允许「无问题无需输出」，模型无冗余时合法返回 `[]`——此前 `validateDecisions` 硬判 non-empty → 整单 failed、审计反复失败，且与模型无关，ChatGPT/Claude 同样踩中；修复：空数组显式短路 `ok:true` no-op）+ 空体修复第二段（`dreamMaxTokens` 默认 8192→32768，思考模型推理烧光预算的根治余量，设置面板可调）+ skipInvalid splice 残留 bug（长度相等≠内容一致，被跳决策残留）；712 测试全绿 |
 | **v0.7.22** | 恢复 v0.6.9 的 skipInvalid 宽容校验路径（issue #89 回归，v0.7.11 重写丢失）：`dreamSkipInvalid`（默认 true）单条非法决策跳过 + 合法子集应用 + run 记 degraded，`allowCrossTypeMerge`（默认 false）显式放宽跨类型合并——弱模型（如 qwen3.8-flash）决策合规抖动不再整单拒绝白烧 LLM 调用；严格模式/sleep 路径行为不变，全局上限/覆盖率下限仍整单拒绝（刷爆上限=模型坏了，非轻微 schema 漂移）；新增 `dreamMinIntervalMinutes`（0-10080，默认 0=不限）autoDream 最小触发间隔，失败/degraded run 也占用间隔（节流防失败调用连发）；feature_flags 白名单 34 键；696 测试全绿 |
@@ -301,6 +305,8 @@ v0.3.0 起新增**记忆基因**层：从记忆里抽取**命名实体**、**带
 | **v0.7.18** | ✅ 完成 | 生态第一步 + 查询收敛 | better-sidebar 软集成（inject 声明 + optional peer `dsh-better-sidebar` + registerTab 复用四视图，未装安全跳过；窄容器 `@container` 适配）+ `/list?deposited=only` 沉淀视图（receipt_chain ∪ source=dream）+ 记忆库沉淀/已归档筛选 chip + 状态页仪表盘化（统计 + 查看全部跳转预置筛选）+ 抽屉归档记忆「恢复」；667 测试全绿 |
 | **v0.7.20** | ✅ 完成 | heat 回归 + 阶段二前端 + better-sidebar 修复 | heat 热度模型完整找回（issue #87，v0.7.10 移植：幂律衰减 + TYPE_DECAY + sleep 热联合双保护 + 实体热投影）+ 验收清单落地（heatEnabled 默认关 / feature_flags 31 键 / lightMode 联动 / sleep 降级审计暴露 / updated_at⊥last_accessed_at 契约）+ 阶段二前端（/list heat 投影、HeatBadge 三档、order=heat 页内排序）+ better-sidebar 修复（issue #88：内层动态子插件）；685 测试全绿 |
 | **v0.7.21** | ✅ 完成 | effort 回退流式修复 | autoDream/sleep 的 catch 式 effort 回退在流式路径是死代码（dsh-llm rc.1 把 adapter 异常转成终态 error finish chunk 不再抛出）→ `streamText` 捕获 finish-chunk 失败原因（`describeStreamFailure` 归一化）+ `withEffortFallback` 增加 `getStreamError` 访问器（effort 被拒去重试）+ `runAuditedLlm` 支持 `spec.streamError`（audit 记真实原因）；688 测试全绿 |
+| **v0.7.26** | ✅ 完成 | 巩固 effort 陷阱根治 + LLM 连通性测试 | 记忆巩固 `UNSUPPORTED_REASONING_EFFORT` 根治（defaultEffort 陷阱：harness 省略 effort 时注入 `reasoning.defaultEffort`，默认档位不被模型支持则任何重试无效）→ 新增 `resolveDreamEffort` 经 `ctx.llm.resolveModelInfo()` 探测模型支持的档位（不支持的配置档位自动换用模型支持的默认/首个档位，无 reasoning 能力则省略字段）；设置面板巩固/睡眠 6 字段补选型提示（引导非思考模型）；新增 `GET /api/dsh-mneme/llm-providers`（宿主侧 provider/model 发现）+ `POST /api/dsh-mneme/test-model`（模型连通性测试，空 body 按巩固路由解析，密钥不经插件侧）；732 测试全绿 |
+| **v0.7.25** | ✅ 完成 | 工具兼容性加固 + 内容预览 + 巩固模型引导 | 新增 `memory_get` 工具（第 8 个模型工具，按 id 读单条记忆全文）+ `memory_search`/`memory_list` render 嵌入标题/元数据/正文预览（宿主只透传 render 文本时模型也能读到内容）+ 巩固模型选型引导（config 注释/README 分类声明）；修复 memory_get execute 嵌套 output 的崩溃（userExecute is not a function）+ 工具重复注册去重（live patch reload）+ Standalone API 端口冲突重试 + client inject 声明对齐 + better-sidebar 集成加固；718 测试全绿 |
 | **v0.7.24** | ✅ 完成 | 桌面端崩溃紧急修复 | v0.7.23 把 webServer 移出 inject 致 cordis Proxy 抛 `cannot get property "webServer" without inject`（未注入属性直接访问抛错而非 undefined），桌面端重启插件树加载失败；修复：恢复 webServer 到 inject（cordis 等宿主就绪再 apply）+ apply/register 守卫改 `ctx.reflect.get`（免 inject 读取、未提供返回 undefined 不抛错，未来 headless 移出 inject 也安全）；真实 cordis + dsh-host-webserver 实测 API 路由 200 / 未知路径 404 / headless 静默不激活；714 测试全绿 |
 | **v0.7.23** | ✅ 完成 | 记忆沉淀「反复失败」根治 + 空体第二段 + skipInvalid splice 修复 | consolidation 合法空数组 `[]` no-op（CONSOLIDATION_PROMPT 允许无问题无需输出；此前 validateDecisions 硬判 non-empty → 整单 failed，模型无关、ChatGPT/Claude 同样踩中；修复：空数组显式短路 ok，不再触发隐式 keep 覆盖率误判）；`dreamMaxTokens` 默认 8192→32768（思考模型推理烧光预算根治余量）；skipInvalid splice 残留 bug（长度相等≠内容一致，被跳决策残留进 apply）；712 测试全绿 |
 | **v0.7.22** | ✅ 完成 | skipInvalid 宽容校验回归（issue #89）+ autoDream 节流 | 恢复 v0.6.9 的 skipInvalid 双轨结构（v0.7.11 重写丢失）：`dreamSkipInvalid` 单条非法决策跳过 + 合法子集应用 + run 记 degraded，`allowCrossTypeMerge` 显式放宽跨类型合并；弱模型（qwen3.8-flash）决策合规抖动不再整单拒绝；新增 `dreamMinIntervalMinutes`（0-10080，默认 0=不限）最小触发间隔，失败/degraded run 也占用间隔；严格模式/sleep 路径行为不变；feature_flags 白名单 34 键；696 测试全绿 |
@@ -375,7 +381,7 @@ dsh web
 | `dreamDelayMs` | `2000` | 整理异步延迟（去抖） |
 | `dreamProvider` / `dreamModel` | 空 | dream 的 LLM 路由覆盖（显式配置优先于 agent 默认模型；留空则回退到 agent 默认模型） |
 | `dreamMaxTokens` | `32768` | dream LLM 调用最大 token 数（上限 131072；思考型模型的 reasoning 与正文共享该预算，正文为空时优先调大，见下方调优指南） |
-| `dreamReasoningEffort` | `none` | dream LLM 推理强度透传：`low` / `medium` / `high` / `none`（`none`=不传该字段，沿用模型默认；思考型模型（如 deepseek-v4-flash）想压低思考可设 `low`；被方舟拒绝该参数时 v0.7.16 起自动去掉重试一次） |
+| `dreamReasoningEffort` | `none` | dream LLM 推理强度透传：`low` / `medium` / `high` / `none`（`none`=不传该字段，沿用模型默认；思考型模型（如 deepseek-v4-flash）想压低思考可设 `low`；v0.7.26+ 模型不支持配置档位时自动换用其支持的默认/首个档位，无 reasoning 能力的型号省略字段） |
 | `apiToken` | 空 | 可选 API 鉴权 token；设置后写操作与密钥接口要求 `Authorization: Bearer <apiToken>` |
 | `embedProvider` | `openai` | 语义后端：`openai`（默认，兼容 v0.1）/ `local`（ONNX 离线）/ `ollama` |
 | `localEmbedModel` | `Xenova/bge-small-zh-v1.5` | 本地 ONNX embedding 模型 |
@@ -508,7 +514,7 @@ dsh-mneme config show                                # 查看当前配置（toke
 │  服务层：saveWithDedupe / injectCandidates        │
 │         / mergeHumanEdits / onWrite 钩子          │
 ├─────────────────────────────────────────────────┤
-│  模型接口：7 个工具 + 自动注入 + 会话摘要          │
+│  模型接口：8 个工具 + 自动注入 + 会话摘要          │
 ├─────────────────────────────────────────────────┤
 │  autoDream：阈值调度 → LLM 决策清单               │
 │            → 校验（fail-safe）→ 应用 → 摘要       │
@@ -525,7 +531,7 @@ src/
 ├── mirror.js         # Markdown 镜像（渲染/解析，人工优先）
 ├── service.js        # 领域逻辑（去重合并、注入筛选、写入钩子）
 ├── config.js         # schemastery 配置 schema
-├── tools.js          # 7 个模型工具（defineTool）
+├── tools.js          # 8 个模型工具（defineTool）
 ├── inject.js         # systemPrompt.context 动态注入
 ├── summarize.js      # 会话结束 LLM 摘要
 ├── dream.js          # autoDream 调度 + runDream（LLM 决策 + 摘要）

package/lib/api.js

@@ -4,6 +4,7 @@ import { timingSafeEqual, randomBytes } from "node:crypto";
 import { FEATURE_FLAG_SPEC } from "./settings.js";
 import { TYPE_FILE, renderMirrorText, parseHumanEdits } from "./mirror.js";
 import { computeHeat } from "./heat.js";
+import { describeStreamFailure, resolveRoute } from "./dream.js";
 
 // headers：少数端点（/export 附件下载）需要追加 Content-Disposition 等响应头。
 function sendJson(res, status, payload, headers = {}) {
@@ -277,6 +278,104 @@ export function createApi(ctx, service, settings, commands, embedder, semantic =
     }
   });
 
+  // --- dream/sleep 模型连通性 + 模型发现（settings 面板）----------------------
+  // Connectivity probe for a dream/sleep model route: runs one minimal LLM call
+  // through the same harness path the consolidation uses and reports success /
+  // failure + latency + error. Reuses describeStreamFailure so the panel shows
+  // the same error wording the audit rows carry. Optional reasoningEffort
+  // mirrors what the consolidation would send — the panel can verify a model
+  // actually accepts the configured effort without tripping a full run.
+  async function testLlmConnectivity(llm, provider, model, reasoningEffort) {
+    const startedAt = Date.now();
+    const elapsed = () => Date.now() - startedAt;
+    const modelId = `${provider}:${model}`;
+    try {
+      let reply = "";
+      let error = "";
+      for await (const chunk of llm.stream({
+        provider,
+        model,
+        purpose: "dsh-mneme-connectivity-test",
+        maxTokens: 16,
+        ...(reasoningEffort && reasoningEffort !== "none" ? { reasoningEffort } : {}),
+        messages: [{ role: "system", content: [{ type: "text", text: "Reply with exactly one word: ok" }] }]
+      })) {
+        if (chunk.type === "text-delta" && typeof chunk.text === "string") reply += chunk.text;
+        if (chunk.type === "finish" && (chunk.reason?.kind === "error" || chunk.reason?.kind === "aborted")) {
+          error = describeStreamFailure(chunk.reason);
+          break;
+        }
+      }
+      if (error) return { ok: false, durationMs: elapsed(), error, modelId };
+      return { ok: true, durationMs: elapsed(), modelId, reply: reply.trim().slice(0, 100) };
+    } catch (error) {
+      return { ok: false, durationMs: elapsed(), error: String(error?.message ?? error), modelId };
+    }
+  }
+
+  // List every provider + model the host has registered, so the panel can offer
+  // a dropdown over REAL models instead of free-text guesses. Read-only, no auth
+  // (same as list/search). Best-effort per provider: one whose model list can't
+  // be resolved yields an empty models array instead of failing the whole call.
+  register({
+    kind: "exact",
+    path: "/api/dsh-mneme/llm-providers",
+    handler(req, res) {
+      try {
+        const llm = ctx.llm;
+        if (typeof llm?.listProviders !== "function" || typeof llm?.listModels !== "function") {
+          return sendJson(res, 501, { error: "llm-unavailable" });
+        }
+        let providers;
+        try { providers = llm.listProviders() ?? []; } catch { providers = []; }
+        return Promise.all(providers.map(async (p) => {
+          let models = [];
+          try { models = (await llm.listModels(p.id)) ?? []; } catch { models = []; }
+          return {
+            provider: p.id,
+            models: models.map((m) => ({ id: m.id, name: m.name ?? m.id }))
+          };
+        })).then((rows) => sendJson(res, 200, { providers: rows }));
+      } catch {
+        return sendJson(res, 500, { error: "internal" });
+      }
+    }
+  });
+
+  // Connectivity test for a dream/sleep model route. Runs one tiny LLM call and
+  // reports ok / failure + latency + error. Auth-gated: it spends the user's
+  // API quota, so a stray local page must not be able to drain it via loopback.
+  register({
+    kind: "exact",
+    path: "/api/dsh-mneme/test-model",
+    handler(req, res) {
+      try {
+        if (req.method !== "POST") return sendJson(res, 404, { error: "not-found" });
+        if (!requireAuth(req, res, apiToken)) return;
+        return readBody(req).then(async (text) => {
+          const body = parseBody(text);
+          let provider = typeof body.provider === "string" ? body.provider.trim() : "";
+          let model = typeof body.model === "string" ? body.model.trim() : "";
+          if ((!provider && model) || (provider && !model)) return sendJson(res, 400, { error: "missing-provider-or-model" });
+          if (!provider && !model) {
+            // 空 = 按巩固路由解析（dreamProvider/dreamModel > agent 默认模型），
+            // 让面板一键测"当前巩固模型"而无需手填。
+            const route = resolveRoute(ctx, config ?? {}, ctx.logger);
+            if (!route) return sendJson(res, 400, { error: "no-route" });
+            provider = route.provider;
+            model = route.model;
+          }
+          const llm = ctx.llm;
+          if (typeof llm?.stream !== "function") return sendJson(res, 501, { error: "llm-unavailable" });
+          const result = await testLlmConnectivity(llm, provider, model, body.reasoningEffort);
+          return sendJson(res, result.ok ? 200 : 502, result);
+        });
+      } catch {
+        return sendJson(res, 500, { error: "internal" });
+      }
+    }
+  });
+
   // --- delete one memory by id ---
   // Mutation route: apiToken-gated like the profile/rules writes above. POST
   // body is JSON { id }. store.remove deletes silently, so existence is checked

package/lib/client.js

@@ -326,6 +326,15 @@ window.__ModuleLoader__.load({
         "memory.features.dreamProvider": "巩固模型 Provider",
         "memory.features.dreamModel": "巩固用模型名",
         "memory.features.dreamModelHint": "留空 = 跟随主对话模型；只影响记忆巩固（autoDream）用的模型",
+        "memory.features.sleepProvider": "睡眠 Provider",
+        "memory.features.sleepModel": "睡眠模型",
+        "memory.features.sleepModelHint": "留空 = 用巩固模型或当前模型；建议选非思考模型",
+        "memory.features.routeFollowDefault": "跟随默认路由",
+        "memory.features.modelTest": "测试连通性",
+        "memory.features.modelTesting": "测试中…",
+        "memory.features.modelTestOk": "连通正常",
+        "memory.features.modelTestFail": "测试失败",
+        "memory.features.modelTestHint": "真实发起一次最小巩固调用，验证 Provider/模型连通与 effort 支持",
         "memory.explorer.viewCards": "卡片",
         "memory.explorer.viewTimeline": "时间线",
         "memory.explorer.viewAria": "视图切换",
@@ -606,6 +615,15 @@ window.__ModuleLoader__.load({
         "memory.features.dreamProvider": "Consolidation provider",
         "memory.features.dreamModel": "Consolidation model",
         "memory.features.dreamModelHint": "Leave empty to follow the main conversation model; only affects autoDream consolidation",
+        "memory.features.sleepProvider": "Sleep provider",
+        "memory.features.sleepModel": "Sleep model",
+        "memory.features.sleepModelHint": "Leave empty to reuse the consolidation model; a non-reasoning model is recommended",
+        "memory.features.routeFollowDefault": "Follow default route",
+        "memory.features.modelTest": "Test connectivity",
+        "memory.features.modelTesting": "Testing…",
+        "memory.features.modelTestOk": "Connected",
+        "memory.features.modelTestFail": "Test failed",
+        "memory.features.modelTestHint": "Fires one minimal consolidation call to verify provider/model connectivity and effort support",
         "memory.explorer.viewCards": "Cards",
         "memory.explorer.viewTimeline": "Timeline",
         "memory.explorer.viewAria": "Switch view",
@@ -750,6 +768,7 @@ window.__ModuleLoader__.load({
       ".mneme-chip:hover{background:var(--dsw-alias-interactive-bg-hover)}",
       ".mneme-chip.mneme-active{color:var(--dsw-alias-state-business-primary);background:color-mix(in srgb,var(--dsw-alias-state-business-primary) 10%,transparent)}",
       ".mneme-select{box-sizing:border-box;height:30px;padding:0 8px;border-radius:8px;border:1px solid var(--dsw-alias-border-l2);background:var(--dsw-alias-bg-base,transparent);color:var(--dsw-alias-label-primary);font-family:inherit;font-size:13px;outline:none}",
+      ".mneme-routeselect{width:240px;max-width:60%}",
       ".mneme-footbtn{border:none;background:none;color:var(--dsw-alias-label-secondary);cursor:pointer;font-family:inherit;font-size:12px;line-height:16px;padding:3px 8px;border-radius:6px}",
       ".mneme-footbtn:hover{background:var(--dsw-alias-interactive-bg-hover);color:var(--dsw-alias-label-primary)}",
       ".mneme-hint{color:var(--dsw-alias-label-tertiary);padding:24px 0;text-align:center;font-size:13px}",
@@ -1601,6 +1620,11 @@ window.__ModuleLoader__.load({
       const [savedTick, setSavedTick] = useState(false);
       const [showAdv, setShowAdv] = useState(false);
       const [strs, setStrs] = useState({}); // 字符串输入的本地草稿：key -> string
+      // 巩固/睡眠模型路由下拉的数据源：GET /llm-providers 探测（云端 v0.7.26+
+      // 的插件侧端点）。null = 端点不可用（404/失败）→ 回退纯文本输入，不挡旧后端。
+      const [routes, setRoutes] = useState(null);
+      // 连通性测试结果：{ running: true } | { ok, ms, detail }
+      const [testState, setTestState] = useState(null);
 
       useEffect(() => {
         let cancelled = false;
@@ -1618,6 +1642,16 @@ window.__ModuleLoader__.load({
         return () => { cancelled = true; };
       }, [t]);
 
+      // 插件侧枚举端点探测：不可用时静默保持 routes=null（文本框回退）。
+      useEffect(() => {
+        let cancelled = false;
+        apiFetch("/api/dsh-mneme/llm-providers")
+          .then((res) => { if (!res.ok) throw new Error("HTTP " + res.status); return res.json(); })
+          .then((j) => { if (!cancelled) setRoutes(Array.isArray(j && j.providers) ? j.providers : []); })
+          .catch(() => {});
+        return () => { cancelled = true; };
+      }, [t]);
+
       const eff = (state && state.effective) || {};
 
       const put = async (patch) => {
@@ -1659,6 +1693,91 @@ window.__ModuleLoader__.load({
         onToggle: () => put({ [k]: !eff[k] })
       });
 
+      // 模型枚举项的统一形状：string 或 {id, name?}（/llm-providers 契约）。
+      const modelLabel = (m) => (typeof m === "string" ? m : String((m && (m.name || m.id)) ?? ""));
+      const modelValue = (m) => (typeof m === "string" ? m : String((m && m.id) ?? ""));
+
+      // 连通性测试：POST /test-model，空 provider/model = 按巩固路由解析
+      // （agent 默认）。durationMs 优先后端值，缺失时客户端兜底计时；成功行
+      // 附模型的实际回复（reply，后端截 100 字符）——「真的答了 ok」而非只报通。
+      const runModelTest = async (provider, model) => {
+        setTestState({ running: true });
+        const started = Date.now();
+        try {
+          const res = await apiFetch("/api/dsh-mneme/test-model", {
+            method: "POST",
+            headers: { "Content-Type": "application/json" },
+            body: JSON.stringify({ provider, model })
+          });
+          const j = await res.json().catch(() => ({}));
+          const ms = typeof j.durationMs === "number" ? j.durationMs : Date.now() - started;
+          if (!res.ok || j.ok === false) {
+            setTestState({
+              ok: false,
+              ms,
+              detail: [j.modelId, j.error || "HTTP " + res.status].filter(Boolean).join(" · ")
+            });
+            return;
+          }
+          setTestState({
+            ok: true,
+            ms,
+            detail: [j.modelId, j.reply ? "「" + j.reply + "」" : ""].filter(Boolean).join(" · ")
+          });
+        } catch (err) {
+          setTestState({ ok: false, ms: Date.now() - started, detail: String((err && err.message) ?? err) });
+        }
+      };
+
+      // 巩固/睡眠路由行：provider/model 级联下拉（数据来自宿主侧已注册的
+      // 适配器，用户不会选到不存在的模型）+ 连通性测试。空值 = 跟随默认
+      // 路由；改动即提交（与 embedProvider 下拉一致）。当前值不在枚举里时
+      // 保留为额外选项，避免静默改值。
+      const routeSelects = (providerKey, modelKey) => {
+        const curP = strs[providerKey] ?? "";
+        const curM = strs[modelKey] ?? "";
+        const entries = Array.isArray(routes) ? routes : [];
+        const entry = entries.find((p) => p && p.provider === curP);
+        const models = (entry && Array.isArray(entry.models)) ? entry.models : [];
+        const mVals = models.map(modelValue);
+        const pList = entries.map((p) => p.provider).concat(
+          curP && !entries.some((p) => p.provider === curP) ? [curP] : []);
+        const putKey = (key) => (e) => {
+          const v = e.target.value;
+          setStrs((c) => ({ ...c, [key]: v }));
+          put({ [key]: v });
+        };
+        return h(react.Fragment, null,
+          h("div", { className: "mneme-featnum" },
+            h("span", { className: "mneme-featnumlabel" }, t(`memory.features.${providerKey}`)),
+            h("select", {
+              className: "mneme-select mneme-routeselect", value: curP, disabled: busy,
+              "aria-label": t(`memory.features.${providerKey}`), onChange: putKey(providerKey)
+            },
+              h("option", { value: "" }, t("memory.features.routeFollowDefault")),
+              pList.map((p) => h("option", { key: p, value: p }, p)))),
+          h("div", { className: "mneme-featnum" },
+            h("span", { className: "mneme-featnumlabel" }, t(`memory.features.${modelKey}`)),
+            h("select", {
+              className: "mneme-select mneme-routeselect", value: curM, disabled: busy,
+              "aria-label": t(`memory.features.${modelKey}`), onChange: putKey(modelKey)
+            },
+              h("option", { value: "" }, t("memory.features.routeFollowDefault")),
+              models.map((m, i) => h("option", { key: modelValue(m) + "|" + i, value: modelValue(m) }, modelLabel(m))),
+              curM && !mVals.includes(curM) ? h("option", { key: "current", value: curM }, curM) : null)),
+          h("div", { className: "mneme-featnum" },
+            h("button", {
+              type: "button", className: "mneme-btn",
+              disabled: busy || (testState && testState.running),
+              onClick: () => runModelTest(curP, curM)
+            }, t((testState && testState.running) ? "memory.features.modelTesting" : "memory.features.modelTest")),
+            testState && !testState.running && h("div", { className: "mneme-featsubhint" },
+              (testState.ok ? "✓ " + t("memory.features.modelTestOk") : "✗ " + t("memory.features.modelTestFail"))
+              + (typeof testState.ms === "number" ? " · " + (testState.ms / 1000).toFixed(1) + "s" : "")
+              + (testState.detail ? " · " + testState.detail : "")))
+        );
+      };
+
       const strRow = (key) => h("div", { className: "mneme-featnum", key },
         h("span", { className: "mneme-featnumlabel" }, t(`memory.features.${key}`)),
         h("input", {
@@ -1689,13 +1808,22 @@ window.__ModuleLoader__.load({
         eff.embedProvider === "ollama" && strRow("ollamaModel")
       );
 
-      // 巩固模型：autoDream 开着才展开，避免闲置配置占版面。
+      // 巩固模型：autoDream 开着才展开，避免闲置配置占版面。/llm-providers
+      // 可用时用级联下拉 + 连通性测试；旧后端（端点 404）回退纯文本输入。
       const dreamSub = eff.autoDream && h("div", { className: "mneme-featsub" },
-        strRow("dreamProvider"),
-        strRow("dreamModel"),
+        Array.isArray(routes)
+          ? routeSelects("dreamProvider", "dreamModel")
+          : h(react.Fragment, null, strRow("dreamProvider"), strRow("dreamModel")),
         h("div", { className: "mneme-featsubhint" }, t("memory.features.dreamModelHint"))
       );
 
+      // 睡眠模型：sleepModeEnabled 开着才展开（sleepProvider/sleepModel 随本版
+      // 进白名单；下拉与测试复用同一 /llm-providers 数据源）。
+      const sleepSub = eff.sleepModeEnabled && Array.isArray(routes) && h("div", { className: "mneme-featsub" },
+        routeSelects("sleepProvider", "sleepModel"),
+        h("div", { className: "mneme-featsubhint" }, t("memory.features.sleepModelHint"))
+      );
+
       if (error && !state) return h("section", { className: "mneme-set-card" },
         h("div", { className: "mneme-set-title" }, t("memory.features.title")),
         h("div", { className: "mneme-set-hint" }, error));
@@ -1713,7 +1841,7 @@ window.__ModuleLoader__.load({
                 h("div", { className: "mneme-featgroup" }, t(`memory.features.${g.key}`)),
                 g.items.map(boolRow),
                 g.key === "group.enhance" && embedSub,
-                g.key === "group.dream" && dreamSub
+                g.key === "group.dream" && h(react.Fragment, null, dreamSub, sleepSub)
               )),
               h("div", { className: "mneme-featgroup" },
                 h("button", {

package/lib/config.js

@@ -62,8 +62,8 @@ export const Config = z.object({
   //     reasoning effort —— 即使去掉 effort 重试，harness 的 defaultEffort 也会顶上来
   //     再次拒绝（UNSUPPORTED_REASONING_EFFORT），插件 fallback 无法绕开。
   //     选用时建议配 dreamReasoningEffort 并实测；不行就换非思考模型。
-  dreamProvider: z.string(),
-  dreamModel: z.string(),
+  dreamProvider: z.string().description("记忆巩固专用模型的服务商（settings「巩固模型」）。巩固反复失败时，优先改用官方非思考模型的服务商（如 deepseek / glm）。"),
+  dreamModel: z.string().description("记忆巩固专用模型。建议选非思考模型（如 deepseek-chat、glm-5-2 类）：思考模型可能烧光 token 预算返回空体，导致巩固失败（UNSUPPORTED_REASONING_EFFORT）。"),
   dreamMaxTokens: z.natural().min(256).max(131072).default(32768),
   // Pass-through reasoning effort for dream's LLM calls. 'none' (default)
   // omits the field so the provider's own default applies; low/medium/high
@@ -78,7 +78,7 @@ export const Config = z.object({
     z.const("medium"),
     z.const("high"),
     z.const("none")
-  ]).default("none"),
+  ]).default("none").description("巩固模型的推理档位：'none'（默认）用服务商自带默认；low/medium/high 原样传递。模型不支持的值会自动换用其支持的档位（v0.7.26+）。"),
   // 滑动窗口上限（v0.4.4）：autoDream 每次只对最近 dreamMaxSnapshotSize 条
   // 记忆做 consolidation。大记忆量下全量快照会把 LLM 输入撑爆（636 记忆 →
   // 677 "missing" errors、applied=0），窗口外的旧记忆不进 snapshot。
@@ -251,8 +251,8 @@ export const Config = z.object({
   sleepMaxPatternPerRun: z.natural().min(0).max(10).default(3),
   // Optional LLM route override for sleep's bulk passes (empty = use dream
   // route / agent default model).
-  sleepProvider: z.string().default(""),
-  sleepModel: z.string().default(""),
+  sleepProvider: z.string().default("").description("sleep 深维护专用模型服务商，留空用巩固模型或当前模型。"),
+  sleepModel: z.string().default("").description("sleep 深维护专用模型，留空用巩固模型或当前模型；建议同巩固模型选非思考模型。"),
   // Pass-through reasoning effort for sleep's LLM passes, same semantics as
   // dreamReasoningEffort: 'none' (default) omits the field; low/medium/high
   // are forwarded verbatim.
@@ -261,7 +261,7 @@ export const Config = z.object({
     z.const("medium"),
     z.const("high"),
     z.const("none")
-  ]).default("none"),
+  ]).default("none").description("同 dreamReasoningEffort：sleep 各阶段 LLM 的推理档位，'none' 用服务商默认。"),
 
   // --- epistemic trust: memory source credibility (v0.4.5) -----------------
   // Distinguish memories by source: observation (measured / witnessed),

package/lib/dream/sleep.js

@@ -17,7 +17,7 @@
 import { randomUUID, createHash } from "node:crypto";
 import { validateDecisions, applyDecisions } from "./decisions.js";
 import { findPotentialConflicts } from "./clustering.js";
-import { buildReceipt, describeStreamFailure, withEffortFallback } from "../dream.js";
+import { buildReceipt, describeStreamFailure, resolveDreamEffort, withEffortFallback } from "../dream.js";
 import { computeHeat } from "../heat.js";
 
 const SUMMARY_MAX = 120;
@@ -190,7 +190,7 @@ async function phaseConflicts(ctx, service, config, logger, runId, semantic = nu
   const listText = selected.map((p) =>
     `候选冲突：\nid=${p.a.id} | type=${p.a.type} | title=${p.a.title}\n${p.a.content}\n---\nid=${p.b.id} | type=${p.b.type} | title=${p.b.title}\n${p.b.content}\n（相似度 ${p.similarity.toFixed(2)}）`
   ).join("\n\n");
-  const sleepEffort = config.sleepReasoningEffort && config.sleepReasoningEffort !== "none" ? config.sleepReasoningEffort : null;
+  const sleepEffort = await resolveDreamEffort(ctx, route, config.sleepReasoningEffort, logger);
   let conflictStreamFailure = "";
   const runConflict = (withEffort) => {
     conflictStreamFailure = "";
@@ -309,7 +309,7 @@ async function phasePatterns(ctx, service, config, logger, runId, signal = null)
     .map((m) => `id=${m.id} | type=${m.type} | importance=${m.importance} | updated=${m.updated_at} | title=${m.title} | content=${m.content}`)
     .join("\n");
   const maxPatterns = config.sleepMaxPatternPerRun ?? 3;
-  const sleepEffort = config.sleepReasoningEffort && config.sleepReasoningEffort !== "none" ? config.sleepReasoningEffort : null;
+  const sleepEffort = await resolveDreamEffort(ctx, route, config.sleepReasoningEffort, logger);
   let patternStreamFailure = "";
   const runPattern = (withEffort) => {
     patternStreamFailure = "";