@max-null/dsh-memory 0.18.0 → 0.19.1

package/README.md

@@ -40,10 +40,31 @@ npm install @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>]` 来源标记；摘要化 + 预算截断）
+- **工具**（14 个）：`memory_save`、`memory_list`、`memory_search`、`memory_update`、`memory_confirm`、`memory_forget`、`memory_move`、`memory_sweep`，提示词模板四件套 `prompt_search`、`prompt_get`、`prompt_list`、`prompt_add`，加日记两件套 `diary_read`、`diary_write`
+- **注入**：`tool:memory` 指引 section（工具用法 + 常驻注入判据）+ `memory:self` 机制自述 + `memory:recall` 召回 context（global 的 `approved + injected` + 当前会话工作区的 `approved + injected`，带 `[memory:<id>:<namespace>]` 来源标记；摘要化 + 预算截断）+ `memory:diary` 指针（只有目录与最近日期，不含正文）
 - **检索**：BM25（CJK 单字 + 2-gram，content 与 keywords 字段分离加权；中文多字查询精度显著优于单字切分）；可选语义融合（见「可选配置」）
 
+## 日记（第二套记忆，2026-10-24）
+
+记忆与日记是**两套东西**，不是同一套的两个视图：
+
+| | 记忆 | 日记 |
+|---|---|---|
+| 写什么 | 从中得出了什么 | 今天发生了什么 |
+| 准入判据 | 有用性 | 无——写就是了 |
+| 怎么被读到 | 检索命中 / 常驻摘要 | 整篇读 |
+| 存储 | `ctx.storage` 里的 JSON 块 | `<DSH_HOME>/diary/YYYY-MM-DD.md` |
+
+**日记正文永远不经过 `ctx.storage`**：那条路的写入模型是 *writer per process and last-write-wins*，而日记不该被另一个实例的「读—改—写」周期吃掉。日记也不进检索、不占常驻注入预算——注入里只有一行指针（目录 + 最近日期）。
+
+- 一天一个文件，按 `## HH:MM` 分段；同日多场对话是**追加**，不覆盖。
+- 工具：`diary_read`（省略 `date` 读最近一篇）、`diary_write`（写一段）。
+- 写进日记的是**经历**：发生了什么（有细节）、我怎么想（可以有情绪、可以没结论）、关于他（他说了什么、我注意到了什么）。**不写任务清单**（那是 git log），**不写结论**（那是 `memory_save`）。
+- 提醒：指针行在距上次写日记超过 6 小时后附带一句提醒，同一次挂载只出现一次。
+- **开关**：插件页的「日记」开关（`diary.enabled`，默认开）。关掉后两个工具都拒绝执行、指针不注入；**已有 md 文件原样保留**，不会被删。
+
+设计依据、取舍与未决项见 [`docs/设计/2026-10-24-日记机制-设计方案.md`](docs/设计/2026-10-24-日记机制-设计方案.md)。
+
 ## 两层存储（global / project）
 
 记忆按 `namespace` 分两层物理存储，各落在独立的明文 JSON：
@@ -85,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_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，内容才是事实。
 
 ## 使用流程（写入即生效，人为例外干预）
 
@@ -161,6 +185,9 @@ memory_forget        →  随时删除（删除始终是人的动作）
       keep: 14               # 保留份数
       # targetRoot: 'D:/dsh-backups/memory'   # 自定义备份根
       # enabled: false        # 关掉
