@modusensus/dsh-mneme 0.4.3 → 0.4.4-beta.1

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

@@ -16,10 +16,10 @@ const CONSOLIDATION_PROMPT = `你是记忆库整理助手。下面是全部记
    - 仅当内容确实需要修正时才使用，不要滥用
    - 每次整理最多输出 2 个 update
    - 24 小时内新建的记忆不可 update
-5. 无问题的条目 → 输出 keep
+5. 无问题的条目无需输出（未提及的条目将自动保留 keep）
 
 规则：
-- 每条记忆至少出现在一个决策中
+- 未在决策中提及的记忆将自动保留（keep），无需为每条记忆输出 keep
 - merge 的 keepSource 必须是 ids 之一
 - 仅合并同类型条目（type 相同）
 - 不要编造 ids；只使用提供的 id
@@ -344,8 +344,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 +502,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-beta.1",
   "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

@@ -16,10 +16,10 @@ const CONSOLIDATION_PROMPT = `你是记忆库整理助手。下面是全部记
    - 仅当内容确实需要修正时才使用，不要滥用
    - 每次整理最多输出 2 个 update
    - 24 小时内新建的记忆不可 update
-5. 无问题的条目 → 输出 keep
+5. 无问题的条目无需输出（未提及的条目将自动保留 keep）
 
 规则：
-- 每条记忆至少出现在一个决策中
+- 未在决策中提及的记忆将自动保留（keep），无需为每条记忆输出 keep
 - merge 的 keepSource 必须是 ids 之一
 - 仅合并同类型条目（type 相同）
 - 不要编造 ids；只使用提供的 id
@@ -344,8 +344,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 +502,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,135 @@ 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();
+});