@modusensus/dsh-mneme 0.4.2 → 0.4.3

package/README.md

@@ -54,6 +54,18 @@
 - **Fail-safe**：非法 LLM 输出（未知 id / 非法 action / 跨类型合并 / 越界 importance）拒绝整单，绝不破坏记忆库
 - **裁决审计**：每次运行写入 `dream_runs` 审计表（输入快照 sha256 digest + 完整输入快照 + 决策清单 + 逐 id 去向 + receipt），可离线回放；merge / conflict / update 幂等应用，重放/并发重复执行无累积副作用；update 记录 `_before` 快照
 
+#### dreamMaxTokens 调优指南
+
+默认 `4096` 已覆盖常规记忆库。当**记忆量大**（数万字符以上）时，决策清单与摘要可能超过默认预算，建议按规模调大：
+
+| 记忆库规模 | 建议 `dreamMaxTokens` |
+|-----------|----------------------|
+| 常规（<1 万字） | `4096`（默认） |
+| 中等（1 万-5 万字） | `65536` |
+| 大型（5 万字以上） | `131072`（上限） |
+
+> 若使用**思考型模型**（如 DeepSeek-R1 类），模型可能把全部预算花在 reasoning 上导致正文为空（日志出现 `no json array in llm output`）。此时把 `dreamReasoningEffort` 设为 `low` 可压制推理开销、把预算留给正文输出；sleep 侧对应 `sleepReasoningEffort`。默认 `none` 不传该字段，完全沿用模型自身默认，行为与旧版本一致。
+
 ### Sleep Mode 系统级睡眠 💤（v0.4.0，opt-in）
 
 从 autoDream 的"被动阈值触发"升级为"主动定时维护 + 分层压缩"。系统空闲 `sleepIdleMinutes` 分钟自动执行深度维护，**默认关闭**（`sleepModeEnabled: false`），开启后行为：
@@ -149,6 +161,7 @@ v0.3.0 起新增**记忆基因**层：从记忆里抽取**命名实体**、**带
 | v0.3.9 | ✅ 完成 | 审计加固 A/B/D/F | compareAndUpdate 同事务原子性、degraded 回执、逐 type 物理终态、整数 fail-closed、并发初始化稳定 |
 | **v0.4.0** | ✅ 完成 | 系统级睡眠 Sleep Mode | 空闲触发的四阶段深度维护（冲突消解 / 归档降级 / 模式发现 / 关系补全）、分层压缩、可中断串行 fail-safe；471 测试全绿 |
 | **v0.4.2** | ✅ 完成 | autoSummarize 自定义模型 | `summarizeProvider`/`summarizeModel` 配置项支持，可独立指定轻量模型（如 qwen3.6-plus）用于会话摘要，节省主模型 token；473 测试全绿 |
+| **v0.4.3** | ✅ 完成 | autoDream 大记忆量修复 | issue#9 B+A：`dreamMaxTokens` 上限 32768→131072 + `dreamReasoningEffort`/`sleepReasoningEffort` 思考开关（none 默认，主对话不受影响）；478 测试全绿 |
 | **v0.5.0+** | 🚀 远期 | 自进化记忆 | 兴趣漂移跟踪 + 跨 workspace 记忆共享（等 DSH 支持） |
 
 > 新能力一律做成**可开关的功能**（配置启用/关闭），默认保守开启、不破坏现有行为。`failure_memories` 表与 autoDream 决策引擎已为后续反思性成长铺好路。
@@ -219,7 +232,8 @@ dsh web
 | `dreamThresholdChars` | `5000` | 触发整理的总字符阈值 |
 | `dreamDelayMs` | `2000` | 整理异步延迟（去抖） |
 | `dreamProvider` / `dreamModel` | 空 | dream 的 LLM 路由回退（默认用 agent 默认模型） |