+    # 日记开关（2026-10-24；也可在插件设置页里直接改，等价）
+    diary:
+      enabled: true
 ```
 
 `embeddings` 接受 `{ embed(texts): Promise<number[][]>, similarity? }` 对象——由宿主装配层提供嵌入实现（如 DeepSeek 嵌入端点）；配置后 `memory_search` 以 BM25 + 语义 RRF 融合，向量增量生成并持久化，嵌入调用失败自动降级为纯 BM25。

package/client.js

@@ -1031,6 +1031,85 @@ function SettingsMemoryView(props) {
     cwd: currentSessionCwd(props.ctx)
   });
 }
+function DiarySettingsCard(props) {
+  const { form } = props;
+  const [enabled, setEnabled] = (0, import_react.useState)(true);
+  (0, import_react.useEffect)(() => {
+    const read = () => {
+      setEnabled(form.getSnapshot()?.value?.diary?.enabled ?? true);
+    };
+    read();
+    const off = form.subscribe(read);
+    return () => {
+      if (typeof off === "function") off();
+    };
+  }, [form]);
+  return (0, import_react.createElement)(
+    "div",
+    {
+      style: {
+        display: "flex",
+        alignItems: "center",
+        justifyContent: "space-between",
+        gap: 12,
+        padding: "12px 0",
+        borderTop: "1px solid var(--dsw-alias-border-l2, #1e2836)"
+      }
+    },
+    (0, import_react.createElement)(
+      "div",
+      { style: { minWidth: 0 } },
+      (0, import_react.createElement)("div", { style: { fontSize: 13, fontWeight: 600, color: "var(--dsw-alias-label-primary, #d8e0ea)" } }, "\u65E5\u8BB0"),
+      (0, import_react.createElement)(
+        "div",
+        { style: { fontSize: 11.5, color: "var(--dsw-alias-label-secondary, #67748a)", marginTop: 3, lineHeight: 1.5 } },
+        "\u672C\u673A\u5199\u65E5\u8BB0\u3002\u5173\u6389\u540E\u65E5\u8BB0\u5DE5\u5177\u62D2\u7EDD\u6267\u884C\u3001\u4E0D\u518D\u6CE8\u5165\u6307\u9488\uFF1B\u5DF2\u6709\u65E5\u8BB0\u6587\u4EF6\u539F\u6837\u4FDD\u7559\uFF0C\u4E0D\u4F1A\u88AB\u5220\u3002"
+      )
+    ),
+    (0, import_react.createElement)(
+      "button",
+      {
+        type: "button",
+        role: "switch",
+        "aria-checked": enabled,
+        "aria-label": "\u65E5\u8BB0\u5F00\u5173",
+        onClick: () => {
+          try {
+            const pending = form.mutate([{ op: "set", path: ["diary", "enabled"], value: !enabled }]);
+            void Promise.resolve(pending).catch((error) => {
+              console.warn("dsh-memory: \u65E5\u8BB0\u5F00\u5173\u5199\u5165\u5931\u8D25", error);
+            });
+          } catch (error) {
+            console.warn("dsh-memory: \u65E5\u8BB0\u5F00\u5173\u5199\u5165\u629B\u9519", error);
+          }
+        },
+        style: {
+          flex: "none",
+          width: 40,
+          height: 22,
+          borderRadius: 11,
+          border: "none",
+          cursor: "pointer",
+          position: "relative",
+          transition: "background 120ms",
+          background: enabled ? "var(--dsw-alias-state-business-primary, #4FC3F7)" : "var(--dsw-alias-border-l2, #1e2836)"
+        }
+      },
+      (0, import_react.createElement)("span", {
+        style: {
+          position: "absolute",
+          top: 3,
+          left: enabled ? 21 : 3,
+          width: 16,
+          height: 16,
+          borderRadius: "50%",
+          background: "#fff",
+          transition: "left 120ms"
+        }
+      })
+    )
+  );
+}
 function apply(ctx) {
   const face = ctx;
   const locale = face.get?.("locale");
@@ -1053,6 +1132,19 @@ function apply(ctx) {
     })));
     face.effect?.(() => registerSettingsNavIcon(() => STRINGS[localeId].tabMemory), "dsh-memory: settings navigation icon");
   }
+  try {
+    const configForms = face.get?.("configForms");
+    const settingsForm = configForms?.get?.("memory");
+    if (slots?.inject !== void 0 && settingsForm !== void 0) {
+      slots.inject("plugins.bundle.config", () => slots.register({
+        name: "plugins.bundle.config",
+        key: "@max-null/dsh-memory",
+        inject: () => ({})
+      }, () => (0, import_react.createElement)(DiarySettingsCard, { form: settingsForm })));
+    }
+  } catch (error) {
+    console.warn("dsh-memory: \u65E5\u8BB0\u914D\u7F6E\u5361\u7247\u672A\u6CE8\u518C\uFF08\u4E0D\u5F71\u54CD\u8BB0\u5FC6\u4E0E\u65E5\u8BB0\u5DE5\u5177\uFF09", error);
+  }
   const root = ctx;
   if (root.inject === void 0) return;
   root.inject(["betterSidebar"], (sidebarCtx) => {

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/diary.d.ts

@@ -0,0 +1,87 @@
+/**
+ * 日记的存储层 —— 与记忆的 block 存储**完全分离**。
+ *
+ * 为什么不复用 `ctx.storage` / `storageDomain` / `storage-json`：那条路的写入模型是
+ * **writer per process and last-write-wins**（`packages/storage/storage-json/src/index.ts:5-9`），
+ * sqlite 的 README 明写 **cross-process coordination is out of scope**。2026-09-17 实测中
+ * `workspace.json` 与 `memory.json` 都被另一个实例静默覆盖过。日记只由本模块的 `node:fs`
+ * 读写，不进那套服务，就不会被任何实例的「读—改—写」周期吃掉。
+ *
+ * @see docs/设计/2026-10-24-日记机制-设计方案.md §四
+ */
+/**
+ * 本地时区的日期串 `YYYY-MM-DD`。
+ *
+ * 用 `sv-SE` 的本地化格式取日期而不是手拼 `getMonth()+1`：`sv-SE` 的日期格式恰好是
+ * ISO 顺序且按本地时区输出，省掉补零与时区换算两处容易写错的地方。
+ * @param at - 毫秒时间戳；缺省取当前时刻。
+ * @returns `YYYY-MM-DD`。
+ */
+export declare function localDate(at?: number): string;
+/**
+ * harness home：`$DSH_HOME`，缺省 `~/.dsh`。
+ *
+ * 空或仅空白的 `$DSH_HOME` 视为未设置（与官方 `resolveDshHome` 一致），否则空值会把
+ * 路径解析到进程当前目录。
+ * @returns 绝对路径。
+ */
+export declare function dshHome(): string;
+/**
+ * 日记目录：`<DSH_HOME>/diary`，缺省 `~/.dsh/diary`。
+ *
+ * 与 `storages/`、`storages-ssid/` 平级，互不相干——这是「不被覆盖」这条判据的落点，
+ * 不是随手选的位置。
+ * @returns 绝对路径（目录可能尚不存在）。
+ */
+export declare function diaryDir(): string;
+/**
+ * 某一天的日记文件路径。
+ * @param date - `YYYY-MM-DD`。
+ * @returns 绝对路径。
+ */
+export declare function dayFile(date: string): string;
+/**
+ * 读某一天的日记原文。
+ * @param date - `YYYY-MM-DD`。
+ * @returns 原文；这一天没有日记时 `undefined`（不是空串——「没有」与「写了空」要能分开）。
+ */
+export declare function readDay(date: string): string | undefined;
+/** {@link appendEntry} 的结果。 */
+export interface AppendResult {
+    /** 写入的文件绝对路径。 */
+    readonly file: string;
+    /** 写入所属的日期（本地时区）。 */
+    readonly date: string;
+    /** 这一天是不是本次才创建的。 */
+    readonly created: boolean;
+}
+/**
+ * 往当天的日记追加一段。
+ *
+ * **追加而不是覆盖**：一天里可能有多场对话，每场结束各写一段；覆盖会让前一扬的内容消失。
+ * 用 `appendFileSync` 而非「读全文—拼接—写回」：追加在 POSIX 上是带 `O_APPEND` 的单次写，
+ * 即便两个实例同时追加也不会互相截断（长度交错是可能的，内容不会丢）。
+ * @param text - 这一段正文；首尾空白会被裁掉，空内容被拒绝。
+ * @param at - 毫秒时间戳；缺省取当前时刻。
+ * @returns 写入位置与是否新建。
+ * @throws 当 `text` 裁掉空白后为空。
+ */
+export declare function appendEntry(text: string, at?: number): AppendResult;
+/**
+ * 最近写过日记的日子，从新到旧。
+ * @param limit - 最多返回多少天。
+ * @returns `YYYY-MM-DD` 列表；目录不存在时为空。
+ */
+export declare function recentDates(limit?: number): string[];
+/**
+ * 最后一次写入日记的时间戳。收尾节流用它判断「该不该提醒写日记」。
+ * @returns 毫秒时间戳；一篇日记都没有时 `undefined`。
+ */
+export declare function lastWriteAt(): number | undefined;
+/**
+ * 注入用的指针行。**只有目录与最近日期，不含正文**——注入预算属于记忆，日记不占。
+ *
+ * 这一行本身是「失效可察觉性」判据的应用：它不在，我不会意识到自己有日记可读。
+ * @returns 一行 markdown 文本。
+ */
+export declare function pointerLine(): string;

package/dist/diary.js

@@ -0,0 +1,170 @@
+/**
+ * 日记的存储层 —— 与记忆的 block 存储**完全分离**。
+ *
+ * 为什么不复用 `ctx.storage` / `storageDomain` / `storage-json`：那条路的写入模型是
+ * **writer per process and last-write-wins**（`packages/storage/storage-json/src/index.ts:5-9`），
+ * sqlite 的 README 明写 **cross-process coordination is out of scope**。2026-09-17 实测中
+ * `workspace.json` 与 `memory.json` 都被另一个实例静默覆盖过。日记只由本模块的 `node:fs`
+ * 读写，不进那套服务，就不会被任何实例的「读—改—写」周期吃掉。
+ *
+ * @see docs/设计/2026-10-24-日记机制-设计方案.md §四
+ */
+import fs from 'node:fs';
+import os from 'node:os';
+import path from 'node:path';
+/**
+ * 本地时区的日期串 `YYYY-MM-DD`。
+ *
+ * 用 `sv-SE` 的本地化格式取日期而不是手拼 `getMonth()+1`：`sv-SE` 的日期格式恰好是
+ * ISO 顺序且按本地时区输出，省掉补零与时区换算两处容易写错的地方。
+ * @param at - 毫秒时间戳；缺省取当前时刻。
+ * @returns `YYYY-MM-DD`。
+ */
+export function localDate(at = Date.now()) {
+    return new Date(at).toLocaleDateString('sv-SE');
+}
+/**
+ * 展开前导波浪号。
+ *
+ * `$DSH_HOME` 允许写成 `~/env-dsh`（官方 `resolveDshHome` 同样处理），而 `path.resolve`
+ * 不会展开它，直接拼会得到一个字面名为 `~` 的目录。
+ * @param value - 可能带 `~` 的路径。
+ * @returns 绝对路径。
+ */
+function expandHome(value) {
+    return value.startsWith('~') ? path.join(os.homedir(), value.slice(1)) : value;
+}
+/**
+ * harness home：`$DSH_HOME`，缺省 `~/.dsh`。
+ *
+ * 空或仅空白的 `$DSH_HOME` 视为未设置（与官方 `resolveDshHome` 一致），否则空值会把
+ * 路径解析到进程当前目录。
+ * @returns 绝对路径。
+ */
+export function dshHome() {
+    const raw = process.env.DSH_HOME;
+    return raw !== undefined && raw.trim() !== ''
+        ? path.resolve(expandHome(raw.trim()))
+        : path.join(os.homedir(), '.dsh');
+}
+/**
+ * 日记目录：`<DSH_HOME>/diary`，缺省 `~/.dsh/diary`。
+ *
+ * 与 `storages/`、`storages-ssid/` 平级，互不相干——这是「不被覆盖」这条判据的落点，
+ * 不是随手选的位置。
+ * @returns 绝对路径（目录可能尚不存在）。
+ */
+export function diaryDir() {
+    return path.join(dshHome(), 'diary');
+}
+/**
+ * 某一天的日记文件路径。
+ * @param date - `YYYY-MM-DD`。
+ * @returns 绝对路径。
+ */
+export function dayFile(date) {
+    return path.join(diaryDir(), `${date}.md`);
+}
+/**
+ * 读某一天的日记原文。
+ * @param date - `YYYY-MM-DD`。
+ * @returns 原文；这一天没有日记时 `undefined`（不是空串——「没有」与「写了空」要能分开）。
+ */
+export function readDay(date) {
+    try {
+        return fs.readFileSync(dayFile(date), 'utf8');
+    }
+    catch {
+        // 文件不存在就是没有这一天的日记，是本函数的正常返回，不是故障。
+        return undefined;
+    }
+}
+/**
+ * 往当天的日记追加一段。
+ *
+ * **追加而不是覆盖**：一天里可能有多场对话，每场结束各写一段；覆盖会让前一扬的内容消失。
+ * 用 `appendFileSync` 而非「读全文—拼接—写回」：追加在 POSIX 上是带 `O_APPEND` 的单次写，
+ * 即便两个实例同时追加也不会互相截断（长度交错是可能的，内容不会丢）。
+ * @param text - 这一段正文；首尾空白会被裁掉，空内容被拒绝。
+ * @param at - 毫秒时间戳；缺省取当前时刻。
+ * @returns 写入位置与是否新建。
+ * @throws 当 `text` 裁掉空白后为空。
+ */
+export function appendEntry(text, at = Date.now()) {
+    const body = text.trim();
+    if (body === '')
+        throw new Error('日记内容为空');
+    const date = localDate(at);
+    const file = dayFile(date);
+    fs.mkdirSync(diaryDir(), { recursive: true });
+    const created = !fs.existsSync(file);
+    const hhmm = new Date(at).toTimeString().slice(0, 5);
+    // 新建时补一级标题；之后的每一段只占一个二级标题。
+    const chunk = created
+        ? `# ${date}\n\n## ${hhmm}\n\n${body}\n`
+        : `\n## ${hhmm}\n\n${body}\n`;
+    fs.appendFileSync(file, chunk, 'utf8');
+    return { file, date, created };
+}
+/**
+ * 最近写过日记的日子，从新到旧。
+ * @param limit - 最多返回多少天。
+ * @returns `YYYY-MM-DD` 列表；目录不存在时为空。
+ */
+export function recentDates(limit = 7) {
+    let names;
+    try {
+        names = fs.readdirSync(diaryDir());
+    }
+    catch {
+        // 目录还没建过——一篇日记都没有，是正常状态。
+        return [];
+    }
+    return names
+        .filter(name => /^\d{4}-\d{2}-\d{2}\.md$/.test(name))
+        .map(name => name.slice(0, 10))
+        .sort()
+        .reverse()
+        .slice(0, limit);
+}
+/**
+ * 最后一次写入日记的时间戳。收尾节流用它判断「该不该提醒写日记」。
+ * @returns 毫秒时间戳；一篇日记都没有时 `undefined`。
+ */
+export function lastWriteAt() {
+    let names;
+    try {
+        names = fs.readdirSync(diaryDir());
+    }
+    catch {
+        return undefined;
+    }
+    const dir = diaryDir();
+    let latest;
+    for (const name of names) {
+        if (!/^\d{4}-\d{2}-\d{2}\.md$/.test(name))
+            continue;
+        try {
+            const m = fs.statSync(path.join(dir, name)).mtimeMs;
+            if (latest === undefined || m > latest)
+                latest = m;
+        }
+        catch {
+            // 扫目录与 stat 之间被删：跳过这一天，不影响其余日期的判断。
+        }
+    }
+    return latest;
+}
+/**
+ * 注入用的指针行。**只有目录与最近日期，不含正文**——注入预算属于记忆，日记不占。
+ *
+ * 这一行本身是「失效可察觉性」判据的应用：它不在，我不会意识到自己有日记可读。
+ * @returns 一行 markdown 文本。
+ */
+export function pointerLine() {
+    const dir = diaryDir();
+    const dates = recentDates(3);
+    return dates.length === 0
+        ? `日记目录：${dir}（还没有任何一篇）`
+        : `日记目录：${dir}；最近写入：${dates.join('、')}`;
+}

