@modusensus/dsh-mneme 0.7.24 → 0.7.26

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/lib/tools.js

@@ -1,6 +1,10 @@
 import { defineTool } from "@deepseek-ai/dsh-tools";
 
 const TEXT_OUTPUT = (text) => [{ type: "text", text }];
+// Per-registry tool-name registry: guards against duplicate registration on
+// live patch reload (DSH Desktop `patchReload: "live"`) where a plugin may be
+// re-applied on the same tools registry without an intervening unregister.
+const REGISTERED_TOOLS = new WeakMap();
 
 // Wire shape emitted by service.toApiList: shared by memory_search and
 // memory_list so their output schemas always declare every key the runtime
@@ -22,6 +26,12 @@ const MEMORY_ITEM_SCHEMA = {
 };
 
 export function createTools(ctx, service, config, embedder) {
+  const toolsRegistry = ctx.tools;
+  let registeredTools = REGISTERED_TOOLS.get(toolsRegistry);
+  if (!registeredTools) {
+    registeredTools = new Set();
+    REGISTERED_TOOLS.set(toolsRegistry, registeredTools);
+  }
   const tools = [
     defineTool({
       name: "memory_save",
@@ -82,7 +92,18 @@ export function createTools(ctx, service, config, embedder) {
             }
           }
         },
-        render: (_args, value) => TEXT_OUTPUT(`Found ${value.items.length} memory entr${value.items.length === 1 ? "y" : "ies"}.`)
+        render: (_args, value) => {
+          const items = value.items ?? [];
+          if (items.length === 0) return TEXT_OUTPUT("No memory entries found.");
+          const body = items
+            .map((m, i) => {
+              const preview = (m.content ?? "").replace(/\s+/g, " ").trim();
+              const cut = preview.length > 200 ? `${preview.slice(0, 200)}…` : preview;
+              return `[${i + 1}] ${m.title}\n    ID: ${m.id} | type: ${m.type} | importance: ${m.importance} | updated: ${m.updated_at}\n    ${cut}`;
+            })
+            .join("\n\n");
+          return TEXT_OUTPUT(`Found ${items.length} memory entr${items.length === 1 ? "y" : "ies"}:\n\n${body}`);
+        }
       },
       async execute(args) {
         const limit = args.limit ?? 20;
@@ -117,7 +138,14 @@ export function createTools(ctx, service, config, embedder) {
             total: { type: "integer", required: true }
           }
         },
-        render: (_args, value) => TEXT_OUTPUT(`${value.items.length} memory entries (of ${value.total}).`)
+        render: (_args, value) => {
+          const items = value.items ?? [];
+          if (items.length === 0) return TEXT_OUTPUT(`0 memory entries (of ${value.total}).`);
+          const body = items
+            .map((m, i) => `[${i + 1}] ${m.title} (type=${m.type}, importance=${m.importance})\n    ID: ${m.id} | updated: ${m.updated_at}`)
+            .join("\n\n");
+          return TEXT_OUTPUT(`${items.length} memory entries (of ${value.total}):\n\n${body}`);
+        }
       },
       async execute(args) {
         const includeArchived = args.include_archived === true;
@@ -131,6 +159,46 @@ export function createTools(ctx, service, config, embedder) {
       }
     }),
 
