@modusensus/dsh-mneme 0.7.21 → 0.7.22

package/README.en.md

@@ -166,6 +166,7 @@ Every **background LLM call** (autoDream consolidation + summary, autoSummarize
 
 | Version | Highlights |
 |------|------|
+| **v0.7.22** | Restored the v0.6.9 skipInvalid tolerant-validation path (issue #89 regression, lost in the v0.7.11 rewrite): `dreamSkipInvalid` (default true) skips individual invalid decisions, applies the valid subset, and marks the run degraded; `allowCrossTypeMerge` (default false) explicitly relaxes cross-type merging — weak models (e.g. qwen3.8-flash) with jittery schema compliance no longer fail the whole batch and burn LLM calls. Strict mode and the sleep path behave unchanged; global caps/coverage floors still reject the whole run (running over cap = broken model, not minor schema drift). New `dreamMinIntervalMinutes` (0–10080, default 0 = unlimited) minimum autoDream trigger interval — failed/degraded runs also consume the interval (throttling exists to stop back-to-back failing calls); feature_flags whitelist now 34 keys; 696 tests green |
 | **v0.7.21** | Fixed autoDream/sleep effort fallback being dead code on the stream path (the catch-based retry from v0.7.16 never fired): dsh-llm rc.1 turns adapter-stage failures (incl. `UNSUPPORTED_REASONING_EFFORT`) into a terminal error finish chunk instead of a throw; `streamText` now captures the finish-chunk failure cause (`describeStreamFailure` normalizes `{code,message}`) + `withEffortFallback` gains a `getStreamError` accessor (retries without effort when rejected) + `runAuditedLlm` supports `spec.streamError` (audit `error_message` carries the real cause; `run.error` stays a stable `"llm failed"`); 688 tests green |
 | **v0.7.20** | Heat model restored (issue #87): v0.7.0 self-evolving memory back (`src/heat.js` power-law decay `H=1/(1+λΔt)^α` + per-type half-lives), sleep demotion dual protection (cold time-window + heat<0.05 + importance<5), touchRecalled gating back on `heatEnabled`, entity heat projection (ego node heat → size/opacity), recall_runs recording on by default; **default OFF** (matches v0.7.12 behavior out of the box) + feature_flags whitelist rollback switch + lightMode linkage + sleep demotion audit counts exposed (workbench can show "N demoted") + phase-two frontend (/list heat projection, HeatBadge three-tier badge, self-gated status heat-distribution card, order=heat page-local sort, all self-gated); better-sidebar fix (issue #88: soft integration moved to an inner dynamic sub-plugin, no more startup failure without bs); 685 tests green |
 | **v0.7.18** | Ecosystem step one + query convergence: better-sidebar soft integration (inject declaration + optional peer `dsh-better-sidebar` + registerTab reusing the four views, safe skip when absent; narrow-container `@container` adaptation) + `/list?deposited=only` view (receipt_chain ∪ source=dream) + deposited/archived filter chips in the library + status-page dashboard (server totals + view-all jumps) + drawer restore for archived memories; 667 tests green |
@@ -219,6 +220,7 @@ Every **background LLM call** (autoDream consolidation + summary, autoSummarize
 | v0.7.18 | ✅ Done | Ecosystem step one + query convergence | better-sidebar soft integration (inject declaration + optional peer + registerTab reusing the four views, safe skip when absent; narrow-container `@container`) + `/list?deposited=only` view + deposited/archived filter chips + status-page dashboard + drawer restore; 667 tests green |
 | v0.7.20 | ✅ Done | Heat restore + phase-two frontend + better-sidebar fix | Heat model fully restored (issue #87, backported from v0.7.10: power-law decay + TYPE_DECAY + sleep heat-combined dual protection + entity heat projection) + acceptance checklist landed (heatEnabled default OFF / feature_flags 31 keys / lightMode linkage / sleep demotion audit / updated_at⊥last_accessed_at contract) + phase-two frontend (/list heat projection, HeatBadge three-tier, order=heat page-local sort) + better-sidebar fix (issue #88: inner dynamic sub-plugin); 685 tests green |
 | v0.7.21 | ✅ Done | effort-fallback stream fix | Catch-based effort fallback was dead code on the stream path (dsh-llm rc.1 turns adapter failures into a terminal error finish chunk instead of a throw) → `streamText` captures the finish-chunk cause (`describeStreamFailure`) + `withEffortFallback` gains a `getStreamError` accessor (retries without effort when rejected) + `runAuditedLlm` supports `spec.streamError` (real cause in audit); 688 tests green |
+| v0.7.22 | ✅ Done | skipInvalid tolerant-validation restore (issue #89) + autoDream throttle | Restored v0.6.9 skipInvalid dual-track structure (lost in the v0.7.11 rewrite): `dreamSkipInvalid` skips individual invalid decisions + applies the valid subset + marks the run degraded; `allowCrossTypeMerge` explicitly relaxes cross-type merging; weak models (qwen3.8-flash) with jittery schema compliance no longer fail the whole batch. New `dreamMinIntervalMinutes` (0–10080, default 0) minimum trigger interval — failed/degraded runs also consume it. Strict mode / sleep path unchanged; feature_flags whitelist 34 keys; 696 tests green |
 | **v0.8.0** | 🚧 Planned (late Sep) | Graph enhancement | Interest-drift visualization + scope isolation (issue #17) + cross-workspace sharing |
 
 > All new capabilities ship as **toggleable features** (enabled/disabled via configuration), conservatively on by default and never breaking existing behavior. The `failure_memories` table and the autoDream decision engine have already paved the way for future reflective growth.

package/README.md

@@ -207,6 +207,7 @@ v0.3.0 起新增**记忆基因**层：从记忆里抽取**命名实体**、**带
 
 | 版本 | 亮点 |
 |------|------|
+| **v0.7.22** | 恢复 v0.6.9 的 skipInvalid 宽容校验路径（issue #89 回归，v0.7.11 重写丢失）：`dreamSkipInvalid`（默认 true）单条非法决策跳过 + 合法子集应用 + run 记 degraded，`allowCrossTypeMerge`（默认 false）显式放宽跨类型合并——弱模型（如 qwen3.8-flash）决策合规抖动不再整单拒绝白烧 LLM 调用；严格模式/sleep 路径行为不变，全局上限/覆盖率下限仍整单拒绝（刷爆上限=模型坏了，非轻微 schema 漂移）；新增 `dreamMinIntervalMinutes`（0-10080，默认 0=不限）autoDream 最小触发间隔，失败/degraded run 也占用间隔（节流防失败调用连发）；feature_flags 白名单 34 键；696 测试全绿 |
 | **v0.7.21** | 修复 autoDream/sleep 的 effort 回退在流式路径失效（v0.7.16 的 catch 式回退是死代码）：dsh-llm rc.1 把 adapter 阶段异常（含 `UNSUPPORTED_REASONING_EFFORT`）转成终态 error finish chunk 不再抛出；`streamText` 现捕获 finish-chunk 失败原因（新增 `describeStreamFailure` 归一化 `{code,message}`）+ `withEffortFallback` 增加 `getStreamError` 访问器（effort 被拒时去掉重试一次）+ `runAuditedLlm` 支持 `spec.streamError`（audit 行 `error_message` 携带真实原因，`run.error` 稳定 `"llm failed"` 不变）；688 测试全绿 |
 | **v0.7.20** | heat 热度模型回归（issue #87）：找回 v0.7.0 自进化记忆（`src/heat.js` 幂律衰减 `H=1/(1+λΔt)^α` + per-type 差异化半衰期）、sleep 降级热联合双保护（时间窗冷 + heat<0.05 + importance<5）、touchRecalled 门控改回 `heatEnabled`、实体热投影（ego 节点 heat → 前端大小/明暗）、recall_runs 默认记录；**默认关**（默认=与 v0.7.12 行为一致）+ feature_flags 白名单回滚开关 + lightMode 联动 + sleep 降级审计计数暴露（工作动态可展示"降级 N 条"）+ 阶段二前端（/list heat 投影、HeatBadge 三档徽章、状态页热度分布卡、order=heat 页内排序，全部自门控）；better-sidebar 修复（issue #88：软集成改内层动态子插件，无 bs 环境不再启动失败）；685 测试全绿 |
 | **v0.7.18** | 生态第一步 + 查询收敛：better-sidebar 软集成（inject 声明 + optional peer `dsh-better-sidebar` + registerTab 复用四视图，未装安全跳过；窄容器 `@container` 适配）+ `/list?deposited=only` 沉淀视图（receipt_chain ∪ source=dream）+ 记忆库沉淀/已归档筛选 chip + 状态页仪表盘化（统计 + 查看全部跳转预置筛选）+ 抽屉归档记忆「恢复」；667 测试全绿 |
@@ -291,6 +292,7 @@ v0.3.0 起新增**记忆基因**层：从记忆里抽取**命名实体**、**带
 | **v0.7.18** | ✅ 完成 | 生态第一步 + 查询收敛 | better-sidebar 软集成（inject 声明 + optional peer `dsh-better-sidebar` + registerTab 复用四视图，未装安全跳过；窄容器 `@container` 适配）+ `/list?deposited=only` 沉淀视图（receipt_chain ∪ source=dream）+ 记忆库沉淀/已归档筛选 chip + 状态页仪表盘化（统计 + 查看全部跳转预置筛选）+ 抽屉归档记忆「恢复」；667 测试全绿 |
 | **v0.7.20** | ✅ 完成 | heat 回归 + 阶段二前端 + better-sidebar 修复 | heat 热度模型完整找回（issue #87，v0.7.10 移植：幂律衰减 + TYPE_DECAY + sleep 热联合双保护 + 实体热投影）+ 验收清单落地（heatEnabled 默认关 / feature_flags 31 键 / lightMode 联动 / sleep 降级审计暴露 / updated_at⊥last_accessed_at 契约）+ 阶段二前端（/list heat 投影、HeatBadge 三档、order=heat 页内排序）+ better-sidebar 修复（issue #88：内层动态子插件）；685 测试全绿 |
 | **v0.7.21** | ✅ 完成 | effort 回退流式修复 | autoDream/sleep 的 catch 式 effort 回退在流式路径是死代码（dsh-llm rc.1 把 adapter 异常转成终态 error finish chunk 不再抛出）→ `streamText` 捕获 finish-chunk 失败原因（`describeStreamFailure` 归一化）+ `withEffortFallback` 增加 `getStreamError` 访问器（effort 被拒去重试）+ `runAuditedLlm` 支持 `spec.streamError`（audit 记真实原因）；688 测试全绿 |
+| **v0.7.22** | ✅ 完成 | skipInvalid 宽容校验回归（issue #89）+ autoDream 节流 | 恢复 v0.6.9 的 skipInvalid 双轨结构（v0.7.11 重写丢失）：`dreamSkipInvalid` 单条非法决策跳过 + 合法子集应用 + run 记 degraded，`allowCrossTypeMerge` 显式放宽跨类型合并；弱模型（qwen3.8-flash）决策合规抖动不再整单拒绝；新增 `dreamMinIntervalMinutes`（0-10080，默认 0=不限）最小触发间隔，失败/degraded run 也占用间隔；严格模式/sleep 路径行为不变；feature_flags 白名单 34 键；696 测试全绿 |
 | **v0.8.0** | 🚧 计划中（9 月末） | 图谱增强 | 兴趣漂移可视化 + scope 隔离（issue #17）+ 跨 workspace 记忆共享 |
 
 > 新能力一律做成**可开关的功能**（配置启用/关闭），默认保守开启、不破坏现有行为。`failure_memories` 表与 autoDream 决策引擎已为后续反思性成长铺好路。

package/lib/config.js

@@ -47,6 +47,11 @@ export const Config = z.object({
   dreamThresholdCount: z.natural().min(1).max(1000).default(10),
   dreamThresholdChars: z.natural().min(100).max(100000).default(5000),
   dreamDelayMs: z.natural().min(0).max(60000).default(2000),
+  // autoDream 触发最小间隔（分钟，0 = 不限制，Issue #89 请求 2）：高频写入
+  // 场景下防止巩固调用（含失败重试）连发刷爆配额。间隔从每次实际开跑时刻
+  // 起算，失败/degraded 的 run 也占用间隔；间隔内的触发请求静默跳过，下一次
+  // 写入事件会重新评估。
+  dreamMinIntervalMinutes: z.natural().min(0).max(10080).default(0),
   dreamProvider: z.string(),
   dreamModel: z.string(),
   dreamMaxTokens: z.natural().min(256).max(131072).default(8192),
@@ -74,6 +79,13 @@ export const Config = z.object({
   // → 整单拒绝，防止残缺输出被隐式 keep 洗白成 ok 后再被真实 apply。0-1，
   // 默认 0.5（至少显式覆盖一半 snapshot）。
   dreamMinExplicitCoverage: z.number().min(0).max(1).default(0.5),
+  // Issue #89：v0.6.9（Issue #26）的宽容路径回归。默认跳过单条非法决策
+  // （未知 id / 跨类型合并等）、应用合法子集、run 记 degraded；设 false 恢复
+  // 整单拒绝的严格模式。全局上限与覆盖率下限不受此开关影响、始终整单拒绝。
+  dreamSkipInvalid: z.boolean().default(true),
+  // 显式开启后放宽跨类型合并检查（类型边界由用户自行承担）；配合
+  // dreamSkipInvalid 理解：关闭 skipInvalid 时跨类型 merge 直接整单拒绝。
+  allowCrossTypeMerge: z.boolean().default(false),
   // 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

@@ -7,12 +7,22 @@ const EPISTEMIC_PRIORITY = { observation: 3, inferred: 2, subjective: 1 };
 
 /**
  * Validate a dream decision list against a snapshot of eligible memories.
- * @param decisions - LLM-produced decision list.
+ * @param decisions - LLM-produced decision list. In skipInvalid mode, invalid
+ *   entries are spliced out of this array in place (the caller reuses the same
+ *   reference downstream for apply/audit); implicit keeps are appended here too.
  * @param snapshot - Map<id, memory> of eligible (non-archived, non-summary) entries.
- * @returns {{ok: boolean, errors: string[]}}
+ * @returns {{ok: boolean, errors: string[], skipped?: Array<{index, action, ids, error}>}}
  */
 export function validateDecisions(decisions, snapshot, options = {}) {
   const errors = [];
+  // Issue #89 回归修复（v0.6.9 / Issue #26 的 skipInvalid 路径原样移植，该路径
+  // 在 v0.7.11 重写中丢失）：skipInvalid 开启时，单条非法决策只跳过该条（记录
+  // 到 skipped、不 claim 任何 id），合法子集照常应用，调用方据此把 run 记为
+  // degraded。全局信号（update/create 上限、显式覆盖率下限）依旧整单拒绝——
+  // 刷爆上限或覆盖率不达标的输出是模型坏了，不是轻微 schema 漂移。
+  const skipped = [];
+  const survivors = [];
+  const skipInvalid = options.skipInvalid === true;
   const maxUpdatePerRun = options.maxUpdatePerRun ?? 2;
   const minAgeHours = options.minAgeHours ?? 24;
   if (!Array.isArray(decisions) || decisions.length === 0) {
@@ -21,106 +31,122 @@ export function validateDecisions(decisions, snapshot, options = {}) {
   const claimed = new Set();
   for (const [index, d] of decisions.entries()) {
     const at = `decision[${index}]`;
+    // 单条校验错误先进 local：skipInvalid 模式下整条跳过，严格模式下才并入
+    // 全局 errors（沿用 v0.6.9 的双轨结构）。
+    const local = [];
+    const ids = d && d.action === "conflict" ? [d.winner, d.loser] : (d?.ids ?? []);
     if (!d || typeof d !== "object" || !ACTIONS.has(d.action)) {
-      errors.push(`${at}: invalid action ${JSON.stringify(d?.action)}`);
-      continue;
-    }
-    const ids = d.action === "conflict" ? [d.winner, d.loser] : (d.ids ?? []);
-    if (d.action === "conflict") {
+      local.push(`${at}: invalid action ${JSON.stringify(d?.action)}`);
+    } else if (d.action === "conflict") {
       if (!d.winner || !d.loser || d.winner === d.loser) {
-        errors.push(`${at}: conflict needs distinct winner and loser`);
-        continue;
+        local.push(`${at}: conflict needs distinct winner and loser`);
       }
     } else if (d.action === "create") {
       // Mint a fresh memory (sleep pattern discovery). Claims no existing id,
       // so it skips the claiming loop below; evidence is optional provenance
       // (already filtered to real ids by the caller) and is stored in content.
       if (typeof d.title !== "string" || !d.title.trim()) {
-        errors.push(`${at}: create needs non-empty title`);
-        continue;
+        local.push(`${at}: create needs non-empty title`);
       }
       if (typeof d.content !== "string" || !d.content.trim()) {
-        errors.push(`${at}: create needs non-empty content`);
-        continue;
+        local.push(`${at}: create needs non-empty content`);
       }
       if (d.importance !== undefined && (!Number.isInteger(d.importance) || d.importance < 1 || d.importance > 5)) {
-        errors.push(`${at}: create importance must be an integer 1-5 when provided`);
+        local.push(`${at}: create importance must be an integer 1-5 when provided`);
       }
       if (typeof d.type !== "string" || !d.type.trim()) {
-        errors.push(`${at}: create needs non-empty type`);
+        local.push(`${at}: create needs non-empty type`);
       }
-      continue;
     } else if (!Array.isArray(d.ids) || d.ids.length === 0) {
-      errors.push(`${at}: ${d.action} needs non-empty ids`);
-      continue;
+      local.push(`${at}: ${d.action} needs non-empty ids`);
     }
     // update-specific field validation runs BEFORE claiming ids, so a failing
     // update never pollutes the claimed set (which drives the "every id must
     // appear in a decision" check below).
-    if (d.action === "update") {
+    if (local.length === 0 && d?.action === "update") {
       // 只能更新单条
       if (!Array.isArray(d.ids) || d.ids.length !== 1) {
-        errors.push(`${at}: update must target exactly one id`);
-        continue;
-      }
-      // 必须产生实际变化
-      const mem = snapshot.get(d.ids[0]);
-      const hasChange = (d.title !== undefined && d.title !== mem?.title)
-        || (d.content !== undefined && d.content !== mem?.content)
-        || (d.importance !== undefined && d.importance !== mem?.importance);
-      if (!hasChange) {
-        errors.push(`${at}: update must change at least one field`);
-        continue;
-      }
-      // 不能更新 summary
-      if (mem?.type === "summary") {
-        errors.push(`${at}: cannot update summary via update action`);
-        continue;
-      }
-      // 保护期：新建记忆不可立即被 update（可配置）
-      const ageHours = (Date.now() - new Date(mem?.created_at).getTime()) / 3600000;
-      if (ageHours < minAgeHours) {
-        errors.push(`${at}: memory too young (< ${minAgeHours}h)`);
-        continue;
+        local.push(`${at}: update must target exactly one id`);
+      } else {
+        // 必须产生实际变化
+        const mem = snapshot.get(d.ids[0]);
+        const hasChange = (d.title !== undefined && d.title !== mem?.title)
+          || (d.content !== undefined && d.content !== mem?.content)
+          || (d.importance !== undefined && d.importance !== mem?.importance);
+        if (!hasChange) {
+          local.push(`${at}: update must change at least one field`);
+        } else if (mem?.type === "summary") {
+          // 不能更新 summary
+          local.push(`${at}: cannot update summary via update action`);
+        } else {
+          // 保护期：新建记忆不可立即被 update（可配置）
+          const ageHours = (Date.now() - new Date(mem?.created_at).getTime()) / 3600000;
+          if (ageHours < minAgeHours) {
+            local.push(`${at}: memory too young (< ${minAgeHours}h)`);
+          }
+        }
       }
     }
-    for (const id of ids) {
-      const mem = snapshot.get(id);
-      if (!mem) {
-        errors.push(`${at}: unknown id ${JSON.stringify(id)}`);
-      } else if (mem.archived || mem.type === "summary") {
-        errors.push(`${at}: id ${JSON.stringify(id)} is archived or summary (not eligible)`);
+    if (local.length === 0 && d && d.action !== "create") {
+      // seen 捕获同一条决策内的重复 id；claimed 只含先前存活决策的 id
+      // （被跳过的决策不 claim，其目标留给其它合法决策/隐式 keep）。
+      const seen = new Set();
+      for (const id of ids) {
+        const mem = snapshot.get(id);
+        if (!mem) {
+          local.push(`${at}: unknown id ${JSON.stringify(id)}`);
+        } else if (mem.archived || mem.type === "summary") {
+          local.push(`${at}: id ${JSON.stringify(id)} is archived or summary (not eligible)`);
+        }
+        if (claimed.has(id) || seen.has(id)) {
+          local.push(`${at}: id ${JSON.stringify(id)} claimed by multiple decisions`);
+        }
+        seen.add(id);
       }
-      if (claimed.has(id)) {
-        errors.push(`${at}: id ${JSON.stringify(id)} claimed by multiple decisions`);
+      if (local.length === 0 && d.action === "merge") {
+        if (!d.keepSource || !d.ids.includes(d.keepSource)) {
+          local.push(`${at}: merge keepSource must be one of ids`);
+        }
+        if (typeof d.title !== "string" || !d.title.trim() || typeof d.content !== "string" || !d.content.trim()) {
+          local.push(`${at}: merge needs non-empty title and content`);
+        }
+        if (d.importance !== undefined && (!Number.isInteger(d.importance) || d.importance < 1 || d.importance > 5)) {
+          local.push(`${at}: merge importance must be an integer 1-5 when provided`);
+        }
+        // Merging across types would blur preference/project/decision boundaries
+        // in the injected context; the snapshot carries each entry's type.
+        // Issue #26 (P1)：默认禁止跨类型合并。用户显式开启 allowCrossTypeMerge
+        // 后放宽该检查，类型边界由用户自行承担。
+        const mergeTypes = new Set(d.ids.map((id) => snapshot.get(id)?.type));
+        if (mergeTypes.size > 1 && options.allowCrossTypeMerge !== true) {
+          local.push(`${at}: merge ids span multiple types (${[...mergeTypes].join(", ")})`);
+        }
       }
-      claimed.add(id);
     }
-    if (d.action === "merge") {
-      if (!d.keepSource || !d.ids.includes(d.keepSource)) {
-        errors.push(`${at}: merge keepSource must be one of ids`);
-      }
-      if (typeof d.title !== "string" || !d.title.trim() || typeof d.content !== "string" || !d.content.trim()) {
-        errors.push(`${at}: merge needs non-empty title and content`);
-      }
-      if (d.importance !== undefined && (!Number.isInteger(d.importance) || d.importance < 1 || d.importance > 5)) {
-        errors.push(`${at}: merge importance must be an integer 1-5 when provided`);
-      }
-      // Merging across types would blur preference/project/decision boundaries
-      // in the injected context; the snapshot carries each entry's type.
-      const mergeTypes = new Set(d.ids.map((id) => snapshot.get(id)?.type));
-      if (mergeTypes.size > 1) {
-        errors.push(`${at}: merge ids span multiple types (${[...mergeTypes].join(", ")})`);
+    if (local.length > 0) {
+      if (skipInvalid) {
+        // 单条非法 → 跳过该决策，不 claim id（其目标记忆留给其它合法决策/隐式
+        // keep），并记录到 skipped 供调用方日志/审计。信息性跳过绝不写入全局
+        // errors，否则会误触发下方的整单拒绝。
+        skipped.push({ index, action: d?.action, ids, error: local.join("; ") });
+      } else {
+        errors.push(...local);
       }
+      continue;
+    }
+    if (d.action !== "create") {
+      for (const id of ids) claimed.add(id);
     }
+    survivors.push(d);
   }
-  // Cap update churn: too many edits in one cycle signals a runaway model
-  const updateCount = decisions.filter((d) => d.action === "update").length;
+  // Cap update churn: too many edits in one cycle signals a runaway model.
+  // 全局信号——skipInvalid 模式下依旧整单拒绝（见函数头注释）。
+  const updateCount = survivors.filter((d) => d.action === "update").length;
   if (updateCount > maxUpdatePerRun) {
     errors.push(`too many update decisions: ${updateCount} > ${maxUpdatePerRun}`);
   }
   // Cap pattern minting per run (sleepMaxPatternPerRun passes through here).
-  const createCount = decisions.filter((d) => d.action === "create").length;
+  const createCount = survivors.filter((d) => d.action === "create").length;
   const maxCreatePerRun = options.maxCreatePerRun ?? 5;
   if (createCount > maxCreatePerRun) {
     errors.push(`too many create decisions: ${createCount} > ${maxCreatePerRun}`);
@@ -137,25 +163,31 @@ export function validateDecisions(decisions, snapshot, options = {}) {
   // snapshot（claimed.size / snapshot.size < dreamMinExplicitCoverage）时整单拒绝，
   // 而不是用 keep 把绝大部分 snapshot 全部"通过"。
   if (errors.length > 0) {
-    return { ok: false, errors };
+    return { ok: false, errors, skipped };
   }
   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 };
+      return { ok: false, errors, skipped };
     }
     for (const id of snapshot.keys()) {
-      if (!claimed.has(id)) decisions.push({ action: "keep", ids: [id] });
+      if (!claimed.has(id)) survivors.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 };
+    if (errors.length > 0) return { ok: false, errors, skipped };
+  }
+  // 调用方下游（apply/audit）复用同一 decisions 引用：就地同步为 survivors——
+  // 在 skipInvalid 模式下去掉被跳过的非法决策；在隐式 keep 下追加补齐的 keep。
+  // 内容一致时（无跳过、无补齐）为 no-op。
+  if (survivors.length !== decisions.length) {
+    decisions.splice(0, decisions.length, ...survivors);
   }
-  return { ok: true, errors };
+  return { ok: true, errors, skipped };
 }
 
 /** Marker thrown when a decision target changed since the run snapshot. */

package/lib/dream.js

@@ -468,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");
@@ -486,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()
@@ -704,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 = {};
@@ -872,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) {
@@ -884,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/lib/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/lib/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/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@modusensus/dsh-mneme",
   "description": "Cross-session memory plugin for DeepSeek Harness with autoDream consolidation: SQLite store, Markdown mirrors, 7 model tools, automatic injection, session summarization, user profile/rules, custom slash commands, vector (semantic) search, and a Web GUI panel",
-  "version": "0.7.21",
+  "version": "0.7.22",
   "license": "MIT",
   "repository": {
     "type": "git",

package/src/config.js

@@ -47,6 +47,11 @@ export const Config = z.object({
   dreamThresholdCount: z.natural().min(1).max(1000).default(10),
   dreamThresholdChars: z.natural().min(100).max(100000).default(5000),
   dreamDelayMs: z.natural().min(0).max(60000).default(2000),
+  // autoDream 触发最小间隔（分钟，0 = 不限制，Issue #89 请求 2）：高频写入
+  // 场景下防止巩固调用（含失败重试）连发刷爆配额。间隔从每次实际开跑时刻
+  // 起算，失败/degraded 的 run 也占用间隔；间隔内的触发请求静默跳过，下一次
+  // 写入事件会重新评估。
+  dreamMinIntervalMinutes: z.natural().min(0).max(10080).default(0),
   dreamProvider: z.string(),
   dreamModel: z.string(),
   dreamMaxTokens: z.natural().min(256).max(131072).default(8192),
@@ -74,6 +79,13 @@ export const Config = z.object({
   // → 整单拒绝，防止残缺输出被隐式 keep 洗白成 ok 后再被真实 apply。0-1，
   // 默认 0.5（至少显式覆盖一半 snapshot）。
   dreamMinExplicitCoverage: z.number().min(0).max(1).default(0.5),
+  // Issue #89：v0.6.9（Issue #26）的宽容路径回归。默认跳过单条非法决策
+  // （未知 id / 跨类型合并等）、应用合法子集、run 记 degraded；设 false 恢复
+  // 整单拒绝的严格模式。全局上限与覆盖率下限不受此开关影响、始终整单拒绝。
+  dreamSkipInvalid: z.boolean().default(true),
+  // 显式开启后放宽跨类型合并检查（类型边界由用户自行承担）；配合
+  // dreamSkipInvalid 理解：关闭 skipInvalid 时跨类型 merge 直接整单拒绝。
+  allowCrossTypeMerge: z.boolean().default(false),
   // 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

@@ -7,12 +7,22 @@ const EPISTEMIC_PRIORITY = { observation: 3, inferred: 2, subjective: 1 };
 
 /**
  * Validate a dream decision list against a snapshot of eligible memories.
- * @param decisions - LLM-produced decision list.
+ * @param decisions - LLM-produced decision list. In skipInvalid mode, invalid
+ *   entries are spliced out of this array in place (the caller reuses the same
+ *   reference downstream for apply/audit); implicit keeps are appended here too.
  * @param snapshot - Map<id, memory> of eligible (non-archived, non-summary) entries.
- * @returns {{ok: boolean, errors: string[]}}
+ * @returns {{ok: boolean, errors: string[], skipped?: Array<{index, action, ids, error}>}}
  */
 export function validateDecisions(decisions, snapshot, options = {}) {
   const errors = [];
+  // Issue #89 回归修复（v0.6.9 / Issue #26 的 skipInvalid 路径原样移植，该路径
+  // 在 v0.7.11 重写中丢失）：skipInvalid 开启时，单条非法决策只跳过该条（记录
+  // 到 skipped、不 claim 任何 id），合法子集照常应用，调用方据此把 run 记为
+  // degraded。全局信号（update/create 上限、显式覆盖率下限）依旧整单拒绝——
+  // 刷爆上限或覆盖率不达标的输出是模型坏了，不是轻微 schema 漂移。
+  const skipped = [];
+  const survivors = [];
+  const skipInvalid = options.skipInvalid === true;
   const maxUpdatePerRun = options.maxUpdatePerRun ?? 2;
   const minAgeHours = options.minAgeHours ?? 24;
   if (!Array.isArray(decisions) || decisions.length === 0) {
@@ -21,106 +31,122 @@ export function validateDecisions(decisions, snapshot, options = {}) {
   const claimed = new Set();
   for (const [index, d] of decisions.entries()) {
     const at = `decision[${index}]`;
+    // 单条校验错误先进 local：skipInvalid 模式下整条跳过，严格模式下才并入
+    // 全局 errors（沿用 v0.6.9 的双轨结构）。
+    const local = [];
+    const ids = d && d.action === "conflict" ? [d.winner, d.loser] : (d?.ids ?? []);
     if (!d || typeof d !== "object" || !ACTIONS.has(d.action)) {
-      errors.push(`${at}: invalid action ${JSON.stringify(d?.action)}`);
-      continue;
-    }
-    const ids = d.action === "conflict" ? [d.winner, d.loser] : (d.ids ?? []);
-    if (d.action === "conflict") {
+      local.push(`${at}: invalid action ${JSON.stringify(d?.action)}`);
+    } else if (d.action === "conflict") {
       if (!d.winner || !d.loser || d.winner === d.loser) {
-        errors.push(`${at}: conflict needs distinct winner and loser`);
-        continue;
+        local.push(`${at}: conflict needs distinct winner and loser`);
       }
     } else if (d.action === "create") {
       // Mint a fresh memory (sleep pattern discovery). Claims no existing id,
       // so it skips the claiming loop below; evidence is optional provenance
       // (already filtered to real ids by the caller) and is stored in content.
       if (typeof d.title !== "string" || !d.title.trim()) {
-        errors.push(`${at}: create needs non-empty title`);
-        continue;
+        local.push(`${at}: create needs non-empty title`);
       }
       if (typeof d.content !== "string" || !d.content.trim()) {
-        errors.push(`${at}: create needs non-empty content`);
-        continue;
+        local.push(`${at}: create needs non-empty content`);
       }
       if (d.importance !== undefined && (!Number.isInteger(d.importance) || d.importance < 1 || d.importance > 5)) {
-        errors.push(`${at}: create importance must be an integer 1-5 when provided`);
+        local.push(`${at}: create importance must be an integer 1-5 when provided`);
       }
       if (typeof d.type !== "string" || !d.type.trim()) {
-        errors.push(`${at}: create needs non-empty type`);
+        local.push(`${at}: create needs non-empty type`);
       }
-      continue;
     } else if (!Array.isArray(d.ids) || d.ids.length === 0) {
-      errors.push(`${at}: ${d.action} needs non-empty ids`);
-      continue;
+      local.push(`${at}: ${d.action} needs non-empty ids`);
     }
     // update-specific field validation runs BEFORE claiming ids, so a failing
     // update never pollutes the claimed set (which drives the "every id must
     // appear in a decision" check below).
-    if (d.action === "update") {
+    if (local.length === 0 && d?.action === "update") {
       // 只能更新单条
       if (!Array.isArray(d.ids) || d.ids.length !== 1) {
-        errors.push(`${at}: update must target exactly one id`);
-        continue;
-      }
-      // 必须产生实际变化
-      const mem = snapshot.get(d.ids[0]);
-      const hasChange = (d.title !== undefined && d.title !== mem?.title)
-        || (d.content !== undefined && d.content !== mem?.content)
-        || (d.importance !== undefined && d.importance !== mem?.importance);
-      if (!hasChange) {
-        errors.push(`${at}: update must change at least one field`);
-        continue;
-      }
-      // 不能更新 summary
-      if (mem?.type === "summary") {
-        errors.push(`${at}: cannot update summary via update action`);
-        continue;
-      }
-      // 保护期：新建记忆不可立即被 update（可配置）
-      const ageHours = (Date.now() - new Date(mem?.created_at).getTime()) / 3600000;
-      if (ageHours < minAgeHours) {
-        errors.push(`${at}: memory too young (< ${minAgeHours}h)`);
-        continue;
+        local.push(`${at}: update must target exactly one id`);
+      } else {
+        // 必须产生实际变化
+        const mem = snapshot.get(d.ids[0]);
+        const hasChange = (d.title !== undefined && d.title !== mem?.title)
+          || (d.content !== undefined && d.content !== mem?.content)
+          || (d.importance !== undefined && d.importance !== mem?.importance);
+        if (!hasChange) {
+          local.push(`${at}: update must change at least one field`);
+        } else if (mem?.type === "summary") {
+          // 不能更新 summary
+          local.push(`${at}: cannot update summary via update action`);
+        } else {
+          // 保护期：新建记忆不可立即被 update（可配置）
+          const ageHours = (Date.now() - new Date(mem?.created_at).getTime()) / 3600000;
+          if (ageHours < minAgeHours) {
+            local.push(`${at}: memory too young (< ${minAgeHours}h)`);
+          }
+        }
       }
     }
-    for (const id of ids) {
-      const mem = snapshot.get(id);
-      if (!mem) {
-        errors.push(`${at}: unknown id ${JSON.stringify(id)}`);
-      } else if (mem.archived || mem.type === "summary") {
-        errors.push(`${at}: id ${JSON.stringify(id)} is archived or summary (not eligible)`);
+    if (local.length === 0 && d && d.action !== "create") {
+      // seen 捕获同一条决策内的重复 id；claimed 只含先前存活决策的 id
+      // （被跳过的决策不 claim，其目标留给其它合法决策/隐式 keep）。
+      const seen = new Set();
+      for (const id of ids) {
+        const mem = snapshot.get(id);
+        if (!mem) {
+          local.push(`${at}: unknown id ${JSON.stringify(id)}`);
+        } else if (mem.archived || mem.type === "summary") {
+          local.push(`${at}: id ${JSON.stringify(id)} is archived or summary (not eligible)`);
+        }
+        if (claimed.has(id) || seen.has(id)) {
+          local.push(`${at}: id ${JSON.stringify(id)} claimed by multiple decisions`);
+        }
+        seen.add(id);
       }
-      if (claimed.has(id)) {
-        errors.push(`${at}: id ${JSON.stringify(id)} claimed by multiple decisions`);
+      if (local.length === 0 && d.action === "merge") {
+        if (!d.keepSource || !d.ids.includes(d.keepSource)) {
+          local.push(`${at}: merge keepSource must be one of ids`);
+        }
+        if (typeof d.title !== "string" || !d.title.trim() || typeof d.content !== "string" || !d.content.trim()) {
+          local.push(`${at}: merge needs non-empty title and content`);
+        }
+        if (d.importance !== undefined && (!Number.isInteger(d.importance) || d.importance < 1 || d.importance > 5)) {
+          local.push(`${at}: merge importance must be an integer 1-5 when provided`);
+        }
+        // Merging across types would blur preference/project/decision boundaries
+        // in the injected context; the snapshot carries each entry's type.
+        // Issue #26 (P1)：默认禁止跨类型合并。用户显式开启 allowCrossTypeMerge
+        // 后放宽该检查，类型边界由用户自行承担。
+        const mergeTypes = new Set(d.ids.map((id) => snapshot.get(id)?.type));
+        if (mergeTypes.size > 1 && options.allowCrossTypeMerge !== true) {
+          local.push(`${at}: merge ids span multiple types (${[...mergeTypes].join(", ")})`);
+        }
       }
-      claimed.add(id);
     }
-    if (d.action === "merge") {
-      if (!d.keepSource || !d.ids.includes(d.keepSource)) {
-        errors.push(`${at}: merge keepSource must be one of ids`);
-      }
-      if (typeof d.title !== "string" || !d.title.trim() || typeof d.content !== "string" || !d.content.trim()) {
-        errors.push(`${at}: merge needs non-empty title and content`);
-      }
-      if (d.importance !== undefined && (!Number.isInteger(d.importance) || d.importance < 1 || d.importance > 5)) {
-        errors.push(`${at}: merge importance must be an integer 1-5 when provided`);
-      }
-      // Merging across types would blur preference/project/decision boundaries
-      // in the injected context; the snapshot carries each entry's type.
-      const mergeTypes = new Set(d.ids.map((id) => snapshot.get(id)?.type));
-      if (mergeTypes.size > 1) {
-        errors.push(`${at}: merge ids span multiple types (${[...mergeTypes].join(", ")})`);
+    if (local.length > 0) {
+      if (skipInvalid) {
+        // 单条非法 → 跳过该决策，不 claim id（其目标记忆留给其它合法决策/隐式
+        // keep），并记录到 skipped 供调用方日志/审计。信息性跳过绝不写入全局
+        // errors，否则会误触发下方的整单拒绝。
+        skipped.push({ index, action: d?.action, ids, error: local.join("; ") });
+      } else {
+        errors.push(...local);
       }
+      continue;
+    }
+    if (d.action !== "create") {
+      for (const id of ids) claimed.add(id);
     }
+    survivors.push(d);
   }
-  // Cap update churn: too many edits in one cycle signals a runaway model
-  const updateCount = decisions.filter((d) => d.action === "update").length;
+  // Cap update churn: too many edits in one cycle signals a runaway model.
+  // 全局信号——skipInvalid 模式下依旧整单拒绝（见函数头注释）。
+  const updateCount = survivors.filter((d) => d.action === "update").length;
   if (updateCount > maxUpdatePerRun) {
     errors.push(`too many update decisions: ${updateCount} > ${maxUpdatePerRun}`);
   }
   // Cap pattern minting per run (sleepMaxPatternPerRun passes through here).
-  const createCount = decisions.filter((d) => d.action === "create").length;
+  const createCount = survivors.filter((d) => d.action === "create").length;
   const maxCreatePerRun = options.maxCreatePerRun ?? 5;
   if (createCount > maxCreatePerRun) {
     errors.push(`too many create decisions: ${createCount} > ${maxCreatePerRun}`);
@@ -137,25 +163,31 @@ export function validateDecisions(decisions, snapshot, options = {}) {
   // snapshot（claimed.size / snapshot.size < dreamMinExplicitCoverage）时整单拒绝，
   // 而不是用 keep 把绝大部分 snapshot 全部"通过"。
   if (errors.length > 0) {
-    return { ok: false, errors };
+    return { ok: false, errors, skipped };
   }
   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 };
+      return { ok: false, errors, skipped };
     }
     for (const id of snapshot.keys()) {
-      if (!claimed.has(id)) decisions.push({ action: "keep", ids: [id] });
+      if (!claimed.has(id)) survivors.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 };
+    if (errors.length > 0) return { ok: false, errors, skipped };
+  }
+  // 调用方下游（apply/audit）复用同一 decisions 引用：就地同步为 survivors——
+  // 在 skipInvalid 模式下去掉被跳过的非法决策；在隐式 keep 下追加补齐的 keep。
+  // 内容一致时（无跳过、无补齐）为 no-op。
+  if (survivors.length !== decisions.length) {
+    decisions.splice(0, decisions.length, ...survivors);
   }
-  return { ok: true, errors };
+  return { ok: true, errors, skipped };
 }
 
 /** Marker thrown when a decision target changed since the run snapshot. */

package/src/dream.js

@@ -468,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");
@@ -486,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()
@@ -704,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 = {};
@@ -872,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) {
@@ -884,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();
+});