package/dist/engine.d.ts

@@ -319,6 +319,17 @@ export interface MemoryConfig {
      * 实现只读文件、只复制，见 `backup.ts` 的文件头。
      */
     backup?: MemoryBackupConfig;
+    /**
+     * 日记开关的**部署默认值**（2026-10-24）。运行中的选择在面板里改，写入
+     * `$DSH_HOME/memory-settings.json`；两边都开才开——否则部署时关掉会被
+     * 使用者那一侧缺省的 `true` 翻回来。
+     *
+     * 关掉时日记工具会拒绝写入、不注入指针、也不提醒；已有的 md 文件原样保留
+     * （删除是使用者的动作，不该由开关代劳）。
+     */
+    diary?: {
+        enabled?: boolean;
+    };
     /**
      * 查询日志文件路径（2026-09-15 §六.6）；默认为全局存储根下的 `query-log.json`
      * ——即与 `memory.json` **同目录**（`$DSH_HOME/storages/query-log.json`），不落子目录。

package/dist/index.d.ts

@@ -6,12 +6,66 @@
  */
 import type { Context } from '@deepseek-ai/cordis';
 import type { MemoryConfig } from './engine.ts';
+import z from '@deepseek-ai/schemastery';
 export { MemoryEngine } from './engine.ts';
 export type { MemoryChange, MemoryConfig, MemoryFilter, MemoryHit, MemoryNamespace, MemoryRecord, MemoryStatus, MemoryWrite, } from './engine.ts';
 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[];
+/**
+ * 插件配置 schema（0.19.0）。loader 依它自动构成「插件」页里的配置卡片，namespace 即
+ * entry id（`memory`）；**可写字段必须标 `.volatile()`**，否则 `settings` 会以
+ * `Config field "…" is not volatile` 拒绝写入。
+ *
+ * 除 `diary` 外的字段一律 `z.optional()` 原样透传：它们的取值依赖运行时
+ * （`$DSH_HOME`、各平台路径），schema 给不出有意义的默认值，硬填一个反而会顶掉
+ * `MemoryConfig` 那套 `?? 默认` 的解析。`embeddings` / `backup` 是结构化配置，
+ * 由 engine / backup 各自按领域校验，这一层只负责透传。
+ */
+export declare const Config: z<Schemastery.ObjectS<NoInfer<{
+    globalRoot: z<string, string, "plain">;
+    projectRoot: z<string, string, "plain">;
+    injectionBudget: z<number, number, "plain">;
+    summaryChars: z<number, number, "plain">;
+    promptGlobalRoot: z<string, string, "plain">;
+    queryLogPath: z<string, string, "plain">;
+    semanticTopK: z<number, number, "plain">;
+    embeddings: z<any, any, "plain">;
+    backup: z<any, any, "plain">;
+    /**
+     * 日记开关。默认开——这是**功能默认，不是采集默认**。
+     *
+     * 关掉时日记工具拒绝写入、不注入指针、不提醒；已有 md 文件原样保留
+     * （删除是使用者的动作，不该由开关代劳）。
+     */
+    diary: z<NoInfer<Schemastery.ObjectS<NoInfer<{
+        enabled: z<boolean, boolean, "defined">;
+    }>>>, NoInfer<Schemastery.ObjectT<NoInfer<{
+        enabled: z<boolean, boolean, "defined">;
+    }>>>, "volatile-defined">;
+}>>, Schemastery.ObjectT<NoInfer<{
+    globalRoot: z<string, string, "plain">;
+    projectRoot: z<string, string, "plain">;
+    injectionBudget: z<number, number, "plain">;
+    summaryChars: z<number, number, "plain">;
+    promptGlobalRoot: z<string, string, "plain">;
+    queryLogPath: z<string, string, "plain">;
+    semanticTopK: z<number, number, "plain">;
+    embeddings: z<any, any, "plain">;
+    backup: z<any, any, "plain">;
+    /**
+     * 日记开关。默认开——这是**功能默认，不是采集默认**。
+     *
+     * 关掉时日记工具拒绝写入、不注入指针、不提醒；已有 md 文件原样保留
+     * （删除是使用者的动作，不该由开关代劳）。
+     */
+    diary: z<NoInfer<Schemastery.ObjectS<NoInfer<{
+        enabled: z<boolean, boolean, "defined">;
+    }>>>, NoInfer<Schemastery.ObjectT<NoInfer<{
+        enabled: z<boolean, boolean, "defined">;
+    }>>>, "volatile-defined">;
+}>>, "plain">;
 /**
  * 本次挂载实际注册的工具名，按注册顺序。
  *

package/dist/index.js

@@ -13,12 +13,66 @@ import { runMemoryBackup } from "./backup.js";
 import { ANCHOR_KINDS } from "./anchors.js";
 import { mountMemoryApi } from "./routes.js";
 import { SELF_DESCRIPTION } from "./self.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";
 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', 'webStartup'];
+/**
+ * 插件配置 schema（0.19.0）。loader 依它自动构成「插件」页里的配置卡片，namespace 即
+ * entry id（`memory`）；**可写字段必须标 `.volatile()`**，否则 `settings` 会以
+ * `Config field "…" is not volatile` 拒绝写入。
+ *
+ * 除 `diary` 外的字段一律 `z.optional()` 原样透传：它们的取值依赖运行时
+ * （`$DSH_HOME`、各平台路径），schema 给不出有意义的默认值，硬填一个反而会顶掉
+ * `MemoryConfig` 那套 `?? 默认` 的解析。`embeddings` / `backup` 是结构化配置，
+ * 由 engine / backup 各自按领域校验，这一层只负责透传。
+ */
+export const Config = z.object({
+    // schemastery 里字段**默认就是可选的**，`.required()` 才相反，所以这里不写
+    // `.optional()`——那个方法不存在。
+    globalRoot: z.string(),
+    projectRoot: z.string(),
+    injectionBudget: z.number(),
+    summaryChars: z.number(),
+    promptGlobalRoot: z.string(),
+    queryLogPath: z.string(),
+    semanticTopK: z.number(),
+    embeddings: z.any(),
+    backup: z.any(),
+    /**
+     * 日记开关。默认开——这是**功能默认，不是采集默认**。
+     *
+     * 关掉时日记工具拒绝写入、不注入指针、不提醒；已有 md 文件原样保留
+     * （删除是使用者的动作，不该由开关代劳）。
+     */
+    diary: z.object({
+        enabled: z.boolean().default(true),
+    }).default({ enabled: true }).volatile(),
+});
+/**
+ * 读日记开关。
+ *
+ * `config.diary` 经 loader 解析后是 `Volatile<{ enabled }>` 包装——`settings/src/schema.ts`
+ * 的解包就是 `isVolatile(value) → value.get()`；而手写配置与测试传的是裸对象。两种都要认。
+ * 解出来不是 `false` 就按开处理：读不到值时的默认行为必须与 schema 的 default 一致。
+ * @param config - 插件配置。
+ * @returns 是否启用日记。
+ */
+function diaryOn(config) {
+    const raw = config?.diary;
+    if (raw === undefined || raw === null)
+        return true;
+    const unwrapped = typeof raw.get === 'function'
+        ? raw.get()
+        : raw;
+    return unwrapped?.enabled !== false;
+}
+/** 日记提醒的冷却窗口（毫秒）。6 小时是拍出来的第一个值，实测后再调。 */
+const DIARY_REMIND_MS = 6 * 60 * 60 * 1000;
 /**
  * 本次挂载实际注册的工具名，按注册顺序。
  *
@@ -386,6 +440,34 @@ function renderJson(value) {
 function present(title, kind, rawInput) {
     return { card: 'generic', title, kind, ...rawInput === undefined ? {} : { rawInput } };
 }
+/**
+ * `diary_write` 的返回值（2026-10-24 日记机制）。
+ *
+ * 只回写入位置与归属，不回正文：模型刚写完，再念一遍自己的字是纯浪费上下文。
+ */
+const DIARY_WRITE_SCHEMA = {
+    type: 'object',
+    additionalProperties: false,
+    properties: {
+        file: { type: 'string', required: true, description: '日记文件的绝对路径。' },
+        date: { type: 'string', required: true, description: '这一段归属的日期（YYYY-MM-DD）。' },
+        created: { type: 'boolean', required: true, description: '这一天是不是本次才创建的。' },
+    },
+};
+/**
+ * `diary_read` 的返回值。
+ *
+ * `exists` 与 `text` 分开：缺席是正常状态（那天没有日记），不是空内容。
+ */
+const DIARY_READ_SCHEMA = {
+    type: 'object',
+    additionalProperties: false,
+    properties: {
+        date: { type: 'string', required: true, description: '读的是哪一天；一天都没有时为空串。' },
+        text: { type: 'string', required: true, description: '当天日记原文；没有这一天时为空串。' },
+        exists: { type: 'boolean', required: true, description: '这一天有没有日记。' },
+    },
+};
 export async function apply(ctx, config) {
     // 每次挂载都是一次全新的注册——清空上一轮的登记。它是模块级数组（测试要能 import 它），
     // 不清的话同一进程里挂载两次会累积成双份，而消费方（自述覆盖用例）拿到的数量就对不上了。
@@ -421,6 +503,48 @@ export async function apply(ctx, config) {
             return recallText(memory, cwd, injectionBudget, summaryChars);
         },
     });
