@max-null/dsh-memory 0.19.0 → 0.19.1

package/README.md

@@ -106,26 +106,29 @@ DSH 存储层的写入是「读—改—写全量覆盖」，且官方两个后
 
 **未覆盖**：`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；日记归档 2026-10-25）
 
 **动机**：2026-10-18 的事故——`.dsh` 下的 storages 被外部整目录删除后，本插件的写入路径（读—改—写全量覆盖）在空磁盘上把内存里的 global 记忆覆盖成一条；而当时 `memory.json` **没有任何一份存在于 `.dsh` 之外**，无从恢复。
 
-**机制**：插件启动后每小时（可配）把记忆文件**只读复制**到 `<home>/.dsh-backups/memory/<YYYYMMDD-HHmmss>/`，并写一份 `manifest.json` 记录来源与文件清单。**插件关闭（dispose）时再补一次**——定时器只在运行期间生效，关 DSH 前最后一段变更靠这一次兜住。保留最近 14 份（可配），超期自动清理。
+**机制**：插件启动后每小时（可配）把记忆文件**只读复制**到 `<home>/.dsh-backups/memory/<YYYYMMDD-HHmmss>/`，并写一份 `manifest.json` 记录来源与文件清单。**插件关闭（dispose）时再补一次**——定时器只在运行期间生效，关 DSH 前最后一段变更靠这一次兜住。保留最近 14 份（可配，**只作用于记忆快照**），超期自动清理。
 
-**无界面**：这是行为类功能，不新增按钮、面板或设置项——行为效果即上面那段：部署后 `~/.dsh-backups/memory/` 下每小时多一个目录，目录里是当次复制出的 `memory.json`、`memory_project_*.json` 与 `manifest.json`。
+**日记另走一条路**：`<DSH_HOME>/diary/*.md` 与记忆同一轮复制，但落在**固定目录** `~/.dsh-backups/memory/diary-archive/`，**只增不删**，不参与上面的轮转。两边的不对称是实的：记忆快照丢一份还有别的份（同一份数据的多个时间点副本），归档里每一篇都是日记的唯一副本，丢了没有任何地方能重建。日记那一侧改过就以日记为准覆盖（人可能在事后改过错字），归档里有而日记里已没有的篇目一律保留——那正是归档的全部价值。归档目录名不匹配轮转正则，因此不需要给清理逻辑开白名单。
+
+**无界面**：这是行为类功能，不新增按钮、面板或设置项——行为效果即上面那段：部署后 `~/.dsh-backups/memory/` 下每小时多一个目录，目录里是当次复制出的 `memory.json`、`memory_project_*.json` 与 `manifest.json`；`diary-archive/` 里则按天累积 `YYYY-MM-DD.md`。
 
 | 项 | 默认值 |
 |---|---|
-| 备份内容 | `memory.json`（global）+ `memory_project_*.json`（project） |
-| 目标目录 | `~/.dsh-backups/memory/<时间戳>/`（**在 `DSH_HOME` 之外**） |
+| 备份内容 | `memory.json`（global）+ `memory_project_*.json`（project）+ `<DSH_HOME>/diary/*.md` |
+| 目标目录 | 记忆：`~/.dsh-backups/memory/<时间戳>/`（**在 `DSH_HOME` 之外**）；日记：`~/.dsh-backups/memory/diary-archive/` |
 | 间隔 | 60 分钟（首次延迟 1 分钟）；**插件关闭时另补一次** |
-| 保留 | 最近 14 份 |
+| 保留 | 记忆：最近 14 份；日记：全部（只增不删） |
 | 失败行为 | 只写日志，不影响记忆读写与启动 |
 
 **边界**：
 
 - 只备份**当前工作区**的 project 文件（`<cwd>/.dsh/storages/`）；其它工作区的 project 记忆不在备份范围。
 - 只读文件、只复制——**绝不复用引擎的写入路径**。写路径会先 `reload()` 再合并，磁盘缺失时它会把内存覆盖掉，正是这次事故的成因；备份不能走同一条路。
+- 日记按**逐字节内容**判断是否已备份过，不按 mtime：复制与编辑都会动 mtime，内容才是事实。
 
 ## 使用流程（写入即生效，人为例外干预）
 

package/dist/backup.d.ts

@@ -1,11 +1,16 @@
 /**
- * 记忆定时备份：把 `memory.json`（global）与 `memory_project_*.json`（project）复制到
- * `DSH_HOME` 之外。
+ * 定时备份：把 `memory.json`（global）、`memory_project_*.json`（project）与
+ * `<DSH_HOME>/diary` 下的日记复制到 `DSH_HOME` 之外。
  *
  * 存在的理由（2026-10-18 事故）：`.dsh` 下的 storages 被外部整目录删除后，dsh-memory 的
  * 写入路径是「reload → 合并 → 写」——空磁盘让 reload 得到空库，写入把内存里的 global
  * 记忆覆盖成一条；而当时 `memory.json` 没有任何一份存在于 `.dsh` 之外，无从恢复。
  *
+ * 两类数据在同一个备份根下、用两种保留策略：记忆是**快照**（时间戳目录、只留最近 N 份），
+ * 日记是**归档**（固定目录、只增不删）——理由见 {@link archiveDiary}。
+ *
+ * 备份能力属于本插件而非宿主壳：上面两类数据都由本插件产生，换个宿主编排它同样该成立。
+ *
  * 铁律：这里**只读文件、只复制**，绝不复用引擎的写入路径、不碰内存状态。备份失败只记
  * 日志，绝不影响记忆本身的读写与启动。
  *
@@ -28,6 +33,8 @@ export interface MemoryBackupOptions {
     globalRoot: string;
     /** project 记忆的根（`<cwd>/.dsh/storages`）。 */
     projectRoot: string;
