npm - @max-null/dsh-memory - Versions diffs - 0.15.0 → 0.16.0 - Mend

@max-null/dsh-memory 0.15.0 → 0.16.0

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (11) hide show

package/README.md CHANGED Viewed

@@ -1,163 +1,188 @@
-# dsh-memory
-本插件属于 **`@max-null/*` 插件系列**——这一系列共同构成 **[SSID（思灵 · Seek Soul in Darkness）](https://github.com/Max-Null/seek-soul-in-darkness)** 桌面体验。SSID 是整合它们的盒：`dsh-capture` · `dsh-chat-rail` · `dsh-chinese-thinking` · `dsh-draft-polish` · `dsh-guardian` · `dsh-habit` · `dsh-memory` · `dsh-node-appearance` · `dsh-plugin-center` · `dsh-quick-toolbar` · `dsh-skill-mcp-center` · `dsh-ssid-panels` · `dsh-ssid-zh-ui` · `dsh-achievements`。
-This plugin belongs to the **`@max-null/*` family** — a set of plugins that together form the **[SSID (思灵 · Seek Soul in Darkness)](https://github.com/Max-Null/seek-soul-in-darkness)** desktop experience.
-一个面向 [DeepSeek Harness](https://github.com/deepseek-ai/deepseek-harness) 的**跨会话明文记忆插件**。遵循「一切皆插件」——它不修改 DSH 源码，声明 `name`/`inject`/`apply`，由 Loader 从 `cordis.yml` 加载。
-## 设计原则
-1. **写入即生效，人是例外干预者**：模型写入的记忆直接生效（`approved`），不再逐条等人放行；人保留随时查看、改写、删除、钉住或回滚的能力——人不在场不等于失控。
-2. **可观测先于精准**：每条记忆是明文，`memory_list` 随时可见、`memory_forget` 随时删除——不存在"静默暗礁"。
-3. **明文是人机共享的审计窗口**：记忆是可读文本，模型可自检其是否过期（有效性锚点会在所绑环境值变化后标记 `stale`），人可随时查看与改写。
-4. **确定性且缓存安全**：BM25 关键词检索是存储的纯函数、无 LLM 调用；固定指引进 system-prompt section，`approved + injected` 记忆进 recall context（global 全量 + 当前会话工作区），逐条为单行摘要并按注入预算截断（超预算按最近使用优先，省略数在面板可见）。
-## 截图
-装完后在设置里多出「记忆」一项，可查看与管理跨会话记忆：
-**入口：** 设置 → 记忆
-| 设置入口与面板 |
-|---|
-| ![设置 → 记忆](docs/shots/memory-settings-1.png) |
-## 用法
-```bash
-npm install @max-null/dsh-memory
-```
-在你的 `cordis.yml` 加一条（其余 storage / system-prompt / tools 由宿主已有；记忆的存储后端由插件自己注册）：
-```yaml
-- id: memory
-  name: '@max-null/dsh-memory'
-```
-## 提供的服务与工具
-- **服务** `ctx.memory`：`remember` / `list` / `search` / `forget` / `setStatus` / `move`
-- **工具**：`memory_save`、`memory_list`、`memory_search`、`memory_confirm`、`memory_forget`、`memory_update`、`memory_move`
-- **注入**：`tool:memory` 指引 section（工具用法 + 常驻注入判据）+ `memory:self` 机制自述 + `memory:recall` 召回 context（global 的 `approved + injected` + 当前会话工作区的 `approved + injected`，带 `[memory:<id>:<namespace>]` 来源标记；摘要化 + 预算截断）
-- **检索**：BM25（CJK 单字 + 2-gram，content 与 keywords 字段分离加权；中文多字查询精度显著优于单字切分）；可选语义融合（见「可选配置」）
-## 两层存储（global / project）
-记忆按 `namespace` 分两层物理存储，各落在独立的明文 JSON：
-| namespace | 默认位置 | 用途 |
-|---|---|---|
-| `global` | `$DSH_HOME/storages/memory.json` | 跨项目的个人偏好 |
-| `project` | `<cwd>/.dsh/storages/memory_project_<hash>.json` | 跟随仓库的项目共识，可 git 分享 |
-两个根都可用 config 覆盖（`globalRoot` / `projectRoot`）。`memory_list` / `memory_search` 不带 `namespace` 过滤时会同时查两层。旧版双重前缀文件名（`memory_project_memory_project_<hash>.json`）在打开时自动迁移为规范名。
-## 跨工作区可见性（0.10.0 / 0.11.0）
-project 记忆按**会话工作区**分文件存放，所以「工作区」就是可见性的边界。0.10.0 起补了三个方向——针对的是同一个盲区：**不知道存在**（检索是有意图的动作，搜不出自己不知道存在的东西）。
-| 方向 | 机制 | 效果 |
-|---|---|---|
-| 向上 | **祖先链** | 在子目录里开会话能检索到父目录的记忆（反向不行，链是单向向上的），结果带 `..` / `../..` 来源标记 |
-| 向下 | **子项目索引行** | 注入里多一行「本工作区下另有 N 个子项目带记忆：xxx（M 条）——用 memory_search 检索」 |
-| 全局 | **记忆索引行** | 注入里多一行「索引：当前可见 N 条记忆，主题集中在 X(14)、Y(12)…——用 memory_search 检索」 |
-三条边界：**写入永远只落当前工作区**（「我在这个项目里记的东西」不该被推理到别处）；但**检索得到的记录就改得动**——`memory_update` / `memory_forget` 同样沿链定位；**注入路径只读当前工作区**（远处的记忆进检索、不进每轮成本）。
-**0.11.0 起，「放错了层」有了显式的修正通道**：`memory_move(id, to)` 把一条记忆移到 `global`、`self`（当前工作区）或相对祖先（`..` / `../..`）。它是**例外动作**——默认写入仍然只落当前工作区，只有当你判定「这条其实属于上一层、或上一层的那一支」时才动它。移动**保持 id**、**从源层删除**（不是复制），并报告移动后源层是否仍看得见它：向上移动源层不失明（继承只向上，`global` 人人可见），向下移动则会让源层及其下层从此看不见它。典型用途是**把放高了的记忆降回它真正属于的工作区**——比如只属于某一个生态的规矩躺在 `global` 里、漏进了无关项目。判据与边界见设计文档 §3.2。
-后两行**不占注入预算**、自消除（没有内容时整行不出现），且**长度常数级**——不随记忆增长。索引行里的主题取自各条的关键词词频，与检索用的是同一套词汇，所以**索引里出现的词就是能搜到的词**。
-**孤儿文件清点**：`node scripts/scan-orphans.mjs [根目录]` 报出「哪些记忆文件当前代码已经打不开」（历史命名遗留：早期无哈希后缀、双重 `memory_project_` 前缀）。**只读，不做任何处置**——旧文件可能含未过隔离检查的内容，处置需人工拍板。
-**祖先链诊断与探针**：`node scripts/ancestor-probe.mjs plan [--cwd <会话 cwd>]` 只读地复算该 cwd 的祖先链（哪些层级带记忆文件、引擎会纳入几级），并回答「这个 cwd 上祖先链是否**可观测**」——若以上祖先层都没有记忆文件，祖先链生效与否行为逐字相同，那是个零差异的观测点。要实测检索侧跨链，用 `seed` / `check` / `clean` 在祖先层造一条临时探针再撤销。**前提**：探针只对**没打开过该层**的会话有效——引擎的表打开即缓存，而写路径的新鲜度门（`refreshForWrite`）只比对 global 与当前 cwd，**不含祖先层**，被缓存过的层会用陈旧内存态覆盖掉外部写入。
-## 多实例共存（0.7.1）
-两个 DSH 实例（例如 DSH web 与 SSiD 桌面壳）可以同时运行、共用同一个 `DSH_HOME`，**记忆不再互相抹掉**。
-DSH 存储层的写入是「读—改—写全量覆盖」，且官方两个后端都声明不做跨进程协调（`storage-json`：*writer per process and last-write-wins is correct*；`storage-sqlite`：*cross-process coordination is out of scope*）。插件层的处置是**写前重读**（等价于 update 前先 select）：每次写入在串行区里先比对存储文件指纹（mtime + size），发现磁盘被别的实例动过就先重载再写。代价是磁盘没变时的一次 `statSync`。
-残余窗口只剩两个实例在**同一瞬间**写——此时后写者赢；同时写**不同**记忆已不再互相影响。
-**未覆盖**：`workspace.json`（工作区登记）由 DSH 自己的 workspace 服务写，插件层够不着，仍会被双实例互相覆盖；根因处置在上游——[discussion #6882](https://github.com/deepseek-ai/deepseek-harness/discussions/6882)。当前防线是轮转快照备份（SSiD 侧 `shell/scripts/backup-storages.mjs` + 计划任务）。
-## 使用流程（写入即生效，人为例外干预）
-提示词模板库（0.6.0）：`prompt_search / prompt_get / prompt_list / prompt_add` 四个工具管理**模板库**——
-md 文件是唯一事实源（`~/.dsh/prompt-library/*.md` 为 global；`<workspace>/.dsh/prompt-library/` 随工作区分享），
-前端（记忆面板「模板」tab / 模型工具）检索同一份索引；模板存在即生效（`source: agent` 角标标识模型新增），
-**永不注入 system prompt**。
-```
-模型 memory_save     →  status: approved，立即生效；命中密钥/凭据规则则隔离（不进检索也不进注入）
-                        给 injected 则同时钉住常驻（0.8.0），不吃下面两条自动规则
-memory_search        →  关键词/语义召回（只搜记忆；模板走 prompt_search 通道，不会混进候选池）
-命中累计 2 次         →  injected: true（自动打开常驻：global + 当前会话工作区，摘要化 + 预算截断）
-30 天未再命中         →  自动撤下常驻（只撤自动开的；人工或模型显式动过的开关双向豁免）
-人（面板 / 开关）     →  钉住 / 删除 / 放行隔离记录 / 回滚
-memory_forget        →  随时删除（删除始终是人的动作）
-```
-两条自动规则撑起淘汰机制：**反复被检索命中**是它值得每轮付费的证据，**长期不再被命中**则自动退出常驻。两者都不删除任何内容——记忆不会无限累积，也不会被系统自行清空。
-自动规则对**低频但关键**的记忆（长期约定、判据、委托）够不着：它们不会被反复检索，够不到阈值；勉强够到也会被 30 天撤下。这类走显式路径——在 `memory_save` / `memory_update` 里给 `injected` 即钉住，写的是与面板开关同一套语义（`injectedAuto: false`），此后不受两条自动规则影响。未审核与已隔离的记录不接受注入。
-注入有**字符预算**（默认 1500，config `injectionBudget`）：装不下的条目**整条丢弃**（不截内容），按「最近更新优先」取舍——所以 `injected: true` 不等于「每轮真的在场」，它只保证有资格排队。0.9.0 起这种出局不再无声：注入末尾会追加一行 `（另有 N 条常驻因预算未注入：…）`，0.9.1 起列出的是**每条的短摘要**而不是 id——查 id 是什么的那一步最容易省略，省略了就等于没报；**清理干净即自行消失**。面板的注入预览里也能展开看明细。诊断行本身不占预算。
-记忆还可声明**有效性锚点**（环境变量 / 工具清单 / 插件版本）：所绑的值变化后，这条记忆被标记 `stale` 并撤下常驻，检索结果里也带出失效提示——环境变了，旧结论就不再被当成仍然正确。
-模型写入不需要人点头，但**人始终能看见并推翻**：面板按「隔离区 / 常驻 / 冷数据」分组，被隔离的记录必须由人放行才会重新进入检索。
-## 为什么明文 + BM25，而不是向量检索
-向量检索的记忆本体是一串不可读的数字，过期信息会成为**无法观测、无法修复的静默暗礁**；BM25 + 明文让每一次召回都可解释、每一条记忆都可见可删。语义（向量）检索作为**可插拔的可选项**（0.5.2，见「可选配置」）——记忆本体仍是明文，向量仅作为检索辅助字段（`vector`，明文可读），且以"可观测 + 可修复"为门槛。
-明文还有一层**跟随仓库分享**的好处：`project` 命名空间的记忆落在项目文件夹内（`<cwd>/.dsh/storages/memory_project_<hash>.json`），随 `git` 提交、分享给所有协作者；`global` 命名空间的记忆留在本地 `$DSH_HOME`。团队的共识（"本项目统一用 Vue3 `<script setup>`"）能沉淀进仓库，而不是散落在每个人的本地。FTS5 的 SQLite 二进制无法这样"跟着仓库走"。
-## 可选配置
-在 `cordis.yml` 的 `config` 里传给插件（均可省略）：
-```yaml
-- id: memory
-  name: '@max-null/dsh-memory'
-  config:
-    injectionBudget: 1500        # 常驻注入预算（字符；null = 不限制）
-    summaryChars: 80             # 单条注入摘要截断上限（字符）
-    semanticTopK: 5              # 语义侧参与融合的 topK（仅配置 embeddings 时生效）
-    # 混合语义检索（可插拔；缺省 = 纯 BM25）
-    # embeddings: { embed: '...' 提供 embed(texts) 的宿主函数 或 插件名 ... }
-```
-`embeddings` 接受 `{ embed(texts): Promise<number[][]>, similarity? }` 对象——由宿主装配层提供嵌入实现（如 DeepSeek 嵌入端点）；配置后 `memory_search` 以 BM25 + 语义 RRF 融合，向量增量生成并持久化，嵌入调用失败自动降级为纯 BM25。
-## SSID 系列
-本插件是 **[SSID（思灵 · Seek Soul in Darkness）](https://github.com/Max-Null/seek-soul-in-darkness)** 全家桶的一员；也可以单独安装到任意 DSH profile——除设置页的记忆面板外不依赖其它同系列插件。
-## 开发
-```bash
-npm install
-npm run typecheck   # tsc 严格类型检查
-npm test            # vitest 单测
-npm run build       # 产出 dist/
-node scripts/verify-loader.mjs   # 用 Loader 端到端验证插件可加载
-node scripts/scan-orphans.mjs [根目录]       # 清点「当前代码打不开」的记忆文件（只读）
-node scripts/unzstd-frames.mjs <源> <目标>   # 解多帧 zstd（读 DSH 会话日志用）
-node scripts/ancestor-probe.mjs plan [--cwd <cwd>]   # 复算祖先链（只读）；seed/check/clean 验 ④-A
-node scripts/analyze-cooccurrence.mjs        # 关键词共现分析（记忆之间有没有关系网，只读）
-npm run check:memory        # 记忆文件存量体检（只读；0 = 全绿 / 1 = 有不合规 / 2 = 用法错）
-```
-## 依赖（peerDependencies，由宿主提供）
-`@deepseek-ai/cordis`（`^4.0.1`），以及 `@deepseek-ai/dsh-storage`、`@deepseek-ai/dsh-storage-domain`、`@deepseek-ai/dsh-storage-json`、`@deepseek-ai/dsh-system-prompt`、`@deepseek-ai/dsh-tools`、`@deepseek-ai/dsh-typert-protocol`——后面六个声明为 **`>=0.1.1-rc.1 <0.3.0`**。
-**为什么写显式范围而不是 caret**：caret 的上界是「下一个 minor」——`^0.1.1-rc.1` 展开为 `>=0.1.1-rc.1 <0.2.0-0`，内核一跨 minor 就判定不满足。而 peer 不满足时插件**不会被加载，也不会出现在 `did not activate` 列表里**：它在进入 fiber 图之前就被跳过，界面不报错，只表现为少一批功能。写成显式范围让 0.1 线与 0.2 线都能装载。
-**验证过的内核**：`0.1.1-rc.2`（原基线）与 `0.2.0-rc.1`（0.12.2 起——typecheck 用其类型定义零错误，并在隔离实例实机加载，三个失败信号全为 0）。下限保持原值不变：它是作者实际验证过的最早版本，比它更早的内核没验证过，不声称支持。
+# dsh-memory
+本插件属于 **`@max-null/*` 插件系列**——这一系列共同构成 **[SSID（思灵 · Seek Soul in Darkness）](https://github.com/Max-Null/seek-soul-in-darkness)** 桌面体验。SSID 是整合它们的盒：`dsh-capture` · `dsh-chat-rail` · `dsh-chinese-thinking` · `dsh-draft-polish` · `dsh-guardian` · `dsh-habit` · `dsh-memory` · `dsh-node-appearance` · `dsh-plugin-center` · `dsh-quick-toolbar` · `dsh-skill-mcp-center` · `dsh-ssid-panels` · `dsh-ssid-zh-ui` · `dsh-achievements`。
+This plugin belongs to the **`@max-null/*` family** — a set of plugins that together form the **[SSID (思灵 · Seek Soul in Darkness)](https://github.com/Max-Null/seek-soul-in-darkness)** desktop experience.
+一个面向 [DeepSeek Harness](https://github.com/deepseek-ai/deepseek-harness) 的**跨会话明文记忆插件**。遵循「一切皆插件」——它不修改 DSH 源码，声明 `name`/`inject`/`apply`，由 Loader 从 `cordis.yml` 加载。
+## 设计原则
+1. **写入即生效，人是例外干预者**：模型写入的记忆直接生效（`approved`），不再逐条等人放行；人保留随时查看、改写、删除、钉住或回滚的能力——人不在场不等于失控。
+2. **可观测先于精准**：每条记忆是明文，`memory_list` 随时可见、`memory_forget` 随时删除——不存在"静默暗礁"。
+3. **明文是人机共享的审计窗口**：记忆是可读文本，模型可自检其是否过期（有效性锚点会在所绑环境值变化后标记 `stale`），人可随时查看与改写。
+4. **确定性且缓存安全**：BM25 关键词检索是存储的纯函数、无 LLM 调用；固定指引进 system-prompt section，`approved + injected` 记忆进 recall context（global 全量 + 当前会话工作区），逐条为单行摘要并按注入预算截断（超预算按最近更新优先取舍，省略数在面板可见）。
+## 截图
+装完后在设置里多出「记忆」一项，可查看与管理跨会话记忆：
+**入口：** 设置 → 记忆
+| 设置入口与面板 |
+|---|
+| ![设置 → 记忆](docs/shots/memory-settings-1.png) |
+## 用法
+```bash
+npm install @max-null/dsh-memory
+```
+在你的 `cordis.yml` 加一条（其余 storage / system-prompt / tools 由宿主已有；记忆的存储后端由插件自己注册）：
+```yaml
+- id: memory
+  name: '@max-null/dsh-memory'
+```
+## 提供的服务与工具
+- **服务** `ctx.memory`：`remember` / `list` / `search` / `forget` / `update` / `move` / `setStatus` / `setInjected` / `supersede` / `retract` / `sweep` / `demoteStale` / `verifyAnchors` / `reload` 等
+- **工具**（12 个）：`memory_save`、`memory_list`、`memory_search`、`memory_update`、`memory_confirm`、`memory_forget`、`memory_move`、`memory_sweep`，加提示词模板四件套 `prompt_search`、`prompt_get`、`prompt_list`、`prompt_add`
+- **注入**：`tool:memory` 指引 section（工具用法 + 常驻注入判据）+ `memory:self` 机制自述 + `memory:recall` 召回 context（global 的 `approved + injected` + 当前会话工作区的 `approved + injected`，带 `[memory:<id>:<namespace>]` 来源标记；摘要化 + 预算截断）
+- **检索**：BM25（CJK 单字 + 2-gram，content 与 keywords 字段分离加权；中文多字查询精度显著优于单字切分）；可选语义融合（见「可选配置」）
+## 两层存储（global / project）
+记忆按 `namespace` 分两层物理存储，各落在独立的明文 JSON：
+| namespace | 默认位置 | 用途 |
+|---|---|---|
+| `global` | `$DSH_HOME/storages/memory.json` | 跨项目的个人偏好 |
+| `project` | `<cwd>/.dsh/storages/memory_project_<hash>.json` | 跟随仓库的项目共识，可 git 分享 |
+两个根都可用 config 覆盖（`globalRoot` / `projectRoot`）。`memory_list` / `memory_search` 不带 `namespace` 过滤时会同时查两层。旧版双重前缀文件名（`memory_project_memory_project_<hash>.json`）在打开时自动迁移为规范名。
+## 跨工作区可见性（0.10.0 / 0.11.0）
+project 记忆按**会话工作区**分文件存放，所以「工作区」就是可见性的边界。0.10.0 起补了三个方向——针对的是同一个盲区：**不知道存在**（检索是有意图的动作，搜不出自己不知道存在的东西）。
+| 方向 | 机制 | 效果 |
+|---|---|---|
+| 向上 | **祖先链** | 在子目录里开会话能检索到父目录的记忆（反向不行，链是单向向上的），结果带 `..` / `../..` 来源标记 |
+| 向下 | **子项目索引行** | 注入里多一行「本工作区下另有 N 个子项目带记忆：xxx（M 条）——用 memory_search 检索」 |
+| 全局 | **记忆索引行** | 注入里多一行「索引：当前可见 N 条记忆，主题集中在 X(14)、Y(12)…——用 memory_search 检索」 |
+三条边界：**写入永远只落当前工作区**（「我在这个项目里记的东西」不该被推理到别处）；但**检索得到的记录就改得动**——`memory_update` / `memory_forget` 同样沿链定位；**注入路径只读当前工作区**（远处的记忆进检索、不进每轮成本）。
+**0.11.0 起，「放错了层」有了显式的修正通道**：`memory_move(id, to)` 把一条记忆移到 `global`、`self`（当前工作区）或相对祖先（`..` / `../..`）。它是**例外动作**——默认写入仍然只落当前工作区，只有当你判定「这条其实属于上一层、或上一层的那一支」时才动它。移动**保持 id**、**从源层删除**（不是复制），并报告移动后源层是否仍看得见它：向上移动源层不失明（继承只向上，`global` 人人可见），向下移动则会让源层及其下层从此看不见它。典型用途是**把放高了的记忆降回它真正属于的工作区**——比如只属于某一个生态的规矩躺在 `global` 里、漏进了无关项目。判据与边界见设计文档 §3.2。
+后两行**不占注入预算**、自消除（没有内容时整行不出现），且**长度常数级**——不随记忆增长。索引行里的主题取自各条的关键词词频，与检索用的是同一套词汇，所以**索引里出现的词就是能搜到的词**。
+**孤儿文件清点**：`node scripts/scan-orphans.mjs [根目录]` 报出「哪些记忆文件当前代码已经打不开」（历史命名遗留：早期无哈希后缀、双重 `memory_project_` 前缀）。**只读，不做任何处置**——旧文件可能含未过隔离检查的内容，处置需人工拍板。
+**祖先链诊断与探针**：`node scripts/ancestor-probe.mjs plan [--cwd <会话 cwd>]` 只读地复算该 cwd 的祖先链（哪些层级带记忆文件、引擎会纳入几级），并回答「这个 cwd 上祖先链是否**可观测**」——若以上祖先层都没有记忆文件，祖先链生效与否行为逐字相同，那是个零差异的观测点。要实测检索侧跨链，用 `seed` / `check` / `clean` 在祖先层造一条临时探针再撤销。**前提**：探针只对**没打开过该层**的会话有效——引擎的表打开即缓存，而写路径的新鲜度门（`refreshForWrite`）只比对 global 与当前 cwd，**不含祖先层**，被缓存过的层会用陈旧内存态覆盖掉外部写入。
+## 多实例共存（0.7.1）
+两个 DSH 实例（例如 DSH web 与 SSiD 桌面壳）可以同时运行、共用同一个 `DSH_HOME`，**记忆不再互相抹掉**。
+DSH 存储层的写入是「读—改—写全量覆盖」，且官方两个后端都声明不做跨进程协调（`storage-json`：*writer per process and last-write-wins is correct*；`storage-sqlite`：*cross-process coordination is out of scope*）。插件层的处置是**写前重读**（等价于 update 前先 select）：每次写入在串行区里先比对存储文件指纹（mtime + size），发现磁盘被别的实例动过就先重载再写。代价是磁盘没变时的一次 `statSync`。
+残余窗口只剩两个实例在**同一瞬间**写——此时后写者赢；同时写**不同**记忆已不再互相影响。
+**未覆盖**：`workspace.json`（工作区登记）由 DSH 自己的 workspace 服务写，插件层够不着，仍会被双实例互相覆盖；根因处置在上游——[discussion #6882](https://github.com/deepseek-ai/deepseek-harness/discussions/6882)。当前防线是轮转快照备份（SSiD 侧 `shell/scripts/backup-storages.mjs` + 计划任务）。
+## 定时备份（2026-10-18）
+**动机**：2026-10-18 的事故——`.dsh` 下的 storages 被外部整目录删除后，本插件的写入路径（读—改—写全量覆盖）在空磁盘上把内存里的 global 记忆覆盖成一条；而当时 `memory.json` **没有任何一份存在于 `.dsh` 之外**，无从恢复。
+**机制**：插件启动后每小时（可配）把记忆文件**只读复制**到 `<home>/.dsh-backups/memory/<YYYYMMDD-HHmmss>/`，并写一份 `manifest.json` 记录来源与文件清单。**插件关闭（dispose）时再补一次**——定时器只在运行期间生效，关 DSH 前最后一段变更靠这一次兜住。保留最近 14 份（可配），超期自动清理。
+**无界面**：这是行为类功能，不新增按钮、面板或设置项——行为效果即上面那段：部署后 `~/.dsh-backups/memory/` 下每小时多一个目录，目录里是当次复制出的 `memory.json`、`memory_project_*.json` 与 `manifest.json`。
+| 项 | 默认值 |
+|---|---|
+| 备份内容 | `memory.json`（global）+ `memory_project_*.json`（project） |
+| 目标目录 | `~/.dsh-backups/memory/<时间戳>/`（**在 `DSH_HOME` 之外**） |
+| 间隔 | 60 分钟（首次延迟 1 分钟）；**插件关闭时另补一次** |
+| 保留 | 最近 14 份 |
+| 失败行为 | 只写日志，不影响记忆读写与启动 |
+**边界**：
+- 只备份**当前工作区**的 project 文件（`<cwd>/.dsh/storages/`）；其它工作区的 project 记忆不在备份范围。
+- 只读文件、只复制——**绝不复用引擎的写入路径**。写路径会先 `reload()` 再合并，磁盘缺失时它会把内存覆盖掉，正是这次事故的成因；备份不能走同一条路。
+## 使用流程（写入即生效，人为例外干预）
+提示词模板库（0.6.0）：`prompt_search / prompt_get / prompt_list / prompt_add` 四个工具管理**模板库**——
+md 文件是唯一事实源（`~/.dsh/prompt-library/*.md` 为 global；`<workspace>/.dsh/prompt-library/` 随工作区分享），
+前端（记忆面板「模板」tab / 模型工具）检索同一份索引；模板存在即生效（`source: agent` 角标标识模型新增），
+**永不注入 system prompt**。
+```
+模型 memory_save     →  status: approved，立即生效；命中密钥/凭据规则则隔离（不进检索也不进注入）
+                        给 injected 则同时钉住常驻（0.8.0），不受自动规则影响
+memory_search        →  关键词/语义召回（只搜记忆；模板走 prompt_search 通道，不会混进候选池）
+人（面板 / 开关）     →  钉住 / 删除 / 放行隔离记录 / 回滚
+memory_forget        →  随时删除（删除始终是人的动作）
+```
+**常驻开关只由人（或模型显式传 `injected`）决定。** 两条自动规则都已在 0.12.0 / 0.13.0 停用：命中次数不再自动升常驻（它只喂体检报告的候选提示），30 天未命中的自动撤下也改为**只计量不生效**——撤下来就基本不会自己回去，那种动作不该由一个没有分布依据的阈值决定（阈值来历见 `docs/设计/2026-09-29-借阅-dsh-mneme-后的自查.md` §二）。两者都不删除任何内容——记忆不会无限累积，也不会被系统自行清空。
+**低频但关键**的记忆（长期约定 / 判据 / 委托）本来就够不着旧阈值，而自动规则停用之后，问题从「够不着」变成了「必须显式说」。这类走显式路径——在 `memory_save` / `memory_update` 里给 `injected` 即钉住，写的是与面板开关同一套语义（`injectedAuto: false`）。未审核与已隔离的记录不接受注入。
+注入有**字符预算**（默认 1500，config `injectionBudget`）：装不下的条目**整条丢弃**（不截内容），按「最近更新优先」取舍——所以 `injected: true` 不等于「每轮真的在场」，它只保证有资格排队。0.9.0 起这种出局不再无声：注入末尾会追加一行 `（另有 N 条常驻因预算未注入：…）`，0.9.1 起列出的是**每条的短摘要**而不是 id——查 id 是什么的那一步最容易省略，省略了就等于没报；**清理干净即自行消失**。面板的注入预览里也能展开看明细。诊断行本身不占预算。
+记忆还可声明**有效性锚点**（环境变量 / 工具清单 / 插件版本）：所绑的值变化后，这条记忆被标记 `stale` 并撤下常驻，检索结果里也带出失效提示——环境变了，旧结论就不再被当成仍然正确。
+模型写入不需要人点头，但**人始终能看见并推翻**：面板按「隔离区 / 常驻 / 冷数据」分组，被隔离的记录必须由人放行才会重新进入检索。
+## 为什么明文 + BM25，而不是向量检索
+向量检索的记忆本体是一串不可读的数字，过期信息会成为**无法观测、无法修复的静默暗礁**；BM25 + 明文让每一次召回都可解释、每一条记忆都可见可删。语义（向量）检索作为**可插拔的可选项**（0.5.2，见「可选配置」）——记忆本体仍是明文，向量仅作为检索辅助字段（`vector`，明文可读），且以"可观测 + 可修复"为门槛。
+明文还有一层**跟随仓库分享**的好处：`project` 命名空间的记忆落在项目文件夹内（`<cwd>/.dsh/storages/memory_project_<hash>.json`），随 `git` 提交、分享给所有协作者；`global` 命名空间的记忆留在本地 `$DSH_HOME`。团队的共识（"本项目统一用 Vue3 `<script setup>`"）能沉淀进仓库，而不是散落在每个人的本地。FTS5 的 SQLite 二进制无法这样"跟着仓库走"。
+## 可选配置
+在 `cordis.yml` 的 `config` 里传给插件（均可省略）：
+```yaml
+- id: memory
+  name: '@max-null/dsh-memory'
+  config:
+    injectionBudget: 1500        # 常驻注入预算（字符；null = 不限制）
+    summaryChars: 80             # 单条注入摘要截断上限（字符）
+    semanticTopK: 5              # 语义侧参与融合的 topK（仅配置 embeddings 时生效）
+    # 混合语义检索（可插拔；缺省 = 纯 BM25）
+    # embeddings: { embed: '...' 提供 embed(texts) 的宿主函数 或 插件名 ... }
+    # 定时备份（2026-10-18；缺省启用，目标在 DSH_HOME 之外）
+    backup:
+      intervalMinutes: 60    # 间隔（分钟）
+      keep: 14               # 保留份数
+      # targetRoot: 'D:/dsh-backups/memory'   # 自定义备份根
+      # enabled: false        # 关掉
+```
+`embeddings` 接受 `{ embed(texts): Promise<number[][]>, similarity? }` 对象——由宿主装配层提供嵌入实现（如 DeepSeek 嵌入端点）；配置后 `memory_search` 以 BM25 + 语义 RRF 融合，向量增量生成并持久化，嵌入调用失败自动降级为纯 BM25。
+## SSID 系列
+本插件是 **[SSID（思灵 · Seek Soul in Darkness）](https://github.com/Max-Null/seek-soul-in-darkness)** 全家桶的一员；也可以单独安装到任意 DSH profile——除设置页的记忆面板外不依赖其它同系列插件。
+## 开发
+```bash
+npm install
+npm run typecheck   # tsc 严格类型检查
+npm test            # vitest 单测
+npm run build       # 产出 dist/
+node scripts/verify-loader.mjs   # 用 Loader 端到端验证插件可加载
+node scripts/scan-orphans.mjs [根目录]       # 清点「当前代码打不开」的记忆文件（只读）
+node scripts/unzstd-frames.mjs <源> <目标>   # 解多帧 zstd（读 DSH 会话日志用）
+node scripts/ancestor-probe.mjs plan [--cwd <cwd>]   # 复算祖先链（只读）；seed/check/clean 验 ④-A
+node scripts/analyze-cooccurrence.mjs        # 关键词共现分析（记忆之间有没有关系网，只读）
+npm run check:memory        # 记忆文件存量体检（只读；0 = 全绿 / 1 = 有不合规 / 2 = 用法错）
+```
+## 依赖（peerDependencies，由宿主提供）
+`@deepseek-ai/cordis`（`^4.0.1`），以及 `@deepseek-ai/dsh-storage`、`@deepseek-ai/dsh-storage-domain`、`@deepseek-ai/dsh-storage-json`、`@deepseek-ai/dsh-system-prompt`、`@deepseek-ai/dsh-tools`、`@deepseek-ai/dsh-typert-protocol`——后面六个声明为 **`>=0.1.1-rc.1 <0.3.0`**。
+**为什么写显式范围而不是 caret**：caret 的上界是「下一个 minor」——`^0.1.1-rc.1` 展开为 `>=0.1.1-rc.1 <0.2.0-0`，内核一跨 minor 就判定不满足。而 peer 不满足时插件**不会被加载，也不会出现在 `did not activate` 列表里**：它在进入 fiber 图之前就被跳过，界面不报错，只表现为少一批功能。写成显式范围让 0.1 线与 0.2 线都能装载。
+**验证过的内核**：`0.1.1-rc.2`（原基线）与 `0.2.0-rc.1`（0.12.2 起——typecheck 用其类型定义零错误，并在隔离实例实机加载，三个失败信号全为 0）。下限保持原值不变：它是作者实际验证过的最早版本，比它更早的内核没验证过，不声称支持。

package/dist/backup.d.ts ADDED Viewed

@@ -0,0 +1,63 @@
+/**
+ * 记忆定时备份：把 `memory.json`（global）与 `memory_project_*.json`（project）复制到
+ * `DSH_HOME` 之外。
+ *
+ * 存在的理由（2026-10-18 事故）：`.dsh` 下的 storages 被外部整目录删除后，dsh-memory 的
+ * 写入路径是「reload → 合并 → 写」——空磁盘让 reload 得到空库，写入把内存里的 global
+ * 记忆覆盖成一条；而当时 `memory.json` 没有任何一份存在于 `.dsh` 之外，无从恢复。
+ *
+ * 铁律：这里**只读文件、只复制**，绝不复用引擎的写入路径、不碰内存状态。备份失败只记
+ * 日志，绝不影响记忆本身的读写与启动。
+ *
+ * @module dsh-memory/backup
+ */
+/** 定时备份的配置（`MemoryConfig.backup`）。 */
+export interface MemoryBackupConfig {
+    /** 是否启用；缺省启用。 */
+    enabled?: boolean;
+    /** 备份间隔（分钟）；默认 60。 */
+    intervalMinutes?: number;
+    /** 保留最近多少份；默认 14。 */
+    keep?: number;
+    /** 备份根目录；默认 `~/.dsh-backups/memory`（必须在 `DSH_HOME` 之外）。 */
+    targetRoot?: string;
+}
+/** {@link runMemoryBackup} 的入参。 */
+export interface MemoryBackupOptions {
+    /** global 记忆的根（`$DSH_HOME/storages`）。 */
+    globalRoot: string;
+    /** project 记忆的根（`<cwd>/.dsh/storages`）。 */
+    projectRoot: string;
+    /** 备份根目录。 */
+    targetRoot: string;
+    /** 保留份数（≥1）。 */
+    keep: number;
+    /** 当前时间；测试可注入。 */
+    now?: Date;
+    /** 日志出口；缺省丢弃。 */
+    log?: (text: string) => void;
+}
+/** 一次备份的结果。 */
+export interface MemoryBackupRun {
+    /** 本次写入的目录；没有可备份文件时为 `null`。 */
+    readonly dir: string | null;
+    /** 实际复制的文件名。 */
+    readonly files: readonly string[];
+    /** 本次清理掉的旧目录名。 */
+    readonly pruned: readonly string[];
+    /** 失败原因；成功时缺省。 */
+    readonly error?: string;
+}
+/**
+ * 把两个根下的记忆文件复制进一份新目录。
+ *
+ * 目标目录按 `now` 命名；同名目录已存在时追加 `-1`、`-2`……每个文件独立复制，单个失败
+ * 只告警、不中断其余文件；`manifest.json` 记录本次来源与文件清单，便于事后核对。
+ * 没有可复制文件时返回 `dir: null`，不创建空目录。
+ *
+ * @param options - 两个来源根、目标根、保留份数与时间注入点。
+ * @returns 本次目录、复制清单、清理清单与失败原因。
+ */
+export declare function runMemoryBackup(options: MemoryBackupOptions): MemoryBackupRun;
+/** 备份目录是否像一个已存在的备份树（测试与自检用）。 */
+export declare function isBackupDirectory(path: string): boolean;

package/dist/backup.js ADDED Viewed

@@ -0,0 +1,128 @@
+/**
+ * 记忆定时备份：把 `memory.json`（global）与 `memory_project_*.json`（project）复制到
+ * `DSH_HOME` 之外。
+ *
+ * 存在的理由（2026-10-18 事故）：`.dsh` 下的 storages 被外部整目录删除后，dsh-memory 的
+ * 写入路径是「reload → 合并 → 写」——空磁盘让 reload 得到空库，写入把内存里的 global
+ * 记忆覆盖成一条；而当时 `memory.json` 没有任何一份存在于 `.dsh` 之外，无从恢复。
+ *
+ * 铁律：这里**只读文件、只复制**，绝不复用引擎的写入路径、不碰内存状态。备份失败只记
+ * 日志，绝不影响记忆本身的读写与启动。
+ *
+ * @module dsh-memory/backup
+ */
+import { copyFileSync, existsSync, mkdirSync, readdirSync, rmSync, statSync, writeFileSync } from 'node:fs';
+import { join } from 'node:path';
+/** 参与备份的名字：global 的 `memory.json` 与 project 的 `memory_project_*.json`。 */
+const BACKUP_FILE = /^(?:memory\.json|memory_project_[A-Za-z0-9_-]+\.json)$/u;
+/** 备份目录名：`YYYYMMDD-HHmmss`，可排序、可读。 */
+function stamp(now) {
+    const pad = (value) => String(value).padStart(2, '0');
+    return `${now.getFullYear()}${pad(now.getMonth() + 1)}${pad(now.getDate())}`
+        + `-${pad(now.getHours())}${pad(now.getMinutes())}${pad(now.getSeconds())}`;
+}
+/** 列出根目录下参与备份的文件名；根不存在或不可读时返回空数组。 */
+function candidateFiles(root, log) {
+    if (!existsSync(root))
+        return [];
+    try {
+        return readdirSync(root).filter((name) => BACKUP_FILE.test(name));
+    }
+    catch (error) {
+        log(`memory backup: 无法读取 ${root}: ${error instanceof Error ? error.message : String(error)}`);
+        return [];
+    }
+}
+/**
+ * 把两个根下的记忆文件复制进一份新目录。
+ *
+ * 目标目录按 `now` 命名；同名目录已存在时追加 `-1`、`-2`……每个文件独立复制，单个失败
+ * 只告警、不中断其余文件；`manifest.json` 记录本次来源与文件清单，便于事后核对。
+ * 没有可复制文件时返回 `dir: null`，不创建空目录。
+ *
+ * @param options - 两个来源根、目标根、保留份数与时间注入点。
+ * @returns 本次目录、复制清单、清理清单与失败原因。
+ */
+export function runMemoryBackup(options) {
+    const log = options.log ?? (() => { });
+    const now = options.now ?? new Date();
+    const globalFiles = candidateFiles(options.globalRoot, log).map(name => ({ name, from: join(options.globalRoot, name) }));
+    const projectFiles = candidateFiles(options.projectRoot, log).map(name => ({ name, from: join(options.projectRoot, name) }));
+    const sources = [...globalFiles, ...projectFiles];
+    if (sources.length === 0) {
+        log('memory backup: 没有可备份的记忆文件');
+        return { dir: null, files: [], pruned: [] };
+    }
+    let base = join(options.targetRoot, stamp(now));
+    let dir = base;
+    for (let suffix = 1; existsSync(dir); suffix += 1)
+        dir = `${base}-${String(suffix)}`;
+    try {
+        mkdirSync(dir, { recursive: true });
+    }
+    catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
+        log(`memory backup: 无法创建 ${dir}: ${message}`);
+        return { dir: null, files: [], pruned: [], error: message };
+    }
+    const files = [];
+    for (const source of sources) {
+        try {
+            copyFileSync(source.from, join(dir, source.name));
+            files.push(source.name);
+        }
+        catch (error) {
+            log(`memory backup: 复制 ${source.name} 失败: ${error instanceof Error ? error.message : String(error)}`);
+        }
+    }
+    try {
+        writeFileSync(join(dir, 'manifest.json'), `${JSON.stringify({
+            createdAt: now.toISOString(),
+            globalRoot: options.globalRoot,
+            projectRoot: options.projectRoot,
+            files,
+        }, null, 2)}\n`, 'utf8');
+    }
+    catch (error) {
+        log(`memory backup: 写 manifest 失败: ${error instanceof Error ? error.message : String(error)}`);
+    }
+    return { dir, files, pruned: pruneBackups(options.targetRoot, options.keep, log) };
+}
+/** 只保留最近 `keep` 份备份目录（按名字排序即时间序），多余的删除。 */
+function pruneBackups(targetRoot, keep, log) {
+    if (!existsSync(targetRoot))
+        return [];
+    let entries;
+    try {
+        entries = readdirSync(targetRoot).filter((name) => /^\d{8}-\d{6}(?:-\d+)?$/u.test(name));
+    }
+    catch (error) {
+        log(`memory backup: 无法读取 ${targetRoot}: ${error instanceof Error ? error.message : String(error)}`);
+        return [];
+    }
+    entries.sort();
+    const pruned = [];
+    const excess = entries.length - Math.max(1, keep);
+    for (let index = 0; index < excess; index += 1) {
+        const name = entries[index];
+        if (name === undefined)
+            break;
+        try {
+            rmSync(join(targetRoot, name), { recursive: true, force: true });
+            pruned.push(name);
+        }
+        catch (error) {
+            log(`memory backup: 清理 ${name} 失败: ${error instanceof Error ? error.message : String(error)}`);
+        }
+    }
+    return pruned;
+}
+/** 备份目录是否像一个已存在的备份树（测试与自检用）。 */
+export function isBackupDirectory(path) {
+    try {
+        return statSync(path).isDirectory();
+    }
+    catch {
+        return false;
+    }
+}

package/dist/engine.d.ts CHANGED Viewed

@@ -6,6 +6,7 @@
  */
 import { Service } from '@deepseek-ai/cordis';
 import { type PromptFile } from './prompt-files.ts';
+import type { MemoryBackupConfig } from './backup.ts';
 import type { AnchorProbes, MemoryAnchor } from './anchors.ts';
 import type { MemorySource, SourceStat } from './query-log.ts';
 export type { MemorySource, QueryLogEntry, SourceStat } from './query-log.ts';
@@ -312,6 +313,12 @@ export interface MemoryConfig {
     /** 全局提示词模板根目录（0.6.0）；默认 `$DSH_HOME/prompt-library`。
      *  project 模板随工作区（`<workspace>/.dsh/prompt-library`，与记忆同构）。 */
     promptGlobalRoot?: string;
+    /**
+     * 定时备份（2026-10-18 事故后新增）：把 `memory.json` 与 `memory_project_*.json`
+     * 复制到 `DSH_HOME` 之外的目录，默认每小时一份、保留 14 份。
+     * 实现只读文件、只复制，见 `backup.ts` 的文件头。
+     */
+    backup?: MemoryBackupConfig;
     /**
      * 查询日志文件路径（2026-09-15 §六.6）；默认为全局存储根下的 `query-log.json`
      * ——即与 `memory.json` **同目录**（`$DSH_HOME/storages/query-log.json`），不落子目录。

package/dist/index.d.ts CHANGED Viewed

@@ -12,4 +12,15 @@ export { MemoryId } from './engine.ts';
 export { bm25FieldScores, bm25Scores, cosineSimilarity, rrfFuse, tokenize } from './bm25.ts';
 export declare const name = "dsh-memory";
 export declare const inject: string[];
+/**
+ * 本次挂载实际注册的工具名，按注册顺序。
+ *
+ * 存在的理由：**自述（`memory:self`）与 README 都要列工具清单，而清单会漏**——0.11.0 加了
+ * `memory_move` 之后，自述的数字与清单一直停在 11，直到 0.14.0 收尾核对才被翻出来（README
+ * 那边更早，只列了 7 个）。`ToolRegistry` 只提供 `register` / `get`，**没有列举 API**，所以
+ * 清单没法从注册表反查；改成注册时登记，清单就有了唯一来源。
+ *
+ * @see test/memory.spec.ts 的自述覆盖用例——它遍历这个数组，不手抄名字。
+ */
+export declare const registeredToolNames: string[];
 export declare function apply(ctx: Context, config?: MemoryConfig): Promise<void>;

package/dist/index.js CHANGED Viewed

@@ -4,9 +4,12 @@
  * domain, system prompt, and tools plugins; it registers `ctx.memory`, four
  * model tools, a stable guidance section, and a recall context.
  */
+import { homedir } from 'node:os';
+import { join } from 'node:path';
 import { defineTool } from '@deepseek-ai/dsh-tools';
 import { MemoryEngine } from "./engine.js";
 import { MemoryGateway } from "./remote.js";
+import { runMemoryBackup } from "./backup.js";
 import { ANCHOR_KINDS } from "./anchors.js";
 import { mountMemoryApi } from "./routes.js";
 import { SELF_DESCRIPTION } from "./self.js";
@@ -15,7 +18,23 @@ export { MemoryEngine } from "./engine.js";
 export { MemoryId } from "./engine.js";
 export { bm25FieldScores, bm25Scores, cosineSimilarity, rrfFuse, tokenize } from "./bm25.js";
 export const name = 'dsh-memory';
-export const inject = ['storage', 'systemPrompt', 'tools', 'webServer', 'webRuntime'];
+export const inject = ['storage', 'systemPrompt', 'tools', 'webServer', 'webStartup'];
+/**
+ * 本次挂载实际注册的工具名，按注册顺序。
+ *
+ * 存在的理由：**自述（`memory:self`）与 README 都要列工具清单，而清单会漏**——0.11.0 加了
+ * `memory_move` 之后，自述的数字与清单一直停在 11，直到 0.14.0 收尾核对才被翻出来（README
+ * 那边更早，只列了 7 个）。`ToolRegistry` 只提供 `register` / `get`，**没有列举 API**，所以
+ * 清单没法从注册表反查；改成注册时登记，清单就有了唯一来源。
+ *
+ * @see test/memory.spec.ts 的自述覆盖用例——它遍历这个数组，不手抄名字。
+ */
+export const registeredToolNames = [];
+/** 登记一个工具名并原样返回——包在 `defineTool` 的 `name` 字段外面。 */
+function registered(toolName) {
+    registeredToolNames.push(toolName);
+    return toolName;
+}
 /**
  * 解析时间过滤参数（0.12.0）：`7d` / `30d` 这类相对天数，或 `YYYY-MM-DD` 绝对日期。
  *
@@ -321,6 +340,9 @@ function present(title, kind, rawInput) {
     return { card: 'generic', title, kind, ...rawInput === undefined ? {} : { rawInput } };
 }
 export async function apply(ctx, config) {
+    // 每次挂载都是一次全新的注册——清空上一轮的登记。它是模块级数组（测试要能 import 它），
+    // 不清的话同一进程里挂载两次会累积成双份，而消费方（自述覆盖用例）拿到的数量就对不上了。
+    registeredToolNames.length = 0;
     await ctx.plugin(MemoryEngine, config);
     await ctx.plugin(MemoryGateway);
     // 0.3.6：自带面板数据通道（HTTP，独立包无需 Typert 构建产物）
@@ -388,7 +410,7 @@ export async function apply(ctx, config) {
             void memory.ensureProjectOpen(cwd).catch(() => { });
     });
     ctx.tools.register(defineTool({
-        name: 'memory_save',
+        name: registered('memory_save'),
         description: 'Save one cross-session memory. It takes effect immediately; credential-like content is quarantined instead. Record durable preferences, corrections and reusable conclusions — not transient state, guesses, or facts readable from the repo (record where to look instead). 保存一条跨会话记忆：写入即生效；命中密钥/凭据规则的写入会被隔离。只记长期偏好、纠正与可复用结论——不记临时状态、推测、或能从仓库读到的事实（那类记「去哪查」）。',
         parameters: {
             content: { type: 'string', required: true, description: 'Plaintext memory content.' },
@@ -425,7 +447,7 @@ export async function apply(ctx, config) {
         presentCall: args => present('Save memory', 'other', args.content),
     }));
     ctx.tools.register(defineTool({
-        name: 'memory_list',
+        name: registered('memory_list'),
         description: 'List every stored memory, optionally filtered by namespace, status, injected switch, or update time. Every memory is plaintext and inspectable. 列出全部记忆，可按 namespace/status/injected/更新时间过滤；均为明文可查。',
         parameters: {
             namespace: { type: 'string', enum: ['global', 'project'], description: 'Restrict to one namespace. 限定单个命名空间.' },
@@ -453,7 +475,7 @@ export async function apply(ctx, config) {
         presentCall: () => present('List memories', 'read'),
     }));
     ctx.tools.register(defineTool({
-        name: 'memory_search',
+        name: registered('memory_search'),
         description: 'Recall stored memories by keyword. Deterministic literal matching — a miss means no stored term matched the query. 按关键词检索记忆（中文 2-gram + 关键词加权；配置嵌入时含语义融合；含待审核条目，被隔离的除外）。',
         parameters: {
             query: { type: 'string', required: true, description: 'Keyword query. 关键词查询.' },
@@ -475,7 +497,7 @@ export async function apply(ctx, config) {
         presentCall: args => present('Search memory', 'read', args.query),
     }));
     ctx.tools.register(defineTool({
-        name: 'prompt_search',
+        name: registered('prompt_search'),
         description: 'Search prompt templates by keyword plus dimension/difficulty/tag filters. Returns matching summaries; call prompt_get for the full text. 按关键词+维度/难度/标签检索提示词模板，返回匹配摘要；取全文用 prompt_get。',
         parameters: {
             query: { type: 'string', required: true, description: 'Keyword query (name/tag/body). 关键词查询（名称/标签/正文）.' },
@@ -517,7 +539,7 @@ export async function apply(ctx, config) {
         presentCall: args => present('Search prompt library', 'read', args.query),
     }));
     ctx.tools.register(defineTool({
-        name: 'prompt_get',
+        name: registered('prompt_get'),
         description: 'Fetch a prompt template full text by id or name (name matches the file stem without the seq prefix). 按 id 或名称取模板全文（名称 = 文件名去序号部分）。',
         parameters: {
             nameOrId: { type: 'string', required: true, description: 'Template id or name. 模板 id 或名称.' },
@@ -546,7 +568,7 @@ export async function apply(ctx, config) {
         presentCall: args => present('Get prompt template', 'read', args.nameOrId),
     }));
     ctx.tools.register(defineTool({
-        name: 'prompt_list',
+        name: registered('prompt_list'),
         description: 'List every prompt template index (no full text), optionally filtered by dimension/difficulty/tag. 列出全部模板索引（不含全文），可按维度/难度/标签过滤。',
         parameters: {
             dimension: { type: 'string', description: '按维度过滤.' },
@@ -575,7 +597,7 @@ export async function apply(ctx, config) {
         presentCall: () => present('List prompt templates', 'read'),
     }));
     ctx.tools.register(defineTool({
-        name: 'prompt_add',
+        name: registered('prompt_add'),
         description: 'Add one prompt template to the library (writes a metadata-marked md file; source=agent is surfaced in the UI). 新增一条提示词模板（写元数据 md 文件；source=agent 在 UI 角标提示）。',
         parameters: {
             name: { type: 'string', required: true, description: 'Template name (also the file stem). 模板名称（也是文件名）.' },
@@ -605,7 +627,7 @@ export async function apply(ctx, config) {
         presentCall: args => present('Add prompt template', 'other', args.name),
     }));
     ctx.tools.register(defineTool({
-        name: 'memory_forget',
+        name: registered('memory_forget'),
         description: 'Delete one stored memory by id. The human owner may remove any memory.',
         parameters: {
             id: { type: 'string', required: true, description: 'Exact memory id from memory_list or memory_search.' },
@@ -620,7 +642,7 @@ export async function apply(ctx, config) {
         presentCall: args => present('Forget memory', 'other', args.id),
     }));
     ctx.tools.register(defineTool({
-        name: 'memory_move',
+        name: registered('memory_move'),
         description: 'Move one memory to another layer: `global`, `self` (the current workspace), or a relative ancestor (`..` / `../..`). Use it when a memory sits at the wrong level — a project-specific rule parked in `global` that leaks into unrelated workspaces, or a fact that turned out to hold for sibling projects too. The record keeps its id, and the result reports whether the source layer still sees it. 把一条记忆移到另一层：`global`、`self`（当前工作区）或相对祖先（`..` / `../..`）。用于记忆待错了层——只属于某个项目的规矩躺在 `global` 里、漏进无关工作区，或某条事实其实对兄弟项目也成立。id 保持不变，结果里会报告移动后源层是否仍看得见它。',
         parameters: {
             id: { type: 'string', required: true, description: 'Exact memory id from memory_list or memory_search. 要移动的记忆 id。' },
@@ -645,7 +667,7 @@ export async function apply(ctx, config) {
         presentCall: args => present('Move memory', 'other', `${args.id} → ${args.to}`),
     }));
     ctx.tools.register(defineTool({
-        name: 'memory_update',
+        name: registered('memory_update'),
         description: 'Update the content, keywords, persistent-injection switch or validity anchor of one stored memory (e.g. correcting stale facts, or re-anchoring a memory whose anchor no longer holds). The record keeps its review status; content that looks like a credential quarantines it instead. 修改一条记忆的内容、关键词、常驻注入开关或有效性锚点（如修正过时信息、把失效的锚点改对）。改动后记忆保持原有审核状态；若新内容命中危险规则则转为隔离。',
         parameters: {
             id: { type: 'string', required: true, description: 'Exact memory id from memory_list. 记忆 id（来自 memory_list）.' },
@@ -696,7 +718,7 @@ export async function apply(ctx, config) {
         presentCall: args => present('Update memory', 'other', args.id),
     }));
     ctx.tools.register(defineTool({
-        name: 'memory_confirm',
+        name: registered('memory_confirm'),
         description: 'Release a quarantined memory: marks it human-reviewed (`approved`) and clears its quarantine. Under the silent mechanism ordinary writes already take effect by themselves, so call this only when the human explicitly asks to release a quarantined memory. 放行一条被隔离的记忆：标记为已审核并解除隔离。静默机制下普通写入已自行生效，因此仅在用户明确要求放行隔离记忆时调用。',
         parameters: {
             id: { type: 'string', required: true, description: 'Exact memory id from memory_list. 记忆 id（来自 memory_list）.' },
@@ -711,7 +733,7 @@ export async function apply(ctx, config) {
         presentCall: args => present('Confirm memory', 'other', args.id),
     }));
     ctx.tools.register(defineTool({
-        name: 'memory_sweep',
+        name: registered('memory_sweep'),
         description: 'Read-only health check: lists stale memories (with the reason), long-unused non-resident ones, candidates that keep being retrieved without being pinned, and how much of the injection budget the resident set takes. Changes nothing. 只读体检：列出失效的记忆（带原因）、久未被检索命中的非常驻记录、被反复检索却未常驻的候选，以及常驻占用了多少注入预算。不修改任何状态——最坏情况是报告不准，而不是误改内容。',
         parameters: {},
         output: {
@@ -723,4 +745,31 @@ export async function apply(ctx, config) {
         },
         presentCall: () => present('Sweep memory', 'other', 'read-only'),
     }));
+    // 定时备份（2026-10-18 事故后新增）：只读复制，绝不走引擎的写入路径。
+    // 首次延迟 1 分钟避开启动高峰；此后按 `backup.intervalMinutes` 重复；`unref` 不挡进程退出。
+    const backup = config?.backup;
+    if (backup?.enabled !== false) {
+        const targetRoot = backup?.targetRoot ?? join(homedir(), '.dsh-backups', 'memory');
+        const intervalMs = Math.max(1, backup?.intervalMinutes ?? 60) * 60_000;
+        const keep = Math.max(1, backup?.keep ?? 14);
+        const roots = {
+            globalRoot: config?.globalRoot ?? join(process.env.DSH_HOME ?? join(homedir(), '.dsh'), 'storages'),
+            projectRoot: config?.projectRoot ?? join(process.cwd(), '.dsh', 'storages'),
+        };
+        ctx.effect(() => {
+            const first = setTimeout(() => {
+                runMemoryBackup({ ...roots, targetRoot, keep });
+            }, 60_000);
+            const timer = setInterval(() => {
+                runMemoryBackup({ ...roots, targetRoot, keep });
+            }, intervalMs);
+            timer.unref();
+            return () => {
+                clearTimeout(first);
+                clearInterval(timer);
+                // 关闭时补一次：定时器只在运行期间生效，关 DSH 前最后一段变更靠这里兜住。
+                runMemoryBackup({ ...roots, targetRoot, keep });
+            };
+        });
+    }
 }

package/dist/routes.js CHANGED Viewed

@@ -121,9 +121,9 @@ function promptProjection(record) {
 }
 /** 挂载 /memory/api 路由（apply 调用）。 */
 export function mountMemoryApi(ctx) {
-    // webServer/webRuntime 由 index.ts 的 inject 声明（Context 类型未扩展，断言访问）
+    // webServer/webStartup 由 index.ts 的 inject 声明（Context 类型未扩展，断言访问）
     const webServer = ctx.webServer;
-    const webRuntime = ctx.webRuntime;
+    const webStartup = ctx.webStartup;
     const api = {
         'list': (payload) => {
             const memory = ctx.get('memory');
@@ -265,7 +265,7 @@ export function mountMemoryApi(ctx) {
             return memory.refreshPromptIndex(cwdOf((payload ?? {})));
         },
     };
-    const fence = (req) => isTrusted(req, webRuntime.trustedHosts);
+    const fence = (req) => isTrusted(req, webStartup.trustedHosts);
     ctx.effect(() => webServer.register({
         kind: 'prefix',
         path: '/memory/api',

package/dist/self.js CHANGED Viewed

@@ -23,7 +23,7 @@ export const SELF_VERSION = (() => {
     }
 })();
 export const SELF_DESCRIPTION = `[记忆系统自述] 本环境内置跨会话记忆服务（dsh-memory v${SELF_VERSION}）。`
-    + '你有 11 个工具：**记忆工具** memory_save / memory_search / memory_list / memory_update / memory_confirm / memory_forget / memory_sweep（`memory_confirm` 仅在用户明确要求放行隔离记录时用；`memory_sweep` 是只读体检——失效清单、久未命中、候选与预算占用，不修改任何状态）；**提示词模板工具** prompt_search / prompt_get / prompt_list / prompt_add（模板是 md 文件、**永不注入**，走这条通道，不会混进记忆检索）。'
+    + '你有 12 个工具：**记忆工具** memory_save / memory_search / memory_list / memory_update / memory_confirm / memory_forget / memory_move / memory_sweep（`memory_confirm` 仅在用户明确要求放行隔离记录时用；`memory_move` 把放错了层的记忆移到 global、当前工作区或相对祖先；`memory_sweep` 是只读体检——失效清单、久未命中、候选与预算占用，不修改任何状态）；**提示词模板工具** prompt_search / prompt_get / prompt_list / prompt_add（模板是 md 文件、**永不注入**，走这条通道，不会混进记忆检索）。'
     + '记忆分两层：`global` 跨项目（偏好 / 习惯 / 环境知识），`project` 跟随工作区（落在 `<cwd>/.dsh/storages/`，随 git 提交分享）。'
     + '**何时写入**（不必刻意找机会，遇到下面这些就动手）：'
     + '① 用户表达长期偏好或约定（「以后都…」「记住…」「我们的规矩是…」）；'
@@ -34,7 +34,7 @@ export const SELF_DESCRIPTION = `[记忆系统自述] 本环境内置跨会话
     + '**锚点（可选）**：若这条记忆描述的是「随某个环境值变化的事实」（某工具版本下的行为、某环境变量决定的配置），用 anchor 参数把它绑到那个值上——值变了它会自动失效并标 stale，不会再被当成仍然正确；绑错了用 memory_update 改（当场重新判定，成立即复活），不要了就传 `anchor: null` 清除。当前锚点随记录一起返回。'
     + '写入即生效（`approved`），人工只在例外时介入；命中密钥/凭据规则的写入会被隔离（不进注入与检索）。'
     + '**常驻注入**：每轮注入「global + 当前会话工作区」里 approved 且开着常驻开关的记忆单行摘要（形如 `- [memory:id:namespace] 摘要`）；全文要靠 memory_search 取。'
-    + '开关只有一条自动规则：**自动升上来的**常驻在 30 天未命中后撤下；命中次数不再自动改变注入状态（它只喂体检报告的候选提示）。**给 memory_save / memory_update 传 `injected` 即显式接管**，此后这条规则也不再适用。'
+    + '常驻开关由人（或模型显式传 `injected`）决定：**自动改变注入状态的规则已全部停用**——命中次数不再自动升常驻（它只喂体检报告的候选提示），30 天未命中的自动撤下也已改为**只计量不生效**（撤下来就基本不会自己回去，那种动作不该由一个没有分布依据的阈值决定）。**给 memory_save / memory_update 传 `injected` 即显式接管**。'
     + '**钉的判据是「失效可察觉性」**：这条记忆若没被想起来，你会不会根本意识不到自己漏了它？会 → 钉常驻（规则 / 委托 / 判据）；不会 → 留检索（事实 / 参考 / 案例）。'
     + '**注入有预算**（默认 1500 字符，约装 11 条），装不下的整条丢弃、按**最近更新**优先取舍（不是最近被检索——检索是「需要时才用」的行为，拿它决定「谁每轮在场」会让查得多的挤掉钉得牢的）——所以「钉了常驻」只等于「有资格排队」。'
     + '装不下时注入末尾会出现一行 `（另有 N 条常驻因预算未注入：…短摘要…）`——**那是「有常驻记忆并不在场」的唯一信号**，看到它就该逐条评估撤下。'

package/package.json CHANGED Viewed

@@ -1,6 +1,6 @@
 {
   "name": "@max-null/dsh-memory",
-  "version": "0.15.0",
+  "version": "0.16.0",
   "description": "Cross-session plaintext memory plugin for the DeepSeek Harness — deterministic BM25 recall, writes take effect immediately, signal-driven injection, no embeddings",
   "license": "MIT",
   "publishConfig": {
@@ -86,6 +86,7 @@
     "@deepseek-ai/dsh-tools": "0.2.0-rc.1",
     "@deepseek-ai/dsh-typert-protocol": "0.2.0-rc.1",
     "@types/node": "^26.2.0",
+    "esbuild": "^0.25.0",
     "tsx": "^4.0.0",
     "typescript": "^5.5.0",
     "vitest": "^2.1.0"

package/dist/client/index.d.ts DELETED Viewed

	@@ -1,2 +0,0 @@
1	- export declare const inject: string[];
2	- export declare function apply(ctx: unknown): void;

package/dist/client/index.js DELETED Viewed

@@ -1,283 +0,0 @@
-/**
- * @max-null/dsh-memory browser half (0.3.3): the memory panel, moved home
- * from dsh-ssid-panels (2026-08-19 用户: 记忆面板应跟随 dsh-memory)。
- * Data goes straight through the Typert `remote.memory` surface
- * (list/search/confirm/forget/setInjected/reload) — no /ssid/api bridge,
- * so any profile with dsh-memory gets the panel. Hosted on better-sidebar
- * as an optional peer (same pattern dsh-ssid-panels used); without it the
- * client half registers nothing.
- */
-import { createElement, useEffect, useState } from 'react';
-export const inject = ['slots', 'locale', 'remote', 'remote.memory'];
-const STRINGS = {
-    zh: {
-        tabMemory: '记忆',
-        memorySearch: '搜索记忆…',
-        empty: '黑暗中未见灵光',
-        confirm: '确认',
-        forget: '删除',
-        groupPending: '待审核',
-        groupOnDemand: '已审核 · 按需',
-        groupInjected: '常驻注入',
-        injectSwitch: '常驻注入',
-        approveFirst: '审核通过后可常驻注入',
-        allNamespaces: '全部',
-        nsGlobal: '全局',
-        nsProject: '项目',
-        organizeMemory: '整理记忆',
-        confirmAll: '全部确认',
-        suggested: '待审核',
-        approved: '已审核',
-        refresh: '刷新',
-    },
-    en: {
-        tabMemory: 'Memory',
-        memorySearch: 'Search memory…',
-        empty: 'No spark in the dark',
-        confirm: 'Confirm',
-        forget: 'Forget',
-        groupPending: 'Pending review',
-        groupOnDemand: 'Approved · on demand',
-        groupInjected: 'Always injected',
-        injectSwitch: 'Inject every turn',
-        approveFirst: 'Approve to enable injection',
-        allNamespaces: 'All',
-        nsGlobal: 'Global',
-        nsProject: 'Project',
-        organizeMemory: 'Organize memory',
-        confirmAll: 'Approve all',
-        suggested: 'Suggested',
-        approved: 'Approved',
-        refresh: 'Refresh',
-    },
-};
-let localeId = 'zh';
-const localeListeners = new Set();
-function adoptLocale(id) {
-    const next = id === 'en' ? 'en' : 'zh';
-    if (next === localeId)
-        return;
-    localeId = next;
-    localeListeners.forEach(l => l());
-}
-function fmt(tpl, vars = {}) {
-    return tpl.replace(/\{(\w+)\}/g, (_, k) => String(vars[k] ?? ''));
-}
-function useT() {
-    const [id, setId] = useState(localeId);
-    useEffect(() => {
-        const l = () => { setId(localeId); };
-        localeListeners.add(l);
-        return () => { localeListeners.delete(l); };
-    }, []);
-    return (key, vars) => fmt(STRINGS[id][key] ?? STRINGS.zh[key], vars);
-}
-// ---- inline-styled primitives (no CSS build step) ----
-const ssid = {
-    accent: '#4FC3F7',
-    wrap: { display: 'flex', flexDirection: 'column', gap: 8, padding: '10px 12px', overflowY: 'auto', height: '100%', boxSizing: 'border-box' },
-    card: {
-        background: 'var(--dsw-alias-bg-layer-1, #131a26)',
-        border: '1px solid var(--dsw-alias-border-l2, #1e2836)',
-        borderRadius: 10,
-        padding: '10px 12px',
-    },
-    title: { fontSize: 12, fontWeight: 600, color: 'var(--dsw-alias-label-secondary, #67748a)', marginBottom: 6, display: 'flex', justifyContent: 'space-between', alignItems: 'center' },
-    text: { fontSize: 12.5, color: 'var(--dsw-alias-label-primary, #d8e0ea)', lineHeight: 1.55 },
-    muted: { fontSize: 11, color: 'var(--dsw-alias-label-secondary, #67748a)' },
-    empty: { padding: '28px 12px', textAlign: 'center', fontSize: 12.5, color: 'var(--dsw-alias-label-secondary, #67748a)' },
-    btn: {
-        padding: '3px 12px', fontSize: 11.5, background: 'none',
-        border: '1px solid var(--dsw-alias-border-l2, #1e2836)', borderRadius: 6,
-        color: 'var(--dsw-alias-label-primary, #d8e0ea)', cursor: 'pointer',
-    },
-};
-// 预填指令（0.3.1+）：过时内容用 memory_update 修正；工具面自查法。
-const ORGANIZE_PROMPT = '请整理我的记忆库：用 memory_list 查看全部记忆，合并重复或可归并的条目，精简冗长内容，为每条补充或修正 keywords；对过时、错误或已变化的内容用 memory_update 修正（会重置为待审核），需要删除的用 memory_forget，需要新增的用 memory_save。判断内容是否过时的方法：把记忆里提到的工具名/数量与你当前实际可用的记忆工具对照——你当前可用：memory_save / memory_list / memory_search / memory_confirm / memory_forget / memory_update（共 6 个）；若记忆中的工具列表、数量、流程与此不符即为过时，用 memory_update 修正。改动全部落在 suggested 等待审核（不要调用 memory_confirm），完成后用一句话汇报整理结果。';
-function MemoryView(props) {
-    const t = useT();
-    const [records, setRecords] = useState([]);
-    const [query, setQuery] = useState('');
-    const [namespace, setNamespace] = useState(null);
-    const [refreshing, setRefreshing] = useState(false);
-    const [organizing, setOrganizing] = useState(false);
-    const reload = async () => {
-        try {
-            setRecords(await props.remote.list());
-        }
-        catch {
-            setRecords([]);
-        }
-    };
-    // 强制重读存储文件（JsonStorageBackend 无 watch——外部编辑后必须 reload）
-    const refreshFromDisk = async () => {
-        setRefreshing(true);
-        try {
-            const value = await props.remote.reload();
-            setRecords(value);
-        }
-        catch {
-            await reload();
-        }
-        finally {
-            setRefreshing(false);
-        }
-    };
-    useEffect(() => { if (props.visible)
-        void reload(); }, [props.visible]);
-    const toggleInjected = async (record) => {
-        if (record.status !== 'approved')
-            return;
-        try {
-            await props.remote.setInjected(record.id, !record.injected);
-        }
-        catch {
-            /* 失败保持原状态 */
-        }
-        await reload();
-    };
-    const confirmAll = async () => {
-        const pending = records.filter(record => record.status === 'suggested');
-        if (pending.length === 0)
-            return;
-        await Promise.all(pending.map(record => props.remote.confirm(record.id).catch(() => null)));
-        await reload();
-    };
-    // 一点即发整理：sessions.create → open → input 就绪（轮询 ≤5s）→ setDraft → submit。
-    // 机制实证自 dsh-better-sidebar conversation-draft.ts；sessions/conversation 软获取。
-    const organize = async () => {
-        if (organizing)
-            return;
-        setOrganizing(true);
-        try {
-            const sessions = props.ctx.get?.('sessions');
-            const conversation = props.ctx.get?.('conversation');
-            if (sessions === undefined || conversation?.input?.for === undefined) {
-                throw new Error('sessions/conversation unavailable');
-            }
-            const sessionId = await sessions.create({});
-            sessions.open(sessionId);
-            let input;
-            for (let i = 0; i < 50; i++) {
-                try {
-                    const actx = sessions.scope(sessionId);
-                    if (actx !== undefined) {
-                        input = conversation.input.for(actx);
-                        if (input !== undefined)
-                            break;
-                    }
-                }
-                catch {
-                    /* not ready yet */
-                }
-                await new Promise((resolve) => setTimeout(resolve, 100));
-            }
-            if (input === undefined)
-                throw new Error('composer input not ready');
-            input.setDraft(ORGANIZE_PROMPT);
-            input.submit();
-        }
-        catch (error) {
-            console.warn('[dsh-memory] organize memory failed:', error);
-        }
-        finally {
-            setOrganizing(false);
-        }
-    };
-    const q = query.trim().toLowerCase();
-    const byNs = namespace === null ? records : records.filter(record => record.namespace === namespace);
-    const filtered = byNs.filter(record => q === '' || record.content.toLowerCase().includes(q));
-    const groups = [
-        { key: 'pending', label: t('groupPending'), items: filtered.filter(record => record.status === 'suggested') },
-        { key: 'ondemand', label: t('groupOnDemand'), items: filtered.filter(record => record.status === 'approved' && !record.injected) },
-        { key: 'injected', label: t('groupInjected'), items: filtered.filter(record => record.status === 'approved' && record.injected) },
-    ].filter(group => group.items.length > 0);
-    return createElement('div', { style: ssid.wrap }, createElement('div', { style: { display: 'flex', gap: 6 } }, createElement('button', {
-        type: 'button',
-        title: t('organizeMemory'),
-        onClick: () => { void organize(); },
-        disabled: organizing,
-        style: { ...ssid.btn, color: ssid.accent, borderColor: ssid.accent },
-    }, organizing ? '…' : t('organizeMemory')), createElement('input', {
-        value: query,
-        onChange: (event) => { setQuery(event.target.value); },
-        placeholder: t('memorySearch'),
-        style: {
-            flex: 1, padding: '6px 10px', fontSize: 12.5, boxSizing: 'border-box',
-            background: 'var(--dsw-alias-bg-layer-1, #0f141d)',
-            border: '1px solid var(--dsw-alias-border-l2, #1e2836)', borderRadius: 8,
-            color: 'var(--dsw-alias-label-primary, #d8e0ea)', outline: 'none',
-        },
-    }), createElement('button', {
-        type: 'button',
-        title: t('refresh'),
-        onClick: () => { void refreshFromDisk(); },
-        disabled: refreshing,
-        style: ssid.btn,
-    }, refreshing ? '…' : '↻')), createElement('div', { style: { display: 'flex', gap: 4 } }, [null, 'global', 'project'].map(ns => createElement('button', {
-        key: ns ?? 'all',
-        onClick: () => { setNamespace(ns); },
-        style: { flex: 1, ...ssid.btn, ...(namespace === ns ? { color: ssid.accent, borderColor: ssid.accent } : {}) },
-    }, ns === null ? t('allNamespaces') : ns === 'global' ? t('nsGlobal') : t('nsProject')))), groups.length === 0
-        ? createElement('div', { style: ssid.empty }, t('empty'))
-        : groups.map(group => createElement('div', { key: group.key, style: { display: 'flex', flexDirection: 'column', gap: 6 } }, createElement('div', { style: ssid.title }, createElement('span', null, group.label), createElement('div', { style: { display: 'flex', alignItems: 'center', gap: 6 } }, group.key === 'pending' && group.items.length > 0
-            ? createElement('button', {
-                type: 'button',
-                title: t('confirmAll'),
-                onClick: () => { void confirmAll(); },
-                style: { ...ssid.btn, padding: '1px 8px', fontSize: 10.5 },
-            }, t('confirmAll'))
-            : null, createElement('span', null, `${group.items.length}`))), group.items.map(record => createElement('div', { key: record.id, style: ssid.card }, createElement('div', { style: ssid.text }, record.content), createElement('div', { style: { ...ssid.muted, marginTop: 6 } }, `${record.namespace} · ${record.status === 'approved' ? t('approved') : t('suggested')}${record.injected ? ` · ${t('groupInjected')}` : ''}`), createElement('div', { style: { display: 'flex', gap: 6, marginTop: 8, alignItems: 'center' } }, createElement('button', {
-            type: 'button',
-            title: record.status === 'approved' ? t('injectSwitch') : t('approveFirst'),
-            disabled: record.status !== 'approved',
-            onClick: () => { void toggleInjected(record); },
-            style: {
-                ...ssid.btn,
-                ...(record.injected ? { color: ssid.accent, borderColor: ssid.accent } : {}),
-                opacity: record.status !== 'approved' ? 0.4 : 1,
-                cursor: record.status !== 'approved' ? 'not-allowed' : 'pointer',
-            },
-        }, record.injected ? `✓ ${t('injectSwitch')}` : t('injectSwitch')), record.status === 'suggested'
-            ? createElement('button', {
-                style: ssid.btn,
-                onClick: () => { void props.remote.confirm(record.id).then(() => reload()); },
-            }, t('confirm'))
-            : null, createElement('button', {
-            style: ssid.btn,
-            onClick: () => { void props.remote.forget(record.id).then(() => reload()); },
-        }, t('forget'))))))));
-}
-// ---- client plugin body ----
-export function apply(ctx) {
-    const face = ctx;
-    const locale = face.get?.('locale');
-    const initial = locale?.getLocale?.()?.active;
-    if (typeof initial === 'string')
-        adoptLocale(initial);
-    face.on?.('locale/change', (snap) => { adoptLocale(snap?.active); });
-    // better-sidebar 可选软依赖：无则面板不注册（host 侧无影响）。
-    const root = ctx;
-    if (root.inject === undefined)
-        return;
-    root.inject(['betterSidebar'], (sidebarCtx) => {
-        const service = sidebarCtx.betterSidebar;
-        if (service?.registerTab === undefined)
-            return;
-        const memory = ctx.remote?.memory;
-        if (memory === undefined)
-            return;
-        const tabCtx = ctx;
-        service.registerTab({
-            id: '@max-null/dsh-memory:memory',
-            title: () => STRINGS[localeId].tabMemory,
-            order: 60,
-            single: true,
-            component: ({ visible }) => createElement(MemoryView, {
-                visible,
-                remote: memory,
-                ctx: tabCtx,
-            }),
-        });
-    });
-}