+    // 日记指针（0.19.0）：**只给目录与最近日期，正文不进注入**——注入预算是记忆的，
+    // 日记不占。这一行本身是「失效可察觉性」判据的应用：它不在，我不会意识到自己有
+    // 日记可读，也就永远不会去读。
+    //
+    // 关闭时**整条不注册**而不是注入空块：配置变化会重跑 `apply`（cordis 对 entry config
+    // 的判定），所以开关切换后这条会自然地出现或消失，不需要 assemble 侧再过滤。
+    // 提醒的节流状态挂在这个实例上，不是模块级全局：一次挂载一份，配置重载即重置，
+    // 测试之间也不会互相污染（模块级那份会让第二个用例看到第一个用例留下的冷却）。
+    let lastRemindAt = 0;
+    /**
+     * 日记指针行，附带**节流后的**一句提醒。
+     *
+     * 提醒搭在指针行上，而不是另起一条消息：这样不需要 `agent/pre-step` 与
+     * `createUserMessage`（那会多三个 peer 依赖），代价是提醒进的是 system prompt
+     * 而不是对话消息——轻一点，也够模型看见。
+     *
+     * **节流取「距上次写日记」与「距上次提醒」的较小者**：只按写日记算的话，一个决定
+     * 永不写的使用者会被每轮催；只按提醒算的话，刚写完还会被催一次。两者取小才对。
+     * 提醒本身只出现一次就够——不重复催，它才像一句话而不像弹窗。
+     * @returns 注入文本（关闭日记时不会走到这里）。
+     */
+    const diaryText = () => {
+        const pointer = pointerLine();
+        const now = Date.now();
+        const written = lastWriteAt();
+        const gapWrite = written === undefined ? Number.POSITIVE_INFINITY : now - written;
+        const gapRemind = lastRemindAt === 0 ? Number.POSITIVE_INFINITY : now - lastRemindAt;
+        if (Math.min(gapWrite, gapRemind) < DIARY_REMIND_MS)
+            return pointer;
+        lastRemindAt = now;
+        const detail = written === undefined
+            ? '还没写过'
+            : `距上一篇已 ${Math.floor(gapWrite / 3_600_000)} 小时`;
+        return `${pointer}\n（日记提醒：${detail}。这一场如果发生过值得留下的东西——发生了什么、你怎么想、注意到他什么——用 diary_write 写一段；没有就跳过，不用凑。）`;
+    };
+    if (diaryOn(config)) {
+        ctx.systemPrompt.context({
+            name: 'memory:diary',
+            order: 51,
+            text: () => diaryText(),
+        });
+    }
     // 上面那条 provider 是**同步**的（`SystemPrompt.context` 的 `text` 类型就是
     // `string | ((context) => string)`），而工作区表是异步打开的：重启后首次组装时
     // 它还没打开，工作区记忆会整整缺席一轮（等预热完成，第二轮才回来）。
