@modusensus/dsh-mneme 0.7.20 → 0.7.22

package/lib/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/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.20",
+  "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/sleep.js

@@ -17,7 +17,7 @@
 import { randomUUID, createHash } from "node:crypto";
 import { validateDecisions, applyDecisions } from "./decisions.js";
 import { findPotentialConflicts } from "./clustering.js";
-import { buildReceipt, withEffortFallback } from "../dream.js";
+import { buildReceipt, describeStreamFailure, withEffortFallback } from "../dream.js";
 import { computeHeat } from "../heat.js";
 
 const SUMMARY_MAX = 120;
@@ -61,12 +61,17 @@ function parseJsonArray(text) {
 }
 
 /** Same stream consumption contract as dream.js. */
-async function streamText(ctx, options) {
+async function streamText(ctx, options, onStreamError) {
   if (!ctx?.llm?.stream) return undefined;
   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 === "finish" && (chunk.reason?.kind === "error" || chunk.reason?.kind === "aborted")) {
+      // Same rc.1 error-as-finish-chunk behavior as dream.js — surface the
+      // cause instead of discarding it.
+      if (typeof onStreamError === "function") {
+        try { onStreamError(chunk.reason); } catch { /* diagnostics only */ }
+      }
       return undefined;
     }
   }
@@ -186,7 +191,10 @@ async function phaseConflicts(ctx, service, config, logger, runId, semantic = nu
     `候选冲突：\nid=${p.a.id} | type=${p.a.type} | title=${p.a.title}\n${p.a.content}\n---\nid=${p.b.id} | type=${p.b.type} | title=${p.b.title}\n${p.b.content}\n（相似度 ${p.similarity.toFixed(2)}）`
   ).join("\n\n");
   const sleepEffort = config.sleepReasoningEffort && config.sleepReasoningEffort !== "none" ? config.sleepReasoningEffort : null;
-  const runConflict = (withEffort) => streamText(ctx, {
+  let conflictStreamFailure = "";
+  const runConflict = (withEffort) => {
+    conflictStreamFailure = "";
+    return streamText(ctx, {
     provider: route.provider,
     model: route.model,
     purpose: "sleep-conflict",
@@ -196,9 +204,13 @@ async function phaseConflicts(ctx, service, config, logger, runId, semantic = nu
       { role: "system", content: [{ type: "text", text: CONFLICT_PROMPT }] },
       { role: "user", content: [{ type: "text", text: listText }] }
     ]
-  });
-  const text = await withEffortFallback(ctx, sleepEffort, () => runConflict(true), () => runConflict(false));
-  if (text === undefined) return { status: "failed", error: "llm failed" };
+  }, (reason) => { conflictStreamFailure = describeStreamFailure(reason); });
+  };
+  const text = await withEffortFallback(ctx, sleepEffort, () => runConflict(true), () => runConflict(false), () => conflictStreamFailure);
+  if (text === undefined) {
+    if (conflictStreamFailure) ctx.logger?.warn?.(`dsh-mneme sleep: conflict stream aborted or errored (${conflictStreamFailure})`);
+    return { status: "failed", error: "llm failed" };
+  }
   const decisions = parseJsonArray(text);
   if (!decisions) return { status: "failed", error: "invalid decisions json" };
   // validateDecisions 要求每个 snapshot id 恰好被 claim 一次。v0.4.4 起它本身
@@ -298,7 +310,10 @@ async function phasePatterns(ctx, service, config, logger, runId, signal = null)
     .join("\n");
   const maxPatterns = config.sleepMaxPatternPerRun ?? 3;
   const sleepEffort = config.sleepReasoningEffort && config.sleepReasoningEffort !== "none" ? config.sleepReasoningEffort : null;
-  const runPattern = (withEffort) => streamText(ctx, {
+  let patternStreamFailure = "";
+  const runPattern = (withEffort) => {
+    patternStreamFailure = "";
+    return streamText(ctx, {
     provider: route.provider,
     model: route.model,
     purpose: "sleep-pattern",
@@ -308,9 +323,13 @@ async function phasePatterns(ctx, service, config, logger, runId, signal = null)
       { role: "system", content: [{ type: "text", text: PATTERN_PROMPT.replace("N", String(maxPatterns)) }] },
       { role: "user", content: [{ type: "text", text: listText }] }
     ]
-  });
-  const text = await withEffortFallback(ctx, sleepEffort, () => runPattern(true), () => runPattern(false));
-  if (text === undefined) return { status: "failed", error: "llm failed" };
+  }, (reason) => { patternStreamFailure = describeStreamFailure(reason); });
+  };
+  const text = await withEffortFallback(ctx, sleepEffort, () => runPattern(true), () => runPattern(false), () => patternStreamFailure);
+  if (text === undefined) {
+    if (patternStreamFailure) ctx.logger?.warn?.(`dsh-mneme sleep: pattern stream aborted or errored (${patternStreamFailure})`);
+    return { status: "failed", error: "llm failed" };
+  }
   const decisions = parseJsonArray(text);
   if (!decisions || decisions.length === 0) return { status: "skipped", reason: "no patterns found" };
   // Evidence ids are provenance refs; an LLM-fabricated id would mint a dead