@modusensus/dsh-mneme 0.4.3 → 0.4.4

package/README.md

@@ -162,6 +162,7 @@ v0.3.0 起新增**记忆基因**层：从记忆里抽取**命名实体**、**带
 | **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.4.4** | ✅ 完成 | autoDream 决策覆盖修复 | issue#9 方案C：滑动窗口 `dreamMaxSnapshotSize`(默认200，updated_at 倒序截断) + 隐式 keep `dreamImplicitKeep`(默认true) + 覆盖率下限 `dreamMinExplicitCoverage`(默认50%) + 固定决策 schema；487 测试全绿 |
 | **v0.5.0+** | 🚀 远期 | 自进化记忆 | 兴趣漂移跟踪 + 跨 workspace 记忆共享（等 DSH 支持） |
 
 > 新能力一律做成**可开关的功能**（配置启用/关闭），默认保守开启、不破坏现有行为。`failure_memories` 表与 autoDream 决策引擎已为后续反思性成长铺好路。

package/lib/config.js

@@ -29,6 +29,19 @@ export const Config = z.object({
     z.const("high"),
     z.const("none")
   ]).default("none"),
+  // 滑动窗口上限（v0.4.4）：autoDream 每次只对最近 dreamMaxSnapshotSize 条
+  // 记忆做 consolidation。大记忆量下全量快照会把 LLM 输入撑爆（636 记忆 →
+  // 677 "missing" errors、applied=0），窗口外的旧记忆不进 snapshot。
+  dreamMaxSnapshotSize: z.natural().min(1).max(1000).default(200),
+  // 隐式 keep（v0.4.4）：LLM 未提及的 snapshot 记忆自动补 {action:"keep"}，
+  // 避免"未覆盖即全拒"白白浪费整轮 run。设为 false 时保留旧的严格校验
+  // （未覆盖即拒绝整单）。
+  dreamImplicitKeep: z.boolean().default(true),
+  // 显式决策覆盖率下限（v0.4.4 fix）：dreamImplicitKeep 开启时，LLM 输出被
+  // 截断只显式 claim 少量 snapshot 记忆（claimed.size / snapshot.size < 该阈值）
+  // → 整单拒绝，防止残缺输出被隐式 keep 洗白成 ok 后再被真实 apply。0-1，
+  // 默认 0.5（至少显式覆盖一半 snapshot）。
+  dreamMinExplicitCoverage: z.number().min(0).max(1).default(0.5),
   // 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.

package/lib/dream/decisions.js

