@modusensus/dsh-mneme 0.7.20 → 0.7.22

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 };
+export { validateDecisions, applyDecisions, withEffortFallback, describeStreamFailure };
 
 
 // Extract the first JSON array from LLM output, tolerating markdown fences,
@@ -238,18 +238,34 @@ function buildRecordReceipts({ runId, committed, snapshot, policyEpoch }) {
  * surfaces as undefined. The caller decides how to treat an empty result.
  * `onUsage` (optional, Bug8) receives any usage chunk for token accounting.
  */
-async function streamText(ctx, options, onUsage) {
+async function streamText(ctx, options, onUsage, onStreamError) {
   let text = "";
   for await (const chunk of ctx.llm.stream(options)) {
     if (chunk.type === "text-delta" && typeof chunk.text === "string") text += chunk.text;
     if (chunk.type === "usage" && typeof onUsage === "function") onUsage(chunk);
     if (chunk.type === "finish" && (chunk.reason?.kind === "error" || chunk.reason?.kind === "aborted")) {
+      // dsh-llm rc.1 turns adapter-stage failures (unknown provider route,
+      // UNSUPPORTED_REASONING_EFFORT from resolveCallWithInfo, …) into a
+      // terminal finish chunk instead of a throw — the cause rides in
+      // chunk.reason.failure {message, code}. Surface it, never swallow it.
+      if (typeof onStreamError === "function") {
+        try { onStreamError(chunk.reason); } catch { /* diagnostics only */ }
+      }
       return undefined;
     }
   }
   return text;
 }
 
+/** One-line human-readable cause from a finish-chunk failure reason. */
+function describeStreamFailure(reason) {
+  const failure = reason?.failure ?? reason ?? {};
+  const code = failure.code ? String(failure.code) : "";
+  const message = String(failure.message ?? failure.error ?? "");
+  if (code && message) return message.includes(code) ? message : `${code}: ${message}`;
+  return code || message;
+}
+
 /**
  * Bug8: wrap a background LLM call so its token/time/status are recorded in the
  * llm_audit_logs table. Best-effort bookkeeping: a failure to WRITE the audit
@@ -279,9 +295,12 @@ async function runAuditedLlm(ctx, service, config, spec, body) {
     });
     if (result === undefined) {
       // stream aborted/errored: the caller treats undefined as a failed run;
-      // record it as error here so the audit shows the truth.
+      // record it as error here so the audit shows the truth. spec.streamError
+      // (a getter) lets the caller attach the finish-chunk cause so the audit
+      // row names it instead of a bare "aborted".
       status = "error";
-      errorMessage = errorMessage ?? "llm stream aborted or errored";
+      const streamErr = typeof spec.streamError === "function" ? String(spec.streamError() ?? "") : "";
+      errorMessage = errorMessage ?? (streamErr ? `llm stream aborted or errored (${streamErr})` : "llm stream aborted or errored");
     } else if (typeof spec.auditError === "function") {
       // A stream that returned text but yields nothing usable is still a
       // failed call — record it as error, not the default success, so the
@@ -328,10 +347,22 @@ async function runAuditedLlm(ctx, service, config, spec, body) {
  * accepted → reasoning capped; rejected → provider default (old behavior),
  * logged so the rejection is observable.
  */
-async function withEffortFallback(ctx, effort, attempt, fallback) {
+async function withEffortFallback(ctx, effort, attempt, fallback, getStreamError) {
   if (!effort || effort === "none") return attempt();
   try {
-    return await attempt();
+    const result = await attempt();
+    if (result === undefined) {
+      // dsh-llm rc.1 streams a provider effort-rejection as a terminal error
+      // finish chunk (adapterStream catches everything, never throws) — match
+      // on the chunk's failure reason here or the retry below is dead code
+      // for the stream path.
+      const reason = String(getStreamError?.() ?? "");
+      if (/reasoning[\s_]*effort|UNSUPPORTED_REASONING_EFFORT/i.test(reason)) {
+        ctx.logger?.warn?.(`dsh-mneme dream: reasoningEffort "${effort}" rejected via stream (${reason}); retrying without it`);
+        return fallback();
+      }
+    }
+    return result;
   } catch (error) {
     const message = String(error?.message ?? error);
     // matches both "reasoning effort" (natural language) and the bare
@@ -437,12 +468,15 @@ async function maintainIndexAfterDream(decisions, service, semantic) {
   if (embedder.modelHash) vectorIndex.markModel?.(embedder.modelHash, embedder.dimension);
 }
 
-export function createDreamScheduler({ onRun, thresholdCount = 10, thresholdChars = 5000, delayMs = 2000, logger, semantic = null }) {
+export function createDreamScheduler({ onRun, thresholdCount = 10, thresholdChars = 5000, delayMs = 2000, minIntervalMs = 0, logger, semantic = null }) {
   let pendingTimer = null;
   let running = false;
   let disposed = false;
   let baseline = { count: 0, chars: 0 };
   let inFlight = null;
+  // Issue #89（请求 2）：上一次实际开跑时刻。失败/degraded 的 run 也占用
+  // 最小间隔——节流的目的正是防止失败调用连发；间隔内的触发静默跳过。
+  let lastRunAt = 0;
 
   function shouldTrigger(service) {
     const memories = service.all().filter((m) => !m.archived && m.type !== "summary");
@@ -455,11 +489,14 @@ export function createDreamScheduler({ onRun, thresholdCount = 10, thresholdChar
 
   function maybeSchedule(service) {
     if (disposed || running || pendingTimer) return false;
+    // Issue #89（请求 2）：最小触发间隔闸门。
+    if (minIntervalMs > 0 && Date.now() - lastRunAt < minIntervalMs) return false;
     const { trigger, count, chars } = shouldTrigger(service);
     if (!trigger) return false;
     pendingTimer = setTimeout(() => {
       pendingTimer = null;
       running = true;
+      lastRunAt = Date.now();
       // Defer the onRun invocation so a synchronous throw cannot escape the
       // timer callback (which would crash the process) and skip the teardown.
       // Errors are logged, never swallowed silently. inFlight lets dispose()
@@ -630,11 +667,15 @@ export function createDreamScheduler({ onRun, thresholdCount = 10, thresholdChar
     // 记 audit error 并在日志带原始输出前 300 字节，便于定位"推理吞预算返回空体"。
     const effort = config.dreamReasoningEffort && config.dreamReasoningEffort !== "none" ? config.dreamReasoningEffort : null;
     let decisions = null;
-    const runConsolidation = (withEffort) => runAuditedLlm(ctx, service, config, {
+    let streamFailure = "";
+    const runConsolidation = (withEffort) => {
+      streamFailure = "";
+      return runAuditedLlm(ctx, service, config, {
       triggerSource: "autoDream",
       operationType: "dream_consolidate",
       modelId: `${route.provider}:${route.model}`,
       relatedMemoryIds: [...snapshot.keys()],
+      streamError: () => streamFailure,
       auditError: (text) => {
         decisions = extractJsonArray(text);
         return Array.isArray(decisions) ? null : "no json array in llm output";
@@ -649,18 +690,19 @@ export function createDreamScheduler({ onRun, thresholdCount = 10, thresholdChar
         { role: "system", content: [{ type: "text", text: consolidationPrompt }] },
         { role: "user", content: [{ type: "text", text: listText }] }
       ]
-    }, reportUsage));
+    }, reportUsage, (reason) => { streamFailure = describeStreamFailure(reason); }));
+    };
     try {
       // Bug8: the consolidation call is audited (tokens/time/status). A throw
       // re-propagates to the catch below; an aborted stream returns undefined
       // and is treated as a failed run after the check below.
-      decisionText = await withEffortFallback(ctx, effort, () => runConsolidation(true), () => runConsolidation(false));
+      decisionText = await withEffortFallback(ctx, effort, () => runConsolidation(true), () => runConsolidation(false), () => streamFailure);
     } catch (error) {
       logger?.warn?.(`dsh-mneme dream: consolidation llm call failed: ${String(error)}`);
       return finish({ ok: false, error: "llm failed", summary: false });
     }
     if (decisionText === undefined) {
-      logger?.warn?.("dsh-mneme dream: consolidation llm stream aborted or errored");
+      logger?.warn?.(`dsh-mneme dream: consolidation llm stream aborted or errored${streamFailure ? ` (${streamFailure})` : ""}`);
       return finish({ ok: false, error: "llm failed", summary: false });
     }
     if (!Array.isArray(decisions)) {
@@ -668,18 +710,26 @@ export function createDreamScheduler({ onRun, thresholdCount = 10, thresholdChar
       logger?.warn?.(`dsh-mneme dream: no json array in llm output (raw length ${decisionText?.length ?? 0}; head: ${head})`);
       return finish({ ok: false, error: "no json array in llm output", summary: false });
     }
-    const { ok, errors } = validateDecisions(decisions, snapshot, {
+    const { ok, errors, skipped } = validateDecisions(decisions, snapshot, {
       maxUpdatePerRun: config.reflectionUpdateMaxPerRun,
       minAgeHours: config.reflectionUpdateMinAgeHours,
       // v0.4.4 fix：显式透传，用户配 dreamImplicitKeep:false 时严格模式必须
       // 真正生效，dreamMinExplicitCoverage 决定隐式 keep 下的覆盖率下限。
       dreamImplicitKeep: config.dreamImplicitKeep,
-      dreamMinExplicitCoverage: config.dreamMinExplicitCoverage
+      dreamMinExplicitCoverage: config.dreamMinExplicitCoverage,
+      // Issue #89：v0.6.9（Issue #26）的宽容路径在 v0.7.11 重写中丢失——单条
+      // 非法决策重新只跳过该条、合法子集照常应用（run 记为 degraded）。
+      skipInvalid: config.dreamSkipInvalid !== false,
+      allowCrossTypeMerge: config.allowCrossTypeMerge === true
     });
     if (!ok) {
       logger?.warn?.(`dsh-mneme dream: invalid decisions: ${errors.join("; ")}`);
       return finish({ ok: false, error: `invalid decisions: ${errors.length} errors`, summary: false });
     }
+    const skippedInvalid = skipped.length > 0;
+    if (skippedInvalid) {
+      logger?.warn?.(`dsh-mneme dream: ${skipped.length} invalid decision(s) skipped (run degrades): ${skipped.map((s) => s.error).join("; ")}`);
+    }
 
     // Capture pre-update snapshots so the audit records what each update changed.
     const updateSnapshots = {};
@@ -782,11 +832,15 @@ export function createDreamScheduler({ onRun, thresholdCount = 10, thresholdChar
     // Summary generation (second LLM call). A throwing stream is reported as
     // a failed run; summary:false marks a run that produced no summary.
     let summaryText;
-    const runSummary = (withEffort) => runAuditedLlm(ctx, service, config, {
+    let summaryStreamFailure = "";
+    const runSummary = (withEffort) => {
+      summaryStreamFailure = "";
+      return runAuditedLlm(ctx, service, config, {
       triggerSource: "autoDream",
       operationType: "dream_summarize",
       modelId: `${route.provider}:${route.model}`,
-      relatedMemoryIds: []
+      relatedMemoryIds: [],
+      streamError: () => summaryStreamFailure
     }, (reportUsage) => streamText(ctx, {
       provider: route.provider,
       model: route.model,
@@ -797,10 +851,11 @@ export function createDreamScheduler({ onRun, thresholdCount = 10, thresholdChar
         { 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") }] }
       ]
-    }, reportUsage));
+    }, reportUsage, (reason) => { summaryStreamFailure = describeStreamFailure(reason); }));
+    };
     try {
       // Bug8: the summary call is audited too (operation dream_summarize).
-      summaryText = await withEffortFallback(ctx, effort, () => runSummary(true), () => runSummary(false));
+      summaryText = await withEffortFallback(ctx, effort, () => runSummary(true), () => runSummary(false), () => summaryStreamFailure);
     } catch (error) {
       logger?.warn?.(`dsh-mneme dream: summary llm call failed: ${String(error)}`);
       return finish({ ok: false, error: "llm failed", applied, decisions: auditDecisions, outcome, frozen: frozenCount, summary: false });
@@ -831,9 +886,11 @@ export function createDreamScheduler({ onRun, thresholdCount = 10, thresholdChar
     //               run. ok:false keeps the scheduler from moving the baseline.
     //   ok        — either real changes landed, or a fresh summary was stored
     //               (all-keep + summary is a substantive summary refresh).
-    //   degraded  — real consolidation landed but the summary came back empty/
-    //               missing: the store was absorbed (ok for the baseline) but
-    //               the run did not produce its full output (marked, not faked).
+    //   degraded  — real consolidation landed but the run did not produce its
+    //               full output: the summary came back empty/missing, or
+    //               skipInvalid dropped individually-invalid decisions
+    //               (Issue #89 — marked, not faked). The valid subset was
+    //               absorbed (ok for the baseline).
     let status;
     let okResult;
     if (partial) {
@@ -843,7 +900,7 @@ export function createDreamScheduler({ onRun, thresholdCount = 10, thresholdChar
       status = summaryStored ? "ok" : "noop";
       okResult = summaryStored;
     } else {
-      status = summaryStored ? "ok" : "degraded";
+      status = summaryStored && !skippedInvalid ? "ok" : "degraded";
       okResult = true;
     }
     return finish({

package/src/index.js

@@ -283,6 +283,7 @@ export const apply = (ctx, config) => {
       thresholdCount: cfg.dreamThresholdCount,
       thresholdChars: cfg.dreamThresholdChars,
       delayMs: cfg.dreamDelayMs,
+      minIntervalMs: (cfg.dreamMinIntervalMinutes ?? 0) * 60000,
       logger: ctx.logger,
       semantic: { embedder, vectorIndex },
       onRun: () => (dream ? dream.runDream(ctx, service, cfg) : Promise.resolve({ ok: true, skipped: true }))

package/src/settings.js

@@ -58,6 +58,9 @@ const FEATURE_FLAG_BOOLEANS = [
   "bm25SearchEnabled",
   "conflictFreezeEnabled",
   "trustEpistemicWeighting",
+  // Issue #89：宽容校验回归（默认开）+ 跨类型合并显式放宽（默认关）。
+  "dreamSkipInvalid",
+  "allowCrossTypeMerge",
   // 嵌套对象开关：config.js 里是 memoryQualityFilter / llmAudit 对象的 enabled
   // 子字段。kv 按点号键平铺存（"memoryQualityFilter.enabled": false），index.js
   // 合并时展开回嵌套对象，api.js 的 effective 从对象子字段取值。
@@ -70,7 +73,8 @@ const FEATURE_FLAG_INT_RANGES = {
   distillRateLimitRetries: [0, 10],
   distillRateLimitBaseDelayMs: [100, 60000],
   distillMaxChars: [1000, 200000],
-  codingBoostFactor: [1, 5]
+  codingBoostFactor: [1, 5],
+  dreamMinIntervalMinutes: [0, 10080]
 };
 // 自由字符串开关（与 config.js 的 z.string() 同名同型）：trim 后 ≤200 字符，
 // 空串合法（= 跟随主对话模型/默认路径，面板显示 placeholder）。

package/test/api.test.js

@@ -527,10 +527,14 @@ 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 覆盖全部 31 个白名单键（含 v0.7.20 新增的 heatEnabled），未覆盖时
-  // 取 bundle 配置的解析默认值；dreamProvider/dreamModel 无 schema 默认值
-  // （Config({}) 解析为 undefined），不编造给前端 → 31 - 2 = 29
-  assert.equal(Object.keys(data.effective).length, 29);
+  // effective 覆盖全部 34 个白名单键（含 v0.7.20 heatEnabled 与 Issue #89 回归
+  // 修复新增的 dreamSkipInvalid/allowCrossTypeMerge/dreamMinIntervalMinutes），
+  // 未覆盖时取 bundle 配置的解析默认值；dreamProvider/dreamModel 无 schema
+  // 默认值（Config({}) 解析为 undefined），不编造给前端 → 34 - 2 = 32
+  assert.equal(Object.keys(data.effective).length, 32);
+  assert.equal(data.effective.dreamSkipInvalid, true);
+  assert.equal(data.effective.allowCrossTypeMerge, false);
+  assert.equal(data.effective.dreamMinIntervalMinutes, 0);
   assert.equal(data.effective.autoInject, true);
   assert.equal(data.effective.codingRetrospect, false);
   assert.equal(data.effective.distillMaxChars, 24000);

package/test/dream.test.js

@@ -899,3 +899,175 @@ test("Bug8: a failed LLM call is recorded with status=error and does not block t
   assert.ok(rows[0].error_message, "error message recorded");
   store.close();
 });
+
+// --- Issue #89 回归修复：v0.6.9（Issue #26）的 skipInvalid 宽容路径在 v0.7.11
+// 重写中丢失，弱模型（如 qwen3.8-flash）单条非法决策导致整单拒绝、合法子集
+// 全部白烧。以下单测自 v0.6.9 测试原样移植，锁定恢复后的行为。-------------
+
+test("validateDecisions skipInvalid: a single invalid decision is skipped, valid subset survives", () => {
+  const snap = new Map([
+    ["p", { id: "p", type: "preference", title: "语言", content: "中文", importance: 3, archived: false, forgotten: false }],
+    ["j", { id: "j", type: "project", title: "插件", content: "内容", importance: 3, archived: false, forgotten: false }],
+    ["a", { id: "a", type: "project", title: "旧A", content: "过时A", importance: 3, archived: false, forgotten: false }],
+    ["b", { id: "b", type: "project", title: "旧B", content: "过时B", importance: 3, archived: false, forgotten: false }]
+  ]);
+  const decisions = [
+    { action: "merge", ids: ["p", "j"], keepSource: "p", title: "跨类型", content: "不应合并", importance: 4 },
+    { action: "archive", ids: ["a"], reason: "stale" },
+    { action: "archive", ids: ["b"], reason: "stale" }
+  ];
+  const { ok, errors, skipped } = validateDecisions(decisions, snap, { skipInvalid: true });
+  assert.equal(ok, true, `valid subset should survive, got: ${errors.join("; ")}`);
+  assert.equal(skipped.length, 1, "cross-type merge recorded as skipped");
+  assert.equal(skipped[0].index, 0, "the skipped one is the cross-type merge");
+  assert.match(skipped[0].error, /multiple types/, "skip reason mentions types");
+  // invalid merge spliced out of the caller's array; valid archives + implicit
+  // keeps for p/j survive (p/j were left unclaimed by the skipped merge)
+  assert.deepEqual(decisions.map((d) => d.action), ["archive", "archive", "keep", "keep"]);
+  assert.deepEqual(decisions[0].ids, ["a"]);
+  assert.ok(decisions.some((d) => d.action === "keep" && d.ids.includes("p")), "p auto-kept");
+  assert.ok(decisions.some((d) => d.action === "keep" && d.ids.includes("j")), "j auto-kept");
+});
+
+test("validateDecisions skipInvalid: an all-invalid batch still rejects (coverage floor guards truncation)", () => {
+  const snap = new Map([
+    ["p", { id: "p", type: "preference", title: "语言", content: "中文", importance: 3, archived: false, forgotten: false }],
+    ["j", { id: "j", type: "project", title: "插件", content: "内容", importance: 3, archived: false, forgotten: false }],
+    ["d1", { id: "d1", type: "decision", title: "决定", content: "内容D", importance: 3, archived: false, forgotten: false }],
+    ["b", { id: "b", type: "project", title: "旧B", content: "过时B", importance: 3, archived: false, forgotten: false }]
+  ]);
+  // both decisions are cross-type merges → both skipped → valid claims = 0
+  const decisions = [
+    { action: "merge", ids: ["p", "j"], keepSource: "p", title: "跨类型", content: "不应合并", importance: 4 },
+    { action: "merge", ids: ["d1", "b"], keepSource: "d1", title: "跨类型2", content: "不应合并", importance: 4 }
+  ];
+  const { ok, errors, skipped } = validateDecisions(decisions, snap, { skipInvalid: true });
+  assert.equal(ok, false, "no valid decisions left → whole batch rejected");
+  assert.equal(skipped.length, 2);
+  assert.ok(errors.some((e) => e.includes("coverage")), "coverage error present");
+  assert.equal(decisions.length, 2, "rejected batch left untouched (splice only on the success path)");
+});
+
+test("validateDecisions skipInvalid: runaway update count still rejects the whole batch (global cap)", () => {
+  const snap = new Map([
+    ["a", { id: "a", type: "project", title: "A", content: "旧A", importance: 3, archived: false, forgotten: false, created_at: "2020-01-01T00:00:00.000Z" }],
+    ["b", { id: "b", type: "project", title: "B", content: "旧B", importance: 3, archived: false, forgotten: false, created_at: "2020-01-01T00:00:00.000Z" }],
+    ["c", { id: "c", type: "project", title: "C", content: "旧C", importance: 3, archived: false, forgotten: false, created_at: "2020-01-01T00:00:00.000Z" }]
+  ]);
+  const decisions = [
+    { action: "update", ids: ["a"], content: "新A" },
+    { action: "update", ids: ["b"], content: "新B" },
+    { action: "update", ids: ["c"], content: "新C" }
+  ];
+  const { ok, errors } = validateDecisions(decisions, snap, { skipInvalid: true });
+  assert.equal(ok, false, "3 updates > default cap 2 → still rejects");
+  assert.ok(errors.some((e) => e.includes("too many update decisions")), "global cap error present");
+});
+
+test("validateDecisions allowCrossTypeMerge: cross-type merge is allowed when the flag is on", () => {
+  const snap = new Map([
+    ["p", { id: "p", type: "preference", title: "语言", content: "中文", importance: 3, archived: false, forgotten: false }],
+    ["j", { id: "j", type: "project", title: "插件", content: "内容", importance: 3, archived: false, forgotten: false }]
+  ]);
+  const decisions = [
+    { action: "merge", ids: ["p", "j"], keepSource: "p", title: "合并", content: "合并内容", importance: 4 }
+  ];
+  const { ok, errors } = validateDecisions(decisions, snap, { allowCrossTypeMerge: true });
+  assert.equal(ok, true, `cross-type merge allowed with the flag, got: ${errors.join("; ")}`);
+  assert.equal(decisions.length, 1, "no keep appended (both snapshot ids claimed)");
+});
+
+test("validateDecisions default (no options) stays strict — sleep passes unchanged", () => {
+  const snap = new Map([
+    ["a", { id: "a", type: "project", title: "A", content: "旧A", importance: 3, archived: false, forgotten: false }],
+    ["b", { id: "b", type: "project", title: "B", content: "旧B", importance: 3, archived: false, forgotten: false }]
+  ]);
+  const { ok, skipped } = validateDecisions([{ action: "archive", ids: ["zzz"], reason: "x" }], snap);
+  assert.equal(ok, false, "strict rejection without skipInvalid");
+  assert.deepEqual(skipped, [], "no skipped bookkeeping in strict mode");
+});
+
+test("issue#89: dream run with a skipped invalid decision lands the valid subset and is marked degraded", async () => {
+  const { store, service } = dreamSetup();
+  const a = service.saveWithDedupe({ type: "project", title: "旧A", content: "过时A" }).memory;
+  const b = service.saveWithDedupe({ type: "project", title: "旧B", content: "过时B" }).memory;
+  const pref = service.saveWithDedupe({ type: "preference", title: "语言", content: "中文" }).memory;
+  const c = service.saveWithDedupe({ type: "project", title: "旧C", content: "过时C" }).memory;
+  const warnings = [];
+  const ctx = {
+    logger: { warn: (m) => warnings.push(String(m)) },
+    llm: {
+      async *stream(options) {
+        const userText = options.messages.find((m) => m.role === "user")?.content?.[0]?.text ?? "";
+        if (userText.startsWith("id=")) {
+          // 一条跨类型 merge（非法 → 跳过）+ 两条合法 archive（覆盖 2/4 快照，
+  // 高于 50% 显式覆盖率下限）
+          yield { type: "text-delta", index: 0, text: JSON.stringify([
+            { action: "merge", ids: [pref.id, a.id], keepSource: pref.id, title: "跨类型", content: "不应合并", importance: 4 },
+            { action: "archive", ids: [b.id], reason: "stale" },
+            { action: "archive", ids: [c.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: "mock", dreamModel: "mock-model" });
+  assert.equal(result.ok, true, "valid subset absorbed (ok for the baseline)");
+  assert.equal(result.status, "degraded", "run marked degraded, not faked ok");
+  assert.equal(store.getById(b.id).archived, true, "valid archive applied");
+  assert.equal(store.getById(pref.id).archived, false, "invalid merge did not touch its targets");
+  assert.ok(warnings.some((w) => w.includes("skipped") && w.includes("multiple types")), "skip reason logged");
+  store.close();
+});
+
+test("issue#89: dreamSkipInvalid:false restores the whole-batch strict rejection", async () => {
+  const { store, service } = dreamSetup();
+  const a = service.saveWithDedupe({ type: "project", title: "旧A", content: "过时A" }).memory;
+  const b = service.saveWithDedupe({ type: "project", title: "旧B", content: "过时B" }).memory;
+  const pref = service.saveWithDedupe({ type: "preference", title: "语言", content: "中文" }).memory;
+  const ctx = {
+    logger: { warn: () => {} },
+    llm: {
+      async *stream(options) {
+        const userText = options.messages.find((m) => m.role === "user")?.content?.[0]?.text ?? "";
+        if (userText.startsWith("id=")) {
+          yield { type: "text-delta", index: 0, text: JSON.stringify([
+            { action: "merge", ids: [pref.id, a.id], keepSource: pref.id, title: "跨类型", content: "不应合并", importance: 4 },
+            { action: "archive", ids: [b.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: "mock", dreamModel: "mock-model", dreamSkipInvalid: false });
+  assert.equal(result.ok, false, "strict mode rejects the batch");
+  assert.equal(result.error, "invalid decisions: 1 errors");
+  assert.equal(store.getById(b.id).archived, false, "nothing applied under strict rejection");
+  store.close();
+});
+
+test("issue#89: minIntervalMs throttles re-triggering regardless of run outcome", async () => {
+  const { store, service } = dreamSetup();
+  let runs = 0;
+  const dream = createDreamScheduler({
+    onRun: async () => { runs++; return { ok: false, error: "llm failed" }; },
+    thresholdCount: 1, thresholdChars: 0, delayMs: 0, minIntervalMs: 80,
+    logger: { warn: () => {} }
+  });
+  service.saveWithDedupe({ type: "project", title: "a", content: "x" });
+  assert.equal(dream.maybeSchedule(service), true, "first trigger scheduled");
+  await new Promise((r) => setTimeout(r, 20)); // delayMs 0 → run already dispatched and finished
+  assert.equal(runs, 1, "ran once");
+  assert.equal(dream.maybeSchedule(service), false, "inside the min interval, even after a failed run");
+  await new Promise((r) => setTimeout(r, 90));
+  assert.equal(dream.maybeSchedule(service), true, "interval elapsed → eligible again (baseline unmoved by failure)");
+  store.close();
+});

package/test/reasoning-effort.test.js

@@ -234,3 +234,117 @@ test("issue#9: sleep forwards sleepReasoningEffort on its LLM passes", async ()
   }
   store.close();
 });
+
+// ------------------------------------------------------------------ stream-level rejection
+// dsh-llm rc.1 converts adapter-stage failures (including the provider's
+// UNSUPPORTED_REASONING_EFFORT throw from resolveCallWithInfo) into a terminal
+// error finish chunk inside adapterStream — the rejection NEVER reaches our
+// catch. The v0.7.16 throw-based fallback was therefore dead code for the
+// stream path; these tests pin the finish-chunk-based fallback.
+
+test("rc.1 stream-level effort rejection (error finish chunk) also triggers the no-effort retry", 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 calls = [];
+  const warnings = [];
+  const ctx = {
+    logger: { warn: (m) => warnings.push(String(m)) },
+    agentDefaultModel: { currentSelection: () => ({ provider: "mock", model: "mock-model" }) },
+    llm: {
+      async *stream(options) {
+        calls.push(options);
+        if (options.reasoningEffort) {
+          yield {
+            type: "finish",
+            reason: {
+              kind: "error",
+              failure: {
+                code: "UNSUPPORTED_REASONING_EFFORT",
+                message: 'provider "mock" model "mock-model" does not support reasoning effort "low"'
+              }
+            }
+          };
+          return;
+        }
+        const userText = options.messages.find((m) => m.role === "user")?.content?.[0]?.text ?? "";
+        if (userText.startsWith("id=")) {
+          yield { type: "text-delta", index: 0, text: JSON.stringify([
+            { action: "merge", ids: [a.id, b.id], keepSource: b.id, title: "合并标题", content: "合并内容", importance: 4 }
+          ]) };
+        } else {
+          yield { type: "text-delta", index: 0, text: "记忆库总览：用户偏好中文。" };
+        }
+        yield { type: "finish", reason: { kind: "stop" } };
+      }
+    }
+  };
+  const result = await dream.runDream(ctx, service, { dreamReasoningEffort: "low" });
+  assert.equal(result.ok, true, "run survives the stream-level effort rejection");
+  assert.ok(result.applied > 0, "consolidation still lands changes");
+  assert.equal(calls[0].reasoningEffort, "low", "first attempt forwards the effort");
+  assert.equal("reasoningEffort" in calls[1], false, "retry omits the rejected effort field");
+  assert.ok(warnings.some((w) => w.includes("rejected via stream")), "the stream-level rejection is logged");
+  store.close();
+});
+
+test("non-effort stream failures are not retried and the finish-chunk cause reaches the audit row", async () => {
+  const store = createStore(":memory:");
+  const service = createService({ store, mirror: null, config: {} });
+  service.saveWithDedupe({ type: "project", title: "主题", content: "内容" });
+  const calls = [];
+  const ctx = {
+    logger: { warn: () => {} },
+    agentDefaultModel: { currentSelection: () => ({ provider: "mock", model: "mock-model" }) },
+    llm: {
+      async *stream(options) {
+        calls.push(options);
+        yield { type: "finish", reason: { kind: "error", failure: { code: "PROVIDER_GONE", message: "provider mock is not registered" } } };
+      }
+    }
+  };
+  const dream = createDreamScheduler({ thresholdCount: 1, thresholdChars: 0, delayMs: 0 });
+  const result = await dream.runDream(ctx, service, { dreamReasoningEffort: "low" });
+  assert.equal(result.ok, false);
+  assert.equal(result.error, "llm failed", "the run error stays the stable short string");
+  assert.equal(calls.length, 1, "no blind retry when the stream failure is not an effort rejection");
+  const row = service.listLlmAudits().find((r) => r.operation_type === "dream_consolidate");
+  assert.ok(row && row.status === "error", "failed consolidation still audited");
+  assert.ok(
+    String(row.error_message).includes("PROVIDER_GONE") && String(row.error_message).includes("provider mock is not registered"),
+    "audit error_message carries the finish-chunk cause"
+  );
+  store.close();
+});
+
+test("sleep passes the stream failure accessor so a stream-level effort rejection retries", 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(null, { provider: "mock", model: "sleep-model" }, captured);
+  ctx.llm.stream = async function* (options) {
+    captured.push(options);
+    if (options.reasoningEffort) {
+      yield {
+        type: "finish",
+        reason: { kind: "error", failure: { code: "UNSUPPORTED_REASONING_EFFORT", message: 'provider "mock" model "sleep-model" does not support reasoning effort "low"' } }
+      };
+      return;
+    }
+    const userText = options.messages.find((m) => m.role === "user")?.content?.[0]?.text ?? "";
+    yield { type: "text-delta", index: 0, text: userText.startsWith("候选冲突")
+      ? JSON.stringify([{ action: "conflict", winner: a.id, loser: b.id, reason: "重复覆盖" }])
+      : "[]" };
+    yield { type: "finish", reason: { kind: "stop" } };
+  };
+  const result = await runSleep(ctx, service, baseConfig({ sleepReasoningEffort: "low" }), ctx.logger, { embedder, vectorIndex }, null);
+  assert.equal(result.status, "ok", "sleep survives the stream-level effort rejection");
+  assert.equal(captured[0].reasoningEffort, "low", "first conflict attempt forwards the effort");
+  assert.equal("reasoningEffort" in captured[1], false, "conflict retry omits the rejected effort field");
+  store.close();
+});