@max-null/dsh-memory 0.15.1 → 0.16.0

package/README.md

@@ -1,161 +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` / `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` + 计划任务）。
-
-## 使用流程（写入即生效，人为例外干预）
-
-提示词模板库（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) 的宿主函数 或 插件名 ... }
-```
-
-`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

@@ -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

@@ -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

@@ -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.js

@@ -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,7 @@ 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'];
 /**
  * 本次挂载实际注册的工具名，按注册顺序。
  *
@@ -742,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

@@ -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/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@max-null/dsh-memory",
-  "version": "0.15.1",
+  "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

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

package/dist/client/index.js

@@ -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,
-            }),
-        });
-    });
-}