sage-mem 0.9.2 → 0.9.3

package/README.md

@@ -156,7 +156,7 @@ SAGE_MEM_DIR=/path/to/your/memory
 - **`baseline: true` 的记忆每场会话第一步无条件注入**，最多 8 条——给「你是谁」「待办清单」这类每次开场都该在场的记忆用。多条 baseline 之间的先后由 `baselinePriority` 决定（数字越大越前，缺省 0），**不按文件名排**
 - 记忆目录读不到、权限错、frontmatter 格式坏，这些都**降级为不注入并写日志**，不会静默失效
 
-单文件上限 512 KB；标签最多 20 个、每个 40 字符（再多就不是标签，是一句话被塞进 `tags` 了）。
+单文件上限 512 KB（写入时校验）；标签最多 20 个、每个 40 字符（再多就不是标签，是一句话被塞进 `tags` 了）。
 
 ## 自动做梦（autodream）
 
@@ -261,7 +261,7 @@ sage-mem 只做三件事，全都在你本机：
 
 | 它做什么 | 具体范围 |
 |---|---|
-| **读记忆** | 只读 `SAGE_MEM_DIR`（默认 `~/.sage-mem/memory`）下的顶层 `*.md`，单文件上限 512 KB |
+| **读记忆** | 只读 `SAGE_MEM_DIR`（默认 `~/.sage-mem/memory`）下的顶层 `*.md`；单文件上限 512 KB 在**写入**时校验 |
 | **写记忆** | 经 agent 的文件工具或设置页写同一个目录；`MEMORY.md`、`session-log.md` 等保留名受保护，设置页碰不到 |
 | **注入** | 把选中的记忆作为上下文交给模型（最多 10 条相关 + 8 条 `baseline`，单场会话累计上限 60 KB） |
 

package/lib/autodream/engine.js