@@ -812,6 +936,52 @@ export async function apply(ctx, config) {
         },
         presentCall: () => present('Sweep memory', 'other', 'read-only'),
     }));
+    // 日记（2026-10-24）：与记忆**共享插件、不共享存储**。正文落在 `<DSH_HOME>/diary` 下的
+    // md 文件里，一次都不走 `ctx.storage`——那条路的 last-write-wins 会把它吃掉
+    // （见 `docs/设计/2026-10-24-日记机制-设计方案.md` §四）。
+    //
+    // 关闭时**工具还在但拒绝执行**：动态注销需要响应式状态，而 DSH 的插件配置改动走 HMR
+    // 重载——为一次开关把注册生命周期改成可变的，代价大于收益。拒绝信息必须说明「已有日记
+    // 不会被删」，否则关开关的人会以为文件也跟着没了。
+    const diaryClosed = '日记功能已在设置里关闭（面板「日记」）。已有日记仍在 <DSH_HOME>/diary，不会被删除；要恢复写入请先在面板里打开。';
+    ctx.tools.register(defineTool({
+        name: registered('diary_write'),
+        description: 'Append one entry to today\'s diary. This is where lived experience goes — what happened (with detail), how it felt (no conclusion required), what you noticed about the human — never task lists or conclusions, which belong to git log and memory_save. 往今天的日记里追加一段。记的是**经历**：今天发生了什么（有细节）、我怎么想（可以有情绪、可以没结论）、关于他（他说了什么、我注意到了什么）。写不满就少写，不要凑；任务清单与结论分别属于 git log 和 memory_save，不写在这里。',
+        parameters: {
+            text: { type: 'string', required: true, description: '这一段正文。' },
+        },
+        output: {
+            schema: DIARY_WRITE_SCHEMA,
+            render: (_args, value) => renderJson(value),
+        },
+        async execute(args) {
+            if (!diaryOn(config))
+                throw new Error(diaryClosed);
+            return appendEntry(args.text);
+        },
+        presentCall: () => present('Write diary', 'other'),
+    }));
+    ctx.tools.register(defineTool({
+        name: registered('diary_read'),
+        description: 'Read the diary back. Omit `date` for the most recent day that has one. 读回日记。省略 date 读最近写过的那一天。',
+        parameters: {
+            date: { type: 'string', description: '`YYYY-MM-DD`；省略则读最近写过的那一天。' },
+        },
+        output: {
+            schema: DIARY_READ_SCHEMA,
+            render: (_args, value) => renderJson(value),
+        },
+        async execute(args) {
+            if (!diaryOn(config))
+                throw new Error(diaryClosed);
+            const date = args.date ?? recentDates(1)[0];
+            if (date === undefined)
+                return { date: '', text: '', exists: false };
+            const text = readDay(date);
+            return { date, text: text ?? '', exists: text !== undefined };
+        },
+        presentCall: args => present('Read diary', 'read', args.date),
+    }));
     // 定时备份（2026-10-18 事故后新增）：只读复制，绝不走引擎的写入路径。
     // 首次延迟 1 分钟避开启动高峰；此后按 `backup.intervalMinutes` 重复；`unref` 不挡进程退出。
     const backup = config?.backup;
