@max-null/dsh-memory 0.19.0 → 0.20.0

package/README.md

@@ -76,6 +76,18 @@ npm install @max-null/dsh-memory
 
 两个根都可用 config 覆盖（`globalRoot` / `projectRoot`）。`memory_list` / `memory_search` 不带 `namespace` 过滤时会同时查两层。旧版双重前缀文件名（`memory_project_memory_project_<hash>.json`）在打开时自动迁移为规范名。
 
+## 主题（topic，0.20.0）
+
+`namespace` 管「在哪生效」，`topic` 管「这条讲什么」，两者正交：
+
+| 字段 | 回答的问题 | 取值 |
+|---|---|---|
+| `namespace` | 换个项目还成立吗 | `global` / `project` |
+| `kind` | 是记忆还是提示词模板 | `fact` / `prompt` |
+| `topic` | 这条记忆讲什么 | 自由字符串：`见闻` / `约定` / `坑` / `偏好` / `事实` / `判据` … |
+
+`memory_save` 传 `topic` 落库，`memory_list` / `memory_search` 传 `topic` 切片。留空或省略即「未分类」。用它把「自己出去逛到的」（`见闻`）和「一起干活时记下的」分开翻，不必再往正文里手写前缀。
+
 ## 跨工作区可见性（0.10.0 / 0.11.0）
 
 project 记忆按**会话工作区**分文件存放，所以「工作区」就是可见性的边界。0.10.0 起补了三个方向——针对的是同一个盲区：**不知道存在**（检索是有意图的动作，搜不出自己不知道存在的东西）。
@@ -106,26 +118,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_HOME>/diary/*.md` 与记忆同一轮复制，但落在**固定目录** `~/.dsh-backups/memory/diary-archive/`，**只增不删**，不参与上面的轮转。两边的不对称是实的：记忆快照丢一份还有别的份（同一份数据的多个时间点副本），归档里每一篇都是日记的唯一副本，丢了没有任何地方能重建。日记那一侧改过就以日记为准覆盖（人可能在事后改过错字），归档里有而日记里已没有的篇目一律保留——那正是归档的全部价值。归档目录名不匹配轮转正则，因此不需要给清理逻辑开白名单。
 
-**无界面**：这是行为类功能，不新增按钮、面板或设置项——行为效果即上面那段：部署后 `~/.dsh-backups/memory/` 下每小时多一个目录，目录里是当次复制出的 `memory.json`、`memory_project_*.json` 与 `manifest.json`。
+**无界面**：这是行为类功能，不新增按钮、面板或设置项——行为效果即上面那段：部署后 `~/.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/engine.d.ts

@@ -81,6 +81,13 @@ export interface MemoryRecord {
     lastUsedAt?: number;
     /** 记录类别（缺省 'fact'）。 */
     kind?: MemoryKind;
+    /**
+     * 记忆主题（0.20.0）：见闻 / 约定 / 坑 / 偏好 / 事实 / 判据 …
+     *
+     * 与 `kind` 正交：`kind` 分「记忆还是提示词模板」，`topic` 分「这条记忆讲什么」。
+     * 存自由字符串，方便「只翻我出去逛到的那些」这类切片。
+     */
+    topic?: string;
     /** prompt 记录元数据（仅 kind==='prompt'）。 */
     meta?: PromptMetaIndex;
     /**
@@ -93,6 +100,8 @@ export interface MemoryWrite {
     content: string;
     namespace?: MemoryNamespace;
     keywords?: string[];
+    /** 记忆主题（0.20.0）：见闻 / 约定 / 坑 / 偏好 / 事实 / 判据 …；省略表示未分类。 */
+    topic?: string;
     /** 写入来源（2026-09-15）；缺省 'agent'（主模型写入）。面板等人工路径传 'human'。 */
     source?: MemorySource;
     /**
@@ -115,6 +124,8 @@ export interface MemoryFilter {
     quarantined?: boolean;
     /** 记录类别过滤（0.6.0）；缺省不过滤（工具层显式传 kind='fact' 保持旧行为）。 */
     kind?: MemoryKind;