@@ -120,6 +120,7 @@ export class AutodreamEngine {
   async snapshot(id, kind = 'run') { return snapshotMod.snapshot.call(this, id, kind) }
   async pruneSnapshots() { return snapshotMod.pruneSnapshots.call(this) }
   async resolveSnapshotDir(id) { return snapshotMod.resolveSnapshotDir.call(this, id) }
+  async verifySnapshot(dir, opts) { return snapshotMod.verifySnapshot.call(this, dir, opts) }
   async listSnapshots() { return snapshotMod.listSnapshots.call(this) }
 
   // ── LLM 循环：实现在 lib/autodream/llm-loop.js ──

package/lib/autodream/rollback.js

@@ -9,9 +9,11 @@
 import { REPORT_DIR } from './config.js'
 import { readJson, safeName, snapshotEntries, stampCompact, stampHuman } from './util.js'
 import { restoreMemory } from '../memory/archive.js'
+import { nameKey } from '../memory/naming.js'
+import { stripArchiveMeta } from '../memory/scan.js'
 import { randomUUID } from 'node:crypto'
-import { copyFile, mkdir, readdir, rename, rm, stat, writeFile } from 'node:fs/promises'
-import { join } from 'node:path'
+import { copyFile, mkdir, readFile, readdir, rename, rm, stat, writeFile } from 'node:fs/promises'
+import { dirname, join } from 'node:path'
 
 /** 读回滚留痕（面板也许要显示「最近谁退回过」）。 */
 export async function listRollbacks(limit = 20) {
@@ -80,6 +82,26 @@ export async function rollback(opts = {}) {
       if (!runManifest) return { ok: false, error: `找不到回滚点 ${snapshotId} 对应的运行记录，只能选「整目录恢复」` }
     }
 
+    /**
+     * ①-a 校验回滚点内容。
+     *
+     * 顺序在保护快照**之前**：判据不成立时连快照都不该建 —— 拒绝要干净，不留任何副作用。
+     * 校验失败一律拒绝整趟，不做「只恢复没坏的那几个」的部分回滚：部分回滚会把记忆目录
+     * 变成「半新半旧」的第三种状态，比不回滚更难收拾，而记忆目录没有版本控制兜底。
+     */
+    const verdict = await this.verifySnapshot(snapDir, { legacy: dirname(snapDir) === this.legacySnapshotRoot })
+    if (!verdict.ok) {
+      this.log('warn', `回滚中止：${verdict.reason}`)
+      this.phase = ''
+      return {
+        ok: false,
+        error:
+          `${verdict.reason}。这份回滚点已不能代表「当时那一版」，拿它覆盖记忆目录风险太大，` +
+          '这次回滚已中止，记忆目录一个字没动。请换一份回滚点。',
+      }
+    }
+    if (verdict.schema === 'unhashed') this.log('warn', `回滚：${verdict.reason}`)
+
     // ① 保护快照
     this.phase = '回滚前保护快照'
     // 带随机后缀：秒级时间戳会撞（同一秒内连点两次回滚是真实用法），
@@ -118,27 +140,50 @@ export async function rollback(opts = {}) {
     // ② 恢复
     this.phase = '恢复文件'
     const snapNames = await snapshotEntries(snapDir)
-    const snapSet = new Set(snapNames)
-    const current = (await readdir(this.memoryDir, { withFileTypes: true }).catch(() => []))
-      .filter((e) => e.isFile() && e.name.toLowerCase().endsWith('.md'))
-      .map((e) => e.name)
+    /**
+     * 快照名录按**归一化名字**索引（`nameKey`：小写归一）。
+     *
+     * Windows / macOS 的文件名大小写不敏感，`a.md` 与 `A.md` 是同一个文件。旧写法用
+     * `new Set(snapNames)` 做大小写敏感的 `has()`：**快照之后只改了大小写的文件**，在整目录
+     * 回滚里会被判成「快照里没有」→ 先被写回、紧接着被 park 进 `archive/` → 活动记忆静默
+     * 消失，而回滚报 `ok:true`（实测复现过）。判据必须与文件系统同宽。
+     */
+    const snapByKey = new Map(snapNames.map((n) => [nameKey(n), n]))
+    /** 名字在当前文件系统上算不算「快照里已有」；返回快照里那一份的**真实文件名**。 */
+    const snapNameOf = (name) => snapByKey.get(nameKey(name)) ?? null
 
     const restored = []
     const parked = []
     const skipped = []
+    /** 说明（不是「跳过」也不是「移走」）：结果达到了，只是过程和常规路径不同，要写进报告。 */
+    const notes = []
     const archiveDir = join(this.memoryDir, 'archive')
     await mkdir(archiveDir, { recursive: true })
 
-    /** 移进 archive/（不删）。同名冲突就跳过并记账，绝不覆盖。 */
+    /**
+     * 移进 archive/（不删）。同名时**换一个退役名**落进去，绝不覆盖，也绝不放弃。
+     *
+     * 旧写法撞名就 `skipped` 走人，代价是：同一趟 `create → archive → create` 的文件，
+     * 归档区已经被本趟占着，回滚要让它从顶层退场时撞名 → 直接放弃 → 那条运行前根本
+     * 不存在的记忆继续活在顶层。目标状态是「顶层没有它」，撞名只是「原件名被占了」
+     * ——换个名字照样达到目标，且仍然一个文件都没删。
+     */
     const park = async (name, why) => {
       const target = join(archiveDir, name)
       const clash = await stat(target).catch(() => null)
-      if (clash) {
-        skipped.push(`${name}（本想${why}，但 archive/ 里已有同名文件）`)
+      if (!clash) {
+        await rename(join(this.memoryDir, name), target)
+        parked.push(`${name}（${why}）`)
+        return true
+      }
+      const retired = `${name.replace(/\.md$/i, '')}.retired-${stamp}-${randomUUID().replace(/-/g, '').slice(0, 6)}.md`
+      try {
+        await rename(join(this.memoryDir, name), join(archiveDir, retired))
+      } catch (err) {
+        skipped.push(`${name}（本想${why}，archive/ 已有同名、退役名也写不进去：${err?.message ?? err}）`)
         return false
       }
-      await rename(join(this.memoryDir, name), target)
-      parked.push(`${name}（${why}）`)
+      parked.push(`${name} → ${retired}（${why}；archive/ 已有同名，改用退役名，未删除）`)
       return true
     }
 
@@ -152,69 +197,93 @@ export async function rollback(opts = {}) {
         }
       }
       // 快照之后新建的文件：整目录回滚要让它退场，但不能删——移进 archive/。
+      // `current` 只在这条分支用得上，扫一遍目录就够了（文件级回滚按 ledger 逐个 stat）。
+      const current = (await readdir(this.memoryDir, { withFileTypes: true }).catch(() => []))
+        .filter((e) => e.isFile() && e.name.toLowerCase().endsWith('.md'))
+        .map((e) => e.name)
       for (const name of current) {
-        if (!snapSet.has(name)) await park(name, '快照里没有，整目录回滚需退场')
+        if (!snapNameOf(name)) await park(name, '快照里没有，整目录回滚需退场')
       }
     } else {
-      for (const c of runManifest.changes ?? []) {
-        const name = c.file
-        if (c.op === 'update') {
-          if (snapSet.has(name)) {
-            try {
-              await copyFile(join(snapDir, name), join(this.memoryDir, name))
-              restored.push(name)
-            } catch (err) {
-              skipped.push(`${name}（写回失败：${err?.message ?? err}）`)
-            }
-          } else {
-            skipped.push(`${name}（回滚点里没有这一版，可能已被别的整理改过）`)
-          }
-        } else if (c.op === 'create') {
-          if (current.includes(name)) await park(name, '本次整理新建，回滚即退场')
-        } else if (c.op === 'archive') {
-          // 归档 = 从顶层移进 archive/；回滚就是把它移回来。
-          const src = join(archiveDir, name)
-          const exists = await stat(src).catch(() => null)
-          const atTop = await stat(join(this.memoryDir, name)).catch(() => null)
-          if (!exists) skipped.push(`${name}（archive/ 里找不到，可能已人工处理过）`)
-          else if (atTop) skipped.push(`${name}（顶层已有同名文件，不覆盖）`)
-          else {
-            await rename(src, join(this.memoryDir, name))
-            restored.push(name)
-          }
-        }
-      }
-
       /**
-       * 策略自动归档也要退回来 —— 它按设计**不写进 `changes`**。
+       * 文件级回滚**按文件聚合**，不按 `changes` 的条目顺序逐条执行。
        *
-       * `engine.js` 把两本账分开了：模型改的进 `changes`，确定性归档策略移走的进
-       * `archive.archived`（已落盘在运行记录 `manifest.json` 里）。只遍历 `changes`
-       * 就会整段漏掉，而这趟运行照样被标成「已回滚」、面板照报「恢复 0 个文件…已回滚」——
-       * 用户以为退回来了，文件其实还躺在 `archive/` 里。
+       * 同一趟里模型完全可能先 `write_memory` 新建、再 `archive_memory` 归档同一个文件。
+       * 逐条执行时 create 那条把它 park 进 `archive/`、archive 那条又把它 `rename` 回顶层 ——
+       * 回滚反而**激活**了一条运行前根本不存在的记忆，而面板照报「已回滚」。
        *
-       * 恢复走 `memory/archive.js` 的共享实现（与手动恢复、模型工具同一份）：它会顺手
-       * 去掉 `archived_at` / `archived_reason` 两行留痕，否则「恢复」回来的是一份带着
-       * 「我已被归档」标记的活记忆。
+       * 判据只有一个：**这个文件在运行前快照里存在吗**。
+       *   存在   → 目标是「顶层有一份运行前的版本」：内容从快照取；若已被归档，从 `archive/`
+       *            洗掉留痕搬回来（走 `memory/archive.js` 的共享实现，与手动恢复同一份）
+       *   不存在 → 目标是「顶层没有它」：在顶层就 park 进 `archive/`；已经在 `archive/` 里
+       *            就留在那儿 —— 「不删」不等于「重新激活」
        *
-       * ⚠️ 只恢复**运行前快照里存在**的文件：策略候选是运行末尾扫出来的，理论上可能包含
-       * 这趟新造的文件，把它搬回来等于凭空激活一条运行前不存在的记忆（Q06 的形态）。
+       * 两本账（模型的 `changes` + 确定性策略的 `archive.archived`）在这里**合流成一个文件清单**：
+       * 策略归档按设计不写进 `changes`，只遍历 `changes` 会整段漏掉；而同一个文件在两本账里
+       * 各出现一次时，逐条执行会互相打架。按文件聚合把这两个问题一起消掉。
        */
+      const ledger = new Set()
+      for (const c of runManifest.changes ?? []) {
+        if (typeof c?.file === 'string' && c.file) ledger.add(c.file)
+      }
       for (const a of runManifest.archive?.archived ?? []) {
-        if (!a?.ok || !a.file) continue
-        const name = a.file
-        if (restored.includes(name)) continue // 上面 `changes` 那段已经把它放回来了
-        if (!snapSet.has(name)) {
-          skipped.push(`${name}（运行前快照里没有，说明是这趟新造的，回滚不激活它）`)
+        if (a?.ok && a.file) ledger.add(a.file)
+      }
+
+      for (const name of ledger) {
+        const atTop = await stat(join(this.memoryDir, name)).catch(() => null)
+        /** 快照里那一份的真实文件名（大小写可能不同），null = 运行前不存在。 */
+        const snapName = snapNameOf(name)
+        if (!snapName) {
+          // 运行前不存在：目标状态是「顶层没有它」。
+          if (atTop) await park(name, '本次整理新建，回滚即退场')
+          // 已被这趟归档进 archive/ 的：留在档案馆，不搬回来。
+          continue
+        }
+        // 运行前存在：目标状态是「顶层是运行前那一版」。
+        if (atTop) {
+          try {
+            await copyFile(join(snapDir, snapName), join(this.memoryDir, name))
+            restored.push(name)
+          } catch (err) {
+            skipped.push(`${name}（写回失败：${err?.message ?? err}）`)
+          }
           continue
         }
-        if (await stat(join(this.memoryDir, name)).catch(() => null)) {
-          skipped.push(`${name}（顶层已有同名文件，不覆盖）`)
+        if (!(await stat(join(archiveDir, name)).catch(() => null))) {
+          skipped.push(`${name}（顶层与 archive/ 里都找不到，可能已人工处理过）`)
           continue
         }
-        const res = await restoreMemory(this.memoryDir, name)
-        if (res.ok) restored.push(name)
-        else skipped.push(`${name}（恢复失败：${res.error}）`)
+        /**
+         * archive/ 里那份**必须是运行前那一版**，才谈得上「移回来」。
+         *
+         * 一个真实的反例：顶层已不在、而 `archive/` 里躺着一份**更早的另一版**时，
+         * 旧写法直接 `restoreMemory()` 把它搬回顶层并报 `restored: 1` —— 出来的既不是
+         * 运行前那一版，档案馆那份还被吃掉了。`snapshot.js` 那句「回滚后是不是真回到了
+         * 那一版」得在这里落地：
+         *   - 洗掉留痕后与快照**逐字节相同** → 就是它，走 `restoreMemory`（顺手洗留痕）
+         *   - 不同 → 它是别的东西：从**快照**复制到顶层，`archive/` 那份原样留着（不删不动）
+         */
+        const snapContent = await readFile(join(snapDir, snapName)).catch(() => null)
+        const archContent = await readFile(join(archiveDir, name), 'utf8').catch(() => null)
+        if (snapContent && archContent !== null && stripArchiveMeta(archContent) === snapContent.toString('utf8')) {
+          const res = await restoreMemory(this.memoryDir, name)
+          if (res.ok) restored.push(name)
+          else skipped.push(`${name}（恢复失败：${res.error}）`)
+        } else if (snapContent) {
+          try {
+            await copyFile(join(snapDir, snapName), join(this.memoryDir, name))
+            restored.push(name)
+            // ⚠️ 记进 notes 而**不是** skipped：文件确实恢复了（restored 里算一个），
+            // 只是没走「从 archive/ 移回」那条常规路径。计进 skipped 会让面板说
+            // 「跳过 1 个」，读者以为它没回来。
+            notes.push(`${name}：archive/ 里那份不是运行前那一版，已改用快照版本写回；archive/ 那份原样保留`)
+          } catch (err) {
+            skipped.push(`${name}（写回失败：${err?.message ?? err}）`)
+          }
+        } else {
+          skipped.push(`${name}（快照里没有这一版，无法恢复）`)
+        }
       }
     }
 
@@ -240,6 +309,9 @@ export async function rollback(opts = {}) {
     if (skipped.length) {
       lines.push('## 跳过', '', ...skipped.map((f) => `- ${f}`), '')
     }
+    if (notes.length) {
+      lines.push('## 说明', '', ...notes.map((n) => `- ${n}`), '')
+    }
     const reportDir = join(this.memoryDir, REPORT_DIR)
     await mkdir(reportDir, { recursive: true })
     await writeFile(join(reportDir, reportName), lines.join('\n'), 'utf8')

package/lib/autodream/settings.js

@@ -8,7 +8,8 @@
 
 import { CONFIG_VERSION, DEFAULT_CONFIG, LEGACY_STATE_FILE } from './config.js'
 import { clampNum, readJson } from './util.js'
-import { mkdir, rename, rm, writeFile } from 'node:fs/promises'
+import { writeFileAtomic } from '../memory/util.js'
+import { mkdir } from 'node:fs/promises'
 
 /**
  * 读配置 + 状态（同一个文件）。缺失或损坏都回落到默认值，绝不让它拖死插件加载。
@@ -50,14 +51,10 @@ export async function load() {
 /** 落盘。写入是原子的（临时文件 + rename），半截文件不会留在盘上。 */
 export async function persist() {
   await mkdir(this.stateRoot, { recursive: true })
-  const tmp = `${this.configPath}.${process.pid}.tmp`
-  try {
-    await writeFile(tmp, JSON.stringify(this.state, null, 2), 'utf8')
-    await rename(tmp, this.configPath)
-  } finally {
-    // rename 成功后 tmp 已不存在（ENOENT），失败时清掉不留垃圾。
-    await rm(tmp, { force: true }).catch(() => {})
-  }
+  // 这里曾经是**第二份** tmp+rename 实现，而且临时名同样固定成 `${configPath}.${pid}.tmp`：
+  // 只修 `memory/util.js` 那份的话，同一个缺陷会原样留在这里（实测 20 次并发配置落盘
+  // 18 次 ENOENT）。两份实现合一，以后只有一处要维护。
+  await writeFileAtomic(this.configPath, JSON.stringify(this.state, null, 2))
 }
 
 /** 给 UI 的完整配置（含有效模型路线与门控快照）。 */

package/lib/autodream/snapshot.js

@@ -10,7 +10,7 @@ import { DEFAULT_CONFIG, PRE_ROLLBACK_KEEP } from './config.js'
 import { readJson, safeName, snapshotEntries, stampHuman } from './util.js'
 import { createHash } from 'node:crypto'
 import { mkdir, readFile, readdir, rm, stat, writeFile } from 'node:fs/promises'
-import { join } from 'node:path'
+import { join, basename } from 'node:path'
 
 /**
  * 把 memory 目录顶层的 markdown 整体快照一份，作为**回滚点**。
@@ -117,6 +117,137 @@ export async function resolveSnapshotDir(id) {
   return null
 }
 
+/**
+ * 校验一份回滚点：内容有没有被外部动过。
+ *
+ * 回滚是**把快照复制回记忆目录**——记忆目录没有版本控制也没有回收站，所以「拿一份假的
+ * 回滚点去覆盖现在」等于一次性销毁当前全部记忆。而快照落盘后一直躺在磁盘上：备份工具
+ * 还原错版本、手工编辑、杀软改写、半截写入，都会让 MANIFEST 里的哈希与实际内容对不上。
+ * 校验失败必须**拒绝整趟回滚**，一个字都不许写。
+ *
+ * 三个方向都要查，缺一个就漏一种攻击面：
+ *   - `missing`  清单里记了、盘上却没有 → 整目录回滚会把它当成「快照里没有」→ 停进 archive/
+ *   - `tampered` 内容与 sha256 不符     → 会把被改过的内容当「原始版本」写回去
+ *   - `extra`    盘上有、清单没记       → 整目录回滚会把它复制进记忆目录（凭空多出一条记忆）
+ *
+ * ⚠️ 已知边界：MANIFEST 与内容同源，**改了内容又顺手改哈希**骗得过这里（没有签名）。
+ * 它防的是「无意的损坏与还原错版本」，不是有意的伪造。
+ *
+ * @returns {Promise<{ok:boolean, schema:'hashed'|'unhashed', checked:number,
+ *   missing:string[], tampered:string[], extra:string[], invalid:string[], reason:string}>}
+ */
+export async function verifySnapshot(dir, opts = {}) {
+  const legacy = opts?.legacy === true
+  /** 无哈希可比（旧版回滚点）：放行，但要说清「这次没法校验」。 */
+  const unhashed = (reason) => ({
+    ok: true,
+    schema: 'unhashed',
+    checked: 0,
+    missing: [],
+    tampered: [],
+    extra: [],
+    invalid: [],
+    reason,
+  })
+  /** 清单本身坏了：**拒绝**。坏掉的清单与「旧版格式」在数据上不可区分，只能从严。 */
+  const broken = (reason) => ({
+    ok: false,
+    schema: 'broken',
+    checked: 0,
+    missing: [],
+    tampered: [],
+    extra: [],
+    invalid: [],
+    reason,
+  })
+
+  /**
+   * ⚠️ 这里**不能**用 `readJson` 那种「读不出来就回 null」的写法。
+   *
+   * 一条真实的绕过：删掉 `MANIFEST.json`（或把它弄成半截 JSON）→ 旧写法一律当成
+   * 「旧版快照没有哈希」放行 → 被篡改的快照内容照样写进记忆目录，**整套校验等于没有**。
+   * 一个文件的删除就能拆掉安全带的修法不叫修法。
+   *
+   * 判据因此收紧成：新版目录（`snapshots/`）里的回滚点**必须**有一份能解析、且带逐文件
+   * 哈希清单的 `MANIFEST.json`；只有旧版目录（`snapshots-legacy/` 一类）才允许没有哈希 ——
+   * 那是历史遗留，废掉它等于把老回滚点全部作废。
+   */
+  let rawManifest
+  try {
+    rawManifest = await readFile(join(dir, 'MANIFEST.json'), 'utf8')
+  } catch (err) {
+    if (err?.code === 'ENOENT' && legacy) {
+      return unhashed('这是一份旧版回滚点（目录里没有 MANIFEST.json），内容无法校验')
+    }
+    return broken(
+      err?.code === 'ENOENT'
+        ? '这份回滚点里没有 MANIFEST.json（新版回滚点必然带它）—— 无法校验内容'
+        : `读不了 MANIFEST.json（${err?.message ?? err}）—— 无法校验内容`,
+    )
+  }
+  let manifest
+  try {
+    manifest = JSON.parse(rawManifest)
+  } catch (err) {
+    return broken(`MANIFEST.json 解析失败（${err?.message ?? err}）—— 无法校验内容`)
+  }
+  const recorded = Array.isArray(manifest?.files) ? manifest.files : null
+  if (!recorded) {
+    if (legacy) return unhashed('这是一份旧版回滚点（MANIFEST 里没有逐文件哈希），内容无法校验')
+    return broken('MANIFEST.json 里没有逐文件哈希清单（files 不是数组）—— 无法校验内容')
+  }
+
+  const missing = []
+  const tampered = []
+  const invalid = []
+  let checked = 0
+  for (const f of recorded) {
+    const name = typeof f?.name === 'string' ? f.name : ''
+    /**
+     * 名字闸门只管一件事：**不许带路径成分**（`..\x.md`、`sub/x.md`、`C:\…` 一律判坏），
+     * 否则 `join(dir, name)` 会指到快照目录外面去。
+     *
+     * 这里**不**复用 autodream 的 `safeName` —— 那套比记忆层（`memory/naming.js`）严，
+     * 而 `snapshot()` 是照着 readdir 的原名记清单的：一份含 `笔记.md` / `a..b.md` 的
+     * 快照会被判成「有非法文件名」而**整份滚不回去**（实测）。
+     * 合法字符集由记忆层定义，这里只做边界防护。
+     */
+    if (!name || name !== basename(name) || name === '.' || name === '..') {
+      invalid.push(name || '(空名字)')
+      continue
+    }
+    let buf
+    try {
+      buf = await readFile(join(dir, name))
+    } catch {
+      missing.push(name)
+      continue
+    }
+    const sha = createHash('sha256').update(buf).digest('hex')
+    if (!f.sha256 || sha !== f.sha256) tampered.push(name)
+    else checked += 1
+  }
+  const known = new Set(recorded.map((f) => f?.name))
+  const extra = (await snapshotEntries(dir)).filter((n) => !known.has(n))
+
+  const ok = !missing.length && !tampered.length && !extra.length && !invalid.length
+  const parts = []
+  if (missing.length) parts.push(`缺 ${missing.length} 个文件（${missing.slice(0, 3).join('、')}）`)
+  if (tampered.length) parts.push(`${tampered.length} 个文件内容与哈希不符（${tampered.slice(0, 3).join('、')}）`)
+  if (extra.length) parts.push(`多出 ${extra.length} 个未记录的文件（${extra.slice(0, 3).join('、')}）`)
+  if (invalid.length) parts.push(`清单里有 ${invalid.length} 个非法文件名`)
+  return {
+    ok,
+    schema: 'hashed',
+    checked,
+    missing,
+    tampered,
+    extra,
+    invalid,
+    reason: ok ? '' : `快照内容校验不通过：${parts.join('；')}`,
+  }
+}
+
 /**
  * 列出所有回滚点（新版 + 旧版目录都列）。
  *

package/lib/autodream/util.js

@@ -36,7 +36,10 @@ export function newRunId(ms) {
 /** 文件名/目录名的白名单校验（快照 id、运行 id、报告名都走这里，别让路径穿越进来）。 */
 export function safeName(raw) {
   const s = String(raw ?? '').trim()
-  if (!s || s.includes('/') || s.includes('\\') || s.includes('..')) return null
+  // `.` 单独放行过：它通过 `[\w.-]+` 且不含 `..`，于是 `snapshotId: '.'` 会被解析成
+  // **快照根目录本身**（`resolveSnapshotDir` 一试就中）—— 一份「拿整个根当回滚点」的请求
+  // 虽然后面会被 MANIFEST 校验拦住，但它根本不该走到那一步。
+  if (s === '.' || !s || s.includes('/') || s.includes('\\') || s.includes('..')) return null
   if (!/^[\w.-]+$/.test(s)) return null
   return s
 }

package/lib/autodream-tools.js

@@ -24,11 +24,12 @@
  * `write_memory` 的 frontmatter 规范都沿用 sage-mem 的既有约定，不另造一套。
  */
 
-import { readFile, readdir, writeFile, stat } from 'node:fs/promises'
+import { readFile, readdir, stat } from 'node:fs/promises'
 import { join, basename } from 'node:path'
 import { createHash } from 'node:crypto'
 import { auditMemoryDir, formatAudit, parseFrontmatterLite } from './autodream-audit.js'
 import { archiveMemory } from './memory/archive.js'
+import { writeFileAtomic } from './memory/util.js'
 
 /** 单次 read_memory 返回的正文上限（字符）。超过就截断并明确告诉模型。 */
 const READ_LIMIT = 20000
@@ -441,7 +442,10 @@ export function createToolRunner(opts) {
             const reason = typeof a.reason === 'string' ? a.reason.trim() : ''
             const selfReported = reason.length >= MIN_REASON_CHARS
             const before = await fileFingerprint(full)
-            await writeFile(full, a.content, 'utf8')
+            // 原子写：这是**唯一**会把模型生成的内容写进记忆目录的路径。
+            // 直写若崩在中途，留下的是半截 frontmatter —— 文件还在、列表还列得出，
+            // 但解析不出类型与标题，检索与星图同时哑掉。
+            await writeFileAtomic(full, a.content)
             const after = await fileFingerprint(full)
             if (!selfReported) {
               // **不拒绝。** 一次改写缺了缘由，拒掉的代价是这条修正彻底丢失——而它可能

package/lib/memory/util.js

@@ -17,21 +17,51 @@ export function warnLog(ctx, msg, sessionId) {
   else console.warn(line)
 }
 
+/**
+ * 进程内的临时文件序号：`writeFileAtomic` 的临时名必须**每次调用都不同**。
+ *
+ * 旧写法是固定的 `${target}.${process.pid}.tmp` —— 同一进程里两个调用同时写同一个目标
+ * （访问台账 flush 与面板写就真实地会抢），会共用同一个临时文件：先写的 rename 成功、
+ * 后写的 rename 拿到 ENOENT，而失败那方的 `finally` 还会把**别人正在用的**临时文件删掉。
+ * 实测 20 次并发只有 4 次成功 —— 另外 16 次全栽在共享的那个临时文件上。
+ *
+ * 序号 + 随机后缀 + pid 一起用：单进程内不会撞，多进程也不会撞。
+ */
+let tmpSeq = 0
+
+/** rename 的瞬时失败码：Windows 上目标正被另一个 rename 覆盖时会短暂 EPERM/EBUSY。 */
+const RENAME_RETRY_CODES = new Set(['EPERM', 'EACCES', 'EBUSY', 'EEXIST'])
+
+/** 带退避重试的 rename —— 并发写同一目标时，瞬时占用不该被当成失败。 */
+async function renameWithRetry(from, to, attempts = 8) {
+  for (let i = 1; ; i++) {
+    try {
+      return await rename(from, to)
+    } catch (err) {
+      if (i >= attempts || !RENAME_RETRY_CODES.has(err?.code)) throw err
+      await new Promise((r) => setTimeout(r, 4 * i))
+    }
+  }
+}
+
 /**
  * 原子写：先写同目录临时文件，再 rename 覆盖目标。
  *
  * 直写的风险是崩在中途（断电、进程被杀、磁盘满）留下半截文件 —— frontmatter
  * 缺半边，这条记忆从此解析不出来、检索不到，而文件看上去还在。
  * 同卷 rename 是原子的：读方要么看到旧全文、要么看到新全文，不存在中间态。
- * 任何一步失败都不碰目标文件，临时文件收尾清掉。
+ * 任何一步失败都不碰目标文件，**自己那份**临时文件收尾清掉。
  */
 export async function writeFileAtomic(target, content) {
-  const tmp = `${target}.${process.pid}.tmp`
+  tmpSeq += 1
+  const uniq = `${process.pid}-${Date.now().toString(36)}-${tmpSeq.toString(36)}-${Math.random().toString(36).slice(2, 8)}`
+  const tmp = `${target}.${uniq}.tmp`
   try {
     await writeFile(tmp, content, 'utf8')
-    await rename(tmp, target)
+    await renameWithRetry(tmp, target)
   } finally {
     // rename 成功后 tmp 已不存在（ENOENT），失败时把它清掉不留垃圾。
+    // 临时名每次唯一，所以这里删的只可能是自己那份。
     await unlink(tmp).catch(() => {})
   }
 }

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "sage-mem",
   "description": "File-based memory plugin for DeepSeek Harness (DSH) — cross-session memory in plain markdown files, with a memory star-map view, type/tag filtering, retrieval aliases, and an optional autodream pass that consolidates memories on demand or on a schedule — with per-run rollback points, a per-file change declaration (what changed and why), and a separately selectable model for the consolidation pass",
-  "version": "0.9.2",
+  "version": "0.9.3",
   "type": "module",
   "main": "lib/index.js",
   "exports": {
@@ -15,11 +15,6 @@
     "cordis.patch.yml",
     "NOTICE"
   ],
-  "scripts": {
-    "test": "node test/run.mjs",
-    "build:client": "node scripts/build-client.mjs",
-    "images": "node scripts/make-readme-images.mjs"
-  },
   "license": "Apache-2.0",
   "engines": {
     "node": ">=18",
@@ -90,5 +85,10 @@
     "ai-agent",
     "agent",
     "claude-code"
-  ]
-}
+  ],
+  "scripts": {
+    "test": "node test/run.mjs",
+    "build:client": "node scripts/build-client.mjs",
+    "images": "node scripts/make-readme-images.mjs"
+  }
+}