dsh-memory-github 0.2.0 → 0.4.0

package/CHANGELOG.md

@@ -1,5 +1,56 @@
 # 更新日志
 
+## 0.4.0 — 2026-10-25
+
+定位从「又一个跨会话记忆插件」改成「**多端共享记忆**」——本地记忆库的同类插件已有上百个，
+多设备共用一份记忆才是这个项目的差异点。
+
+### 新增
+
+- **`autoRecall` 自动召回（默认开）**：每轮从当前用户消息抽检索词（英文整词、中文双字滑窗），
+  给归档打分（标题 ×3 / 标签 ×2 / 正文 ×1），把最相关的几条直接注入系统提示。
+  不需要模型"想起来去 `memory_search`"——这是竞品最影响体感的能力，用纯词袋实现，
+  不发 LLM 请求、不引入数据库。
+  - `autoRecall: false` 关闭
+  - `autoRecallLimit: 5` 最多注入几条
+  - `autoRecallMinScore: 4` 分数门槛（调高更保守，避免无关记忆干扰）
+- 用户消息文本从 `user/message` 事件的 `content` 取（兼容字符串与 block 数组两种形态）。
+
+### 文档
+
+- README 重写开头：说明「为什么不跟本地库插件比功能」、适合与不适合的场景
+- 特性列表、配置示例补上 `autoRecall` 三项
+
+### 测试
+
+- 冒烟测试 63 → **68 条**（覆盖：命中相关归档、不注入无关归档、无相关时不硬塞、关闭开关）
+
+## 0.3.0 — 2026-10-25
+
+参考同类插件（dsh-prime-memory、meow-memory、@try-works/dsh-memory、@modusensus/dsh-mneme 等
+百余个生态作品）后补齐的「记忆全生命周期」能力。仍然零依赖、纯 Markdown + git。
+
+### 新增
+
+- **`memory_update`**：改已有归档的 title / tags / content，刷新 `updated` 并自动提交推送。
+- **`memory_forget`**：`archive`（移到 `notes/archive/`，可回滚）或 `delete`（直接删文件）。
+- **`memory_stats`**：条数、总大小、标签分布、核心记忆长度、后端信息、最近更新时间。
+- **`memory_history`**：GitHub 后端的提交历史，可追溯某条记忆何时被哪个工具写进来。
+- **`recentLimit`**：每轮在系统提示末尾注入最近 N 条归档的 id / 标题 / 标签（默认关）。
+  竞品普遍靠「自动召回」提升命中率；这个是最便宜的近似做法，不引入数据库。
+- **查重提示**：`memory_write` 写入前与已有归档做词袋 Jaccard 比较（≥45%），
+  命中就在返回里提示「考虑用 `memory_update`」，减少同一件事写两遍。可用 `dedupeHint: false` 关闭。
+
+### 改进
+
+- `findNote` 现在支持三种定位方式：id 精确 / id 前缀 / **标题** / id 含该 slug，
+  并且多处命中时明确列出候选，不再直接报"找不到"。
+- 只读模式（`role: child`）下新增的两个读工具 `memory_stats`、`memory_history` 也可用。
+
+### 测试
+
+- 冒烟测试从 42 条扩到 **63 条**（覆盖 update / forget / stats / history / recentLimit / 查重）。
+
 ## 0.2.0 — 2026-10-25
 
 ### 新增

package/README.md