+    /** 日记的根（`$DSH_HOME/diary`）；缺省不备份日记。 */
+    diaryRoot?: string;
     /** 备份根目录。 */
     targetRoot: string;
     /** 保留份数（≥1）。 */
@@ -37,6 +44,13 @@ export interface MemoryBackupOptions {
     /** 日志出口；缺省丢弃。 */
     log?: (text: string) => void;
 }
+/** 日记归档的结果。 */
+export interface DiaryArchiveRun {
+    /** 本次复制进归档的篇数（含内容变化后的覆盖）。 */
+    readonly copied: number;
+    /** 归档里已存在且与日记逐字节相同的篇数。 */
+    readonly kept: number;
+}
 /** 一次备份的结果。 */
 export interface MemoryBackupRun {
     /** 本次写入的目录；没有可备份文件时为 `null`。 */
@@ -45,18 +59,28 @@ export interface MemoryBackupRun {
     readonly files: readonly string[];
     /** 本次清理掉的旧目录名。 */
     readonly pruned: readonly string[];
+    /**
+     * 日记归档的结果；入参没给 `diaryRoot` 时为 `undefined`（视为「不备份日记」）。
+     *
+     * 与 `files` 分开记：日记**不**落进本次的快照目录，它在固定的 `diary-archive/` 里
+     * 保持一份持续累积的副本，不做时间点切片。
+     */
+    readonly diary?: DiaryArchiveRun;
     /** 失败原因；成功时缺省。 */
     readonly error?: string;
 }
 /**
- * 把两个根下的记忆文件复制进一份新目录。
+ * 备份一次：记忆走时间戳快照，日记走 {@link archiveDiary} 的累积归档。
  *
  * 目标目录按 `now` 命名；同名目录已存在时追加 `-1`、`-2`……每个文件独立复制，单个失败
  * 只告警、不中断其余文件；`manifest.json` 记录本次来源与文件清单，便于事后核对。
  * 没有可复制文件时返回 `dir: null`，不创建空目录。
  *
- * @param options - 两个来源根、目标根、保留份数与时间注入点。
- * @returns 本次目录、复制清单、清理清单与失败原因。
+ * 日记归档先于「记忆文件是否存在」的判断执行：它落在固定的 `diary-archive/`，不依赖本次
+ * 快照目录，所以只剩日记可备份时照样该归档。
+ *
+ * @param options - 两个来源根、日记根、目标根、保留份数与时间注入点。
+ * @returns 本次目录、复制清单、清理清单、日记归档结果与失败原因。
  */
 export declare function runMemoryBackup(options: MemoryBackupOptions): MemoryBackupRun;
 /** 备份目录是否像一个已存在的备份树（测试与自检用）。 */

package/dist/backup.js

@@ -1,20 +1,40 @@
 /**
- * 记忆定时备份：把 `memory.json`（global）与 `memory_project_*.json`（project）复制到
- * `DSH_HOME` 之外。
+ * 定时备份：把 `memory.json`（global）、`memory_project_*.json`（project）与
+ * `<DSH_HOME>/diary` 下的日记复制到 `DSH_HOME` 之外。
  *
  * 存在的理由（2026-10-18 事故）：`.dsh` 下的 storages 被外部整目录删除后，dsh-memory 的
  * 写入路径是「reload → 合并 → 写」——空磁盘让 reload 得到空库，写入把内存里的 global
  * 记忆覆盖成一条；而当时 `memory.json` 没有任何一份存在于 `.dsh` 之外，无从恢复。
  *
+ * 两类数据在同一个备份根下、用两种保留策略：记忆是**快照**（时间戳目录、只留最近 N 份），
+ * 日记是**归档**（固定目录、只增不删）——理由见 {@link archiveDiary}。
+ *
+ * 备份能力属于本插件而非宿主壳：上面两类数据都由本插件产生，换个宿主编排它同样该成立。
+ *
  * 铁律：这里**只读文件、只复制**，绝不复用引擎的写入路径、不碰内存状态。备份失败只记
  * 日志，绝不影响记忆本身的读写与启动。
  *
  * @module dsh-memory/backup
  */
-import { copyFileSync, existsSync, mkdirSync, readdirSync, rmSync, statSync, writeFileSync } from 'node:fs';
+import { copyFileSync, existsSync, mkdirSync, readFileSync, 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;
+/** 参与归档的日记篇目：与 `diary.ts` 的按天分文件一致（`YYYY-MM-DD.md`）。 */
+const DIARY_FILE = /^\d{4}-\d{2}-\d{2}\.md$/u;
+/**
+ * 日记归档目录名，固定在备份根下。
+ *
+ * 之所以是固定名而不是时间戳：它**必须不匹配** {@link pruneBackups} 的
+ * `^\d{8}-\d{6}(?:-\d+)?$`。记忆快照丢一份还有别的份（同一份数据的多个时间点副本），
+ * 日记归档里每一篇都是**唯一**的备份——丢了没有任何地方能重建它。只增不删因此是硬要求，
+ * 而靠这个名字天然躲开轮转，不必再给清理逻辑开白名单。
+ */
+const DIARY_ARCHIVE_DIR = 'diary-archive';
+/** 从 `unknown` 错误里取可读信息（`catch` 绑定的类型是 `unknown`）。 */
+function reason(error) {
+    return error instanceof Error ? error.message : String(error);
+}
 /** 备份目录名：`YYYYMMDD-HHmmss`，可排序、可读。 */
 function stamp(now) {
     const pad = (value) => String(value).padStart(2, '0');
@@ -29,29 +49,93 @@ function candidateFiles(root, log) {
         return readdirSync(root).filter((name) => BACKUP_FILE.test(name));
     }
     catch (error) {
-        log(`memory backup: 无法读取 ${root}: ${error instanceof Error ? error.message : String(error)}`);
+        log(`memory backup: 无法读取 ${root}: ${reason(error)}`);
         return [];
     }
 }
 /**
- * 把两个根下的记忆文件复制进一份新目录。
+ * 把日记镜像进 `<targetRoot>/diary-archive/`。
+ *
+ * 保留策略与记忆快照相反：快照按时间戳分目录、只留最近 `keep` 份；归档**只增不删**，
+ * 理由见 {@link DIARY_ARCHIVE_DIR}。
+ *
+ * 三档处理：
+ * - 归档里没有 → 复制，计入 `copied`
+ * - 两边逐字节相同 → 跳过，计入 `kept`（绝大多数情况：日记写到归档之间没有变化）
+ * - 不同 → **以日记为准覆盖**，计入 `copied`：人可能在事后改过错字，日记那一侧才是当前的；
+ *   归档不是版本库，它只为「原件没了」这一件事存在
+ *
+ * 归档里独有、日记里已经没有的篇目**一律保留**——那正是归档的全部价值。
+ * 逐篇独立处理，单篇失败只告警、不抛出（模块头的铁律）。
+ *
+ * @param diaryRoot - 日记根（`$DSH_HOME/diary`）。
+ * @param targetRoot - 备份根；归档落在其下的 `diary-archive/`。
+ * @param log - 日志出口。
+ * @returns 写入与跳过的篇数；没有日记可归档时两项都是 0，且不创建任何目录。
+ */
+function archiveDiary(diaryRoot, targetRoot, log) {
+    const nothing = { copied: 0, kept: 0 };
+    if (!existsSync(diaryRoot))
+        return nothing;
+    let names;
+    try {
+        names = readdirSync(diaryRoot).filter((name) => DIARY_FILE.test(name));
+    }
+    catch (error) {
+        log(`memory backup: 无法读取日记目录 ${diaryRoot}: ${reason(error)}`);
+        return nothing;
+    }
+    if (names.length === 0)
+        return nothing;
+    const archiveDir = join(targetRoot, DIARY_ARCHIVE_DIR);
+    let copied = 0;
+    let kept = 0;
+    for (const name of names) {
+        const from = join(diaryRoot, name);
+        const to = join(archiveDir, name);
+        try {
+            // 比字节而不是比 mtime：复制与编辑都会动 mtime，内容才是「是否已经备份过」的事实。
+            if (existsSync(to) && readFileSync(from).equals(readFileSync(to))) {
+                kept += 1;
+                continue;
+            }
+            mkdirSync(archiveDir, { recursive: true });
+            copyFileSync(from, to);
+            copied += 1;
+        }
+        catch (error) {
+            log(`memory backup: 归档日记 ${name} 失败: ${reason(error)}`);
+        }
+    }
+    return { copied, kept };
+}
+/**
+ * 备份一次：记忆走时间戳快照，日记走 {@link archiveDiary} 的累积归档。
  *
  * 目标目录按 `now` 命名；同名目录已存在时追加 `-1`、`-2`……每个文件独立复制，单个失败
  * 只告警、不中断其余文件；`manifest.json` 记录本次来源与文件清单，便于事后核对。
  * 没有可复制文件时返回 `dir: null`，不创建空目录。
  *
- * @param options - 两个来源根、目标根、保留份数与时间注入点。
- * @returns 本次目录、复制清单、清理清单与失败原因。
+ * 日记归档先于「记忆文件是否存在」的判断执行：它落在固定的 `diary-archive/`，不依赖本次
+ * 快照目录，所以只剩日记可备份时照样该归档。
+ *
+ * @param options - 两个来源根、日记根、目标根、保留份数与时间注入点。
+ * @returns 本次目录、复制清单、清理清单、日记归档结果与失败原因。
  */
 export function runMemoryBackup(options) {
     const log = options.log ?? (() => { });
     const now = options.now ?? new Date();
+    const diary = options.diaryRoot === undefined
+        ? undefined
+        : archiveDiary(options.diaryRoot, options.targetRoot, log);
     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: [] };
+        return diary === undefined
+            ? { dir: null, files: [], pruned: [] }
+            : { dir: null, files: [], pruned: [], diary };
     }
     let base = join(options.targetRoot, stamp(now));
     let dir = base;
@@ -61,7 +145,7 @@ export function runMemoryBackup(options) {
         mkdirSync(dir, { recursive: true });
     }
     catch (error) {
-        const message = error instanceof Error ? error.message : String(error);
+        const message = reason(error);
         log(`memory backup: 无法创建 ${dir}: ${message}`);
         return { dir: null, files: [], pruned: [], error: message };
     }
@@ -72,7 +156,7 @@ export function runMemoryBackup(options) {
             files.push(source.name);
         }
         catch (error) {
-            log(`memory backup: 复制 ${source.name} 失败: ${error instanceof Error ? error.message : String(error)}`);
+            log(`memory backup: 复制 ${source.name} 失败: ${reason(error)}`);
         }
     }
     try {
@@ -81,14 +165,22 @@ export function runMemoryBackup(options) {
             globalRoot: options.globalRoot,
             projectRoot: options.projectRoot,
             files,
+            // 日记不在本次快照目录里，manifest 只记「这一轮归档做了什么」，不列篇名。
+            ...(diary === undefined ? {} : { diary: { root: options.diaryRoot, ...diary } }),
         }, null, 2)}\n`, 'utf8');
     }
     catch (error) {
-        log(`memory backup: 写 manifest 失败: ${error instanceof Error ? error.message : String(error)}`);
+        log(`memory backup: 写 manifest 失败: ${reason(error)}`);
     }
-    return { dir, files, pruned: pruneBackups(options.targetRoot, options.keep, log) };
+    const pruned = pruneBackups(options.targetRoot, options.keep, log);
+    return diary === undefined ? { dir, files, pruned } : { dir, files, pruned, diary };
 }
-/** 只保留最近 `keep` 份备份目录（按名字排序即时间序），多余的删除。 */
+/**
+ * 只保留最近 `keep` 份时间戳快照目录（按名字排序即时间序），多余的删除。
+ *
+ * 只认 `YYYYMMDD-HHmmss`（含 `-1` 这类冲突后缀）：`diary-archive` 等固定名目录因此永远
+ * 不在清理范围内——日记只增不删是硬要求，不是配置项。
+ */
 function pruneBackups(targetRoot, keep, log) {
     if (!existsSync(targetRoot))
         return [];
@@ -97,7 +189,7 @@ function pruneBackups(targetRoot, keep, log) {
         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)}`);
