@modusensus/dsh-mneme 0.1.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Modusensus
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,179 @@
+# dsh-mneme
+
+> 给 DeepSeek Harness 的跨会话记忆插件：让 Agent 记住你、记住项目、自动整理记忆。
+
+`dsh-mneme` 是一个 [DeepSeek Harness (DSH)](https://github.com/deepseek-ai/deepseek-harness) 插件，为 Agent 提供持久的跨会话记忆能力。它借鉴了 Claude 的 **Dream 机制** 与 cc-haha / Claude Code 的 **autoDream** 实现思路——不仅**存储**记忆，还会**自动巩固**（去重、合并、冲突裁决、摘要生成），让记忆库越用越精炼。
+
+## ✨ 功能
+
+### 记忆存储（SQLite + Markdown 镜像）
+
+- **SQLite 主存储**：`~/.dsh/memory/memory.db`，`node:sqlite` 内置，零原生依赖
+- **Markdown 镜像**：`preferences.md` / `projects.md` / `decisions.md` / `history.md` / `summary.md`，人类可读、可手工编辑（**人工修改优先**合并回库）
+- **4+1 种记忆类型**：`preference`（偏好）/ `project`（项目）/ `decision`（决策）/ `history`（历史）/ `summary`（总览）
+
+### 模型工具（6 个）
+
+| 工具 | 功能 |
+|------|------|
+| `memory_save` | 记录一条记忆（自动按标题去重合并） |
+| `memory_search` | 全文搜索（中文子串友好） |
+| `memory_list` | 按类型分页列出 |
+| `memory_update` | 修改已有记忆 |
+| `memory_delete` | 删除记忆 |
+| `memory_forget` | 抑制注入（降权不删除，可恢复） |
+
+### 自动注入 + 会话摘要
+
+- **自动注入**：新会话开局注入记忆摘要（`summary` 优先 + 少量高重要性条目）
+- **会话摘要**：`turn/end` 时用 LLM 提炼本次会话的偏好/决策/教训，自动入库（过滤 plugin 注入上下文，避免污染）
+
+### autoDream 自动记忆整理 🧠
+
+- **触发**：记忆数 > 10 或总字符 > 5000 时，异步自动触发（不阻塞写入）
+- **决策清单式整理**：LLM 输出 `keep` / `merge` / `archive` / `conflict` 决策清单，服务端校验后逐条应用
+  - `merge`：合并主题相近的条目，保留信息最完整者
+  - `archive`：归档过时/冗余条目（可恢复，不物理删除）
+  - `conflict`：裁决矛盾信息，胜者保留、败者归档并追加溯源注释
+- **摘要生成**：整理后生成"记忆库总览"（单一实例），作为下次会话的优先注入
+- **Fail-safe**：非法 LLM 输出（未知 id / 非法 action / 跨类型合并 / 越界 importance）拒绝整单，绝不破坏记忆库
+
+### Web 记忆面板
+
+侧边栏"记忆"按钮 → 模态面板：按类型浏览、全文搜索、查看详情。
+
+## 📦 安装
+
+### 前置条件
+
+- [DeepSeek Harness](https://github.com/deepseek-ai/deepseek-harness)（DSH）
+- Node 24+（`node:sqlite`）
+
+### 安装步骤
+
+#### 方式一：npm 安装（推荐）
+
+```bash
+# 1. 在 DSH web profile 安装插件
+dsh plugin --profile web add @modusensus/dsh-mneme
+
+# 2. 在 ~/.dsh/profiles/web/cordis.patch.yml 注册插件（见下方配置块）
+# 3. 重启
+dsh web
+```
+
+#### 方式二：从源码安装
+
+```bash
+git clone https://github.com/modusensus/dsh-mneme.git
+```
+
+在 `~/.dsh/profiles/web/package.json` 添加依赖：
+
+```json
+{
+  "dependencies": {
+    "@modusensus/dsh-mneme": "file:/path/to/dsh-mneme"
+  }
+}
+```
+
+#### 插件注册（`~/.dsh/profiles/web/cordis.patch.yml`）
+
+```yaml
+- insert:
+    - id: dsh-mneme
+      name: '@modusensus/dsh-mneme'
+      config:
+        memoryDir: ~/.dsh/memory
+        autoInject: true
+        autoSummarize: true
+        maxInjectedItems: 5
+        importanceThreshold: 3
+        autoDream: true
+        dreamThresholdCount: 10
+        dreamThresholdChars: 5000
+        dreamDelayMs: 2000
+```
+
+最后安装依赖并重启：
+
+```bash
+cd ~/.dsh/profiles/web
+pnpm install
+dsh web
+```
+
+## ⚙️ 配置
+
+| 键 | 默认值 | 说明 |
+|----|--------|------|
+| `memoryDir` | `~/.dsh/memory` | 记忆存储目录（SQLite + Markdown） |
+| `autoInject` | `true` | 会话启动自动注入记忆 |
+| `autoSummarize` | `true` | 会话结束自动提炼摘要 |
+| `maxInjectedItems` | `5` | 最多注入几条记忆 |
+| `importanceThreshold` | `3` | 注入的最低重要性（1-5） |
+| `autoDream` | `true` | 自动记忆整理开关 |
+| `dreamThresholdCount` | `10` | 触发整理的记忆条数阈值 |
+| `dreamThresholdChars` | `5000` | 触发整理的总字符阈值 |
+| `dreamDelayMs` | `2000` | 整理异步延迟（去抖） |
+| `dreamProvider` / `dreamModel` | 空 | dream 的 LLM 路由回退（默认用 agent 默认模型） |
+
+## 🏗️ 架构
+
+```
+┌─────────────────────────────────────────────────┐
+│  存储层：SQLite (archived/forgotten 状态)         │
+│         + Markdown 镜像（人工可编辑，双向同步）    │
+├─────────────────────────────────────────────────┤
+│  服务层：saveWithDedupe / injectCandidates        │
+│         / mergeHumanEdits / onWrite 钩子          │
+├─────────────────────────────────────────────────┤
+│  模型接口：6 个工具 + 自动注入 + 会话摘要          │
+├─────────────────────────────────────────────────┤
+│  autoDream：阈值调度 → LLM 决策清单               │
+│            → 校验（fail-safe）→ 应用 → 摘要       │
+├─────────────────────────────────────────────────┤
+│  Web 面板：侧边栏入口 + 浏览/搜索/详情            │
+└─────────────────────────────────────────────────┘
+```
+
+**源码结构**：
+
+```
+src/
+├── store.js          # SQLite 存储（CRUD、搜索、归档/遗忘、schema 迁移）
+├── mirror.js         # Markdown 镜像（渲染/解析，人工优先）
+├── service.js        # 领域逻辑（去重合并、注入筛选、写入钩子）
+├── config.js         # schemastery 配置 schema
+├── tools.js          # 6 个模型工具（defineTool）
+├── inject.js         # systemPrompt.context 动态注入
+├── summarize.js      # 会话结束 LLM 摘要
+├── dream.js          # autoDream 调度 + runDream（LLM 决策 + 摘要）
+├── dream/decisions.js# 决策校验（fail-safe）+ 决策应用
+├── api.js            # HTTP 路由（Web 面板数据通道）
+└── index.js          # 插件接线
+lib/
+├── client.js         # Web 面板（手写 ModuleLoader bundle）
+└── *.js              # src 的同步分发产物
+test/                 # 104 个 node:test 测试
+```
+
+## 🧪 开发
+
+```bash
+cd dsh-mneme
+node --test --test-isolation=none test/*.test.js
+```
+
+> 注：`--test-isolation=none` 用于受限沙箱（禁止子进程 spawn）；普通环境可直接 `node --test`。
+
+## 📄 设计文档
+
+- [记忆库设计](docs/superpowers/specs/2026-08-13-dsh-memory-design.md)
+- [autoDream 设计](docs/superpowers/specs/2026-08-13-dsh-memory-autodream-design.md)
+- [实施计划](docs/superpowers/plans/2026-08-13-dsh-memory-autodream.md)
+
+## 📜 License
+
+MIT

package/lib/api.js

@@ -0,0 +1,59 @@
+import { URL } from "node:url";
+
+function sendJson(res, status, payload) {
+  res.writeHead(status, { "Content-Type": "application/json; charset=utf-8" });
+  res.end(JSON.stringify(payload));
+}
+
+export function createApi(ctx, service) {
+  const disposers = [];
+
+  // /api/dsh-mneme prefix fallback → 404 JSON for unknown sub-paths
+  disposers.push(ctx.webServer.register({
+    kind: "prefix",
+    path: "/api/dsh-mneme",
+    handler(req, res) {
+      sendJson(res, 404, { error: "not-found" });
+    }
+  }));
+
+  disposers.push(ctx.webServer.register({
+    kind: "exact",
+    path: "/api/dsh-mneme/list",
+    handler(req, res) {
+      try {
+        const url = new URL(req.url, "http://localhost");
+        const type = url.searchParams.get("type") ?? undefined;
+        const limit = Number(url.searchParams.get("limit") ?? 50);
+        const offset = Number(url.searchParams.get("offset") ?? 0);
+        const items = service.toApiList(service.list({ type, limit, offset }));
+        sendJson(res, 200, { items, total: service.count(type) });
+      } catch {
+        sendJson(res, 500, { error: "internal" });
+      }
+    }
+  }));
+
+  disposers.push(ctx.webServer.register({
+    kind: "exact",
+    path: "/api/dsh-mneme/search",
+    handler(req, res) {
+      try {
+        const url = new URL(req.url, "http://localhost");
+        const q = url.searchParams.get("q") ?? "";
+        const limit = Number(url.searchParams.get("limit") ?? 20);
+        const items = service.toApiList(service.search(q, { limit }));
+        sendJson(res, 200, { items });
+      } catch {
+        sendJson(res, 500, { error: "internal" });
+      }
+    }
+  }));
+
+  return {
+    routes: 3,
+    dispose: () => {
+      for (const dispose of disposers) dispose();
+    }
+  };
+}

package/lib/client.js

@@ -0,0 +1,187 @@
+window.__ModuleLoader__.load({
+  id: "dsh-mneme",
+  factory: (require) => {
+    var module = { exports: {} };
+    var exports = module.exports;
+
+    let react = require("react");
+    let reactDom = require("react-dom");
+    let { useState, useEffect, useCallback, useRef } = react;
+    let { createPortal } = reactDom;
+
+    const inject = ["slots", "locale"];
+
+    const NS = "memory";
+
+    const dictionaries = {
+      zh: {
+        "memory.panel.title": "记忆库",
+        "memory.panel.search": "搜索记忆…",
+        "memory.panel.empty": "暂无记忆条目",
+        "memory.panel.open": "记忆",
+        "memory.tab.all": "全部",
+        "memory.tab.preference": "偏好",
+        "memory.tab.project": "项目",
+        "memory.tab.decision": "决策",
+        "memory.tab.history": "历史"
+      },
+      en: {
+        "memory.panel.title": "Memory",
+        "memory.panel.search": "Search memories…",
+        "memory.panel.empty": "No memories yet",
+        "memory.panel.open": "Memory",
+        "memory.tab.all": "All",
+        "memory.tab.preference": "Preferences",
+        "memory.tab.project": "Projects",
+        "memory.tab.decision": "Decisions",
+        "memory.tab.history": "History"
+      }
+    };
+
+    function typeLabel(t, type) {
+      const key = `memory.tab.${type}`;
+      const label = t(key);
+      return label && label !== key ? label : String(type);
+    }
+
+    function formatDate(value) {
+      if (!value) return "—";
+      const date = new Date(value);
+      return Number.isNaN(date.getTime()) ? "—" : date.toLocaleString();
+    }
+
+    function MemoryPanel({ t, onClose }) {
+      const [tab, setTab] = useState("all");
+      const [query, setQuery] = useState("");
+      const [items, setItems] = useState([]);
+      const [loading, setLoading] = useState(false);
+      const abortRef = useRef(null);
+
+      const load = useCallback(async () => {
+        abortRef.current?.abort();
+        const controller = new AbortController();
+        abortRef.current = controller;
+        setLoading(true);
+        try {
+          const params = new URLSearchParams();
+          if (tab !== "all") params.set("type", tab);
+          const url = query.trim()
+            ? `/api/dsh-mneme/search?q=${encodeURIComponent(query.trim())}`
+            : `/api/dsh-mneme/list?${params.toString()}`;
+          const res = await fetch(url, { signal: controller.signal });
+          const data = await res.json();
+          setItems(data.items || []);
+        } catch (error) {
+          if (error.name === "AbortError") return;
+          setItems([]);
+        } finally {
+          setLoading(false);
+        }
+      }, [tab, query]);
+
+      useEffect(() => {
+        load();
+        return () => abortRef.current?.abort();
+      }, [load]);
+
+      const tabs = ["all", "preference", "project", "decision", "history"];
+
+      return createPortal(
+        react.createElement("div", { style: styles.overlay },
+          react.createElement("div", { style: styles.panel },
+            react.createElement("div", { style: styles.header },
+              react.createElement("span", { style: styles.title }, t("memory.panel.title")),
+              react.createElement("button", { style: styles.close, onClick: onClose }, "×")
+            ),
+            react.createElement("input", {
+              style: styles.search,
+              placeholder: t("memory.panel.search"),
+              value: query,
+              onChange: (e) => setQuery(e.target.value)
+            }),
+            react.createElement("div", { style: styles.tabs },
+              tabs.map((key) =>
+                react.createElement("button", {
+                  key,
+                  style: { ...styles.tab, ...(tab === key ? styles.tabActive : {}) },
+                  onClick: () => setTab(key)
+                }, t(`memory.tab.${key}`))
+              )
+            ),
+            react.createElement("div", { style: styles.list },
+              loading
+                ? react.createElement("div", { style: styles.hint }, "…")
+                : items.length === 0
+                  ? react.createElement("div", { style: styles.hint }, t("memory.panel.empty"))
+                  : items.map((item) =>
+                      react.createElement("div", { key: item.id, style: styles.card },
+                        react.createElement("div", { style: styles.cardTitle },
+                          react.createElement("span", null, item.title),
+                          react.createElement("span", { style: styles.badge },
+                            `${typeLabel(t, item.type)} · ★${item.importance}`
+                          )
+                        ),
+                        react.createElement("div", { style: styles.cardContent }, item.content),
+                        react.createElement("div", { style: styles.cardMeta },
+                          formatDate(item.updated_at)
+                        )
+                      )
+                    )
+            )
+          )
+        ),
+        document.body
+      );
+    }
+
+    const styles = {
+      overlay: { position: "fixed", inset: 0, background: "rgba(0,0,0,0.4)", zIndex: 1000, display: "flex", alignItems: "center", justifyContent: "center" },
+      panel: { background: "var(--dsw-alias-bg-base, #fff)", borderRadius: 12, width: 640, maxWidth: "90vw", maxHeight: "80vh", display: "flex", flexDirection: "column", padding: 16, boxShadow: "0 8px 40px rgba(0,0,0,0.2)" },
+      header: { display: "flex", justifyContent: "space-between", alignItems: "center", marginBottom: 12 },
+      title: { fontSize: 16, fontWeight: 600 },
+      close: { border: "none", background: "none", fontSize: 20, cursor: "pointer", color: "var(--dsw-alias-label-secondary, #666)" },
+      search: { padding: "8px 12px", borderRadius: 8, border: "1px solid var(--dsw-alias-border-l2, #ddd)", marginBottom: 12, fontSize: 14 },
+      tabs: { display: "flex", gap: 6, marginBottom: 12, flexWrap: "wrap" },
+      tab: { padding: "4px 10px", borderRadius: 999, border: "1px solid var(--dsw-alias-border-l2, #ddd)", background: "none", cursor: "pointer", fontSize: 12 },
+      tabActive: { background: "var(--dsw-alias-interactive-bg-active, #eee)" },
+      list: { overflowY: "auto", display: "flex", flexDirection: "column", gap: 8 },
+      hint: { color: "var(--dsw-alias-label-tertiary, #999)", padding: "24px 0", textAlign: "center" },
+      card: { border: "1px solid var(--dsw-alias-border-l1, #eee)", borderRadius: 8, padding: "10px 12px" },
+      cardTitle: { display: "flex", justifyContent: "space-between", alignItems: "center", marginBottom: 4, fontSize: 14, fontWeight: 600 },
+      badge: { fontSize: 11, color: "var(--dsw-alias-label-tertiary, #999)" },
+      cardContent: { fontSize: 13, color: "var(--dsw-alias-label-secondary, #555)", marginBottom: 4, whiteSpace: "pre-wrap", wordBreak: "break-word" },
+      cardMeta: { fontSize: 11, color: "var(--dsw-alias-label-tertiary, #999)" },
+      footerButton: { padding: "4px 10px", borderRadius: 8, border: "1px solid var(--dsw-alias-border-l2, #ddd)", background: "none", cursor: "pointer", fontSize: 12, margin: "2px 8px" },
+      footerButtonActive: { background: "var(--dsw-alias-interactive-bg-active, #eee)" }
+    };
+
+    function apply(ctx) {
+      ctx.effect(() => ctx.locale.register(NS, dictionaries), "dsh-mneme: dictionaries");
+
+      ctx.effect(() => {
+        const t = ctx.locale.bind(NS);
+        return ctx.slots.inject("sidebar.footer.action", () =>
+          ctx.slots.register({
+            name: "sidebar.footer.action",
+            id: "memory",
+            locale: NS,
+            inject: () => ({})
+          }, () => {
+            const [open, setOpen] = react.useState(false);
+            return react.createElement(react.Fragment, null,
+              react.createElement("button", {
+                onClick: () => setOpen(true),
+                style: { ...styles.footerButton, ...(open ? styles.footerButtonActive : {}) }
+              }, t("memory.panel.open")),
+              open && react.createElement(MemoryPanel, { t, onClose: () => setOpen(false) })
+            );
+          })
+        );
+      }, "dsh-mneme: sidebar action");
+    }
+
+    exports.apply = apply;
+    exports.inject = inject;
+    return module.exports;
+  }
+});

package/lib/config.js

@@ -0,0 +1,15 @@
+import z from "@deepseek-ai/schemastery";
+
+export const Config = z.object({
+  memoryDir: z.string().default("~/.dsh/memory"),
+  autoInject: z.boolean().default(true),
+  autoSummarize: z.boolean().default(true),
+  maxInjectedItems: z.natural().min(1).max(20).default(5),
+  importanceThreshold: z.natural().min(1).max(5).default(3),
+  autoDream: z.boolean().default(true),
+  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),
+  dreamProvider: z.string(),
+  dreamModel: z.string()
+});

package/lib/dream/decisions.js

@@ -0,0 +1,121 @@
+const ACTIONS = new Set(["keep", "merge", "archive", "conflict"]);
+
+/**
+ * Validate a dream decision list against a snapshot of eligible memories.
+ * @param decisions - LLM-produced decision list.
+ * @param snapshot - Map<id, memory> of eligible (non-archived, non-summary) entries.
+ * @returns {{ok: boolean, errors: string[]}}
+ */
+export function validateDecisions(decisions, snapshot) {
+  const errors = [];
+  if (!Array.isArray(decisions) || decisions.length === 0) {
+    return { ok: false, errors: ["decision list must be a non-empty array"] };
+  }
+  const claimed = new Set();
+  for (const [index, d] of decisions.entries()) {
+    const at = `decision[${index}]`;
+    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") {
+      if (!d.winner || !d.loser || d.winner === d.loser) {
+        errors.push(`${at}: conflict needs distinct winner and loser`);
+        continue;
+      }
+    } else if (!Array.isArray(d.ids) || d.ids.length === 0) {
+      errors.push(`${at}: ${d.action} needs non-empty ids`);
+      continue;
+    }
+    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 (claimed.has(id)) {
+        errors.push(`${at}: id ${JSON.stringify(id)} claimed by multiple decisions`);
+      }
+      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(", ")})`);
+      }
+    }
+  }
+  // Every snapshot id must appear in at least one decision
+  for (const id of snapshot.keys()) {
+    if (!claimed.has(id)) errors.push(`memory ${JSON.stringify(id)} missing from decisions`);
+  }
+  return { ok: errors.length === 0, errors };
+}
+
+/**
+ * Apply a validated decision list to the service. Caller must validate first.
+ *
+ * Note: merge is intentionally non-atomic — the keeper is updated before the
+ * other sources are archived, so a failure between the two never loses content.
+ *
+ * @param decisions - validated decision list.
+ * @param service - memory service (saveWithDedupe/getById/update/setArchived).
+ * @param logger - optional logger ({ warn }); per-decision failures are logged.
+ * @returns number of applied decisions (archive counts each archived memory as one).
+ */
+export function applyDecisions(decisions, service, logger = null) {
+  let applied = 0;
+  for (const [i, d] of decisions.entries()) {
+    try {
+      if (d.action === "keep") continue;
+      if (d.action === "archive") {
+        for (const id of d.ids) {
+          const mem = service.getById(id);
+          if (mem && !mem.archived) { service.setArchived(id, true); applied++; }
+        }
+      } else if (d.action === "merge") {
+        const keeper = service.getById(d.keepSource);
+        if (!keeper || keeper.archived) continue;
+        service.update(d.keepSource, {
+          title: d.title,
+          content: d.content,
+          importance: d.importance ?? Math.max(keeper.importance, ...d.ids.map((id) => service.getById(id)?.importance ?? 1))
+        });
+        for (const id of d.ids) {
+          if (id !== d.keepSource) {
+            const mem = service.getById(id);
+            if (mem && !mem.archived) { service.setArchived(id, true); }
+          }
+        }
+        applied++;
+      } else if (d.action === "conflict") {
+        const winner = service.getById(d.winner);
+        const loser = service.getById(d.loser);
+        if (!winner || !loser) continue;
+        service.update(d.winner, {
+          content: `${winner.content}\n\n（已否决旧信息：${[...loser.content].slice(0, 100).join("")}）`
+        });
+        service.setArchived(d.loser, true);
+        applied++;
+      }
+    } catch (error) {
+      // Skip individual bad decision; never corrupt the store. The optional
+      // logger makes the failure visible instead of failing silently.
+      logger?.warn?.(`dsh-mneme dream: failed to apply ${d.action} at index ${i}: ${error.message}`);
+    }
+  }
+  return applied;
+}