@@ -3,22 +3,39 @@
 [![test](https://github.com/Administrator016/dsh-memory-github/actions/workflows/test.yml/badge.svg)](https://github.com/Administrator016/dsh-memory-github/actions/workflows/test.yml)
 [![license](https://img.shields.io/github/license/Administrator016/dsh-memory-github)](LICENSE)
 
-给 [DeepSeek Harness](https://github.com/deepseek-ai/deepseek-harness) 用的**跨会话记忆插件**。
+给 [DeepSeek Harness](https://github.com/deepseek-ai/deepseek-harness) 用的**多端共享记忆插件**。
 
-默认把记忆存在本地目录；想要换机器也能接着用，就把它接成一个 **GitHub 私有仓库**——
-插件会在每次写入后自动 commit + push，启动时自动 pull。
+生态里同类插件有上百个（`dsh-prime-memory`、`meow-memory`、`dsh-mnemonic`…），绝大多数是
+**本地库**：SQLite、向量索引、面板 UI，功能很强，但**只在那一台机器上**。
+这个插件的取舍相反——不引入数据库、不调 embedding，只用一个目录 + 一个 git 仓库，
+把「手机 / 电脑 / 移动硬盘」这些设备连成**同一份记忆**：
+
+- 一台机当**整理端**（`role: primary`）负责写和推
+- 其余机器当**子端**（`role: child`）只读，想留话就写 `inbox/`，整理端处理完归档
+- 换机器：`git clone` 或拷贝目录即恢复；连不联网都能用
 
 > 记忆分两层：**核心记忆**（`MEMORY.md`，每轮注入系统提示，硬上限可配）和**归档记忆**
-> （`notes/*.md` + `index.json`，按关键词检索）。模型自己决定什么时候写、写什么。
+> （`notes/*.md` + `index.json`，按关键词检索 + **自动召回**）。模型自己决定什么时候写、写什么。
 
 ## 特性
 
 - 🧠 **两段式记忆**：核心记忆常驻注入，归档记忆按需检索（`memory_search` / `memory_read`）
-- 💾 **默认本地**：一个目录就是记忆库（Markdown + JSON，随便备份、随便看）
-- ☁️ **可选 GitHub**：同一个目录套上 git，写入自动推送、启动自动拉取
-- 🔒 **只读模式**：`readOnly: true` 只注册读工具，适合"手机写入、电脑只读"这类多设备分工
+- 🎯 **自动召回**：每轮按你的消息自动挑几条相关归档注入（无需模型想起来去 search）
+- 🌐 **多端共享**：`primary` / `child` 角色分工，GitHub 做同步总线
+- 💾 **零依赖**：一个目录就是记忆库（Markdown + JSON），可读、可审计、可 `git diff`
+- ☁️ **可选 GitHub**：写入自动 commit + push，启动自动 pull，冲突自动 `rebase --abort`
+- 🔒 **只读模式**：`readOnly: true` 只注册读工具，适合"手机写入、电脑只读"这类分工
 - 🩹 **索引自愈**：`index.json` 丢了会从 `notes/` 重建，不会因为一个文件损坏就丢记忆
-- 🧪 **自带冒烟测试**：`node test/smoke.mjs`，30 条断言不依赖 DSH 运行时
+- 🧪 **自带测试**：`node test/smoke.mjs`（68 条断言）+ `test/git-backend.mjs`（12 条），不依赖 DSH 运行时
+
+## 什么时候适合用它
+
+✅ 你有多台设备（手机 + 电脑），想让它们记住同一批事
+✅ 你想知道 AI 到底记住了什么（纯 Markdown，直接打开看）
+✅ 记忆要能带走、能版本管理、能自己审查
+
+❌ 你要的是单机最强检索（那去用带 BM25 / 向量库的插件）
+❌ 你要的是聊天框里的记忆面板 UI（本项目没有客户端插件）
 
 ## 两种后端
 
@@ -29,6 +46,7 @@
 | 多设备 | 各存各的 | 共享一份，自动 pull / push |
 | 依赖 | 无 | `git` 可执行文件 |
 
+
 ## 安装
 
 **方式一：npm（推荐）**
@@ -81,6 +99,11 @@ dsh plugin --profile desktop add link:/path/to/dsh-memory-github
     pushOnTurnEnd: false      # 每轮结束若有未提交改动就推送
     remindEvery: 6            # 每 N 条用户消息没动记忆 → 注入提醒（0=关）
     staleMinutes: 0           # 距上次同步超过 N 分钟 → 提示先 pull（0=关）
+    autoRecall: true          # 按当前用户消息自动召回相关归档（默认开）
+    autoRecallLimit: 5        # 自动召回最多注入几条
+    autoRecallMinScore: 4     # 自动召回打分门槛，调高更保守
+    recentLimit: 0            # 额外注入最近 N 条归档标题（0=关）
+    dedupeHint: true          # 写入时提示与已有归档高度相似
     commitMessage: 'memory: {tool}'   # {tool} 会替换成触发的工具名
     gitBin: git               # git 可执行文件（不在 PATH 就写绝对路径）
     authorName: dsh-memory
@@ -113,13 +136,24 @@ dsh plugin --profile desktop add link:/path/to/dsh-memory-github
 
 | 工具 | 作用 |
 |---|---|
-| `memory_write` | 保存一条归档记忆（title / content / tags），立刻进索引 |
+| `memory_write` | 保存一条归档记忆（title / content / tags），立刻进索引；写入前会做**相似度查重** |
+| `memory_update` | 改已有归档的 title / tags / content，刷新 `updated` |
+| `memory_forget` | `archive`（移到 `notes/archive/` 可回滚）或 `delete` |
 | `memory_core` | 编辑 `MEMORY.md`：`append` / `replace` / `remove` 某个分节 |
 | `memory_search` | 按关键词检索（标题权重 6、标签 3、正文按出现次数），返回摘要 |
 | `memory_read` | 按 id 读全文，支持唯一前缀 |
 | `memory_list` | 列出归档（新→旧），可按标签过滤 |
+| `memory_stats` | 条数、总大小、标签分布、核心记忆长度、后端与最近更新 |
+| `memory_history` | 提交历史（GitHub 后端），追溯某条记忆是何时被哪个工具写进来的 |
 | `memory_sync` | `status` / `pull` / `push`，GitHub 后端专用 |
 
+**查重**：`memory_write` 会把新内容与已有归档做词袋相似度比较（Jaccard ≥ 45% 视为高度相似），
+命中时在返回里提示「考虑改用 `memory_update`」。关掉：`dedupeHint: false`。
+
+**最近归档注入**：`recentLimit: 5` 会在每轮系统提示末尾附上最近 5 条归档的 id/标题/标签，
+让模型"看得见目录"，召回率比纯靠 `memory_search` 高。默认关闭（`0`）。
+
+
 模型侧的使用约定由插件注入的系统提示承载：核心记忆里写"永远要记住的"，
 归档里写"以后可能用得上、但不用每轮都占上下文的"。
 

package/lib/index.js

@@ -12,7 +12,7 @@
  *   - readOnly=true 时只注册读工具，适合"手机写入、电脑只读"这类分工
  */
 import {
-  existsSync, mkdirSync, readFileSync, readdirSync, renameSync, statSync, writeFileSync,
+  existsSync, mkdirSync, readFileSync, readdirSync, renameSync, statSync, unlinkSync, writeFileSync,
 } from 'node:fs';
 import { join } from 'node:path';
 import { homedir } from 'node:os';
@@ -34,6 +34,11 @@ const DEFAULTS = {
   pushOnTurnEnd: false,    // 每轮结束时若有未提交改动就推送
   remindEvery: 6,          // 每 N 条用户消息、且期间没动过记忆 → 提醒（0=关）
   staleMinutes: 0,         // 距上次同步超过 N 分钟 → 提醒（0=关）
+  recentLimit: 0,          // 每轮额外注入最近 N 条归档的标题与标签（0=关）
+  autoRecall: true,        // 按当前用户消息自动召回相关归档并注入（不用模型主动 search）
+  autoRecallLimit: 5,      // 自动召回最多注入几条
+  autoRecallMinScore: 4,   // 自动召回打分门槛，越高越保守
+  dedupeHint: true,        // 写入时检查是否与已有归档高度相似
   commitMessage: 'memory: {tool}',
   gitBin: 'git',
   authorName: 'dsh-memory',
@@ -179,6 +184,148 @@ function saveIndex(p, notes) {
   return sorted;
 }
 
+/** 按 id（或唯一前缀）找到一条归档。 */
+function findNote(p, want) {
+  const id = String(want ?? '').replace(/\.md$/, '').trim();
+  if (!id) return { error: 'id 不能为空。' };
+  const notes = loadIndex(p);
+  const exact = notes.find((n) => n.id === id);
+  if (exact) return { note: exact, notes };
+
+  // 依次尝试：id 前缀 / 标题（忽略大小写）/ id 后缀（用户常只给 slug）
+  const byPrefix = notes.filter((n) => n.id.startsWith(id));
+  if (byPrefix.length === 1) return { note: byPrefix[0], notes };
+  const lower = id.toLowerCase();
+  const byTitle = notes.filter((n) => String(n.title ?? '').toLowerCase() === lower);
+  if (byTitle.length === 1) return { note: byTitle[0], notes };
+  const bySuffix = notes.filter((n) => n.id.includes(`-${id}`));
+  if (bySuffix.length === 1) return { note: bySuffix[0], notes };
+
+  const candidates = [...byPrefix, ...byTitle, ...bySuffix].filter((n, i, arr) => arr.findIndex((x) => x.id === n.id) === i);
+  if (candidates.length > 1) {
+    return {
+      error: `「${id}」匹配到 ${candidates.length} 条，请给更长前缀或完整 id：\n`
+        + candidates.map((n) => `- ${n.id}  ${n.title}`).join('\n'),
+    };
+  }
+  return { error: `没有找到 id 为「${id}」的记忆。` };
+}
+
+/** 词袋：用于相似度判断（标题 / 标签 / 正文前 600 字）。 */
+function tokenSet(text) {
+  const set = new Set();
+  for (const tok of String(text ?? '').toLowerCase().split(/[^\p{L}\p{N}]+/u)) {
+    if (tok && tok.length > 1) set.add(tok);
+  }
+  return set;
+}
+
+function jaccard(a, b) {
+  if (!a.size || !b.size) return 0;
+  let inter = 0;
+  for (const x of a) if (b.has(x)) inter += 1;
+  return inter / (a.size + b.size - inter);
+}
+
+/** 写入前查重：返回最多 3 条高相似（Jaccard ≥ 0.45）的归档。 */
+function similarNotes(p, title, content) {
+  const mine = tokenSet(`${title} ${String(content ?? '').slice(0, 600)}`);
+  const hits = [];
+  for (const n of loadIndex(p)) {
+    // 只比正文，不要把 frontmatter 里的 id/时间戳算进相似度，否则会把相似度稀释掉
+    const parsed = parseNoteFile(readTextSafe(join(p.notes, `${n.id}.md`), ''));
+    const body = parsed.content ?? '';
+    const theirs = tokenSet(`${n.title} ${(n.tags ?? []).join(' ')} ${body.slice(0, 600)}`);
+    const score = jaccard(mine, theirs);
+    if (score >= 0.45) hits.push({ id: n.id, title: n.title, score });
+  }
+  hits.sort((a, b) => b.score - a.score);
+  return hits.slice(0, 3);
+}
+
+/** 把归档移到 notes/archive/（保留内容，可回滚）。 */
+function archiveNoteFile(p, id) {
+  const dir = join(p.notes, 'archive');
+  mkdirSync(dir, { recursive: true });
+  const from = join(p.notes, `${id}.md`);
+  const to = join(dir, `${id}.md`);
+  renameSync(from, to);
+  return to;
+}
+
+/** 最近 N 条归档的标题清单，用于注入系统提示。 */
+function recentSection(p, limit) {
+  const n = Number(limit);
+  if (!Number.isFinite(n) || n <= 0) return '';
+  const notes = loadIndex(p).slice(0, Math.floor(n));
+  if (!notes.length) return '';
+  const lines = notes.map((x) => `- \`${x.id}\` ${x.title}${(x.tags ?? []).length ? '  #' + x.tags.join(' #') : ''}`);
+  return ['', `### 最近归档（${notes.length} 条，细节用 memory_search）`, ...lines].join('\n');
+}
+
+/**
+ * 从用户消息里抽检索词：英文/数字按整词，中文按双字滑窗（中文没有空格，整句当词反而匹配不上）。
+ */
+function recallTerms(text) {
+  const terms = new Set();
+  for (const w of String(text ?? '').toLowerCase().split(/[^\p{L}\p{N}]+/u)) {
+    if (!w) continue;
+    if (/^[a-z0-9]+$/.test(w)) {
+      if (w.length > 1) terms.add(w);
+    } else {
+      for (let i = 0; i < w.length - 1; i += 1) terms.add(w.slice(i, i + 2));
+    }
+  }
+  return [...terms].slice(0, 150);
+}
+
+/**
+ * 自动召回：拿当前用户消息的词去给归档打分，注入最相关的几条。
+ * 竞品的卖点就是"不用问它就记得"，这里用纯词袋实现，不发 LLM 请求、不需要数据库。
+ */
+function autoRecallSection(p, config, query) {
+  if (config.autoRecall === false) return '';
+  const limit = Number(config.autoRecallLimit);
+  if (!Number.isFinite(limit) || limit <= 0) return '';
+  const terms = recallTerms(query);
+  if (!terms.length) return '';
+  const minScore = Number.isFinite(Number(config.autoRecallMinScore)) ? Number(config.autoRecallMinScore) : 4;
+
+  const scored = [];
+  for (const n of loadIndex(p)) {
+    const parsed = parseNoteFile(readTextSafe(join(p.notes, `${n.id}.md`), ''));
+    const title = String(n.title ?? '').toLowerCase();
+    const tags = (n.tags ?? []).join(' ').toLowerCase();
+    const body = (parsed.content ?? '').toLowerCase();
+    let score = 0;
+    for (const t of terms) {
+      if (title.includes(t)) score += 3;
+      if (tags.includes(t)) score += 2;
+      if (body.includes(t)) score += 1;
+    }
+    if (score >= minScore) scored.push({ n, score });
+  }
+  if (!scored.length) return '';
+  scored.sort((a, b) => b.score - a.score);
+  const top = scored.slice(0, Math.floor(limit));
+  const lines = top.map(({ n }) => `- \`${n.id}\` ${n.title}${(n.tags ?? []).length ? '  #' + n.tags.join(' #') : ''}`);
+  return [
+    '',
+    `### 可能与当前任务相关的归档（自动召回 ${top.length} 条，细节用 memory_read / memory_search）`,
+    ...lines,
+  ].join('\n');
+}
+
+/** 把一条 user/message 事件的 content 取成纯文本。 */
+function messageText(data) {
+  const c = data?.content;
+  if (typeof c === 'string') return c;
+  if (Array.isArray(c)) {
+    return c.map((b) => (typeof b === 'string' ? b : (b?.text ?? ''))).join('\n');
+  }
+  return '';
+}
+
 // ---------------------------------------------------------------- core 记忆
 
 function coreLimit(config) {
@@ -446,7 +593,7 @@ export function apply(ctx, config0) {
   const readOnly = Boolean(config.readOnly) || config.role === 'child';
 
   // 提醒状态：消息计数 / 最近一次记忆活动 / 最近一次成功同步
-  const syncState = { count: 0, lastActivity: activityStamp(p), lastSyncAt: Date.now() };
+  const syncState = { count: 0, lastActivity: activityStamp(p), lastSyncAt: Date.now(), lastUserText: '' };
 
   const doPull = () => {
     const r = gitPull(p, config);
@@ -495,7 +642,9 @@ export function apply(ctx, config0) {
     name: 'dsh-memory-github:core',
     order: 60,
     text: () => {
-      const base = coreSection(readCore(p), coreLimit(config));
+      const base = coreSection(readCore(p), coreLimit(config))
+        + recentSection(p, config.recentLimit)
+        + autoRecallSection(p, config, syncState.lastUserText);
       const stamp = activityStamp(p);
       if (stamp > syncState.lastActivity) {
         // 记忆被写过（本进程写的，或别的进程/设备同步下来的），计数归零
@@ -528,6 +677,7 @@ export function apply(ctx, config0) {
       if (!event || typeof event.type !== 'string') return;
       if (event.type === 'user/message') {
         syncState.count += 1;
+        syncState.lastUserText = messageText(event.data);
       } else if (event.type === 'turn/end' && githubMode && config.pushOnTurnEnd && !readOnly) {
         enqueue(() => {
           try {
@@ -564,6 +714,9 @@ export function apply(ctx, config0) {
           ? args.tags.filter((t) => typeof t === 'string' && t.trim()).map((t) => t.trim())
           : [];
         try {
+          const dupes = config.dedupeHint === false
+            ? []
+            : similarNotes(p, title, content);
           return await enqueue(() => {
             ensureDirs(p);
             const notes = loadIndex(p);
@@ -576,7 +729,11 @@ export function apply(ctx, config0) {
             atomicWrite(join(p.notes, `${id}.md`), text);
             saveIndex(p, [meta, ...notes]);
             const sync = afterWrite('memory_write');
-            return `已保存 [${id}] ${title}${tags.length ? ' #' + tags.join(' #') : ''}。${sync}`;
+            const hint = dupes.length
+              ? '\n注意：和已有归档高度相似，考虑改用 memory_update：\n'
+                + dupes.map((d) => `- ${d.id}  ${d.title}（相似度 ${(d.score * 100).toFixed(0)}%）`).join('\n')
+              : '';
+            return `已保存 [${id}] ${title}${tags.length ? ' #' + tags.join(' #') : ''}。${sync}${hint}`;
           });
         } catch (e) {
           return errText(e);
@@ -699,6 +856,142 @@ export function apply(ctx, config0) {
         }
       },
     },
+    {
+      name: 'memory_update',
+      description: '修改一条已有归档记忆（title / tags / content 三选一或多选）。id 支持唯一前缀。修改后 updated 时间会刷新，GitHub 后端会自动提交推送。',
+      parameters: {
+        type: 'object',
+        additionalProperties: false,
+        properties: {
+          id: { type: 'string', description: '记忆 id，支持唯一前缀' },
+          title: { type: 'string', description: '新标题（可选）' },
+          content: { type: 'string', description: '新正文（可选，整体替换）' },
+          tags: { type: 'array', items: { type: 'string' }, description: '新标签列表（可选，整体替换）' },
+        },
+        required: ['id'],
+      },
+      output: outputText,
+      async execute(args) {
+        try {
+          return await enqueue(() => {
+            const found = findNote(p, args.id);
+            if (found.error) return found.error;
+            const note = found.note;
+            const file = join(p.notes, `${note.id}.md`);
+            const parsed = parseNoteFile(readTextSafe(file));
+            const oldContent = parsed.content ?? '';
+            const nextMeta = {
+              id: note.id,
+              title: typeof args.title === 'string' && args.title.trim() ? args.title.replace(/\s+/g, ' ').trim() : note.title,
+              tags: Array.isArray(args.tags)
+                ? args.tags.filter((t) => typeof t === 'string' && t.trim()).map((t) => t.trim())
+                : (note.tags ?? []),
+              created: note.created,
+              updated: new Date().toISOString(),
+            };
+            const nextContent = typeof args.content === 'string' ? args.content : oldContent;
+            if (!nextContent.trim()) return '更新失败：content 不能为空。';
+            const text = noteFileText(nextMeta, nextContent);
+            atomicWrite(file, text);
+            const notes = found.notes.map((n) => (n.id === note.id
+              ? { ...n, title: nextMeta.title, tags: nextMeta.tags, updated: nextMeta.updated, size: Buffer.byteLength(text) }
+              : n));
+            saveIndex(p, notes);
+            const sync = afterWrite('memory_update');
+            return `已更新 [${note.id}] ${nextMeta.title}。${sync}`;
+          });
+        } catch (e) {
+          return errText(e);
+        }
+      },
+    },
+    {
+      name: 'memory_forget',
+      description: '处理一条不再需要的归档记忆。mode=archive（默认）移到 notes/archive/ 保留可回滚；mode=delete 直接从 notes/ 删除文件。',
+      parameters: {
+        type: 'object',
+        additionalProperties: false,
+        properties: {
+          id: { type: 'string', description: '记忆 id，支持唯一前缀' },
+          mode: { type: 'string', enum: ['archive', 'delete'], description: '默认 archive' },
+        },
+        required: ['id'],
+      },
+      output: outputText,
+      async execute(args) {
+        try {
+          return await enqueue(() => {
+            const found = findNote(p, args.id);
+            if (found.error) return found.error;
+            const note = found.note;
+            const mode = args.mode === 'delete' ? 'delete' : 'archive';
+            const file = join(p.notes, `${note.id}.md`);
+            if (mode === 'delete') {
+              if (existsSync(file)) unlinkSync(file);
+            } else {
+              archiveNoteFile(p, note.id);
+            }
+            saveIndex(p, found.notes.filter((n) => n.id !== note.id));
+            const sync = afterWrite(`memory_forget:${mode}`);
+            return `已${mode === 'delete' ? '删除' : '归档'} [${note.id}] ${note.title}。${sync}`;
+          });
+        } catch (e) {
+          return errText(e);
+        }
+      },
+    },
+    {
+      name: 'memory_stats',
+      description: '记忆库概况：归档条数、总大小、标签分布、核心记忆长度、后端与最近更新时间。',
+      parameters: { type: 'object', additionalProperties: false, properties: {} },
+      output: outputText,
+      async execute() {
+        try {
+          const notes = loadIndex(p);
+          const tags = new Map();
+          let bytes = 0;
+          for (const n of notes) {
+            bytes += n.size ?? 0;
+            for (const t of n.tags ?? []) tags.set(t, (tags.get(t) ?? 0) + 1);
+          }
+          const core = readCore(p);
+          const lines = [
+            `目录：${p.dir}`,
+            `归档：${notes.length} 条，共 ${(bytes / 1024).toFixed(1)} KB`,
+            `核心记忆：${core.trim() ? `${core.length} 字符` : '空'}`,
+            `后端：${config.backend}${githubMode ? `（${config.remote || '未设 remote'} · ${config.branch}）` : ''}`,
+            `最近更新：${notes[0]?.updated ?? '—'}`,
+          ];
+          if (tags.size) {
+            lines.push(`标签：${[...tags.entries()].sort((a, b) => b[1] - a[1]).map(([t, c]) => `${t}(${c})`).join(' ')}`);
+          }
+          return lines.join('\n');
+        } catch (e) {
+          return errText(e);
+        }
+      },
+    },
+    {
+      name: 'memory_history',
+      description: '看记忆库的提交历史（仅 GitHub 后端）。返回最近若干次提交的 hash 与信息，用来追溯某条记忆是什么时候、被哪个工具写进来的。',
+      parameters: {
+        type: 'object',
+        additionalProperties: false,
+        properties: { limit: { type: 'integer', description: '条数，默认 10' } },
+      },
+      output: outputText,
+      async execute(args) {
+        if (!githubMode) return '当前是 local 后端，没有提交历史。';
+        try {
+          const n = Math.max(1, Math.min(Number(args.limit) || 10, 100));
+          const r = git(p, config, ['log', `-${n}`, '--pretty=format:%h  %ad  %s', '--date=short']);
+          if (r.status !== 0) return `读取历史失败：${(r.stderr || r.stdout || '').trim() || `exit ${r.status}`}`;
+          return (r.stdout || '').trim() || '还没有提交记录。';
+        } catch (e) {
+          return errText(e);
+        }
+      },
+    },
     {
       name: 'memory_sync',
       description: 'GitHub 后端专用：action=status 看仓库状态，pull 拉取远端，push 提交并推送本地改动。local 后端调用会提示未启用。',
@@ -744,7 +1037,7 @@ export function apply(ctx, config0) {
     },
   ];
 
-  const WRITE_TOOLS = new Set(['memory_write', 'memory_core']);
+  const WRITE_TOOLS = new Set(['memory_write', 'memory_core', 'memory_update', 'memory_forget']);
   const registered = [];
   for (const def of defs) {
     if (readOnly && WRITE_TOOLS.has(def.name)) continue;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "dsh-memory-github",
-  "version": "0.2.0",
+  "version": "0.4.0",
   "description": "Cross-session memory for DeepSeek Harness. Local memory store by default, optional GitHub-backed sync (git), with primary/child roles for multi-device setups.",
   "type": "module",
   "main": "lib/index.js",