-| `dreamMaxTokens` | `4096` | dream LLM 调用最大 token 数 |
+| `dreamMaxTokens` | `4096` | dream LLM 调用最大 token 数（上限 131072；大记忆量建议调大，见下方调优指南） |
+| `dreamReasoningEffort` | `none` | dream LLM 推理强度透传：`low` / `medium` / `high` / `none`（`none`=不传该字段，使用模型默认；思考型模型预算被推理耗尽导致正文为空时可设 `low`） |
 | `apiToken` | 空 | 可选 API 鉴权 token；设置后写操作与密钥接口要求 `Authorization: Bearer <apiToken>` |
 | `embedProvider` | `openai` | 语义后端：`openai`（默认，兼容 v0.1）/ `local`（ONNX 离线）/ `ollama` |
 | `localEmbedModel` | `Xenova/bge-small-zh-v1.5` | 本地 ONNX embedding 模型 |

package/lib/config.js

@@ -17,7 +17,18 @@ export const Config = z.object({
   dreamDelayMs: z.natural().min(0).max(60000).default(2000),
   dreamProvider: z.string(),
   dreamModel: z.string(),
-  dreamMaxTokens: z.natural().min(256).max(32768).default(4096),
+  dreamMaxTokens: z.natural().min(256).max(131072).default(4096),
+  // 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").
+  dreamReasoningEffort: z.union([
+    z.const("low"),
+    z.const("medium"),
+    z.const("high"),
+    z.const("none")
+  ]).default("none"),
   // Rule version for dream adjudication: when this bumps, older dream_runs
   // degrade to historical evidence (their receipts no longer drive live
   // decisions). Default 0 = no versioning in use yet.
@@ -134,4 +145,13 @@ export const Config = z.object({
   // route / agent default model).
   sleepProvider: z.string().default(""),
   sleepModel: z.string().default(""),
+  // Pass-through reasoning effort for sleep's LLM passes, same semantics as
+  // dreamReasoningEffort: 'none' (default) omits the field; low/medium/high
+  // are forwarded verbatim.
+  sleepReasoningEffort: z.union([
+    z.const("low"),
+    z.const("medium"),
+    z.const("high"),
+    z.const("none")
+  ]).default("none"),
 });

package/lib/dream/sleep.js

@@ -187,6 +187,9 @@ async function phaseConflicts(ctx, service, config, logger, runId, semantic = nu
     model: route.model,
     purpose: "sleep-conflict",
     maxTokens: 2048,
+    ...(config.sleepReasoningEffort && config.sleepReasoningEffort !== "none"
+      ? { reasoningEffort: config.sleepReasoningEffort }
+      : {}),
     messages: [
       { role: "system", content: [{ type: "text", text: CONFLICT_PROMPT }] },
       { role: "user", content: [{ type: "text", text: listText }] }
@@ -286,6 +289,9 @@ async function phasePatterns(ctx, service, config, logger, runId, signal = null)
     model: route.model,
     purpose: "sleep-pattern",
     maxTokens: 2048,
+    ...(config.sleepReasoningEffort && config.sleepReasoningEffort !== "none"
+      ? { reasoningEffort: config.sleepReasoningEffort }
+      : {}),
     messages: [
       { role: "system", content: [{ type: "text", text: PATTERN_PROMPT.replace("N", String(maxPatterns)) }] },
       { role: "user", content: [{ type: "text", text: listText }] }

package/lib/dream.js

@@ -457,6 +457,9 @@ export function createDreamScheduler({ onRun, thresholdCount = 10, thresholdChar
         model: route.model,
         purpose: "compaction",
         maxTokens: config.dreamMaxTokens ?? 4096,
+        ...(config.dreamReasoningEffort && config.dreamReasoningEffort !== "none"
+          ? { reasoningEffort: config.dreamReasoningEffort }
+          : {}),
         messages: [
           { role: "system", content: [{ type: "text", text: consolidationPrompt }] },
           { role: "user", content: [{ type: "text", text: listText }] }
@@ -600,6 +603,9 @@ export function createDreamScheduler({ onRun, thresholdCount = 10, thresholdChar
         model: route.model,
         purpose: "compaction",
         maxTokens: config.dreamMaxTokens ?? 2048,
+        ...(config.dreamReasoningEffort && config.dreamReasoningEffort !== "none"
+          ? { reasoningEffort: config.dreamReasoningEffort }
+          : {}),
         messages: [
           { role: "system", content: [{ type: "text", text: SUMMARY_PROMPT }] },
           { role: "user", content: [{ type: "text", text: service.all().filter((m) => !m.archived && m.type !== "summary").map((m) => `- ${m.title}: ${m.content}`).join("\n") }] }

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.4.2",
+  "version": "0.4.3",
   "license": "MIT",
   "type": "module",
   "main": "lib/index.js",
@@ -64,4 +64,4 @@
   "overrides": {
     "adm-zip": "0.6.0"
   }
-}
+}

package/src/config.js

@@ -17,7 +17,18 @@ export const Config = z.object({
   dreamDelayMs: z.natural().min(0).max(60000).default(2000),
   dreamProvider: z.string(),
   dreamModel: z.string(),
-  dreamMaxTokens: z.natural().min(256).max(32768).default(4096),
+  dreamMaxTokens: z.natural().min(256).max(131072).default(4096),
+  // 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").
+  dreamReasoningEffort: z.union([
+    z.const("low"),
+    z.const("medium"),
+    z.const("high"),
+    z.const("none")
+  ]).default("none"),
   // Rule version for dream adjudication: when this bumps, older dream_runs
   // degrade to historical evidence (their receipts no longer drive live
   // decisions). Default 0 = no versioning in use yet.
@@ -134,4 +145,13 @@ export const Config = z.object({
   // route / agent default model).
   sleepProvider: z.string().default(""),
   sleepModel: z.string().default(""),
+  // Pass-through reasoning effort for sleep's LLM passes, same semantics as
+  // dreamReasoningEffort: 'none' (default) omits the field; low/medium/high
+  // are forwarded verbatim.
+  sleepReasoningEffort: z.union([
+    z.const("low"),
+    z.const("medium"),
+    z.const("high"),
+    z.const("none")
+  ]).default("none"),
 });

package/src/dream/sleep.js

@@ -187,6 +187,9 @@ async function phaseConflicts(ctx, service, config, logger, runId, semantic = nu
     model: route.model,
     purpose: "sleep-conflict",
     maxTokens: 2048,
+    ...(config.sleepReasoningEffort && config.sleepReasoningEffort !== "none"
+      ? { reasoningEffort: config.sleepReasoningEffort }
+      : {}),
     messages: [
       { role: "system", content: [{ type: "text", text: CONFLICT_PROMPT }] },
       { role: "user", content: [{ type: "text", text: listText }] }
@@ -286,6 +289,9 @@ async function phasePatterns(ctx, service, config, logger, runId, signal = null)
     model: route.model,
     purpose: "sleep-pattern",
     maxTokens: 2048,
+    ...(config.sleepReasoningEffort && config.sleepReasoningEffort !== "none"
+      ? { reasoningEffort: config.sleepReasoningEffort }
+      : {}),
     messages: [
       { role: "system", content: [{ type: "text", text: PATTERN_PROMPT.replace("N", String(maxPatterns)) }] },
       { role: "user", content: [{ type: "text", text: listText }] }

package/src/dream.js

@@ -457,6 +457,9 @@ export function createDreamScheduler({ onRun, thresholdCount = 10, thresholdChar
         model: route.model,
         purpose: "compaction",
         maxTokens: config.dreamMaxTokens ?? 4096,
+        ...(config.dreamReasoningEffort && config.dreamReasoningEffort !== "none"
+          ? { reasoningEffort: config.dreamReasoningEffort }
+          : {}),
         messages: [
           { role: "system", content: [{ type: "text", text: consolidationPrompt }] },
           { role: "user", content: [{ type: "text", text: listText }] }
@@ -600,6 +603,9 @@ export function createDreamScheduler({ onRun, thresholdCount = 10, thresholdChar
         model: route.model,
         purpose: "compaction",
         maxTokens: config.dreamMaxTokens ?? 2048,
+        ...(config.dreamReasoningEffort && config.dreamReasoningEffort !== "none"
+          ? { reasoningEffort: config.dreamReasoningEffort }
+          : {}),
         messages: [
           { role: "system", content: [{ type: "text", text: SUMMARY_PROMPT }] },
           { role: "user", content: [{ type: "text", text: service.all().filter((m) => !m.archived && m.type !== "summary").map((m) => `- ${m.title}: ${m.content}`).join("\n") }] }

package/test/reasoning-effort.test.js

@@ -0,0 +1,172 @@
+// Regression for issue #9:
+//  - B: dreamMaxTokens cap widened (min 256, max 131072) so large memory
+//    libraries no longer starve the consolidation output.
+//  - A: dreamReasoningEffort / sleepReasoningEffort pass-through. Default
+//    'none' must OMIT the reasoningEffort field entirely (the provider's own
+//    default applies); low/medium/high are forwarded verbatim on every dream /
+//    sleep LLM call. Asserted by capturing the options each llm.stream() sees.
+import test from "node:test";
+import assert from "node:assert/strict";
+import { Config } from "../src/config.js";
+import { createDreamScheduler } from "../src/dream.js";
+import { runSleep } from "../src/dream/sleep.js";
+import { createStore } from "../src/store.js";
+import { createService } from "../src/service.js";
+import { createVectorIndex } from "../src/vector-index.js";
+
+const embedder = {
+  embedSingle: async () => [1, 0, 0],
+  embed: async () => [1, 0, 0],
+  schedule: () => {},
+  modelHash: "mock#1",
+  dimension: 3
+};
+
+// ---------------------------------------------------------------- config schema
+
+test("issue#9: dreamMaxTokens accepts the widened 131072 cap and defaults to 4096", () => {
+  assert.equal(Config({}).dreamMaxTokens, 4096, "default unchanged");
+  assert.equal(Config({ dreamMaxTokens: 131072 }).dreamMaxTokens, 131072, "new upper bound accepted");
+  assert.equal(Config({ dreamMaxTokens: 65536 }).dreamMaxTokens, 65536, "intermediate value accepted");
+});
+
+test("issue#9: reasoningEffort config defaults to none and rejects unknown values", () => {
+  const cfg = Config({});
+  assert.equal(cfg.dreamReasoningEffort, "none");
+  assert.equal(cfg.sleepReasoningEffort, "none");
+  assert.equal(Config({ dreamReasoningEffort: "high" }).dreamReasoningEffort, "high");
+  assert.equal(Config({ sleepReasoningEffort: "medium" }).sleepReasoningEffort, "medium");
+  assert.throws(() => Config({ dreamReasoningEffort: "bogus" }), "invalid effort rejected");
+  assert.throws(() => Config({ sleepReasoningEffort: "ultra" }), "invalid effort rejected");
+});
+
+// ---------------------------------------------------------------- dream passthrough
+
+/** dream ctx that records every llm.stream() call's options for inspection. */
+function dreamCtx({ onConsolidation, summaryText = "记忆库总览：用户偏好中文。", captured = [] } = {}) {
+  return {
+    logger: { warn: () => {} },
+    agentDefaultModel: { currentSelection: () => ({ provider: "mock", model: "mock-model" }) },
+    llm: {
+      async *stream(options) {
+        captured.push(options);
+        const userText = options.messages.find((m) => m.role === "user")?.content?.[0]?.text ?? "";
+        if (userText.startsWith("id=")) {
+          yield { type: "text-delta", index: 0, text: onConsolidation ? onConsolidation(userText) : "[]" };
+        } else {
+          yield { type: "text-delta", index: 0, text: summaryText };
+        }
+        yield { type: "finish", reason: { kind: "stop" } };
+      }
+    }
+  };
+}
+
+test("issue#9: dream omits reasoningEffort under default 'none' and still consolidates (applied>0)", async () => {
+  const store = createStore(":memory:");
+  const service = createService({ store, mirror: null, config: {} });
+  const dream = createDreamScheduler({ onRun: () => Promise.resolve({ ok: true, skipped: true }) });
+  const { memory: a } = service.saveWithDedupe({ type: "project", title: "插件", content: "旧", importance: 3 });
+  const { memory: b } = service.saveWithDedupe({ type: "project", title: "插件2", content: "新细节", importance: 4 });
+  const captured = [];
+  const ctx = dreamCtx({
+    captured,
+    onConsolidation: () => JSON.stringify([
+      { action: "merge", ids: [a.id, b.id], keepSource: b.id, title: "插件总览", content: "合并内容", importance: 4 }
+    ])
+  });
+  const result = await dream.runDream(ctx, service, {});
+  assert.equal(result.ok, true);
+  assert.ok(result.applied > 0, "end-to-end dream run still lands changes");
+  assert.equal(captured.length, 2, "consolidation + summary both hit the LLM");
+  for (const options of captured) {
+    assert.equal("reasoningEffort" in options, false, `default 'none' must not forward reasoningEffort (${options.purpose})`);
+  }
+  store.close();
+});
+
+test("issue#9: dream forwards dreamReasoningEffort on both LLM calls", async () => {
+  const store = createStore(":memory:");
+  const service = createService({ store, mirror: null, config: {} });
+  const dream = createDreamScheduler({ onRun: () => Promise.resolve({ ok: true, skipped: true }) });
+  const { memory: a } = service.saveWithDedupe({ type: "project", title: "插件", content: "旧", importance: 3 });
+  const { memory: b } = service.saveWithDedupe({ type: "project", title: "插件2", content: "新细节", importance: 4 });
+  const captured = [];
+  const ctx = dreamCtx({
+    captured,
+    onConsolidation: () => JSON.stringify([
+      { action: "merge", ids: [a.id, b.id], keepSource: b.id, title: "插件总览", content: "合并内容", importance: 4 }
+    ])
+  });
+  const result = await dream.runDream(ctx, service, { dreamReasoningEffort: "high" });
+  assert.equal(result.ok, true);
+  assert.equal(captured.length, 2);
+  for (const options of captured) {
+    assert.equal(options.reasoningEffort, "high", `reasoningEffort forwarded on ${options.purpose}`);
+  }
+  store.close();
+});
+
+// ---------------------------------------------------------------- sleep passthrough
+
+function sleepSetup() {
+  const store = createStore(":memory:");
+  const service = createService({ store, mirror: null, config: {} });
+  const vectorIndex = createVectorIndex({ store });
+  service.setEmbedder(embedder);
+  service.setVectorIndex(vectorIndex);
+  return { store, service, vectorIndex };
+}
+
+function baseConfig(overrides = {}) {
+  return {
+    sleepModeEnabled: true,
+    sleepIdleMinutes: 5,
+    sleepMinIntervalHours: 8,
+    sleepConflictStrictness: "normal",
+    sleepArchiveDays: 30,
+    sleepCompressDays: 90,
+    sleepPatternMinMemories: 10,
+    sleepMaxPatternPerRun: 3,
+    ...overrides
+  };
+}
+
+/** sleep ctx that records every llm.stream() call's options. */
+function sleepCtx(onConsolidation, selection = { provider: "mock", model: "sleep-model" }, captured = []) {
+  return {
+    logger: { warn: () => {}, info: () => {} },
+    agentDefaultModel: { currentSelection: () => selection },
+    llm: {
+      async *stream(options) {
+        captured.push(options);
+        const userText = options.messages.find((m) => m.role === "user")?.content?.[0]?.text ?? "";
+        yield { type: "text-delta", index: 0, text: onConsolidation ? onConsolidation(userText) : "[]" };
+        yield { type: "finish", reason: { kind: "stop" } };
+      }
+    }
+  };
+}
+
+test("issue#9: sleep forwards sleepReasoningEffort on its LLM passes", async () => {
+  const { store, service, vectorIndex } = sleepSetup();
+  const a = service.saveWithDedupe({ type: "project", title: "主题X", content: "内容A 关于主题X", importance: 3 }).memory;
+  const b = service.saveWithDedupe({ type: "project", title: "主题X副本", content: "内容B 关于主题X", importance: 3 }).memory;
+  vectorIndex.saveEmbedding(a.id, [1, 0, 0]);
+  vectorIndex.saveEmbedding(b.id, [1, 0, 0]);
+  const captured = [];
+  const ctx = sleepCtx(
+    (userText) => userText.startsWith("候选冲突")
+      ? JSON.stringify([{ action: "conflict", winner: a.id, loser: b.id, reason: "重复覆盖" }])
+      : "[]",
+    { provider: "mock", model: "sleep-model" },
+    captured
+  );
+  const result = await runSleep(ctx, service, baseConfig({ sleepReasoningEffort: "medium" }), ctx.logger, { embedder, vectorIndex }, null);
+  assert.equal(result.status, "ok");
+  assert.ok(captured.length >= 2, "conflict + pattern passes both hit the LLM");
+  for (const options of captured) {
+    assert.equal(options.reasoningEffort, "medium", `reasoningEffort forwarded on ${options.purpose}`);
+  }
+  store.close();
+});