@modusensus/dsh-mneme 0.8.1 → 0.8.3

package/lib/store.js

@@ -22,6 +22,9 @@ CREATE TABLE IF NOT EXISTS memories (
 );
 CREATE INDEX IF NOT EXISTS idx_memories_type ON memories(type);
 CREATE INDEX IF NOT EXISTS idx_memories_importance ON memories(importance);
+-- Issue #202：all()/list() 按 updated_at 排序，无索引时走临时 B 树全表排序
+-- （5k 行实测 all() 231ms → 135ms）。IF NOT EXISTS 幂等，存量库启动即建。
+CREATE INDEX IF NOT EXISTS idx_memories_updated ON memories(updated_at);
 
 -- autoDream audit trail: one row per consolidation run, capturing the exact
 -- input snapshot digest + the LLM decision list + per-id outcome + a compact
@@ -717,11 +720,51 @@ export function createStore(path) {
     }
   }
 
+  // Issue #202：embedding 解析缓存。检索路径此前每次调用都对全部带向量行
+  // JSON.parse（993 × 512 维 ≈ 48 ms/次，且 SQL 拖着 10 MB 的 TEXT），余弦本身
+  // 只占 3%。向量只经 setEmbedding 写入（单一失效点），把解析结果按 id 缓存，
+  // 命中即零解析；上限 FIFO 驱逐防大库内存无界（4000 × 512 维 double ≈ 16 MB）。
+  const embeddingCache = new Map();
+  const EMBEDDING_CACHE_MAX = 4000;
+
+  function cacheEmbedding(id, vector) {
+    if (embeddingCache.size >= EMBEDDING_CACHE_MAX && !embeddingCache.has(id)) {
+      const oldest = embeddingCache.keys().next().value;
+      embeddingCache.delete(oldest);
+    }
+    embeddingCache.set(id, vector);
+  }
+
+  /** Parsed embedding for one id (cache-first); undefined when none/parse
+   *  failure. Single read path shared by searchVector / getEmbedding(s). */
+  function getParsedEmbedding(id) {
+    const cached = embeddingCache.get(id);
+    if (cached) return cached;
+    const row = db.prepare("SELECT embedding FROM memories WHERE id = ?").get(id);
+    if (!row?.embedding) return undefined;
+    try {
+      const v = JSON.parse(row.embedding);
+      if (Array.isArray(v) && v.length) {
+        cacheEmbedding(id, v);
+        return v;
+      }
+    } catch { /* corrupt embedding text: treated as absent */ }
+    return undefined;
+  }
+
+  // all()/list() 的显式列清单：从实际 schema 派生（迁移后），只排除 embedding
+  // 列——consolidation/sleep/inject 的消费方都不读向量，而它是全表里最重的一列
+  // （5k 行库 ≈ 9.4 MB TEXT），每次全表调用都白搬。经 PRAGMA 派生而非硬编码，
+  // schema 演进时自动跟随。
+  const memoryColumns = db.prepare("PRAGMA table_info(memories)").all()
+    .map((c) => c.name)
+    .filter((n) => n !== "embedding");
+  const memoryColumnList = memoryColumns.join(", ");
+
   // Per-instance monotonic timestamp guard: consecutive writes within the same
   // millisecond must still produce strictly increasing timestamps (test asserts
   // updated_at != created_at). State lives in the store closure, not module scope.