+        log(`memory backup: 无法读取 ${targetRoot}: ${reason(error)}`);
         return [];
     }
     entries.sort();
@@ -112,7 +204,7 @@ function pruneBackups(targetRoot, keep, log) {
             pruned.push(name);
         }
         catch (error) {
-            log(`memory backup: 清理 ${name} 失败: ${error instanceof Error ? error.message : String(error)}`);
+            log(`memory backup: 清理 ${name} 失败: ${reason(error)}`);
         }
     }
     return pruned;

package/dist/index.js

@@ -13,7 +13,7 @@ import { runMemoryBackup } from "./backup.js";
 import { ANCHOR_KINDS } from "./anchors.js";
 import { mountMemoryApi } from "./routes.js";
 import { SELF_DESCRIPTION } from "./self.js";
-import { appendEntry, lastWriteAt, pointerLine, readDay, recentDates } from "./diary.js";
+import { appendEntry, diaryDir, lastWriteAt, pointerLine, readDay, recentDates } from "./diary.js";
 import z from '@deepseek-ai/schemastery';
 import { DEFAULT_INJECTION_BUDGET, DEFAULT_SUMMARY_CHARS, candidateNotice, indexNotice, neighborNotice, neutralizeBraces, omittedNotice, renderInjection, staleNotice } from "./injection.js";
 export { MemoryEngine } from "./engine.js";
@@ -992,6 +992,8 @@ export async function apply(ctx, config) {
         const roots = {
             globalRoot: config?.globalRoot ?? join(process.env.DSH_HOME ?? join(homedir(), '.dsh'), 'storages'),
             projectRoot: config?.projectRoot ?? join(process.cwd(), '.dsh', 'storages'),
+            // 日记在 `storages` 之外，得单独给根——漏了这一项就等于「备份记忆、不备份日记」。
+            diaryRoot: diaryDir(),
         };
         ctx.effect(() => {
             const first = setTimeout(() => {

package/package.json

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