@modusensus/dsh-mneme 0.7.25 → 0.7.27

package/lib/dream.js

@@ -1,7 +1,7 @@
 import { validateDecisions, applyDecisions } from "./dream/decisions.js";
 import { clusterMemories, findPotentialConflicts } from "./dream/clustering.js";
 import { createHash, randomUUID } from "node:crypto";
-export { validateDecisions, applyDecisions, withEffortFallback, describeStreamFailure };
+export { validateDecisions, applyDecisions, withEffortFallback, describeStreamFailure, resolveDreamEffort, resolveRoute };
 
 
 // Extract the first JSON array from LLM output, tolerating markdown fences,
@@ -373,6 +373,60 @@ async function withEffortFallback(ctx, effort, attempt, fallback, getStreamError
   }
 }
 
+/**
+ * Resolve the reasoning effort to actually send for a dream/sleep route.
+ *
+ * Reasoning-effort config that the provider does not accept trips the harness's
+ * UNSUPPORTED_REASONING_EFFORT, and the defaultEffort trap makes retrying
+ * "without the field" useless: the harness substitutes `reasoning.defaultEffort`,
+ * which may itself be unsupported (DSH Desktop volcano-engine adapter declares
+ * defaultEffort=low that its model rejects). So instead of blind retries, ask
+ * the harness for the model's declared capability and pick a value that is
+ * actually accepted — or omit the field entirely when the model declares no
+ * reasoning capability at all.
+ *
+ * @returns a supported effort id, or null when no effort should be sent, or the
+ *   configured value unchanged when the capability query is unavailable.
+ */
+async function resolveDreamEffort(ctx, route, configuredEffort, logger) {
+  if (!configuredEffort || configuredEffort === "none") return null;
+  // Capability query unavailable (older harness / minimal mocks): forward the
+  // configured value as before — absence of the API proves nothing about the
+  // model, and withEffortFallback still guards against rejection.
+  if (typeof ctx?.llm?.resolveModelInfo !== "function") return configuredEffort;
+  try {
+    const info = await ctx.llm.resolveModelInfo(route.provider, route.model);
+    const reasoning = info?.reasoning;
+    if (!reasoning) {
+      // Model declares no reasoning capability: the harness rejects ANY
+      // explicit effort for such a model, and omitting the field is safe
+      // (no reasoning capability → no defaultEffort substitution).
+      logger?.warn?.(`dsh-mneme dream: model ${route.provider}:${route.model} declares no reasoning capability; ignoring configured effort "${configuredEffort}"`);
+      return null;
+    }
+    const supported = reasoning.efforts?.map((effort) => effort.id) ?? [];
+    if (supported.includes(configuredEffort)) return configuredEffort;
+    // Configured effort unsupported → pick defaultEffort if it is supported,
+    // else the first declared effort, so the run never trips
+    // UNSUPPORTED_REASONING_EFFORT (nor the defaultEffort trap: we always
+    // pass an explicit value, so the harness never falls back to a poison
+    // default).
+    const picked = reasoning.defaultEffort && supported.includes(reasoning.defaultEffort)
+      ? reasoning.defaultEffort
+      : supported[0];
+    if (picked) {
+      logger?.warn?.(`dsh-mneme dream: model ${route.provider}:${route.model} does not support effort "${configuredEffort}" (supported: ${supported.join(", ")}); using "${picked}"`);
+      return picked;
+    }
+    return null;
+  } catch (error) {
+    // Capability query failed — forward the configured value; withEffortFallback
+    // still retries on rejection as before.
+    logger?.warn?.(`dsh-mneme dream: resolveModelInfo failed (${String(error?.message ?? error)}); forwarding effort as configured`);
+    return configuredEffort;
+  }
+}
+
 /**
  * Resolve the LLM route (Issue #25): an explicit plugin config
  * (dreamProvider/dreamModel) is the user's declared override and wins; the
@@ -665,7 +719,7 @@ export function createDreamScheduler({ onRun, thresholdCount = 10, thresholdChar
     // （不带该字段），避免 thinking 模型配置 low/medium 直接整单失败。解析放
     // 在 auditError 检查器里、闭包交回主流程，避免二次解析；解析失败同时如实
     // 记 audit error 并在日志带原始输出前 300 字节，便于定位"推理吞预算返回空体"。
-    const effort = config.dreamReasoningEffort && config.dreamReasoningEffort !== "none" ? config.dreamReasoningEffort : null;
+    const effort = await resolveDreamEffort(ctx, route, config.dreamReasoningEffort, logger);
     let decisions = null;
     let streamFailure = "";
     const runConsolidation = (withEffort) => {

package/lib/settings.js

@@ -82,6 +82,10 @@ const FEATURE_FLAG_INT_RANGES = {
 const FEATURE_FLAG_STRINGS = [
   "dreamProvider",
   "dreamModel",
+  // 睡眠侧专用路由（sleep.js 的 config-first 第三层）：面板下拉随
+  // /llm-providers 端点一起提供，留空 = 用巩固模型或当前模型。
+  "sleepProvider",
+  "sleepModel",
   "localEmbedModel",
   "ollamaModel"
 ];

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@modusensus/dsh-mneme",
   "description": "Cross-session memory plugin for DeepSeek Harness with autoDream consolidation: SQLite store, Markdown mirrors, 7 model tools, automatic injection, session summarization, user profile/rules, custom slash commands, vector (semantic) search, and a Web GUI panel",
-  "version": "0.7.25",
+  "version": "0.7.27",
   "license": "MIT",
   "repository": {
     "type": "git",

package/src/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/src/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/src/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 = "";

package/src/dream.js

@@ -1,7 +1,7 @@
 import { validateDecisions, applyDecisions } from "./dream/decisions.js";
 import { clusterMemories, findPotentialConflicts } from "./dream/clustering.js";
 import { createHash, randomUUID } from "node:crypto";
-export { validateDecisions, applyDecisions, withEffortFallback, describeStreamFailure };
+export { validateDecisions, applyDecisions, withEffortFallback, describeStreamFailure, resolveDreamEffort, resolveRoute };
 
 
 // Extract the first JSON array from LLM output, tolerating markdown fences,
@@ -373,6 +373,60 @@ async function withEffortFallback(ctx, effort, attempt, fallback, getStreamError
   }
 }
 
+/**
+ * Resolve the reasoning effort to actually send for a dream/sleep route.
+ *
+ * Reasoning-effort config that the provider does not accept trips the harness's
+ * UNSUPPORTED_REASONING_EFFORT, and the defaultEffort trap makes retrying
+ * "without the field" useless: the harness substitutes `reasoning.defaultEffort`,
+ * which may itself be unsupported (DSH Desktop volcano-engine adapter declares
+ * defaultEffort=low that its model rejects). So instead of blind retries, ask
+ * the harness for the model's declared capability and pick a value that is
+ * actually accepted — or omit the field entirely when the model declares no
+ * reasoning capability at all.
+ *
+ * @returns a supported effort id, or null when no effort should be sent, or the
+ *   configured value unchanged when the capability query is unavailable.
+ */
+async function resolveDreamEffort(ctx, route, configuredEffort, logger) {
+  if (!configuredEffort || configuredEffort === "none") return null;
+  // Capability query unavailable (older harness / minimal mocks): forward the
+  // configured value as before — absence of the API proves nothing about the
+  // model, and withEffortFallback still guards against rejection.
+  if (typeof ctx?.llm?.resolveModelInfo !== "function") return configuredEffort;
+  try {
+    const info = await ctx.llm.resolveModelInfo(route.provider, route.model);
+    const reasoning = info?.reasoning;
+    if (!reasoning) {
+      // Model declares no reasoning capability: the harness rejects ANY
+      // explicit effort for such a model, and omitting the field is safe
+      // (no reasoning capability → no defaultEffort substitution).
+      logger?.warn?.(`dsh-mneme dream: model ${route.provider}:${route.model} declares no reasoning capability; ignoring configured effort "${configuredEffort}"`);
+      return null;
+    }
+    const supported = reasoning.efforts?.map((effort) => effort.id) ?? [];
+    if (supported.includes(configuredEffort)) return configuredEffort;
+    // Configured effort unsupported → pick defaultEffort if it is supported,
+    // else the first declared effort, so the run never trips
+    // UNSUPPORTED_REASONING_EFFORT (nor the defaultEffort trap: we always
+    // pass an explicit value, so the harness never falls back to a poison
+    // default).
+    const picked = reasoning.defaultEffort && supported.includes(reasoning.defaultEffort)
+      ? reasoning.defaultEffort
+      : supported[0];
+    if (picked) {
+      logger?.warn?.(`dsh-mneme dream: model ${route.provider}:${route.model} does not support effort "${configuredEffort}" (supported: ${supported.join(", ")}); using "${picked}"`);
+      return picked;
+    }
+    return null;
+  } catch (error) {
+    // Capability query failed — forward the configured value; withEffortFallback
+    // still retries on rejection as before.
+    logger?.warn?.(`dsh-mneme dream: resolveModelInfo failed (${String(error?.message ?? error)}); forwarding effort as configured`);
+    return configuredEffort;
+  }
+}
+
 /**
  * Resolve the LLM route (Issue #25): an explicit plugin config
  * (dreamProvider/dreamModel) is the user's declared override and wins; the
@@ -665,7 +719,7 @@ export function createDreamScheduler({ onRun, thresholdCount = 10, thresholdChar
     // （不带该字段），避免 thinking 模型配置 low/medium 直接整单失败。解析放
     // 在 auditError 检查器里、闭包交回主流程，避免二次解析；解析失败同时如实
     // 记 audit error 并在日志带原始输出前 300 字节，便于定位"推理吞预算返回空体"。
-    const effort = config.dreamReasoningEffort && config.dreamReasoningEffort !== "none" ? config.dreamReasoningEffort : null;
+    const effort = await resolveDreamEffort(ctx, route, config.dreamReasoningEffort, logger);
     let decisions = null;
     let streamFailure = "";
     const runConsolidation = (withEffort) => {

package/src/settings.js

@@ -82,6 +82,10 @@ const FEATURE_FLAG_INT_RANGES = {
 const FEATURE_FLAG_STRINGS = [
   "dreamProvider",
   "dreamModel",
+  // 睡眠侧专用路由（sleep.js 的 config-first 第三层）：面板下拉随
+  // /llm-providers 端点一起提供，留空 = 用巩固模型或当前模型。
+  "sleepProvider",
+  "sleepModel",
   "localEmbedModel",
   "ollamaModel"
 ];

package/test/api.test.js

@@ -527,16 +527,18 @@ test("GET /api/dsh-mneme/features returns empty overrides and effective config d
   assert.equal(res.statusCode, 200);
   const data = JSON.parse(res.body);
   assert.deepEqual(data.overrides, {});
-  // effective 覆盖全部 35 个白名单键（含 v0.7.20 heatEnabled、Issue #89 新增
-  // dreamSkipInvalid/allowCrossTypeMerge/dreamMinIntervalMinutes 与本轮补入面板
-  // 的 dreamMaxTokens），未覆盖时取 bundle 配置的解析默认值；
-  // dreamProvider/dreamModel 无 schema 默认值（Config({}) 解析为 undefined），
-  // 不编造给前端 → 35 - 2 = 33
-  assert.equal(Object.keys(data.effective).length, 33);
+  // effective 覆盖全部 37 个白名单键（含 v0.7.20 heatEnabled、Issue #89 新增
+  // dreamSkipInvalid/allowCrossTypeMerge/dreamMinIntervalMinutes、面板可调的
+  // dreamMaxTokens 与本轮睡眠路由 sleepProvider/sleepModel），未覆盖时取
+  // bundle 配置的解析默认值；dreamProvider/dreamModel 无 schema 默认值
+  // （Config({}) 解析为 undefined），不编造给前端 → 37 - 2 = 35
+  assert.equal(Object.keys(data.effective).length, 35);
   assert.equal(data.effective.dreamSkipInvalid, true);
   assert.equal(data.effective.allowCrossTypeMerge, false);
   assert.equal(data.effective.dreamMinIntervalMinutes, 0);
   assert.equal(data.effective.dreamMaxTokens, 32768);
+  assert.equal(data.effective.sleepProvider, "");
+  assert.equal(data.effective.sleepModel, "");
   assert.equal(data.effective.autoInject, true);
   assert.equal(data.effective.codingRetrospect, false);
   assert.equal(data.effective.distillMaxChars, 24000);
@@ -1083,3 +1085,166 @@ test("GET /api/dsh-mneme/list projects per-memory heat only when heatEnabled=tru
     assert.ok(typeof v === "number" && v >= 0 && v <= 1, "heat values stay within [0,1]");
   }
 });
+
+// ---------------------------------------------------------------- llm-providers / test-model
+// Settings-panel support: enumerate host-registered providers/models so the
+// panel can offer a dropdown over real models, and probe connectivity with a
+// minimal LLM call (same harness path the consolidation uses).
+
+function setupLlm(llm, apiToken = "", extraCtx = {}, config = null) {
+  const store = createStore(":memory:");
+  const service = createService({ store, mirror: null, config: {} });
+  const settings = createSettings(store.db);
+  const commands = { add: () => {}, remove: () => {}, list: () => [] };
+  const routes = [];
+  const ctx = {
+    webServer: { register(route) { routes.push(route); return () => {}; } },
+    llm,
+    ...extraCtx
+  };
+  const api = createApi(ctx, service, settings, commands, undefined, undefined, apiToken, config);
+  return { routes };
+}
+
+const MOCK_LLM = {
+  listProviders: () => [
+    { id: "deepseek", name: "DeepSeek" },
+    { id: "broken", name: "Broken Adapter" }
+  ],
+  listModels: async (provider) => {
+    if (provider === "broken") throw new Error("provider not reachable");
+    return [{ id: "deepseek-chat", name: "DeepSeek Chat" }, { id: "deepseek-reasoner", name: "DeepSeek Reasoner" }];
+  },
+  async *stream(options) {
+    MOCK_LLM.lastOptions = options;
+    if (options.model === "bad-model") {
+      yield {
+        type: "finish",
+        reason: { kind: "error", failure: { code: "AUTH_FAILED", message: "invalid api key" } }
+      };
+      return;
+    }
+    if (options.reasoningEffort === "reject") {
+      throw new Error('UNSUPPORTED_REASONING_EFFORT: provider "mock" model "mock-model" does not support reasoning effort "reject"');
+    }
+    yield { type: "text-delta", index: 0, text: " ok " };
+    yield { type: "finish", reason: { kind: "stop" } };
+  }
+};
+
+test("GET /api/dsh-mneme/llm-providers lists host providers with models, per-provider best effort", async () => {
+  const { routes } = setupLlm(MOCK_LLM);
+  const route = routes.find((r) => r.path === "/api/dsh-mneme/llm-providers");
+  const res = new FakeRes();
+  await route.handler(req("/api/dsh-mneme/llm-providers"), res);
+  assert.equal(res.statusCode, 200);
+  const data = JSON.parse(res.body);
+  assert.equal(data.providers.length, 2);
+  const deepseek = data.providers.find((p) => p.provider === "deepseek");
+  assert.deepEqual(deepseek.models.map((m) => m.id), ["deepseek-chat", "deepseek-reasoner"]);
+  const broken = data.providers.find((p) => p.provider === "broken");
+  assert.deepEqual(broken.models, [], "a provider whose model list throws degrades to empty, not a hard fail");
+});
+
+test("GET /api/dsh-mneme/llm-providers without ctx.llm returns 501", async () => {
+  const { routes } = setup();
+  const route = routes.find((r) => r.path === "/api/dsh-mneme/llm-providers");
+  const res = new FakeRes();
+  await route.handler(req("/api/dsh-mneme/llm-providers"), res);
+  assert.equal(res.statusCode, 501);
+  assert.equal(JSON.parse(res.body).error, "llm-unavailable");
+});
+
+test("POST /api/dsh-mneme/test-model succeeds and reports reply + latency", async () => {
+  const { routes } = setupLlm(MOCK_LLM);
+  const route = routes.find((r) => r.path === "/api/dsh-mneme/test-model");
+  const res = new FakeRes();
+  await route.handler(req("/api/dsh-mneme/test-model", "POST", { provider: "deepseek", model: "deepseek-chat" }), res);
+  assert.equal(res.statusCode, 200);
+  const data = JSON.parse(res.body);
+  assert.equal(data.ok, true);
+  assert.equal(data.reply, "ok", "reply trimmed");
+  assert.ok(data.durationMs >= 0);
+  assert.equal(data.modelId, "deepseek:deepseek-chat", "modelId reports the probed route");
+  assert.equal(MOCK_LLM.lastOptions.provider, "deepseek");
+  assert.equal(MOCK_LLM.lastOptions.purpose, "dsh-mneme-connectivity-test");
+  assert.equal("reasoningEffort" in MOCK_LLM.lastOptions, false, "no effort configured -> field omitted");
+});
+
+test("POST /api/dsh-mneme/test-model forwards reasoningEffort verbatim", async () => {
+  const { routes } = setupLlm(MOCK_LLM);
+  const route = routes.find((r) => r.path === "/api/dsh-mneme/test-model");
+  const res = new FakeRes();
+  await route.handler(req("/api/dsh-mneme/test-model", "POST", { provider: "deepseek", model: "deepseek-chat", reasoningEffort: "low" }), res);
+  assert.equal(res.statusCode, 200);
+  assert.equal(MOCK_LLM.lastOptions.reasoningEffort, "low", "effort forwarded to the probe call");
+});
+
+test("POST /api/dsh-mneme/test-model reports stream-level failure with 502", async () => {
+  const { routes } = setupLlm(MOCK_LLM);
+  const route = routes.find((r) => r.path === "/api/dsh-mneme/test-model");
+  const res = new FakeRes();
+  await route.handler(req("/api/dsh-mneme/test-model", "POST", { provider: "deepseek", model: "bad-model" }), res);
+  assert.equal(res.statusCode, 502);
+  const data = JSON.parse(res.body);
+  assert.equal(data.ok, false);
+  assert.match(data.error, /AUTH_FAILED/, "stream failure reason surfaced like audit rows");
+});
+
+test("POST /api/dsh-mneme/test-model reports thrown failure with 502", async () => {
+  const { routes } = setupLlm(MOCK_LLM);
+  const route = routes.find((r) => r.path === "/api/dsh-mneme/test-model");
+  const res = new FakeRes();
+  await route.handler(req("/api/dsh-mneme/test-model", "POST", { provider: "mock", model: "mock-model", reasoningEffort: "reject" }), res);
+  assert.equal(res.statusCode, 502);
+  const data = JSON.parse(res.body);
+  assert.equal(data.ok, false);
+  assert.match(data.error, /UNSUPPORTED_REASONING_EFFORT/, "throw path surfaces the harness rejection");
+});
+
+test("POST /api/dsh-mneme/test-model resolves empty body against the consolidation route", async () => {
+  // Empty provider/model = "test whatever consolidation uses now": the route
+  // falls back to agentDefaultModel (config dreamProvider/dreamModel absent),
+  // the probe runs against that model, and modelId reports what was tested.
+  const { routes } = setupLlm(MOCK_LLM, "", {
+    agentDefaultModel: { currentSelection: () => ({ provider: "sel-provider", model: "sel-model" }) }
+  });
+  const route = routes.find((r) => r.path === "/api/dsh-mneme/test-model");
+  const res = new FakeRes();
+  await route.handler(req("/api/dsh-mneme/test-model", "POST", {}), res);
+  assert.equal(res.statusCode, 200);
+  const data = JSON.parse(res.body);
+  assert.equal(data.ok, true);
+  assert.equal(data.modelId, "sel-provider:sel-model", "probe ran against the resolved consolidation route");
+  assert.equal(MOCK_LLM.lastOptions.provider, "sel-provider");
+  assert.equal(MOCK_LLM.lastOptions.model, "sel-model");
+});
+
+test("POST /api/dsh-mneme/test-model validates input and llm availability", async () => {
+  const { routes } = setupLlm(MOCK_LLM);
+  const route = routes.find((r) => r.path === "/api/dsh-mneme/test-model");
+  let res = new FakeRes();
+  await route.handler(req("/api/dsh-mneme/test-model", "POST", { provider: "deepseek" }), res);
+  assert.equal(res.statusCode, 400, "partial input (provider without model) rejected");
+  assert.equal(JSON.parse(res.body).error, "missing-provider-or-model");
+
+  // empty body with no route (no agentDefaultModel, no config route) -> no-route
+  res = new FakeRes();
+  await route.handler(req("/api/dsh-mneme/test-model", "POST", {}), res);
+  assert.equal(res.statusCode, 400, "empty body with no resolvable route rejected");
+  assert.equal(JSON.parse(res.body).error, "no-route");
+
+  const { routes: routesNoLlm } = setup();
+  const routeNoLlm = routesNoLlm.find((r) => r.path === "/api/dsh-mneme/test-model");
+  res = new FakeRes();
+  await routeNoLlm.handler(req("/api/dsh-mneme/test-model", "POST", { provider: "deepseek", model: "deepseek-chat" }), res);
+  assert.equal(res.statusCode, 501, "no ctx.llm -> llm-unavailable");
+});
+
+test("POST /api/dsh-mneme/test-model is auth-gated like other expensive endpoints", async () => {
+  const { routes } = setupLlm(MOCK_LLM, "secret-token");
+  const route = routes.find((r) => r.path === "/api/dsh-mneme/test-model");
+  const res = new FakeRes();
+  await route.handler(req("/api/dsh-mneme/test-model", "POST", { provider: "deepseek", model: "deepseek-chat" }), res);
+  assert.equal(res.statusCode, 401, "probe spends the user's API quota, so it must require auth");
+});

package/test/client.test.js

@@ -147,7 +147,7 @@ test("sidebar entry portals above the workspaces region with footer fallback", (
     "the portal entry persists across collapse (no footer jump); footer fallback only covers portal failure"
   );
   assert.ok(
-    clientSource.includes('className: `${nativeCls} mneme-topentry-native`'.replace("${nativeCls} mneme-topentry-native", "${nativeCls} mneme-topentry-native")),
+    clientSource.includes('className: `${nativeCls} mneme-topentry-native`'),
     "the entry must reuse the host New-Session button class for native geometry alignment"
   );
   assert.ok(
@@ -466,3 +466,74 @@ test("heat badges render from the /list projection and self-hide when off", () =
     "toggling heat sort must land on the cards view (sort does not apply to the month tree)"
   );
 });
+
+// 巩固/睡眠模型路由 UI：下拉数据来自宿主侧已注册适配器（/llm-providers，
+// 云端插件侧端点），「测试连通性」走 POST /test-model 真实最小调用。旧后端
+// 端点 404 时必须回退纯文本输入——前端自门控，不挡旧版本。
+test("consolidation/sleep model routing: provider dropdowns from /llm-providers, connectivity test via /test-model, graceful fallback", () => {
+  // 1. 端点探测与降级
+  assert.ok(
+    clientSource.includes('apiFetch("/api/dsh-mneme/llm-providers")'),
+    "the features card must probe GET /llm-providers for the route dropdowns"
+  );
+  assert.ok(
+    /setRoutes\(Array\.isArray\(j && j\.providers\) \? j\.providers : \[\]\)/.test(clientSource),
+    "the probe must only accept a {providers: []} shape"
+  );
+  assert.ok(
+    /Array\.isArray\(routes\)\s*\?\s*routeSelects\("dreamProvider", "dreamModel"\)/.test(clientSource),
+    "dream routing must upgrade to dropdowns only when the probe succeeded"
+  );
+  assert.ok(
+    /:\s*h\(react\.Fragment, null, strRow\("dreamProvider"\), strRow\("dreamModel"\)\)/.test(clientSource),
+    "when /llm-providers is unavailable the plain text inputs must remain (old-backend fallback)"
+  );
+  // 2. 睡眠侧行：跟随 sleepModeEnabled 门控，与巩固共用数据源
+  assert.ok(
+    /const sleepSub = eff\.sleepModeEnabled && Array\.isArray\(routes\) && h\("div", \{ className: "mneme-featsub" \},\s*\n\s*routeSelects\("sleepProvider", "sleepModel"\)/.test(clientSource),
+    "the sleep route row must gate on sleepModeEnabled and share the providers source"
+  );
+  // 3. 连通性测试：真实最小调用 + 结果展示（成功/失败 + 耗时 + 报错原因）
+  assert.ok(
+    clientSource.includes('apiFetch("/api/dsh-mneme/test-model", {'),
+    "the connectivity test must POST /test-model"
+  );
+  assert.ok(
+    /body: JSON\.stringify\(\{ provider, model \}\)/.test(clientSource),
+    "the test payload must carry the selected provider/model (empty = follow default route)"
+  );
+  assert.ok(
+    /typeof j\.durationMs === "number" \? j\.durationMs : Date\.now\(\) - started/.test(clientSource),
+    "the result duration must prefer the backend's durationMs and fall back to client timing"
+  );
+  assert.ok(
+    /detail: \[j\.modelId, j\.reply \? "「" \+ j\.reply \+ "」" : ""\]\.filter\(Boolean\)\.join\(" · "\)/.test(clientSource),
+    "the success line must surface the model's actual reply (backend caps it at 100 chars)"
+  );
+  assert.ok(
+    /detail: \[j\.modelId, j\.error \|\| "HTTP " \+ res\.status\]\.filter\(Boolean\)\.join\(" · "\)/.test(clientSource),
+    "the failure line must carry the tested modelId plus the backend error (502/400 bodies)"
+  );
+  assert.ok(
+    clientSource.includes("memory.features.modelTestOk") && clientSource.includes("memory.features.modelTestFail"),
+    "the result line must render success/failure with the localized labels"
+  );
+  // 4. 下拉改动即提交（与 embedProvider 一致），当前值不在枚举时保留为额外选项
+  assert.ok(
+    /setStrs\(\(c\) => \(\{ \.\.\.c, \[key\]: v \}\)\);\s*\n\s*put\(\{ \[key\]: v \}\)/.test(clientSource),
+    "select changes must commit through the features PUT like the embed provider select"
+  );
+  assert.ok(
+    /curM && !mVals\.includes\(curM\) \? h\("option", \{ key: "current", value: curM \}, curM\) : null/.test(clientSource),
+    "a configured value missing from the provider's model list must survive as an extra option"
+  );
+  // 5. 双语 i18n 与样式
+  for (const key of ["routeFollowDefault", "modelTest", "modelTesting", "modelTestOk", "modelTestFail", "sleepModelHint"]) {
+    const occurrences = clientSource.split(`"memory.features.${key}"`).length - 1;
+    assert.ok(occurrences >= 2, `i18n key memory.features.${key} must exist in both zh and en (got ${occurrences})`);
+  }
+  assert.ok(
+    clientSource.includes(".mneme-routeselect{width:240px;max-width:60%}"),
+    "the route selects must share the string-input width budget"
+  );
+});