@@ -120,11 +120,37 @@ export function validateDecisions(decisions, snapshot, options = {}) {
   if (createCount > maxCreatePerRun) {
     errors.push(`too many create decisions: ${createCount} > ${maxCreatePerRun}`);
   }
-  // Every snapshot id must appear in at least one decision
-  for (const id of snapshot.keys()) {
-    if (!claimed.has(id)) errors.push(`memory ${JSON.stringify(id)} missing from decisions`);
+  // v0.4.4: 隐式 keep。默认（dreamImplicitKeep !== false）下，未 claim 的
+  // snapshot 记忆自动补 {action:"keep"}，而不是整体拒绝——大记忆量下 LLM 漏报
+  // 一两条就全拒（636 记忆 → 677 errors）会白白浪费整轮 run。设 false 则保留
+  // 旧的严格"全量覆盖"校验。补齐的 keep 直接 append 到 decisions，调用方
+  // （runDream/applyDecisions/audit）复用同一数组即可覆盖全部 snapshot 记忆。
+  //
+  // v0.4.4 fix（残缺输出防洗白）：先收集所有非覆盖类 errors，有错直接 ok:false
+  // 且绝不 push 任何补齐 keep——残缺决策必须被真实拒绝，不能被隐式 keep 洗白成
+  // ok 后再 apply。只有无错时才检查显式覆盖率：LLM 输出被截断只 claim 少量
+  // snapshot（claimed.size / snapshot.size < dreamMinExplicitCoverage）时整单拒绝，
+  // 而不是用 keep 把绝大部分 snapshot 全部"通过"。
+  if (errors.length > 0) {
+    return { ok: false, errors };
   }
-  return { ok: errors.length === 0, errors };
+  const minCoverage = options.dreamMinExplicitCoverage ?? 0.5;
+  if (options.dreamImplicitKeep !== false) {
+    const coverage = snapshot.size > 0 ? claimed.size / snapshot.size : 1;
+    if (coverage < minCoverage) {
+      errors.push(`explicit decision coverage ${Math.round(coverage * 100)}% < minimum ${Math.round(minCoverage * 100)}%`);
+      return { ok: false, errors };
+    }
+    for (const id of snapshot.keys()) {
+      if (!claimed.has(id)) decisions.push({ action: "keep", ids: [id] });
+    }
+  } else {
+    for (const id of snapshot.keys()) {
+      if (!claimed.has(id)) errors.push(`memory ${JSON.stringify(id)} missing from decisions`);
+    }
+    if (errors.length > 0) return { ok: false, errors };
+  }
+  return { ok: true, errors };
 }
 
 /** Marker thrown when a decision target changed since the run snapshot. */

package/lib/dream/sleep.js

@@ -198,11 +198,9 @@ async function phaseConflicts(ctx, service, config, logger, runId, semantic = nu
   if (text === undefined) return { status: "failed", error: "llm failed" };
   const decisions = parseJsonArray(text);
   if (!decisions) return { status: "failed", error: "invalid decisions json" };
-  // validateDecisions requires every snapshot id to be claimed exactly once.
-  // An LLM that omits a pair would otherwise fail the whole phase, so any
-  // snapshot id the output leaves uncovered is defaulted to `keep` — the
-  // fail-safe reading is "no conflict decided" rather than "conflict phase
-  // aborted". validateDecisions stays strict for the dream consolidation path.
+  // validateDecisions 要求每个 snapshot id 恰好被 claim 一次。v0.4.4 起它本身
+  // 就会为未覆盖的 id 自动补 keep（dreamImplicitKeep 默认开启），这里保留显式
+  // 预填作为防御性双保险——漏判读作"未裁决冲突"而非"冲突阶段整体失败"。
   const covered = new Set();
   for (const d of decisions) {
     if (d?.action === "conflict") {

package/lib/dream.js

@@ -6,25 +6,47 @@ export { validateDecisions, applyDecisions };
 const SUMMARY_PROMPT = `你是记忆库摘要助手。根据整理后的记忆，生成一段 150-200 字的记忆库总览，覆盖：用户偏好、活跃项目、关键决策。之后作为会话上下文注入。只输出摘要文本，不要其他内容。`;
 
 const CONSOLIDATION_PROMPT = `你是记忆库整理助手。下面是全部记忆条目（id、类型、标题、内容、重要性、更新时间）。
-请执行记忆巩固（consolidation）：
-1. 识别主题相近的条目 → 输出 merge（合并为更精炼的摘要，保留信息最完整的 id 作为 keepSource）
-2. 识别重复/过时信息 → 输出 archive
-3. 识别内容矛盾的条目 → 输出 conflict（根据时间新旧、来源完整性、信息具体程度判断 winner/loser）
-4. 发现单条记忆中的信息已过时、错误或遗漏 → 输出 update（直接修正内容）
+请执行记忆巩固（consolidation），输出一个决策 JSON 数组。
+
+【决策格式（必须严格遵守）】
+每个决策必须是对象，字段固定：
+- "action"：必填。取值只能是 "keep" / "merge" / "archive" / "update" / "conflict" 之一（字段名必须是 action，严禁写成 type）
+- "ids"：必填，数组，本决策涉及的记忆 id 列表
+- "reason"：可选，字符串，决策理由
+- "importance"：可选，整数 1-5
+- merge 额外字段："keepSource"（单个 id 字符串，必须是 ids 之一）+ 合并后的 "title"、"content"
+- conflict 额外字段："winner" 与 "loser"，都是【单个 id 字符串，不是数组】
+- update 额外字段：修正后的 "title" 和/或 "content"；"ids" 只能包含一个 id
+
+【决策 JSON 示例】
+[
+  { "action": "merge", "ids": ["m1", "m2"], "keepSource": "m1", "title": "合并标题", "content": "合并后的摘要内容", "importance": 4, "reason": "主题相近" },
+  { "action": "conflict", "winner": "m3", "loser": "m4", "reason": "内容矛盾，保留更新的信息" },
+  { "action": "update", "ids": ["m5"], "content": "修正后的内容", "reason": "信息过时" },
+  { "action": "archive", "ids": ["m6"], "reason": "重复或过时" }
+]
+
+【任务】
+1. 识别主题相近的条目 → merge（合并为更精炼的摘要，保留信息最完整的 id 作为 keepSource）
+2. 识别重复/过时信息 → archive
+3. 识别内容矛盾的条目 → conflict（按时间新旧、来源完整性、信息具体程度判断 winner/loser）
+4. 发现单条记忆中的信息过时、错误或遗漏 → update（直接修正内容）
    - update 的 ids 只能包含一个 id
    - 必须提供修正后的 title 和/或 content
    - 仅当内容确实需要修正时才使用，不要滥用
    - 每次整理最多输出 2 个 update
    - 24 小时内新建的记忆不可 update
-5. 无问题的条目 → 输出 keep
+5. 无问题的条目无需输出（未提及的条目将自动保留 keep）
 
-规则：
-- 每条记忆至少出现在一个决策中
+【硬性规则】
+- 字段名必须精确为 "action"，严禁写成 "type"；字段名统一用双引号
+- conflict 的 winner/loser、merge 的 keepSource 都是【单个 id 字符串，绝不是数组】
+- 每条记忆最多被 claim 一次：同一个 id 不能出现在多个决策中（同一 id 不能被 merge 和 conflict/archive 等重复占用）
+- 未在决策中提及的记忆将自动保留（keep），无需为每条记忆输出 keep
 - merge 的 keepSource 必须是 ids 之一
 - 仅合并同类型条目（type 相同）
 - 不要编造 ids；只使用提供的 id
 - 重要性 1-5，合并后取最高
-- update 只能改一条，且要有实际变化
 - 只输出 JSON 数组，不要其他文字`;
 
 function totalChars(memories) {
@@ -344,8 +366,21 @@ export function createDreamScheduler({ onRun, thresholdCount = 10, thresholdChar
 
   async function runDream(ctx, service, config) {
     const logger = ctx.logger;
-    const memories = service.all().filter((m) => !m.archived && m.type !== "summary");
+    let memories = service.all().filter((m) => !m.archived && m.type !== "summary");
     if (memories.length === 0) return { ok: true, applied: 0, skipped: true, summary: false };
+    // v0.4.4 滑动窗口：只 consolidation 最近 dreamMaxSnapshotSize 条记忆，
+    // 窗口外的旧记忆不进 snapshot（大记忆量下全量快照会撑爆 LLM 输入，配合
+    // 隐式 keep 让 run 始终可收敛）。按 updated_at 倒序取前 maxSize 条。
+    const maxSize = Number.isInteger(config.dreamMaxSnapshotSize) ? config.dreamMaxSnapshotSize : 200;
+    memories = [...memories]
+      .sort((a, b) => {
+        const ta = String(a.updated_at ?? "");
+        const tb = String(b.updated_at ?? "");
+        if (ta < tb) return 1;
+        if (ta > tb) return -1;
+        return a.id < b.id ? -1 : a.id > b.id ? 1 : 0;
+      })
+      .slice(0, Math.max(1, maxSize));
     const snapshot = new Map(memories.map((m) => [m.id, m]));
     const route = resolveRoute(ctx, config, logger);
     const runId = randomUUID();
@@ -489,7 +524,11 @@ export function createDreamScheduler({ onRun, thresholdCount = 10, thresholdChar
     }
     const { ok, errors } = validateDecisions(decisions, snapshot, {
       maxUpdatePerRun: config.reflectionUpdateMaxPerRun,
-      minAgeHours: config.reflectionUpdateMinAgeHours
+      minAgeHours: config.reflectionUpdateMinAgeHours,
+      // v0.4.4 fix：显式透传，用户配 dreamImplicitKeep:false 时严格模式必须
+      // 真正生效，dreamMinExplicitCoverage 决定隐式 keep 下的覆盖率下限。
+      dreamImplicitKeep: config.dreamImplicitKeep,
+      dreamMinExplicitCoverage: config.dreamMinExplicitCoverage
     });
     if (!ok) {
       logger?.warn?.(`dsh-mneme dream: invalid decisions: ${errors.join("; ")}`);

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.3",
+  "version": "0.4.4",
   "license": "MIT",
   "type": "module",
   "main": "lib/index.js",

package/src/config.js

@@ -29,6 +29,19 @@ export const Config = z.object({
     z.const("high"),
     z.const("none")
   ]).default("none"),
+  // 滑动窗口上限（v0.4.4）：autoDream 每次只对最近 dreamMaxSnapshotSize 条
+  // 记忆做 consolidation。大记忆量下全量快照会把 LLM 输入撑爆（636 记忆 →
+  // 677 "missing" errors、applied=0），窗口外的旧记忆不进 snapshot。
+  dreamMaxSnapshotSize: z.natural().min(1).max(1000).default(200),
+  // 隐式 keep（v0.4.4）：LLM 未提及的 snapshot 记忆自动补 {action:"keep"}，
+  // 避免"未覆盖即全拒"白白浪费整轮 run。设为 false 时保留旧的严格校验
+  // （未覆盖即拒绝整单）。
+  dreamImplicitKeep: z.boolean().default(true),
+  // 显式决策覆盖率下限（v0.4.4 fix）：dreamImplicitKeep 开启时，LLM 输出被
+  // 截断只显式 claim 少量 snapshot 记忆（claimed.size / snapshot.size < 该阈值）
+  // → 整单拒绝，防止残缺输出被隐式 keep 洗白成 ok 后再被真实 apply。0-1，
+  // 默认 0.5（至少显式覆盖一半 snapshot）。
+  dreamMinExplicitCoverage: z.number().min(0).max(1).default(0.5),
   // 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.

package/src/dream/decisions.js

@@ -120,11 +120,37 @@ export function validateDecisions(decisions, snapshot, options = {}) {
   if (createCount > maxCreatePerRun) {
     errors.push(`too many create decisions: ${createCount} > ${maxCreatePerRun}`);
   }
-  // Every snapshot id must appear in at least one decision
-  for (const id of snapshot.keys()) {
-    if (!claimed.has(id)) errors.push(`memory ${JSON.stringify(id)} missing from decisions`);
+  // v0.4.4: 隐式 keep。默认（dreamImplicitKeep !== false）下，未 claim 的
+  // snapshot 记忆自动补 {action:"keep"}，而不是整体拒绝——大记忆量下 LLM 漏报
+  // 一两条就全拒（636 记忆 → 677 errors）会白白浪费整轮 run。设 false 则保留
+  // 旧的严格"全量覆盖"校验。补齐的 keep 直接 append 到 decisions，调用方
+  // （runDream/applyDecisions/audit）复用同一数组即可覆盖全部 snapshot 记忆。
+  //
+  // v0.4.4 fix（残缺输出防洗白）：先收集所有非覆盖类 errors，有错直接 ok:false
+  // 且绝不 push 任何补齐 keep——残缺决策必须被真实拒绝，不能被隐式 keep 洗白成
+  // ok 后再 apply。只有无错时才检查显式覆盖率：LLM 输出被截断只 claim 少量
+  // snapshot（claimed.size / snapshot.size < dreamMinExplicitCoverage）时整单拒绝，
+  // 而不是用 keep 把绝大部分 snapshot 全部"通过"。
+  if (errors.length > 0) {
+    return { ok: false, errors };
   }
-  return { ok: errors.length === 0, errors };
+  const minCoverage = options.dreamMinExplicitCoverage ?? 0.5;
+  if (options.dreamImplicitKeep !== false) {
+    const coverage = snapshot.size > 0 ? claimed.size / snapshot.size : 1;
+    if (coverage < minCoverage) {
+      errors.push(`explicit decision coverage ${Math.round(coverage * 100)}% < minimum ${Math.round(minCoverage * 100)}%`);
+      return { ok: false, errors };
+    }
+    for (const id of snapshot.keys()) {
+      if (!claimed.has(id)) decisions.push({ action: "keep", ids: [id] });
+    }
+  } else {
+    for (const id of snapshot.keys()) {
+      if (!claimed.has(id)) errors.push(`memory ${JSON.stringify(id)} missing from decisions`);
+    }
+    if (errors.length > 0) return { ok: false, errors };
+  }
+  return { ok: true, errors };
 }
 
 /** Marker thrown when a decision target changed since the run snapshot. */

package/src/dream/sleep.js

@@ -198,11 +198,9 @@ async function phaseConflicts(ctx, service, config, logger, runId, semantic = nu
   if (text === undefined) return { status: "failed", error: "llm failed" };
   const decisions = parseJsonArray(text);
   if (!decisions) return { status: "failed", error: "invalid decisions json" };
-  // validateDecisions requires every snapshot id to be claimed exactly once.
-  // An LLM that omits a pair would otherwise fail the whole phase, so any
-  // snapshot id the output leaves uncovered is defaulted to `keep` — the
-  // fail-safe reading is "no conflict decided" rather than "conflict phase
-  // aborted". validateDecisions stays strict for the dream consolidation path.
+  // validateDecisions 要求每个 snapshot id 恰好被 claim 一次。v0.4.4 起它本身
+  // 就会为未覆盖的 id 自动补 keep（dreamImplicitKeep 默认开启），这里保留显式
+  // 预填作为防御性双保险——漏判读作"未裁决冲突"而非"冲突阶段整体失败"。
   const covered = new Set();
   for (const d of decisions) {
     if (d?.action === "conflict") {

package/src/dream.js

@@ -6,25 +6,47 @@ export { validateDecisions, applyDecisions };
 const SUMMARY_PROMPT = `你是记忆库摘要助手。根据整理后的记忆，生成一段 150-200 字的记忆库总览，覆盖：用户偏好、活跃项目、关键决策。之后作为会话上下文注入。只输出摘要文本，不要其他内容。`;
 
 const CONSOLIDATION_PROMPT = `你是记忆库整理助手。下面是全部记忆条目（id、类型、标题、内容、重要性、更新时间）。
-请执行记忆巩固（consolidation）：
-1. 识别主题相近的条目 → 输出 merge（合并为更精炼的摘要，保留信息最完整的 id 作为 keepSource）
-2. 识别重复/过时信息 → 输出 archive
-3. 识别内容矛盾的条目 → 输出 conflict（根据时间新旧、来源完整性、信息具体程度判断 winner/loser）
-4. 发现单条记忆中的信息已过时、错误或遗漏 → 输出 update（直接修正内容）
+请执行记忆巩固（consolidation），输出一个决策 JSON 数组。
+
+【决策格式（必须严格遵守）】
+每个决策必须是对象，字段固定：
+- "action"：必填。取值只能是 "keep" / "merge" / "archive" / "update" / "conflict" 之一（字段名必须是 action，严禁写成 type）
+- "ids"：必填，数组，本决策涉及的记忆 id 列表
+- "reason"：可选，字符串，决策理由
+- "importance"：可选，整数 1-5
+- merge 额外字段："keepSource"（单个 id 字符串，必须是 ids 之一）+ 合并后的 "title"、"content"
+- conflict 额外字段："winner" 与 "loser"，都是【单个 id 字符串，不是数组】
+- update 额外字段：修正后的 "title" 和/或 "content"；"ids" 只能包含一个 id
+
+【决策 JSON 示例】
+[
+  { "action": "merge", "ids": ["m1", "m2"], "keepSource": "m1", "title": "合并标题", "content": "合并后的摘要内容", "importance": 4, "reason": "主题相近" },
+  { "action": "conflict", "winner": "m3", "loser": "m4", "reason": "内容矛盾，保留更新的信息" },
+  { "action": "update", "ids": ["m5"], "content": "修正后的内容", "reason": "信息过时" },
+  { "action": "archive", "ids": ["m6"], "reason": "重复或过时" }
+]
+
+【任务】
+1. 识别主题相近的条目 → merge（合并为更精炼的摘要，保留信息最完整的 id 作为 keepSource）
+2. 识别重复/过时信息 → archive
+3. 识别内容矛盾的条目 → conflict（按时间新旧、来源完整性、信息具体程度判断 winner/loser）
+4. 发现单条记忆中的信息过时、错误或遗漏 → update（直接修正内容）
    - update 的 ids 只能包含一个 id
    - 必须提供修正后的 title 和/或 content
    - 仅当内容确实需要修正时才使用，不要滥用
    - 每次整理最多输出 2 个 update
    - 24 小时内新建的记忆不可 update
-5. 无问题的条目 → 输出 keep
+5. 无问题的条目无需输出（未提及的条目将自动保留 keep）
 
-规则：
-- 每条记忆至少出现在一个决策中
+【硬性规则】
+- 字段名必须精确为 "action"，严禁写成 "type"；字段名统一用双引号
+- conflict 的 winner/loser、merge 的 keepSource 都是【单个 id 字符串，绝不是数组】
+- 每条记忆最多被 claim 一次：同一个 id 不能出现在多个决策中（同一 id 不能被 merge 和 conflict/archive 等重复占用）
+- 未在决策中提及的记忆将自动保留（keep），无需为每条记忆输出 keep
 - merge 的 keepSource 必须是 ids 之一
 - 仅合并同类型条目（type 相同）
 - 不要编造 ids；只使用提供的 id
 - 重要性 1-5，合并后取最高
-- update 只能改一条，且要有实际变化
 - 只输出 JSON 数组，不要其他文字`;
 
 function totalChars(memories) {
@@ -344,8 +366,21 @@ export function createDreamScheduler({ onRun, thresholdCount = 10, thresholdChar
 
   async function runDream(ctx, service, config) {
     const logger = ctx.logger;
-    const memories = service.all().filter((m) => !m.archived && m.type !== "summary");
+    let memories = service.all().filter((m) => !m.archived && m.type !== "summary");
     if (memories.length === 0) return { ok: true, applied: 0, skipped: true, summary: false };
+    // v0.4.4 滑动窗口：只 consolidation 最近 dreamMaxSnapshotSize 条记忆，
+    // 窗口外的旧记忆不进 snapshot（大记忆量下全量快照会撑爆 LLM 输入，配合
+    // 隐式 keep 让 run 始终可收敛）。按 updated_at 倒序取前 maxSize 条。
+    const maxSize = Number.isInteger(config.dreamMaxSnapshotSize) ? config.dreamMaxSnapshotSize : 200;
+    memories = [...memories]
+      .sort((a, b) => {
+        const ta = String(a.updated_at ?? "");
+        const tb = String(b.updated_at ?? "");
+        if (ta < tb) return 1;
+        if (ta > tb) return -1;
+        return a.id < b.id ? -1 : a.id > b.id ? 1 : 0;
+      })
+      .slice(0, Math.max(1, maxSize));
     const snapshot = new Map(memories.map((m) => [m.id, m]));
     const route = resolveRoute(ctx, config, logger);
     const runId = randomUUID();
@@ -489,7 +524,11 @@ export function createDreamScheduler({ onRun, thresholdCount = 10, thresholdChar
     }
     const { ok, errors } = validateDecisions(decisions, snapshot, {
       maxUpdatePerRun: config.reflectionUpdateMaxPerRun,
-      minAgeHours: config.reflectionUpdateMinAgeHours
+      minAgeHours: config.reflectionUpdateMinAgeHours,
+      // v0.4.4 fix：显式透传，用户配 dreamImplicitKeep:false 时严格模式必须
+      // 真正生效，dreamMinExplicitCoverage 决定隐式 keep 下的覆盖率下限。
+      dreamImplicitKeep: config.dreamImplicitKeep,
+      dreamMinExplicitCoverage: config.dreamMinExplicitCoverage
     });
     if (!ok) {
       logger?.warn?.(`dsh-mneme dream: invalid decisions: ${errors.join("; ")}`);

package/test/config.test.js

@@ -17,6 +17,25 @@ test("rerank is opt-in: default config does not enable the local reranker", () =
   assert.equal(enabled.rerankEnabled && enabled.rerankProvider === "local", true, "explicit opt-in opens the gate");
 });
 
+test("dream sliding window + implicit keep config defaults and bounds (v0.4.4)", () => {
+  const cfg = Config({});
+  assert.equal(cfg.dreamMaxSnapshotSize, 200, "window defaults to 200");
+  assert.equal(cfg.dreamImplicitKeep, true, "implicit keep defaults to true");
+  const capped = Config({ dreamMaxSnapshotSize: 1000 });
+  assert.equal(capped.dreamMaxSnapshotSize, 1000, "upper bound accepted");
+  const off = Config({ dreamImplicitKeep: false });
+  assert.equal(off.dreamImplicitKeep, false, "implicit keep can be disabled");
+});
+
+test("dream explicit coverage threshold config defaults and bounds (v0.4.4 fix)", () => {
+  const cfg = Config({});
+  assert.equal(cfg.dreamMinExplicitCoverage, 0.5, "coverage threshold defaults to 0.5");
+  const low = Config({ dreamMinExplicitCoverage: 0.1 });
+  assert.equal(low.dreamMinExplicitCoverage, 0.1, "lower bound accepted");
+  const high = Config({ dreamMinExplicitCoverage: 1 });
+  assert.equal(high.dreamMinExplicitCoverage, 1, "upper bound accepted");
+});
+
 test("startup probe: the reranker module never statically imports transformers/onnxruntime", () => {
   // LocalReranker is imported eagerly by index.js, so a bare install must not
   // pull onnxruntime in at module load. The heavy load is a lazy dynamic import

package/test/dream.test.js

@@ -3,6 +3,7 @@ import assert from "node:assert/strict";
 import { validateDecisions, applyDecisions, createDreamScheduler } from "../src/dream.js";
 import { createStore } from "../src/store.js";
 import { createService } from "../src/service.js";
+import { mockCtx } from "./helpers/dream-mock.js";
 
 function snapshot(ids, type = "project") {
   return new Map(ids.map((id, i) => [id, { id, type, title: `t${i}`, content: `c${i}`, importance: 3, archived: false, forgotten: false }]));
@@ -87,9 +88,19 @@ test("summary entries cannot be decision targets", () => {
   assert.equal(ok, false);
 });
 
-test("every snapshot memory must be covered by a decision", () => {
+test("uncovered snapshot memories are auto-filled with keep (implicit keep, v0.4.4)", () => {
   const snap = snapshot(["a", "b"]);
-  const { ok, errors } = validateDecisions([{ action: "keep", ids: ["a"] }], snap);
+  const decisions = [{ action: "keep", ids: ["a"] }];
+  const { ok, errors } = validateDecisions(decisions, snap);
+  assert.equal(ok, true, errors.join("; "));
+  assert.equal(decisions.length, 2, "keep appended for the uncovered snapshot id");
+  assert.ok(decisions.some((d) => d.action === "keep" && d.ids.includes("b")), "b auto-kept");
+});
+
+test("dreamImplicitKeep=false keeps the strict full-coverage validation", () => {
+  const snap = snapshot(["a", "b"]);
+  const decisions = [{ action: "keep", ids: ["a"] }];
+  const { ok, errors } = validateDecisions(decisions, snap, { dreamImplicitKeep: false });
   assert.equal(ok, false);
   assert.ok(errors.some((e) => e.includes("missing from decisions")));
 });
@@ -671,3 +682,168 @@ test("runDream freeze store failure never blocks the run (fail-safe)", async ()
   assert.equal(store.getById(w.id).content, "8月20日", "winner untouched");
   store.close();
 });
+
+// --- v0.4.4: 大记忆量 autoDream（滑动窗口 + 隐式 keep）回归 -----------------
+
+test("autoDream with 650 memories: sliding window truncates snapshot + implicit keep fills uncovered ids", async () => {
+  const { store, service } = dreamSetup();
+  // seed 650 memories — the size that used to produce 677 "missing from
+  // decisions" errors and applied=0 under the strict full-coverage check
+  for (let i = 0; i < 650; i++) {
+    service.saveWithDedupe({ type: "project", title: `主题${i}`, content: `内容${i}`, importance: 3 });
+  }
+  // mock LLM claims only a small subset (20 archives) and never emits keeps
+  // for the rest — implicit keep must auto-fill the uncovered snapshot ids
+  const ctx = mockCtx({
+    onConsolidation: (listText) => {
+      const ids = [...listText.matchAll(/id=([^\s|]+)\s*\|\s*type=(\w+)\s*\|\s*importance=\d+/g)]
+        .map((m) => m[1]);
+      return JSON.stringify(ids.slice(0, 20).map((id) => ({ action: "archive", ids: [id], reason: "stale" })));
+    }
+  });
+  const dream = createDreamScheduler({ thresholdCount: 1, thresholdChars: 0, delayMs: 0 });
+  const result = await dream.runDream(ctx, service, {
+    dreamProvider: "deepseek", dreamModel: "deepseek-chat", dreamMaxSnapshotSize: 200,
+    // mock only claims 20/200 = 10%; the implicit-keep coverage floor must be
+    // lowered so this deliberate "tiny explicit claim" scenario still passes
+    // (it exercises the window + keep-fill, not the coverage guard)
+    dreamMinExplicitCoverage: 0.1
+  });
+  assert.equal(result.ok, true, "run succeeds instead of 677-error rejection");
+  assert.ok(result.applied > 0, "archive decisions applied");
+  // snapshot capped at the sliding window
+  const run = store.listDreamRuns()[0];
+  assert.equal(run.input_count, 200, "snapshot truncated to dreamMaxSnapshotSize");
+  // decisions cover exactly the snapshot window, with implicit keeps
+  assert.equal(result.decisions.length, 200, "decisions count = snapshot count");
+  assert.equal(result.decisions.filter((d) => d.action === "archive").length, 20, "claimed subset present");
+  assert.equal(result.decisions.filter((d) => d.action === "keep").length, 180, "uncovered ids auto-kept");
+  assert.equal(store.getById(result.decisions.find((d) => d.action === "archive").ids[0]).archived, true, "an archive landed");
+  store.close();
+});
+
+// --- v0.4.4 fix: 残缺输出防洗白（显式覆盖率下限） + 严格模式透传 --------------
+
+test("validateDecisions rejects a truncated output whose explicit coverage is below the floor", () => {
+  const snap = snapshot(["a", "b", "c", "d"]);
+  const decisions = [{ action: "keep", ids: ["a"] }]; // claims 1/4 = 25%
+  const { ok, errors } = validateDecisions(decisions, snap, { dreamMinExplicitCoverage: 0.5 });
+  assert.equal(ok, false, "low explicit coverage rejects the whole list");
+  assert.ok(
+    errors.some((e) => e.includes("explicit decision coverage 25% < minimum 50%")),
+    `coverage error present, got: ${errors.join("; ")}`
+  );
+  assert.equal(decisions.length, 1, "no keep-fill pushed on rejection (nothing washed white)");
+});
+
+test("validateDecisions covers the whole snapshot when explicit coverage meets the floor", () => {
+  const snap = snapshot(["a", "b", "c", "d"]);
+  const decisions = [{ action: "archive", ids: ["a", "b"], reason: "stale" }]; // claims 2/4 = 50%
+  const { ok, errors } = validateDecisions(decisions, snap, { dreamMinExplicitCoverage: 0.5 });
+  assert.equal(ok, true, errors.join("; "));
+  assert.equal(decisions.length, 3, "archive + 2 implicit keeps for c/d");
+  assert.equal(decisions.filter((d) => d.action === "keep").length, 2);
+});
+
+test("runDream with dreamImplicitKeep=false rejects a partial mock output (missing from decisions)", async () => {
+  const { store, service } = dreamSetup();
+  for (let i = 0; i < 3; i++) {
+    service.saveWithDedupe({ type: "project", title: `主题${i}`, content: `内容${i}`, importance: 3 });
+  }
+  // mock only claims the first snapshot id, misses the rest — strict mode must
+  // reject the whole run instead of auto-keeping the uncovered ids
+  const warnings = [];
+  const ctx = {
+    warnings,
+    logger: { warn: (m) => warnings.push(m) },
+    agentDefaultModel: { currentSelection: () => ({ provider: "mock", model: "stress-model" }) },
+    llm: {
+      async *stream(options) {
+        const userText = options.messages.find((m) => m.role === "user")?.content?.[0]?.text ?? "";
+        if (userText.startsWith("id=")) {
+          const ids = [...userText.matchAll(/id=([^\s|]+)\s*\|\s*type=(\w+)\s*\|\s*importance=\d+/g)].map((m) => m[1]);
+          yield { type: "text-delta", index: 0, text: JSON.stringify(ids.slice(0, 1).map((id) => ({ action: "archive", ids: [id], reason: "stale" }))) };
+        } else {
+          yield { type: "text-delta", index: 0, text: "记忆库总览摘要" };
+        }
+        yield { type: "finish", reason: { kind: "stop" } };
+      }
+    }
+  };
+  const dream = createDreamScheduler({ thresholdCount: 1, thresholdChars: 0, delayMs: 0 });
+  const result = await dream.runDream(ctx, service, {
+    dreamProvider: "deepseek", dreamModel: "deepseek-chat",
+    dreamImplicitKeep: false
+  });
+  assert.equal(result.ok, false, "strict mode rejects the partial output");
+  assert.match(result.error, /invalid decisions: \d+ errors/);
+  assert.ok(warnings.some((m) => m.includes("missing from decisions")), "warned which ids are missing");
+  assert.equal(store.listDreamRuns()[0].status, "failed", "run audited as failed");
+  store.close();
+});
+
+test("runDream sliding window keeps the newest N memories and excludes the oldest", async () => {
+  const { store, service } = dreamSetup();
+  // seed 5 memories, backdate updated_at so i=0 is oldest (5h ago), i=4 newest (1h ago)
+  const ids = [];
+  for (let i = 0; i < 5; i++) {
+    const { memory } = service.saveWithDedupe({ type: "project", title: `主题${i}`, content: `内容${i}`, importance: 3 });
+    ids.push(memory.id);
+  }
+  for (let i = 0; i < 5; i++) {
+    const old = new Date(Date.now() - (5 - i) * 3600000).toISOString();
+    store.db.prepare("UPDATE memories SET updated_at = ?, created_at = ? WHERE id = ?").run(old, old, ids[i]);
+  }
+  const ctx = mockCtx({
+    onConsolidation: (listText) => {
+      const inWindow = [...listText.matchAll(/id=([^\s|]+)\s*\|\s*type=(\w+)\s*\|\s*importance=\d+/g)]
+        .map((m) => m[1]);
+      return JSON.stringify(inWindow.map((id) => ({ action: "keep", ids: [id] })));
+    }
+  });
+  const dream = createDreamScheduler({ thresholdCount: 1, thresholdChars: 0, delayMs: 0 });
+  const result = await dream.runDream(ctx, service, {
+    dreamProvider: "deepseek", dreamModel: "deepseek-chat", dreamMaxSnapshotSize: 3
+  });
+  const run = store.listDreamRuns()[0];
+  assert.equal(run.input_count, 3, "window capped at dreamMaxSnapshotSize");
+  const windowIds = run.input.map((m) => m.id).sort();
+  const expected = [ids[2], ids[3], ids[4]].sort(); // newest 3 by updated_at
+  assert.deepEqual(windowIds, expected, "window contains the newest 3 memories");
+  assert.ok(!windowIds.includes(ids[0]), "oldest memory excluded from the window");
+  assert.equal(result.decisions.length, 3, "decisions cover exactly the window");
+  store.close();
+});
+
+// --- v0.4.4 fix: 决策 JSON schema 固化（kimi 等模型输出合规） -----------------
+
+test("consolidation prompt pins the decision schema (action field, single-string winner/loser, single claim per id)", async () => {
+  const { store, service } = dreamSetup();
+  service.saveWithDedupe({ type: "project", title: "a", content: "x" });
+  let systemText = "";
+  const ctx = {
+    logger: { warn: () => {} },
+    llm: {
+      async *stream(options) {
+        systemText = options.messages.find((m) => m.role === "system")?.content?.[0]?.text ?? "";
+        yield { type: "text-delta", text: "[]" };
+        yield { type: "finish", reason: { kind: "ok" } };
+      }
+    }
+  };
+  const dream = createDreamScheduler({ thresholdCount: 1, thresholdChars: 0, delayMs: 0 });
+  await dream.runDream(ctx, service, { dreamProvider: "deepseek", dreamModel: "deepseek-chat" });
+  // 字段名必须写死为 action（kimi 曾输出 "type" 导致整单拒绝）
+  assert.match(systemText, /"action"/, "prompt names the action field");
+  assert.match(systemText, /严禁写成\s*type/, "prompt forbids the type field name");
+  // conflict winner/loser 是单个 id 字符串而非数组
+  assert.match(systemText, /"winner"/, "prompt names the winner field");
+  assert.match(systemText, /"loser"/, "prompt names the loser field");
+  assert.match(systemText, /单个 id 字符串/, "winner/loser must be a single id string");
+  assert.match(systemText, /不是数组|绝不是数组/, "winner/loser must not be an array");
+  // 同一 id 不可被多个决策重复 claim
+  assert.match(systemText, /最多被 claim 一次/, "each memory claimed at most once");
+  // 决策 JSON 示例块
+  assert.match(systemText, /决策 JSON 示例/, "prompt includes a canonical example block");
+  store.close();
+});