+    defineTool({
+      name: "memory_get",
+      description: "Fetch one memory entry by ID and return its full content as text. Use after memory_list to read a specific entry.",
+      parameters: {
+        id: { type: "string", required: true, description: "Memory id" }
+      },
+      output: {
+        schema: {
+          type: "object",
+          additionalProperties: false,
+          properties: {
+            memory: {
+              type: "object",
+              additionalProperties: false,
+              properties: {
+                id: { type: "string", required: true },
+                title: { type: "string", required: true },
+                type: { type: "string", required: true },
+                importance: { type: "integer", required: true },
+                tags: { type: "array", items: { type: "string" } },
+                content: { type: "string", required: true },
+                source: { type: "string" },
+                created_at: { type: "string" },
+                updated_at: { type: "string" }
+              }
+            }
+          }
+        },
+        render: (_args, value) => {
+          const m = value.memory;
+          return TEXT_OUTPUT(`${m.title}\nID: ${m.id} | type: ${m.type} | importance: ${m.importance}\n\n${m.content}`);
+        }
+      },
+      async execute(args) {
+        const memory = service.getById(args.id);
+        if (memory === undefined) throw new Error("memory not found");
+        return { memory: service.toApiList([memory])[0] };
+      }
+    }),
+
     defineTool({
       name: "memory_update",
       description: "Modify an existing memory entry (title, content, type, tags, importance).",
@@ -267,7 +335,12 @@ export function createTools(ctx, service, config, embedder) {
   ];
 
   for (const tool of tools) {
-    ctx.tools.register(tool);
+          if (registeredTools.has(tool.name)) {
+        ctx.logger?.warn?.(`[dsh-mneme] tool "${tool.name}" already registered, skipping duplicate`);
+        continue;
+      }
+      registeredTools.add(tool.name);
+      ctx.tools.register(tool);
   }
 
   return tools;

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.24",
+  "version": "0.7.26",
   "license": "MIT",
   "repository": {
     "type": "git",
@@ -37,9 +37,7 @@
     "client": {
       "inject": [
         "slots",
-        "locale",
-        "layout",
-        "connection"
+        "locale"
       ],
       "platform": "web"
     },
@@ -54,7 +52,7 @@
     "@deepseek-ai/dsh-system-prompt": "^0.1.0-rc.6",
     "@deepseek-ai/dsh-tools": "^0.1.0-rc.6",
     "@deepseek-ai/schemastery": "^3.18.1",
-    "dsh-better-sidebar": "*"
+    "dsh-better-sidebar": "^0.18.0"
   },
   "peerDependenciesMeta": {
     "dsh-better-sidebar": {

package/src/api-standalone.js

@@ -16,6 +16,46 @@ const DEFAULT_HOST = "127.0.0.1";
 // Hardcoded release version (package.json is bumped at publish time and may
 // lag the code that ships in between).
 const VERSION = "0.7.12";
+const MAX_PORT_ATTEMPTS = 20;
+
+/**
+ * Listen with automatic EADDRINUSE recovery. Tries the configured port, then
+ * the next MAX_PORT_ATTEMPTS-1 ports, and finally falls back to port 0 so the
+ * OS assigns a free port. Multiple DSH profiles/instances sharing the default
+ * port no longer leave the standalone API permanently unavailable.
+ */
+function listenWithRetry(server, startPort, host, logger) {
+  return new Promise((resolve, reject) => {
+    let attempt = 0;
+    const tryListen = (port) => {
+      const onListening = () => {
+        server.off("error", onError);
+        const address = server.address();
+        resolve(address && typeof address === "object" ? address.port : port);
+      };
+      const onError = (error) => {
+        server.off("listening", onListening);
+        if (error?.code === "EADDRINUSE" && attempt < MAX_PORT_ATTEMPTS - 1) {
+          attempt++;
+          const next = startPort + attempt;
+          logger?.warn?.(`[dsh-mneme] standalone API port ${port} in use, retrying ${next}`);
+          tryListen(next);
+          return;
+        }
+        if (error?.code === "EADDRINUSE") {
+          logger?.warn?.(`[dsh-mneme] standalone API port ${port} still in use, falling back to OS-assigned port`);
+          tryListen(0);
+          return;
+        }
+        reject(error);
+      };
+      server.once("listening", onListening);
+      server.once("error", onError);
+      server.listen(port, host);
+    };
+    tryListen(startPort);
+  });
+}
 
 function sendJson(res, status, payload) {
   res.writeHead(status, { "Content-Type": "application/json; charset=utf-8" });
@@ -243,10 +283,10 @@ export function createStandaloneApi({ service, store, config = {}, logger, setti
     logger?.warn?.(`[dsh-mneme] standalone API error: ${String(error)}`);
   });
   const ready = new Promise((resolve, reject) => {
-    server.once("listening", resolve);
-    server.once("error", reject);
+    // listening handled by listenWithRetry
+    listenWithRetry(server, boundPort, boundHost, logger).then(resolve, reject);
   });
-  server.listen(boundPort, boundHost);
+  // server.listen is called inside listenWithRetry
   ready.then(() => {
     const address = server.address();
     if (address && typeof address === "object") {

package/src/config.js

@@ -52,20 +52,33 @@ export const Config = z.object({
   // 起算，失败/degraded 的 run 也占用间隔；间隔内的触发请求静默跳过，下一次
   // 写入事件会重新评估。
   dreamMinIntervalMinutes: z.natural().min(0).max(10080).default(0),
-  dreamProvider: z.string(),
-  dreamModel: z.string(),
+  // 巩固模型路由（settings panel「巩固模型」/ dreamProvider+dreamModel）：
+  // dream 的记忆沉淀专用 LLM 路由，显式配置优先于 agent 默认模型（config-first，
+  // Issue #25）。模型分类声明：
+  //   - 非思考模型（推荐，如 glm-5-2 类）：无 reasoning 声明，effort 请求被 harness
+  //     拒绝后 withEffortFallback 去掉字段重试即成功；空体/no json array 风险最低。
+  //   - 思考模型（如 deepseek-v4-flash-ga 等 v4-flash-ga 系）：默认开推理，可能烧光
+  //     token 预算返回空体；且部分（如 v4-flash-ga）在 harness 侧被声明为不接受任何
+  //     reasoning effort —— 即使去掉 effort 重试，harness 的 defaultEffort 也会顶上来
+  //     再次拒绝（UNSUPPORTED_REASONING_EFFORT），插件 fallback 无法绕开。
+  //     选用时建议配 dreamReasoningEffort 并实测；不行就换非思考模型。
+  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
   // are forwarded verbatim. Useful to cap reasoning spend on thinking-type
   // models that would otherwise drain the whole token budget and return an
   // empty body ("no json array in llm output").
+  // Caveat: on some thinking models (e.g. v4-flash-ga) the harness declares NO
+  // supported effort, so even the fallback retry (field stripped) is rejected
+  // again via its defaultEffort — prefer a non-reasoning dreamProvider/dreamModel.
   dreamReasoningEffort: z.union([
     z.const("low"),
     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。
@@ -238,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.
@@ -248,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 };
 
 
 // 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/src/tools.js

@@ -1,6 +1,10 @@
 import { defineTool } from "@deepseek-ai/dsh-tools";
 
 const TEXT_OUTPUT = (text) => [{ type: "text", text }];
+// Per-registry tool-name registry: guards against duplicate registration on
+// live patch reload (DSH Desktop `patchReload: "live"`) where a plugin may be
+// re-applied on the same tools registry without an intervening unregister.
+const REGISTERED_TOOLS = new WeakMap();
 
 // Wire shape emitted by service.toApiList: shared by memory_search and
 // memory_list so their output schemas always declare every key the runtime
@@ -22,6 +26,12 @@ const MEMORY_ITEM_SCHEMA = {
 };
 
 export function createTools(ctx, service, config, embedder) {
+  const toolsRegistry = ctx.tools;
+  let registeredTools = REGISTERED_TOOLS.get(toolsRegistry);
+  if (!registeredTools) {
+    registeredTools = new Set();
+    REGISTERED_TOOLS.set(toolsRegistry, registeredTools);
+  }
   const tools = [
     defineTool({
       name: "memory_save",
@@ -82,7 +92,18 @@ export function createTools(ctx, service, config, embedder) {
             }
           }
         },
-        render: (_args, value) => TEXT_OUTPUT(`Found ${value.items.length} memory entr${value.items.length === 1 ? "y" : "ies"}.`)
+        render: (_args, value) => {
+          const items = value.items ?? [];
+          if (items.length === 0) return TEXT_OUTPUT("No memory entries found.");
+          const body = items
+            .map((m, i) => {
+              const preview = (m.content ?? "").replace(/\s+/g, " ").trim();
+              const cut = preview.length > 200 ? `${preview.slice(0, 200)}…` : preview;
+              return `[${i + 1}] ${m.title}\n    ID: ${m.id} | type: ${m.type} | importance: ${m.importance} | updated: ${m.updated_at}\n    ${cut}`;
+            })
+            .join("\n\n");
+          return TEXT_OUTPUT(`Found ${items.length} memory entr${items.length === 1 ? "y" : "ies"}:\n\n${body}`);
+        }
       },
       async execute(args) {
         const limit = args.limit ?? 20;
@@ -117,7 +138,14 @@ export function createTools(ctx, service, config, embedder) {
             total: { type: "integer", required: true }
           }
         },
-        render: (_args, value) => TEXT_OUTPUT(`${value.items.length} memory entries (of ${value.total}).`)
+        render: (_args, value) => {
+          const items = value.items ?? [];
+          if (items.length === 0) return TEXT_OUTPUT(`0 memory entries (of ${value.total}).`);
+          const body = items
+            .map((m, i) => `[${i + 1}] ${m.title} (type=${m.type}, importance=${m.importance})\n    ID: ${m.id} | updated: ${m.updated_at}`)
+            .join("\n\n");
+          return TEXT_OUTPUT(`${items.length} memory entries (of ${value.total}):\n\n${body}`);
+        }
       },
       async execute(args) {
         const includeArchived = args.include_archived === true;
@@ -131,6 +159,46 @@ export function createTools(ctx, service, config, embedder) {
       }
     }),
 
+    defineTool({
+      name: "memory_get",
+      description: "Fetch one memory entry by ID and return its full content as text. Use after memory_list to read a specific entry.",
+      parameters: {
+        id: { type: "string", required: true, description: "Memory id" }
+      },
+      output: {
+        schema: {
+          type: "object",
+          additionalProperties: false,
+          properties: {
+            memory: {
+              type: "object",
+              additionalProperties: false,
+              properties: {
+                id: { type: "string", required: true },
+                title: { type: "string", required: true },
+                type: { type: "string", required: true },
+                importance: { type: "integer", required: true },
+                tags: { type: "array", items: { type: "string" } },
+                content: { type: "string", required: true },
+                source: { type: "string" },
+                created_at: { type: "string" },
+                updated_at: { type: "string" }
+              }
+            }
+          }
+        },
+        render: (_args, value) => {
+          const m = value.memory;
+          return TEXT_OUTPUT(`${m.title}\nID: ${m.id} | type: ${m.type} | importance: ${m.importance}\n\n${m.content}`);
+        }
+      },
+      async execute(args) {
+        const memory = service.getById(args.id);
+        if (memory === undefined) throw new Error("memory not found");
+        return { memory: service.toApiList([memory])[0] };
+      }
+    }),
+
     defineTool({
       name: "memory_update",
       description: "Modify an existing memory entry (title, content, type, tags, importance).",
@@ -267,7 +335,12 @@ export function createTools(ctx, service, config, embedder) {
   ];
 
   for (const tool of tools) {
-    ctx.tools.register(tool);
+          if (registeredTools.has(tool.name)) {
+        ctx.logger?.warn?.(`[dsh-mneme] tool "${tool.name}" already registered, skipping duplicate`);
+        continue;
+      }
+      registeredTools.add(tool.name);
+      ctx.tools.register(tool);
   }
 
   return tools;

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);

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(
@@ -235,7 +235,7 @@ test("better-sidebar tab mounts via an inner sub-plugin, standalone mode intact"
     "the inner apply must still guard the service shape before registering"
   );
   assert.ok(
-    /id: "dsh-mneme:memory"/.test(clientSource),
+    /(?:const TAB_ID = |id: )"dsh-mneme:memory"/.test(clientSource),
     "the registered tab id must be package-prefixed"
   );
   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"
+  );
+});