-  let lastTs = "";
-  function nowIso() {
+  let lastTs = "";  function nowIso() {
     let ts = new Date().toISOString();
     if (lastTs && ts <= lastTs) {
       const d = new Date(lastTs);
@@ -925,6 +968,10 @@ export function createStore(path) {
         now,
         id
       );
+      // Issue #202：update 可直写 embedding（patch.embedding），缓存条目失效，
+      // 下次读取按库值重解析。宁滥勿缺——即便本 patch 未含 embedding，丢一条
+      // 缓存只多一次点查重解析。
+      embeddingCache.delete(id);
       // Desired generation bumped in the same transaction as the update (peer
       // blocker 1: crash between write and sync must still be recoverable).
       incrementGeneration();
@@ -995,6 +1042,8 @@ export function createStore(path) {
         expectedUpdatedAt
       );
       if (result.changes === 0) return; // CAS miss: a concurrent write won
+      // Issue #202：同 update——CAS 命中即可能改写 embedding，失效缓存条目。
+      embeddingCache.delete(id);
       // Only bump desired generation on a successful CAS — a miss writes nothing.
       incrementGeneration();
       applied = true;
@@ -1177,7 +1226,9 @@ export function createStore(path) {
   }
 
   function all() {
-    const rows = db.prepare("SELECT * FROM memories ORDER BY updated_at DESC").all();
+    // Issue #202：显式列清单排除 embedding——toRow 本就不输出向量，SELECT *
+    // 纯属把全表最重的列（9.4 MB TEXT/5k 行）拖进内存再丢弃。
+    const rows = db.prepare(`SELECT ${memoryColumnList} FROM memories ORDER BY updated_at DESC`).all();
     return rows.map(toRow);
   }
 
@@ -1185,6 +1236,17 @@ export function createStore(path) {
   function setEmbedding(id, vector) {
     const json = Array.isArray(vector) && vector.length ? JSON.stringify(vector) : null;
     db.prepare("UPDATE memories SET embedding = ? WHERE id = ?").run(json, id);
+    // Issue #202：单一写入口即单一失效点——重写缓存条目（向量在手上不必重解析），
+    // 清空则移除，删除过的 id 不会被下一次 searchVector 的 id 集合选中。
+    if (json) {
+      try {
+        const parsed = JSON.parse(json);
+        if (Array.isArray(parsed) && parsed.length) cacheEmbedding(id, parsed);
+        else embeddingCache.delete(id);
+      } catch { embeddingCache.delete(id); }
+    } else {
+      embeddingCache.delete(id);
+    }
   }
 
   /** Batch fetch stored embeddings by id (v0.5.0 search-time semantic dedup).
@@ -1193,19 +1255,10 @@ export function createStore(path) {
   function getEmbeddings(ids) {
     const out = new Map();
     const list = (Array.isArray(ids) ? ids : []).filter(Boolean);
-    for (let i = 0; i < list.length; i += 100) {
-      const chunk = list.slice(i, i + 100);
-      const rows = db.prepare(
-        `SELECT id, embedding FROM memories
-         WHERE embedding IS NOT NULL AND embedding != ''
-           AND id IN (${chunk.map(() => "?").join(",")})`
-      ).all(...chunk);
-      for (const row of rows) {
-        try {
-          const vec = JSON.parse(row.embedding);
-          if (Array.isArray(vec) && vec.length) out.set(row.id, vec);
-        } catch { /* corrupt row: skip */ }
-      }
+    for (const id of list) {
+      // Issue #202：走同一解析缓存（语义去重的批量读也免重复 parse）。
+      const vec = getParsedEmbedding(id);
+      if (vec) out.set(id, vec);
     }
     return out;
   }
@@ -1280,24 +1333,30 @@ export function createStore(path) {
   function searchVector(vector, { limit = 20, includeArchived = false, threshold = 0 } = {}) {
     if (!Array.isArray(vector) || !vector.length) return [];
     const archivedFilter = includeArchived ? "" : "archived = 0 AND ";
+    // Issue #202：只取 id 列（~40 KB）而非 SELECT *（~11 MB）——向量从缓存取，
+    // 缓存未命中时按 id 点查 embedding 再解析回填。SQL 里保留 embedding 的
+    // IS NOT NULL 过滤，保证「有向量的行」集合始终以库为准（删除/清空即时生效）。
     const rows = db.prepare(
-      `SELECT * FROM memories
+      `SELECT id FROM memories
        WHERE ${archivedFilter}forgotten = 0 AND embedding IS NOT NULL AND embedding != ''`
     ).all();
     const scored = [];
     for (const row of rows) {
-      let v;
-      try {
-        v = JSON.parse(row.embedding);
-      } catch {
-        continue;
-      }
+      const v = getParsedEmbedding(row.id);
+      if (!v) continue;
       const score = cosine(vector, v);
-      if (score >= threshold) scored.push({ row, score });
+      if (score >= threshold) scored.push({ row: { id: row.id }, score });
     }
     scored.sort((a, b) => b.score - a.score);
     const { limit: lim } = sanitizePage(limit, 0, 20);
-    return scored.slice(0, lim).map(({ row, score }) => ({ ...toRow(row), score }));
+    // Top-N 回表：只对入选行取完整字段（主键点查 ≤ lim 行），评分别拖着正文走。
+    const getFull = db.prepare("SELECT * FROM memories WHERE id = ?");
+    const out = [];
+    for (const { row, score } of scored.slice(0, lim)) {
+      const full = getFull.get(row.id);
+      if (full) out.push({ ...toRow(full), score });
+    }
+    return out;
   }
 
   // --- autoDream audit trail ----------------------------------------------
@@ -2245,6 +2304,7 @@ export function createStore(path) {
     search,
     setEmbedding,
     getEmbeddings,
+    getParsedEmbedding,
     embeddedCount,
     needsEmbedding,
     searchVector,

package/lib/summarize.js

@@ -144,7 +144,7 @@ function collectMessages(session, maxChars = 8000, language = "zh") {
         break;
     }
   }
-  return lines.length ? [createUserMessage({ content: [{ type: "text", text: trim(lines.join("\n"), maxChars) }] })] : [];
+  return lines.length ? [createUserMessage({ content: [{ type: "text", text: trim(lines.join("\n"), maxChars) }], source: { kind: "plugin", plugin: "dsh-mneme" } })] : [];
 }
 
 // ── 智能调速器（429 保护）─────────────────────────────────────────────
@@ -265,7 +265,7 @@ export function createSummarizer(ctx, service, config) {
         model: route.model,
         purpose: "summarization",
         messages: [
-          { role: "system", content: [{ type: "text", text: config.codingRetrospect ? STR.prompts.codingSummary[langOf(config)] : STR.prompts.summary[langOf(config)] }] },
+          { role: "system", content: [{ type: "text", text: config.codingRetrospect ? STR.prompts.codingSummary[langOf(config)] : STR.prompts.summary[langOf(config)] }], source: { kind: "plugin", plugin: "dsh-mneme" } },
           ...messages
         ],
         signal: controller.signal

package/lib/tools.js

@@ -39,6 +39,8 @@ const MEMORY_ITEM_SCHEMA = {
     updated_at: { type: "string", required: true }
   }
 };
+// 导出供回归测试断言 memory_get 与共享 schema 同源（#184 防漂移护栏）。
+export { MEMORY_ITEM_SCHEMA };
 
 // v0.8.0 A2：occurred 时间窗参数 → store 过滤选项（list/count 同口径）；
 // 未传参返回空对象，既有调用方不受影响。（A3 复核：此处入参仅含 occurred 边界。）
@@ -277,25 +279,10 @@ export function createTools(ctx, service, config, embedder) {
           type: "object",
           additionalProperties: false,
           properties: {
-            memory: {
-              type: "object",
-              additionalProperties: false,
-              properties: {
-                id: { type: "string", required: true },
-                title: { type: "string", required: true },
-                type: { type: "string", required: true },
-                importance: { type: "integer", required: true },
-                tags: { type: "array", items: { type: "string" } },
-                content: { type: "string", required: true },
-                source: { type: "string" },
-                agent_scope: { type: "string" },
-                workspace_scope: { type: "string" },
-                sensitivity: { type: "string" },
-                occurred_at: { type: "string" },
-                created_at: { type: "string" },
-                updated_at: { type: "string" }
-              }
-            }
+            // 与 memory_search / memory_list 共用同一份 item schema——DTO 由
+            // toApiList 统一产出，内联副本曾漏掉 v0.8.1 的 scope 来源三键，
+            // 任何被标注过的行都过不了 in-process 校验（#184）。
+            memory: MEMORY_ITEM_SCHEMA
           }
         },
         render: (_args, value) => {

package/lib/vector-index.js

@@ -56,14 +56,8 @@ export function createVectorIndex({ store, logger }) {
 
     /** Read one memory's cached vector; undefined when none/parse failure. */
     getEmbedding(id) {
-      const row = db.prepare("SELECT embedding FROM memories WHERE id = ?").get(id);
-      if (!row?.embedding) return undefined;
-      try {
-        const v = JSON.parse(row.embedding);
-        return Array.isArray(v) && v.length ? v : undefined;
-      } catch {
-        return undefined;
-      }
+      // Issue #202：走 store 的解析缓存（与 searchVector/getEmbeddings 同源）。
+      return store.getParsedEmbedding(id);
     },
 
     /** Cosine search over embedded rows; results carry a 0..1 score. */

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.8.1",
+  "version": "0.8.3",
   "license": "MIT",
   "repository": {
     "type": "git",
@@ -80,6 +80,7 @@
     "prepack": "npm run sync",
     "test": "node --test test/*.test.js",
     "test:coverage": "c8 node --test test/*.test.js",
+    "badge:sync": "node scripts/sync-test-badge.mjs",
     "e2e": "node scripts/e2e-dsh.js",
     "stress": "node scripts/stress-dsh.js"
   },

package/scripts/sync-test-badge.mjs

@@ -0,0 +1,61 @@
+// 发版流水线的徽章对齐（release.yml 的 badge job 调用；手动可跑 npm run badge:sync）。
+//
+// 做三件事：
+//   1. 跑一遍全量测试（npm test），取最后的 `pass N` 汇总数；
+//   2. 把双 README 的 tests 徽章（img.shields.io/badge/tests-N%20passed）与
+//      开发命令注释（# N 个测试 / # N tests）刷成该数字；
+//   3. 有变化就写回文件（由调用方决定是否 commit/push），无变化静默退出。
+//
+// 测试失败（fail>0 或进程非零退出）时以非零退出且不改任何文件——徽章永远
+// 不可能指向一次没跑绿的套件。历史版本表里的「N 测试全绿」是各版本当时的
+// 真实记录，刻意不在替换范围内（正则只打徽章与 `#` 注释两种形状）。
+import { execSync } from "node:child_process";
+import { readFileSync, writeFileSync } from "node:fs";
+import { dirname, join } from "node:path";
+import { fileURLToPath } from "node:url";
+
+const scriptDir = dirname(fileURLToPath(import.meta.url));
+const repoRoot = join(scriptDir, "..", "..");
+
+// 1) 全量测试
+let output;
+try {
+  output = execSync("npm test", {
+    cwd: join(repoRoot, "dsh-mneme"),
+    encoding: "utf8",
+    stdio: ["ignore", "pipe", "pipe"],
+    maxBuffer: 64 * 1024 * 1024
+  });
+} catch (error) {
+  const tail = String(error.stdout ?? "").split("\n").slice(-25).join("\n");
+  console.error("npm test 未跑绿，徽章不更新：\n" + tail);
+  process.exit(1);
+}
+
+// 2) 取汇总 pass 数（spec reporter 的 `ℹ pass N`；取最后一处防逐用例行干扰）
+const matches = [...output.matchAll(/pass (\d+)/g)];
+const pass = matches.length ? Number(matches[matches.length - 1][1]) : 0;
+if (!pass) {
+  console.error("无法从测试输出解析 pass 数，徽章不更新");
+  process.exit(1);
+}
+
+// 3) 刷双 README（徽章 + 两行开发命令注释）
+const targets = [
+  join(repoRoot, "README.md"),
+  join(repoRoot, "dsh-mneme", "README.md")
+];
+let changed = 0;
+for (const file of targets) {
+  let text = readFileSync(file, "utf8");
+  const next = text
+    .replace(/tests-\d+%20passed-/g, `tests-${pass}%20passed-`)
+    .replace(/(#\s*)\d+( 个测试)/g, `$1${pass}$2`)
+    .replace(/(#\s*)\d+( tests)/g, `$1${pass}$2`);
+  if (next !== text) {
+    writeFileSync(file, next);
+    changed += 1;
+    console.log(`updated: ${file}`);
+  }
+}
+console.log(`pass=${pass}, files changed=${changed}`);

package/src/api-standalone.js

@@ -152,6 +152,18 @@ export function createStandaloneApi({ service, store, config = {}, logger, setti
         return;
       }
 
+      // --- GET /profile: user self-description -------------------------------
+      if (req.method === "GET" && pathname === "/profile") {
+        sendJson(res, 200, { profile: settings?.getProfile?.() ?? "" });
+        return;
+      }
+
+      // --- GET /rules: agent behavior rules -----------------------------------
+      if (req.method === "GET" && pathname === "/rules") {
+        sendJson(res, 200, { rules: settings?.getRules?.() ?? [] });
+        return;
+      }
+
       // --- GET /memories: paged + filtered list (same semantics as the
       //     internal /api/dsh-mneme/list) ------------------------------------
       if (req.method === "GET" && pathname === "/memories") {

package/src/api.js

@@ -330,7 +330,17 @@ export function createApi(ctx, service, settings, commands, embedder, semantic =
         // 按钮无放大风险。
         maxTokens: 1024,
         ...(reasoningEffort && reasoningEffort !== "none" ? { reasoningEffort } : {}),
-        messages: [{ role: "system", content: [{ type: "text", text: "Reply with exactly one word: ok" }] }]
+        // role 用 user 而非 system（#189 后续）：0.1.6-alpha.1 起适配器把 system
+        // 抽成顶层参数，system-only 对话会被官方 API 以
+        // 「messages: at least one message is required」整单拒绝——探测按钮 502。
+        // user 消息在任何适配器下都是一条合法对话，探测从此不怕 host 演进。
+        messages: [
+          {
+            role: "user",
+            content: [{ type: "text", text: "Reply with exactly one word: ok" }],
+            source: { kind: "plugin", plugin: "dsh-mneme" }
+          }
+        ]
       })) {
         if (chunk.type === "text-delta" && typeof chunk.text === "string") reply += chunk.text;
         if (chunk.type === "finish" && (chunk.reason?.kind === "error" || chunk.reason?.kind === "aborted")) {
@@ -1298,7 +1308,7 @@ export function createApi(ctx, service, settings, commands, embedder, semantic =
   });
 
   return {
-    routes: 23,
+    routes: 30,
     dispose: () => {
       for (const dispose of disposers) dispose();
     }

package/src/config.js

@@ -37,6 +37,11 @@ export const Config = z.object({
   distillRateLimitRetries: z.natural().min(0).max(10).default(3),
   distillRateLimitBaseDelayMs: z.natural().min(100).max(60000).default(1000),
   maxInjectedItems: z.natural().min(1).max(20).default(5),
+  // Issue #205：注入位跨轮轮换。同一会话里，最近 N 个不同用户查询轮次注入过
+  // 的记忆本轮不再优先（新鲜优先、原序回填，槽位数不变）；长会话中避免相邻
+  // 轮次反复注入同一条（实测 15.5h 会话 86 次注入 93% 重复）。0 = 关闭（默认，
+  // 保持既有行为）。会话边界自动重置：新会话从零开始。
+  injectRotationTurns: z.natural().min(0).max(20).default(0),
   importanceThreshold: z.natural().min(1).max(5).default(3),
   // 编码记忆蒸馏（codingRetrospect，opt-in，默认关）。开启时，turn/end 蒸馏
   // 额外提取三类编码专属记忆：rejected_solution（被否决方案）/ pitfall（踩坑）/
@@ -111,6 +116,10 @@ export const Config = z.object({
   // 记忆做 consolidation。大记忆量下全量快照会把 LLM 输入撑爆（636 记忆 →
   // 677 "missing" errors、applied=0），窗口外的旧记忆不进 snapshot。
   dreamMaxSnapshotSize: z.natural().min(1).max(1000).default(200),
+  // Issue #104 方向 2：单轮 archive 决策上限。一次性大扫除（12 条互不相关主题
+  // 被批量归档，其中 8 条疑似误伤长保留类型）是失控信号，与 update 上限同类的
+  // 全局闸门：skipInvalid 也不豁免，超限整单拒绝。正常清理可调高。
+  dreamMaxArchivePerRun: z.natural().min(1).max(200).default(8),
   // Issue #125：候选集构造方式。"window"（默认，等同现状）只取最近
   // dreamMaxSnapshotSize 条；"hybrid" 在此基础上并入**向量翻出的高相似组**——
   // 本机实测 45 对「双方活跃且 sim≥0.85」里 0 对能同时进窗口（窗口覆盖率 11.7%），
@@ -176,6 +185,11 @@ export const Config = z.object({
   embedModelCacheDir: z.string().default(""),
   embedModelMirror: z.string().default("https://hf-mirror.com"),
 
+  // issue #194：模型文件下载的断点续传与重试。开启时 transformers.js 的 env.fetch 被
+  // 替换为带断点续传的实现（已收字节落盘、Range/If-Range 续传、空闲看门狗），大文件
+  // 中断后不必整份重来；关闭 = env.fetch 保持原样（线上回滚开关）。
+  resilientModelDownload: z.boolean().default(true),
+
   // 自管运行时目录（issue #131）。空 = ~/.dsh/mneme/runtime：里面放收编或下载来的
   // transformers + onnxruntime 闭包，插件经 src/runtime/loader.js 的三层解析加载它。
   // 目的就是让这条重依赖不必留在宿主 profile 的依赖图里——profile 是所有插件共用的
@@ -257,6 +271,10 @@ export const Config = z.object({
   rerankBatchSize: z.natural().min(1).max(64).default(8),
   rerankMaxCandidates: z.natural().min(5).max(100).default(30),
   rerankScoreThreshold: z.number().min(0).max(1).default(0.1),
+  // #188：量化档，与嵌入层的 useDtype 同语义（q8 = model_quantized.onnx，约为
+  // fp32 体积的 1/4）。此前重排层不传 dtype，即使缓存里已有量化文件也会去下载
+  // 1GB 级的 model.onnx。非法值由 transformers 在 init 时抛出 → 重排降级并告警。
+  rerankDtype: z.string().default("q8"),
 
   // --- reflection: update decision + failure tracking (v0.2.1) ------------
   reflectionUpdateEnabled: z.boolean().default(true),

package/src/dream/decisions.js

@@ -11,6 +11,15 @@ export const ACTIONS = new Set(["keep", "merge", "archive", "conflict", "update"
 // = preferred. observation (measured) > inferred (derived) > subjective (guess).
 const EPISTEMIC_PRIORITY = { observation: 3, inferred: 2, subjective: 1 };
 
+// Issue #104 方向 2：archive 类型护栏的长保留类型集合——这些类型的存在意义
+// 就是长期保存（踩坑记录、约束、用户偏好、挖掘出的模式），LLM 以「价值判断」
+// 类理由批量归档它们时误伤损失最大。conflict 裁决的败者归档不经过 archive
+// action（走 applyDecisions 的 conflict 分支），不受此护栏影响。
+const ARCHIVE_GUARDED_TYPES = new Set(["preference", "pattern", "rejected_solution", "constraint", "pitfall"]);
+// 「重复 / 过时」类理由的关键词（中英双语）。命中才允许归档长保留类型；
+// 词表宁可放宽也不误拦——护栏只跳过单条并落明细，不整单拒绝。
+const ARCHIVE_RATIONALE_RE = /重复|过时|陈旧|过期|已被取代|被取代|冗余|不再使用|旧版|废弃|stale|outdated|obsolete|dup(?:licate|licat)?|superseded|redundant|deprecated|expired|replaced/i;
+
 /**
  * Validate a dream decision list against a snapshot of eligible memories.
  * @param decisions - LLM-produced decision list. In skipInvalid mode, invalid
@@ -128,6 +137,21 @@ export function validateDecisions(decisions, snapshot, options = {}) {
     // 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).
+    // Issue #104 方向 2：archive 类型护栏。长保留类型的 archive 决策必须携带
+    // 「重复 / 过时」类理由（提示词对 archive 的定义本就如此），「价值判断」类
+    // 理由（保持整洁、参考价值低……）不放行——单条跳过记 skipped（run 记
+    // degraded，明细进 dream_runs.skipped），绝不整单拒绝。未知 id 在下方通用
+    // 校验里另行报错，这里 snapshot.get 为 undefined 时跳过护栏判断。
+    if (local.length === 0 && d?.action === "archive") {
+      const guardedTypes = new Set();
+      for (const id of d.ids) {
+        const mem = snapshot.get(id);
+        if (mem && ARCHIVE_GUARDED_TYPES.has(mem.type)) guardedTypes.add(mem.type);
+      }
+      if (guardedTypes.size > 0 && !ARCHIVE_RATIONALE_RE.test(String(d.reason ?? ""))) {
+        local.push(`${at}: archive of long-retention type(s) ${[...guardedTypes].join(", ")} needs a duplicate/outdated rationale (重复/过时), got: ${JSON.stringify(String(d.reason ?? "")).slice(0, 60)}`);
+      }
+    }
     if (local.length === 0 && d?.action === "update") {
       // 只能更新单条
       if (!Array.isArray(d.ids) || d.ids.length !== 1) {
@@ -216,26 +240,49 @@ export function validateDecisions(decisions, snapshot, options = {}) {
   if (createCount > maxCreatePerRun) {
     errors.push(`too many create decisions: ${createCount} > ${maxCreatePerRun}`);
   }
+  // Issue #104 方向 2：archive 批量上限——一次性大扫除（12 条互不相关主题被
+  // 批量归档）是失控信号，与 update 上限同一类全局闸门：skipInvalid 也不豁免，
+  // 超限整单拒绝；正常的大规模清理由用户调高 dreamMaxArchivePerRun。
+  const archiveCount = survivors.filter((d) => d.action === "archive").length;
+  const maxArchivePerRun = options.maxArchivePerRun ?? 8;
+  if (archiveCount > maxArchivePerRun) {
+    errors.push(`too many archive decisions: ${archiveCount} > ${maxArchivePerRun}`);
+  }
+  // Issue #89 防洗白核心（#104 方向 1 重审后保留）：全部决策都被跳过、合法
+  // 子集为空时仍整单拒绝——宽容的前提是「有合法子集可应用」；模型输出整体
+  // 非法（如全部幻觉 id）是真故障，不能被隐式 keep 洗成 ok。#104 只豁免
+  // 「有合法子集但覆盖率不足」的良性挑重点（见下方 coverageShortfall）。
+  if (options.skipInvalid === true && skipped.length > 0 && survivors.length === 0 && errors.length === 0) {
+    errors.push(`all ${skipped.length} decision(s) invalid — nothing valid survived validation`);
+    return { ok: false, errors, skipped, resolvedShortIds };
+  }
   // v0.4.4: 隐式 keep。默认（dreamImplicitKeep !== false）下，未 claim 的
   // snapshot 记忆自动补 {action:"keep"}，而不是整体拒绝——大记忆量下 LLM 漏报
   // 一两条就全拒（636 记忆 → 677 errors）会白白浪费整轮 run。设 false 则保留
   // 旧的严格"全量覆盖"校验。补齐的 keep 直接 append 到 decisions，调用方
   // （runDream/applyDecisions/audit）复用同一数组即可覆盖全部 snapshot 记忆。
   //
-  // v0.4.4 fix（残缺输出防洗白）：先收集所有非覆盖类 errors，有错直接 ok:false
-  // 且绝不 push 任何补齐 keep——残缺决策必须被真实拒绝，不能被隐式 keep 洗白成
-  // ok 后再 apply。只有无错时才检查显式覆盖率：LLM 输出被截断只 claim 少量
-  // snapshot（claimed.size / snapshot.size < dreamMinExplicitCoverage）时整单拒绝，
-  // 而不是用 keep 把绝大部分 snapshot 全部"通过"。
+  // v0.4.4 fix（残缺输出防洗白）→ Issue #104 方向 1 重审：显式覆盖率护栏的
+  // 初衷是拦「输出截断 → 只 claim 少量 → 其余被隐式 keep 洗白」，但它无法区分
+  // 恶性截断与良性挑重点——而提示词硬性规则本身要求「无问题的条目无需输出」，
+  // 挑重点正是要求的行为。官方路由 + 强模型的实测（heptaspirit：81 轮 failed
+  // 全是 coverage，LLM 调用本身成功、applied=0）证明这是常规路径而非边角。
+  // 处置：覆盖率不足不再 ok:false 整单拒绝，改为返回 coverageShortfall 理由、
+  // 照常补齐隐式 keep——调用方把 run 记 degraded（合法子集已应用），护栏以
+  // 状态暴露而非一票否决，与 skipInvalid 同一宽容哲学。明确异常信号（create
+  // 上限等硬错误）保持整单拒绝。要恢复旧行为可设 dreamImplicitKeep:false
+  // （严格模式，缺失即 error）或 dreamMinExplicitCoverage: 0（关护栏）。
+  // 非覆盖类硬错误（create 上限溢出、严格模式缺失 id）仍然先整单拒绝——
+  // #104 方向 1 只豁免 coverage 这一个信号，防洗白语义对它们原样保留。
   if (errors.length > 0) {
     return { ok: false, errors, skipped, resolvedShortIds };
   }
   const minCoverage = options.dreamMinExplicitCoverage ?? 0.5;
+  let coverageShortfall = null;
   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, skipped, resolvedShortIds };
+      coverageShortfall = `explicit decision coverage ${Math.round(coverage * 100)}% < minimum ${Math.round(minCoverage * 100)}%`;
     }
     for (const id of snapshot.keys()) {
       if (!claimed.has(id)) survivors.push({ action: "keep", ids: [id] });
@@ -252,7 +299,7 @@ export function validateDecisions(decisions, snapshot, options = {}) {
   // 当"被跳过的非法决策数 == 隐式补齐的 keep 数"时长度回到相等但内容已变，
   // 被跳过的决策会残留进 apply/audit。一律无条件 splice 最安全。
   decisions.splice(0, decisions.length, ...survivors);
-  return { ok: true, errors, skipped, resolvedShortIds };
+  return { ok: true, errors, skipped, resolvedShortIds, coverageShortfall };
 }
 
 /** Marker thrown when a decision target changed since the run snapshot. */

package/src/dream/sleep.js

@@ -239,8 +239,8 @@ async function phaseConflicts(ctx, service, config, logger, runId, semantic = nu
     maxTokens: 2048,
     ...(withEffort && sleepEffort ? { reasoningEffort: sleepEffort } : {}),
     messages: [
-      { role: "system", content: [{ type: "text", text: conflictPrompt }] },
-      { role: "user", content: [{ type: "text", text: listText }] }
+      { role: "system", content: [{ type: "text", text: conflictPrompt }], source: { kind: "plugin", plugin: "dsh-mneme" } },
+      { role: "user", content: [{ type: "text", text: listText }], source: { kind: "plugin", plugin: "dsh-mneme" } }
     ]
   }, (reason) => { conflictStreamFailure = describeStreamFailure(reason); });
   };
@@ -390,8 +390,8 @@ async function phasePatterns(ctx, service, config, logger, runId, signal = null)
     maxTokens: 2048,
     ...(withEffort && sleepEffort ? { reasoningEffort: sleepEffort } : {}),
     messages: [
-      { role: "system", content: [{ type: "text", text: STR.prompts.pattern[language].replace("N", String(maxPatterns)) }] },
-      { role: "user", content: [{ type: "text", text: listText }] }
+      { role: "system", content: [{ type: "text", text: STR.prompts.pattern[language].replace("N", String(maxPatterns)) }], source: { kind: "plugin", plugin: "dsh-mneme" } },
+      { role: "user", content: [{ type: "text", text: listText }], source: { kind: "plugin", plugin: "dsh-mneme" } }
     ]
   }, (reason) => { patternStreamFailure = describeStreamFailure(reason); });
   };
@@ -596,7 +596,33 @@ export function createSleepScheduler({
     const delay = Math.max(0, idleMs - (now() - lastWriteAt)) + 1000;
     idleTimer = setTimeoutFn(async () => {
       idleTimer = null;
-      await maybeSchedule();
+      // Issue #187：false = 撞上 CD（或 run 失败）——此前这里直接丢弃，"CD 到期"
+      // 成了没有监听者的时刻，要等下一次写入才救回来。改为按剩余窗口重排。
+      const ran = await maybeSchedule();
+      if (!ran) armNextWindow();
+    }, delay);
+    idleTimer.unref?.();
+  }
+
+  // Issue #187：撞 CD / run 失败后的补挂表——按「剩余 CD / 剩余静默」里更晚的
+  // 到点时刻重排一次，回调里重复同样的判断所以不会空转。跑成了一轮就不重排：
+  // 安静的库没有要处理的新东西，触发权交还给下一次写入的 noteWrite。
+  function armNextWindow() {
+    if (disposed || idleTimer) return;
+    if (config.sleepModeEnabled !== true) return;
+    // lastRunAt === 0 表示从未跑过（此路径不该出现，防御性返回）。
+    if (lastRunAt <= 0) return;
+    const idleMs = (config.sleepIdleMinutes ?? 5) * 60000;
+    const cdMs = (config.sleepMinIntervalHours ?? 8) * 3600000;
+    const delay = Math.max(
+      lastRunAt + cdMs - now(),
+      lastWriteAt + idleMs - now(),
+      0
+    ) + 1000;
+    idleTimer = setTimeoutFn(async () => {
+      idleTimer = null;
+      const ran = await maybeSchedule();
+      if (!ran) armNextWindow();
     }, delay);
     idleTimer.unref?.();
   }
@@ -665,5 +691,10 @@ export function createSleepScheduler({
     }
   }
 
+  // Issue #187（同族缺陷）：构造即挂表——重启后只要没发生过写入，此前永远没有
+  // 闹钟，安静多久都不会触发。lastWriteAt 已在构造时设为当前时刻，shouldRun 的
+  // 静默条件自然生效：重启后静默满 idleMinutes 才可能起跑。
+  armIdleTimer();
+
   return { noteWrite, maybeSchedule, shouldRun, dispose };
 }