+    /** 主题过滤（0.20.0）：只取这个 topic 的记录；缺省不过滤。 */
+    topic?: string;
     /**
      * 更新时间下界 / 上界（0.12.0；epoch ms，含端点）。
      *

package/dist/engine.js

@@ -145,10 +145,11 @@ function toRecord(id, block) {
         ...block.stale === undefined ? {} : { stale: block.stale },
         ...block.staleReason === undefined ? {} : { staleReason: block.staleReason },
     };
-    // 0.6.0 模板库字段（缺省 fact；prompt 元数据透传）
+    // 0.6.0 模板库字段（缺省 fact；prompt 元数据透传）；0.20.0 起带主题
     return {
         ...base,
         ...block.kind === undefined ? {} : { kind: block.kind },
+        ...block.topic === undefined ? {} : { topic: block.topic },
         ...block.meta === undefined ? {} : { meta: block.meta },
     };
 }
@@ -758,6 +759,8 @@ export class MemoryEngine extends Service {
             ...input.injected === undefined ? {} : { injectedAuto: false },
             // 有效性锚点（可选）：值变了这条记忆会被标 stale，不再被当成仍然正确
             ...input.anchor === undefined ? {} : { anchor: input.anchor },
+            // 主题（0.20.0）：省略即未分类，与 `kind`（fact/prompt）正交
+            ...input.topic === undefined || input.topic.trim() === '' ? {} : { topic: input.topic.trim() },
             ...verdict.quarantined
                 ? { quarantined: true, ...verdict.reason === undefined ? {} : { quarantineReason: verdict.reason } }
                 : {},
@@ -778,7 +781,8 @@ export class MemoryEngine extends Service {
             // 0.12.0：按更新时间筛——与注入排序、注入行的日期标记同一个依据，不制造第二个「新」的定义
             && (filter?.after === undefined || record.updatedAt >= filter.after)
             && (filter?.before === undefined || record.updatedAt <= filter.before)
-            && (filter?.kind === undefined || (record.kind ?? 'fact') === filter.kind));
+            && (filter?.kind === undefined || (record.kind ?? 'fact') === filter.kind)
+            && (filter?.topic === undefined || record.topic === filter.topic));
     }
     /**
      * 关键词检索。每次成功返回的检索都记一条查询日志（⑥ 2026-09-15）——命中与否都记：

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";
@@ -125,6 +125,7 @@ const RECORD_SCHEMA = {
         injected: { type: 'boolean', required: true },
         content: { type: 'string', required: true },
         keywords: { type: 'array', required: true, items: { type: 'string' } },
+        topic: { type: 'string', description: '主题（0.20.0）：见闻 / 约定 / 坑 / 偏好 / 事实 / 判据 …；缺省表示未分类。' },
         createdAt: { type: 'number', required: true },
         updatedAt: { type: 'number', required: true },
         lastUsedAt: { type: 'number' },
@@ -296,6 +297,7 @@ function recordValue(record) {
         injected: record.injected,
         content: record.content,
         keywords: record.keywords,
+        ...record.topic === undefined ? {} : { topic: record.topic },
         createdAt: record.createdAt,
         updatedAt: record.updatedAt,
         ...record.lastUsedAt === undefined ? {} : { lastUsedAt: record.lastUsedAt },
@@ -587,6 +589,7 @@ export async function apply(ctx, config) {
             content: { type: 'string', required: true, description: 'Plaintext memory content.' },
             namespace: { type: 'string', enum: ['global', 'project'], description: 'Where it applies; defaults to global.' },
             keywords: { type: 'array', items: { type: 'string' }, description: 'Explicit searchable anchors for memory_search. Give several angles (synonyms, abbreviations, zh/en) or it will not be found later. 多角度关键词（同义词、缩写、中英），否则将来检索不到它。' },
+            topic: { type: 'string', description: 'What this memory is about, one short word: 见闻 (things noticed while wandering) / 约定 (standing agreement) / 坑 (a pitfall hit) / 偏好 (a preference) / 事实 / 判据. Orthogonal to namespace. 主题：见闻 / 约定 / 坑 / 偏好 / 事实 / 判据；与 namespace 正交，缺省表示未分类。' },
             injected: { type: 'boolean', description: 'Set true to make this memory resident in every turn\'s context, as a deliberate decision that no longer auto-expires. Reserve it for rules, standing agreements and judgement criteria — the kind that must apply even when nobody thinks to search for them. Facts, references and case notes stay search-only (omit it). 设为 true 让这条记忆每轮常驻上下文，且视为有意决定、不再被自动淘汰。只用于规则、长期约定与判据——那些「没人想起来搜也必须生效」的记忆；事实、参考与案例留作按需检索（省略即可）。' },
             anchor: {
                 type: 'object',
@@ -609,6 +612,7 @@ export async function apply(ctx, config) {
                 content: args.content,
                 ...args.namespace === undefined ? {} : { namespace: args.namespace },
                 ...args.keywords === undefined ? {} : { keywords: args.keywords },
+                ...args.topic === undefined ? {} : { topic: args.topic },
                 ...args.injected === undefined ? {} : { injected: args.injected },
                 // 参数已由 tool schema 校验，这里的窄化只为过类型
                 ...args.anchor === undefined
@@ -632,6 +636,7 @@ export async function apply(ctx, config) {
             namespace: { type: 'string', enum: ['global', 'project'], description: 'Restrict to one namespace. 限定单个命名空间.' },
             status: { type: 'string', enum: ['suggested', 'approved'], description: 'Restrict to one review status. 限定审核状态（suggested=待审核 / approved=已审核）.' },
             injected: { type: 'boolean', description: 'Restrict by the persistent-injection switch. 按常驻注入开关过滤.' },
+            topic: { type: 'string', description: 'Restrict to one topic (见闻 / 约定 / 坑 / 偏好 / 事实 / 判据 …). 按主题过滤（0.20.0）.' },
             after: { type: 'string', description: 'Only memories updated at/after this time: `YYYY-MM-DD`, or a relative form like `7d` / `30d`. 只返回此后更新过的记忆（`YYYY-MM-DD`，或相对形式 `7d` / `30d`）.' },
             before: { type: 'string', description: 'Only memories updated at/before this time (same forms as `after`). 只返回此前更新过的记忆（写法同 after）.' },
         },
@@ -647,6 +652,7 @@ export async function apply(ctx, config) {
                 ...args.namespace === undefined ? {} : { namespace: args.namespace },
                 ...args.status === undefined ? {} : { status: args.status },
                 ...args.injected === undefined ? {} : { injected: args.injected },
+                ...args.topic === undefined ? {} : { topic: args.topic },
                 ...after === undefined ? {} : { after },
                 ...before === undefined ? {} : { before },
             }, execProjectCwd(exec)).then(records => records.map(recordValue));
@@ -661,6 +667,7 @@ export async function apply(ctx, config) {
             namespace: { type: 'string', enum: ['global', 'project'], description: 'Restrict to one namespace. 限定单个命名空间.' },
             status: { type: 'string', enum: ['suggested', 'approved'], description: 'Restrict to one review status. 限定审核状态.' },
             kind: { type: 'string', enum: ['fact', 'prompt'], description: 'Restrict by record kind — fact (memories, default) or prompt (templates; use prompt_search instead). 按记录类别过滤：fact=记忆（默认）/ prompt=模板（模板请用 prompt_search）.' },
+            topic: { type: 'string', description: 'Restrict to one topic (见闻 / 约定 / 坑 / 偏好 / 事实 / 判据 …). 按主题过滤（0.20.0）.' },
             limit: { type: 'integer', default: DEFAULT_SEARCH_LIMIT, description: 'Maximum hits to return (default 20; 0 = no limit; negative falls back to 20). 最多返回条数（默认 20；0 = 不限；负数按 20）.' },
         },
         output: {
@@ -676,6 +683,7 @@ export async function apply(ctx, config) {
                 ...args.namespace === undefined ? {} : { namespace: args.namespace },
                 ...args.status === undefined ? {} : { status: args.status },
                 ...args.kind === undefined ? {} : { kind: args.kind },
+                ...args.topic === undefined ? {} : { topic: args.topic },
             }, execProjectCwd(exec)).then(hits => (limit === 0 ? hits : hits.slice(0, limit)).map(hitValue));
         },
         presentCall: args => present('Search memory', 'read', args.query),
@@ -992,6 +1000,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/dist/schema.d.ts

@@ -63,6 +63,7 @@ export declare const blockSchema: z.ZodObject<{
         fact: "fact";
         prompt: "prompt";
     }>>;
+    topic: z.ZodOptional<z.ZodString>;
     meta: z.ZodOptional<z.ZodObject<{
         seq: z.ZodOptional<z.ZodNumber>;
         name: z.ZodString;

package/dist/schema.js

@@ -45,6 +45,14 @@ export const blockSchema = z.object({
     lastUsedAt: z.number().optional(),
     vector: z.array(z.number()).optional(),
     kind: z.enum(['fact', 'prompt']).optional(),
+    /**
+     * 记忆主题（0.20.0）：见闻 / 约定 / 坑 / 偏好 / 事实 / 判据 … 自由字符串。
+     *
+     * 与 `kind` 正交——`kind` 分「记忆还是提示词模板」（记录类别），`topic` 分「这条记忆讲什么」
+     * （内容主题）。用自由字符串而不是枚举：新增主题不该要求改 schema，而枚举一旦写死，
+     * 存量文件里出现未登记的值会被门三判成不合规、进而整块读不出来。
+     */
+    topic: z.string().optional(),
     meta: z.object({
         seq: z.number().optional(),
         name: z.string(),

package/package.json

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