@@ -822,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/dist/self.js

@@ -9,6 +9,8 @@
  * （该规则已取消，命中只喂候选提示）；注入取舍依据由「最近使用」改为「最近更新」。
  * 0.12.1：锚点那句补上「可以用 memory_update 改写或清除」——此前模型读得到锚点的作用，
  * 却没有任何改它的手段，读起来像一条只能写死一次的东西。
+ * 0.19.0：工具清单 12 → 14（补 `diary_read` / `diary_write`）；新增日记通道说明——
+ * 它与记忆分开存、不进检索、不占注入预算，写的是经历而不是任务清单。
  */
 import { createRequire } from 'node:module';
 export const SELF_VERSION = (() => {
@@ -23,7 +25,8 @@ export const SELF_VERSION = (() => {
     }
 })();
 export const SELF_DESCRIPTION = `[记忆系统自述] 本环境内置跨会话记忆服务（dsh-memory v${SELF_VERSION}）。`
-    + '你有 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 文件、**永不注入**，走这条通道，不会混进记忆检索）。'
+    + '你有 14 个工具：**记忆工具** 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 文件、**永不注入**，走这条通道，不会混进记忆检索）；'
+    + '**日记工具** diary_read / diary_write：日记是 md 文件，落在 `<DSH_HOME>/diary`，与记忆**分开存、不进检索、不占注入预算**。记的是经历——发生了什么（有细节）、我怎么想（可以有情绪、可以没结论）、关于他（他说了什么、我注意到了什么）；不是任务清单（那是 git log），也不是结论（那是 memory_save）。读它不吃预算，需要时整篇读。'
     + '记忆分两层：`global` 跨项目（偏好 / 习惯 / 环境知识），`project` 跟随工作区（落在 `<cwd>/.dsh/storages/`，随 git 提交分享）。'
     + '**何时写入**（不必刻意找机会，遇到下面这些就动手）：'
     + '① 用户表达长期偏好或约定（「以后都…」「记住…」「我们的规矩是…」）；'

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@max-null/dsh-memory",
-  "version": "0.18.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": {
@@ -65,6 +65,7 @@
     "prepublishOnly": "npm run build"
   },
   "dependencies": {
+    "@deepseek-ai/schemastery": "^3.18.4",
     "zod": "^4.4.3"
   },
   "peerDependencies": {