sage-mem 0.9.2 → 0.9.4

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 ──
@@ -237,6 +238,7 @@ export class AutodreamEngine {
         sessionsRoot: this.sessionsRoot,
         apply: !!cfg.apply,
         withSessions,
+        ctx: this.ctx,
       })
       const toolSchemas = autodreamToolSchemas({ apply: !!cfg.apply, withSessions })
 

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-audit.js

@@ -23,6 +23,8 @@
 
 import { readdir, readFile } from 'node:fs/promises'
 import { join } from 'node:path'
+import { inspectMemoryEntry } from './memory/scan.js'
+import { warnLog } from './memory/util.js'
 
 /** 索引文件名。它本身不是一条记忆，是索引。 */
 const INDEX_FILE = 'MEMORY.md'
@@ -98,7 +100,23 @@ async function readDirSnapshot(dir) {
   const all = entries
     .filter((e) => e.isFile() && e.name.toLowerCase().endsWith('.md'))
     .map((e) => e.name)
-  const files = all.filter((f) => !AUDIT_SKIP_FILES.has(f.toLowerCase()))
+  const files = []
+  for (const f of all) {
+    if (AUDIT_SKIP_FILES.has(f.toLowerCase())) continue
+    /**
+     * 与「列表 / 注入 / 模型工具」同一条闸门。
+     *
+     * 审计原先自己扫目录、不过闸门，于是同一个目录会给出互相矛盾的两个数：
+     * 列表说 1 条（链接 / 超大的被跳过），体检说 3 条 —— 用户根本不知道该信哪个。
+     * 被跳过的条目在这里同样不计入 fileCount，原因落到日志。
+     */
+    const gate = await inspectMemoryEntry(join(dir, f))
+    if (!gate.ok) {
+      warnLog(null, `audit: skip ${f}: ${gate.error}`)
+      continue
+    }
+    files.push(f)
+  }
   let indexText = ''
   try {
     indexText = await readFile(join(dir, INDEX_FILE), 'utf8')

package/lib/autodream-tools.js

@@ -24,11 +24,13 @@
  * `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, warnLog } from './memory/util.js'
+import { inspectMemoryEntry, reservedIdentitySet } from './memory/scan.js'
 
 /** 单次 read_memory 返回的正文上限（字符）。超过就截断并明确告诉模型。 */
 const READ_LIMIT = 20000
@@ -102,7 +104,7 @@ function ageDays(ms) {
  * @param {string} memoryDir
  * @returns {Promise<Array<object>>}
  */
-async function scanEntries(memoryDir) {
+async function scanEntries(memoryDir, ctx) {
   let entries
   try {
     entries = await readdir(memoryDir, { withFileTypes: true })
@@ -110,14 +112,25 @@ async function scanEntries(memoryDir) {
     if (err?.code === 'ENOENT') return []
     throw err
   }
+  const reservedIds = await reservedIdentitySet(memoryDir)
   const names = entries
     .filter((e) => e.isFile() && e.name.toLowerCase().endsWith('.md') && !NON_ENTRY_FILES.has(e.name.toLowerCase()))
     .map((e) => e.name)
   const out = []
   for (const name of names) {
     const full = join(memoryDir, name)
+    // 与注入 / 面板同一条闸门：模型看到的清单不该包含「住在别处」的文件。
+    const gate = await inspectMemoryEntry(full)
+    if (!gate.ok) {
+      warnLog(ctx, `autodream: skip ${name}: ${gate.error}`)
+      continue
+    }
+    if (gate.id && reservedIds.has(gate.id)) {
+      warnLog(ctx, `autodream: skip ${name}: 这是某个保留名的另一个名字`)
+      continue
+    }
     try {
-      const [content, info] = await Promise.all([readFile(full, 'utf8'), stat(full)])
+      const content = await readFile(full, 'utf8')
       const meta = parseFrontmatterLite(content)
       const body = content.replace(/^---\r?\n[\s\S]*?\r?\n---/, '')
       const h1 = body.match(/^#\s+(.+)$/m)
@@ -125,8 +138,8 @@ async function scanEntries(memoryDir) {
         file: name,
         // 索引不是一条记忆：标出来，否则模型会看到「MEMORY.md · reference」而困惑。
         type: name.toLowerCase() === INDEX_FILE ? '索引' : meta.type || 'reference',
-        bytes: info.size,
-        mtimeMs: info.mtimeMs,
+        bytes: gate.size,
+        mtimeMs: gate.mtimeMs,
         title: (h1 ? h1[1] : meta.name || '').trim(),
         description: meta.description || '',
       })
@@ -326,7 +339,7 @@ const MIN_REASON_CHARS = 4
  * @returns {{run:(name:string, args:object)=>Promise<string>, touchedFiles:()=>string[], changes:()=>object[], warnings:()=>string[]}}
  */
 export function createToolRunner(opts) {
-  const { memoryDir, sessionsRoot, apply, withSessions } = opts
+  const { memoryDir, sessionsRoot, apply, withSessions, ctx } = opts
   let listCache = null
   let auditCache = null
   const touched = []
@@ -395,7 +408,7 @@ export function createToolRunner(opts) {
       try {
         switch (name) {
           case 'list_memory': {
-            if (!listCache) listCache = await scanEntries(memoryDir)
+            if (!listCache) listCache = await scanEntries(memoryDir, ctx)
             const lines = listCache.map(
               (e) =>
                 `- ${e.file} · ${e.type} · ${Math.round(e.bytes / 1024)}KB · ${ageDays(e.mtimeMs)}天前 · ${localStamp(e.mtimeMs)}\n    ${(e.title || '(无标题)').slice(0, 60)}${e.description ? ' — ' + e.description.slice(0, LIST_DESC_CHARS) : ''}`,
@@ -407,6 +420,17 @@ export function createToolRunner(opts) {
             if (!validated) return `错误：文件名不合法（只能是 memory 目录顶层的 .md 文件名）：${String(a.file)}`
             // 统一落到磁盘上的真实名字：NTFS 大小写不敏感，`A.md` 与 `a.md` 是同一个文件。
             const full = join(memoryDir, await resolveRealName(memoryDir, basename(validated)))
+            /**
+             * 过闸门再读：**名字在记忆目录里不等于内容住在记忆目录里**。
+             * 注入与面板两条腿都挡住了，这条腿（模型工具）也必须挡 ——
+             * 否则外部文件的内容照样会被读进来、送进模型上下文。
+             */
+            const gate = await inspectMemoryEntry(full)
+            if (!gate.ok) {
+              return gate.code === 'missing'
+                ? `错误：没有这个文件：${basename(full)}`
+                : `错误：拒绝读取 ${basename(full)}：${gate.error}`
+            }
             const content = await readFile(full, 'utf8').catch((err) => {
               if (err?.code === 'ENOENT') return null
               throw err
@@ -441,7 +465,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/index.js

@@ -22,12 +22,12 @@ import { MAX_BASELINE, MAX_CHARS_PER_FILE, MAX_FILE_BYTES, MAX_RESULTS, MAX_SESS
 import { parseAliases, parseBaseline, parseBaselinePriority, parseFrontmatter, parseTags } from './memory/frontmatter.js'
 import { isReserved, nameKey, safeName } from './memory/naming.js'
 import { ageDays, bigrams, extractText, score, selectBaseline, selectRelevant } from './memory/retrieval.js'
-import { MEMORY_ARCHIVE_DIR, addArchiveMeta, extractTitle, readArchivedMeta, scanArchived, scanMemoryFiles, scanStars } from './memory/scan.js'
+import { MEMORY_ARCHIVE_DIR, addArchiveMeta, extractTitle, inspectDir, inspectMemoryEntry, readArchivedMeta, scanArchived, scanMemoryFiles, scanStars, shadowsReserved } from './memory/scan.js'
 import { archiveMemory, restoreMemory } from './memory/archive.js'
 import { flushAccess, pickArchiveCandidates, readAccessLedger, recordAccess } from './memory/access.js'
 import { warnLog, writeFileAtomic } from './memory/util.js'
 import { Remote, TypertRemoteService } from '@deepseek-ai/dsh-typert-protocol'
-import { mkdir, readFile, stat, unlink, writeFile } from 'node:fs/promises'
+import { mkdir, readFile, unlink, writeFile } from 'node:fs/promises'
 import { basename, join } from 'node:path'
 
 /**
@@ -121,6 +121,9 @@ async function readReservedFile() {
 function rawName(raw) {
   const s = typeof raw === 'string' ? raw : ''
   if (!s || basename(s) !== s) return null
+  // `:` 是 NTFS 交替数据流的分隔符：`MEMORY.md:evil.md` 能过扩展名判据，落盘却是写到
+  // 索引的隐藏流上（`readdir` 看不见）。与 `safeName` 同一条理由，这里也要拒。
+  if (s.includes(':')) return null
   return /\.md$/i.test(s) ? s : null
 }
 
@@ -389,11 +392,24 @@ export class MemoryGateway extends TypertRemoteService {
     })
   }
 
-  /** 读单个记忆文件全文。 */
+  /**
+   * 读单个记忆文件全文。
+   *
+   * 过闸门再读：名字在记忆目录里**不等于**内容住在记忆目录里 —— 符号链接 / 目录联接 /
+   * 硬链接都能让一次「读自己的记忆」变成读别人的文件，而读到的内容会被注入模型上下文。
+   */
   async readFile(name) {
     const safe = safeName(name)
     if (!safe) throw new Error('sage-mem: invalid file name')
-    const content = await readFile(join(MEMORY_DIR, safe), 'utf8')
+    const full = join(MEMORY_DIR, safe)
+    // 名字不是保留名 ≠ 文件不是保留名：8.3 短名（`MEMORY~1.MD`）文本上与索引毫无关系，
+    // 却是同一个文件。别把索引当普通记忆交出去。
+    if (await shadowsReserved(full)) {
+      throw new Error(`sage-mem: refusing to read ${safe}: 这是某个保留名（索引 / 流水）的另一个名字`)
+    }
+    const gate = await inspectMemoryEntry(full)
+    if (!gate.ok) throw new Error(`sage-mem: refusing to read ${safe}: ${gate.error}`)
+    const content = await readFile(full, 'utf8')
     return { name: safe, content }
   }
 
@@ -412,6 +428,12 @@ export class MemoryGateway extends TypertRemoteService {
     }
     const safe = safeName(name)
     if (!safe) throw new Error('sage-mem: invalid file name')
+    // 名字文本不是保留名 **不等于** 文件不是保留名：NTFS 的 8.3 短名（`MEMORY~1.MD`）
+    // 在文本上跟索引毫无关系，inode 却是同一个 —— 实测它能改写索引。
+    // 保留名保护必须落在**文件身份**上，否则「保留名不可写」这句承诺是假的。
+    if (await shadowsReserved(join(MEMORY_DIR, safe))) {
+      return { ok: false, file: safe, error: `sage-mem: reserved file (它的另一个名字是 ${safe})，请用文件工具改` }
+    }
     // 不加这一层，传个对象进来会被 String() 写成 "[object Object]" 还回 { ok: true }，
     // 原文件就此被一行垃圾顶掉，且没有任何错误信号。
     if (typeof content !== 'string') {
@@ -421,7 +443,19 @@ export class MemoryGateway extends TypertRemoteService {
     if (bytes > MAX_FILE_BYTES) {
       return { ok: false, file: safe, error: `sage-mem: content too large (${bytes} bytes > ${MAX_FILE_BYTES})` }
     }
-    await writeFileAtomic(join(MEMORY_DIR, safe), content)
+    /**
+     * 目标已存在时也要过闸门：链接 / 硬链接一律拒绝。
+     *
+     * 原子写本身不会写穿链接（rename 换掉的是链接本身），但那样「改这条记忆」就变成了
+     * 「把这个名字指向别处」—— 用户以为改的是记忆，实际磁盘上多了一个指向外部的名字。
+     * `limitBytes = 0` 表示不在这里判体积（上面刚按字符数查过）。
+     */
+    const target = join(MEMORY_DIR, safe)
+    const existing = await inspectMemoryEntry(target, { limitBytes: null })
+    if (!existing.ok && existing.code !== 'missing') {
+      return { ok: false, file: safe, error: `sage-mem: refusing to write ${safe}: ${existing.error}` }
+    }
+    await writeFileAtomic(target, content)
     return { ok: true, file: safe }
   }
 
@@ -432,6 +466,10 @@ export class MemoryGateway extends TypertRemoteService {
     }
     const safe = safeName(name)
     if (!safe) throw new Error('sage-mem: invalid file name')
+    // 同 writeFile：8.3 短名能绕过名字文本判据，删除保护也必须看文件身份。
+    if (await shadowsReserved(join(MEMORY_DIR, safe))) {
+      return { ok: false, error: `sage-mem: reserved file (它的另一个名字是 ${safe})，拒绝删除` }
+    }
     await unlink(join(MEMORY_DIR, safe))
     return { ok: true }
   }
@@ -497,11 +535,19 @@ export class MemoryGateway extends TypertRemoteService {
   async readArchived(name) {
     const safe = safeName(name)
     if (!safe) throw new Error('sage-mem: invalid file name')
+    // 归档区本身先过目录闸门：它若是指向别处的联接，读归档就等于读外部的文件。
+    const dirGate = await inspectDir(MEMORY_ARCHIVE_DIR)
+    if (!dirGate.ok) throw new Error(`sage-mem: archive dir unavailable: ${dirGate.error}`)
     const full = join(MEMORY_ARCHIVE_DIR, safe)
-    const info = await stat(full).catch(() => null)
+    const gate = await inspectMemoryEntry(full)
     // 找不到就抛：与 readFile 一致。静默返回空串会让面板显示一个「空的记忆」，
     // 而用户改完一存 —— 就把一条真实内容顶掉了。
-    if (!info?.isFile()) throw new Error(`sage-mem: archived file not found: ${safe}`)
+    if (!gate.ok) {
+      // ⚠️「形状不对」与「不存在」是两回事：把联接 / 超限都报成「文件不存在」，
+      // 会让用户去找一个明明躺在盘上的文件。
+      if (gate.code === 'missing') throw new Error(`sage-mem: archived file not found: ${safe}`)
+      throw new Error(`sage-mem: refusing to read archived ${safe}: ${gate.error}`)
+    }
     const content = await readFile(full, 'utf8')
     return { name: safe, content }
   }
@@ -520,10 +566,21 @@ export class MemoryGateway extends TypertRemoteService {
     }
     const safe = safeName(name)
     if (!safe) throw new Error('sage-mem: invalid file name')
+    const dirGate = await inspectDir(MEMORY_ARCHIVE_DIR)
+    if (!dirGate.ok) return { ok: false, file: safe, error: `sage-mem: archive dir unavailable: ${dirGate.error}` }
     const full = join(MEMORY_ARCHIVE_DIR, safe)
-    const info = await stat(full).catch(() => null)
+    const gate = await inspectMemoryEntry(full, { limitBytes: null })
     // 只改归档区里**已经存在**的文件：这条 remote 不是「把任意文件写进归档区」的后门。
-    if (!info?.isFile()) return { ok: false, file: safe, error: `sage-mem: archived file not found: ${safe}` }
+    if (!gate.ok) {
+      return {
+        ok: false,
+        file: safe,
+        error:
+          gate.code === 'missing'
+            ? `sage-mem: archived file not found: ${safe}`
+            : `sage-mem: refusing to write archived ${safe}: ${gate.error}`,
+      }
+    }
     if (typeof content !== 'string') {
       return { ok: false, file: safe, error: `sage-mem: content must be a string, got ${typeof content}` }
     }
@@ -669,9 +726,15 @@ export class MemoryGateway extends TypertRemoteService {
     }
     const safe = rawName(name)
     if (!safe) return { ok: false, error: `sage-mem: invalid file name: ${String(name)}` }
+    // 保留名同样过闸门：链接 / 硬链接一样能把「读索引 / 读流水」变成读外部文件。
+    // ⚠️ 体积**不**在这里判（`limitBytes = 0`）：流水天然比单条记忆大得多，
+    // 它有自己的上限（`MAX_RAW_BYTES`，见上面的注释）。
+    const full = join(MEMORY_DIR, safe)
+    const gate = await inspectMemoryEntry(full, { limitBytes: null })
+    if (!gate.ok) throw new Error(`sage-mem: refusing to read ${safe}: ${gate.error}`)
     // 读不到就抛（与 readFile 一致）：静默返回空串会让面板显示一份「空的索引」，
     // 用户一存就把真索引顶掉。
-    const content = await readFile(join(MEMORY_DIR, safe), 'utf8')
+    const content = await readFile(full, 'utf8')
     return { name: safe, content }
   }
 
@@ -699,7 +762,14 @@ export class MemoryGateway extends TypertRemoteService {
         error: `sage-mem: content too large (${bytes} bytes > ${MAX_RAW_BYTES / (1024 * 1024)} MB raw limit)`,
       }
     }
-    await writeFileAtomic(join(MEMORY_DIR, safe), content)
+    const target = join(MEMORY_DIR, safe)
+    // 与 `writeFile` 同一条理由：目标已存在时若是链接 / 硬链接，一律拒绝 ——
+    // 「改这份索引」不该变成「把这个名字指向别处」。体积由上面那道 `MAX_RAW_BYTES` 管。
+    const existing = await inspectMemoryEntry(target, { limitBytes: null })
+    if (!existing.ok && existing.code !== 'missing') {
+      return { ok: false, file: safe, error: `sage-mem: refusing to write ${safe}: ${existing.error}` }
+    }
+    await writeFileAtomic(target, content)
     return { ok: true, file: safe }
   }
 }

package/lib/memory/archive.js

@@ -15,7 +15,7 @@
  * 就是临时目录），拿模块级常量会写错地方 —— 那是会碰到真实记忆的危险错误。
  */
 
-import { ARCHIVE_DIR_NAME, addArchiveMeta, localStamp, stripArchiveMeta } from './scan.js'
+import { ARCHIVE_DIR_NAME, addArchiveMeta, inspectDir, inspectMemoryEntry, localStamp, stripArchiveMeta } from './scan.js'
 import { isReserved, nameKey, safeName } from './naming.js'
 import { writeFileAtomic } from './util.js'
 import { mkdir, readFile, stat, unlink } from 'node:fs/promises'
@@ -49,9 +49,26 @@ export async function archiveMemory(memoryDir, name, reason, at = localStamp())
   const safe = gate.safe
   const src = join(memoryDir, safe)
   const dst = join(archiveDirOf(memoryDir), safe)
-  const info = await stat(src).catch(() => null)
+  /**
+   * 两道闸门，缺一不可：
+   *   - 源文件：链接 / 硬链接指向的可能是记忆目录**之外**的文件，归档它 = 把它从外部搬走
+   *   - 归档区：它若被换成指向外部的目录联接，归档 = 把记忆搬出记忆目录
+   * （体积不在这里判：归档是搬移，不是写入。）
+   */
+  const srcGate = await inspectMemoryEntry(src, { limitBytes: null })
   // 根目录里没有 → 文件名写错，或者它已经是归档态（归档区那份不该再归档一次）。
-  if (!info?.isFile()) return { ok: false, code: 'not-found', error: `sage-mem: file not found: ${safe}` }
+  if (!srcGate.ok) {
+    return {
+      ok: false,
+      code: srcGate.code === 'missing' ? 'not-found' : srcGate.code,
+      error: `sage-mem: file not found: ${safe}（${srcGate.error}）`,
+    }
+  }
+  const dirGate = await inspectDir(archiveDirOf(memoryDir))
+  // 归档区还不存在是正常状态（下面 mkdir 会建）。
+  if (!dirGate.ok && dirGate.code !== 'missing') {
+    return { ok: false, code: dirGate.code, error: `sage-mem: archive dir unavailable: ${dirGate.error}` }
+  }
   if (await stat(dst).catch(() => null)) {
     // 归档区已有同名：不覆盖 —— 那份旧归档可能是用户想留的另一版。
     return { ok: false, code: 'exists', error: `sage-mem: already archived: ${safe}` }
@@ -79,11 +96,25 @@ export async function restoreMemory(memoryDir, name) {
   const safe = gate.safe
   const dst = join(memoryDir, safe)
   const src = join(archiveDirOf(memoryDir), safe)
-  const info = await stat(src).catch(() => null)
-  if (!info?.isFile()) return { ok: false, code: 'not-archived', error: `sage-mem: not archived: ${safe}` }
-  if (await stat(dst).catch(() => null)) {
+  // 归档区过目录闸门：联接指向外部时，「恢复」会把外部的文件搬进记忆目录。
+  const dirGate = await inspectDir(archiveDirOf(memoryDir))
+  if (!dirGate.ok) {
+    return {
+      ok: false,
+      code: dirGate.code === 'missing' ? 'not-archived' : dirGate.code,
+      error: `sage-mem: not archived: ${safe}（${dirGate.error}）`,
+    }
+  }
+  const srcGate = await inspectMemoryEntry(src, { limitBytes: null })
+  if (!srcGate.ok) return { ok: false, code: 'not-archived', error: `sage-mem: not archived: ${safe}（${srcGate.error}）` }
+  // 顶层已有同名（且不是链接）时拒绝：根目录那份是正在用的记忆，归档这份只是退役版。
+  const dstGate = await inspectMemoryEntry(dst, { limitBytes: null })
+  if (dstGate.ok) {
     return { ok: false, code: 'target-exists', error: `sage-mem: already exists, refusing to overwrite: ${safe}` }
   }
+  if (dstGate.code !== 'missing') {
+    return { ok: false, code: dstGate.code, error: `sage-mem: refusing to restore over ${safe}: ${dstGate.error}` }
+  }
   const content = await readFile(src, 'utf8')
   await writeFileAtomic(dst, stripArchiveMeta(content))
   await unlink(src)

package/lib/memory/naming.js

@@ -48,6 +48,11 @@ export function safeName(raw) {
   // basename 与原文不一致＝含目录成分。旧版是「悄悄取 basename 继续」，
   // 与 starmap 那套（要求 safe === raw）行为不一致；现在统一为拒绝。
   if (basename(raw) !== raw) return null
+  // `:` 在 NTFS 上是**交替数据流**的分隔符：`MEMORY.md:evil.md` 以 `.md` 结尾、能过下面
+  // 所有判据，落盘时却会写到索引的隐藏数据流上（`readdir` 看不见，只写流不报错）。
+  // 实测更糟：`writeFile('MEMORY.md:evil.md')` 会在 `rename` 处抛**未捕获**的 EINVAL ——
+  // 违背「拒绝一律返回 {ok:false}、不抛」这条契约。正常文件名不允许 `:`，直接拒。
+  if (raw.includes(':')) return null
   if (!/\.md$/i.test(raw)) return null
   if (isNonEntry(raw)) return null
   return raw

package/lib/memory/scan.js

@@ -10,11 +10,11 @@
  * 文件可能被手工搬来搬去，随文件走的元数据才不会与文件脱节。
  */
 
-import { MEMORY_DIR } from './config.js'
+import { MAX_FILE_BYTES, MEMORY_DIR, RESERVED_FILES } from './config.js'
 import { parseBaseline, parseFrontmatter } from './frontmatter.js'
 import { isMemoryEntry } from './naming.js'
 import { warnLog } from './util.js'
-import { readFile, readdir, stat } from 'node:fs/promises'
+import { lstat, readFile, readdir } from 'node:fs/promises'
 import { join } from 'node:path'
 
 /** 归档区目录名。与 autodream 工具里的 ARCHIVE_DIR 同名同义（同一个目录）。 */
@@ -112,18 +112,160 @@ export function addArchiveMeta(content, reason, at) {
   return stripped.slice(0, m.index) + block.join(eol) + stripped.slice(m.index + m[0].length)
 }
 
+/**
+ * 记忆文件形状闸门：只认「普通文件、体积在给定上限内」的 `.md`。
+ *
+ * 为什么要闸门：记忆目录里的一条 `x.md` **不一定真的住在记忆目录里** ——
+ * **符号链接 / 目录联接**把名字留在记忆目录、把内容指到任意路径：读它就是读别人的文件，
+ * 写它就是改别人的文件，而这些内容会被注入模型上下文。
+ * 用 `lstat` 而不是 `stat`：`stat` 会跟随链接，永远看不出这一层。
+ *
+ * ⚠️ 本机实测：Windows 上 `symlink()`（文件或目录）要特权、默认 EPERM，但
+ * `symlink(dir, 'junction')` **能建** —— 所以这不是理论风险。
+ *
+ * **硬链接（`nlink > 1`）不拦，只提示**（返回值里的 `links`，由调用方负责出声）。
+ * 取舍理由：硬链接**不提供**「指向任意路径」的能力（不能跨卷，只能由已在同卷上有权限的人建），
+ * 它带来的是「内容可能被记忆目录之外改到」—— 这是完整性提示，不是越界读取。
+ * 而拦它的代价是**真实误伤**：`cp -al` / `rsync --link-dest` 这类快照备份会让源文件的
+ * `nlink` 变成 2，于是整条记忆从注入与面板里静默消失（实测复现过）。
+ * 宁可提示、不可丢记忆 —— 与「大小写判定宁可多留」同一条原则。
+ *
+ * 体积上限也在这里：它原先只写在**写入**路径上，读路径谁来都全量读进内存，
+ * 等于上限只在「自己人写」的前提下成立（一条被手工粘进来的日志就能把整轮注入吃光）。
+ *
+ * @param {string} full — 绝对路径
+ * @param {{limitBytes?: number|null}} [opts] — `limitBytes: null` = **不判体积**（归档区用）；
+ *   不传则用 `MAX_FILE_BYTES`。⚠️ 显式 `null` 与「随便传个 0 / NaN」是两回事：
+ *   非有限数一律按「超过上限」处理，不会静默把闸门关掉。
+ * @returns {Promise<{ok:true,size:number,mtimeMs:number,links:number}|{ok:false,code:string,error:string}>}
+ */
+export async function inspectMemoryEntry(full, opts = {}) {
+  const limitBytes = opts?.limitBytes === undefined ? MAX_FILE_BYTES : opts.limitBytes
+  let info
+  try {
+    info = await lstat(full)
+  } catch (err) {
+    return {
+      ok: false,
+      code: err?.code === 'ENOENT' ? 'missing' : 'stat-failed',
+      error: `读不到文件属性（${err?.code ?? err}）`,
+    }
+  }
+  if (info.isSymbolicLink()) return { ok: false, code: 'symlink', error: '是指向别处的符号链接 / 目录联接' }
+  if (!info.isFile()) return { ok: false, code: 'not-file', error: '不是普通文件' }
+  // null = 明确「不判体积」；其余一律按数值上限处理（0 / NaN / 字符串都会被当成超限）。
+  if (limitBytes !== null && (!Number.isFinite(limitBytes) || info.size > limitBytes)) {
+    return {
+      ok: false,
+      code: 'too-big',
+      error: Number.isFinite(limitBytes)
+        ? `体积 ${info.size} 字节，超过单文件上限 ${limitBytes} 字节`
+        : `体积 ${info.size} 字节，上限参数不合法（${String(limitBytes)}）`,
+    }
+  }
+  return { ok: true, size: info.size, mtimeMs: info.mtimeMs, links: info.nlink, id: identityOf(info) }
+}
+
+/** 文件身份键（`dev:ino`）。拿不到 inode 的平台返回 null（那就退回名字文本判据）。 */
+export function identityOf(info) {
+  return info && info.ino ? `${info.dev}:${info.ino}` : null
+}
+
+/**
+ * 保留名在磁盘上的**文件身份**集合（`dev:ino`）。
+ *
+ * 为什么需要它：保留名保护原先只比**名字文本**（`nameKey` 归一 + 小写）。但 NTFS 上一个
+ * 文件可以有第二个 8.3 短名 —— `MEMORY~1.MD` 与 `MEMORY.md` 文本上毫无关系，判据却必须
+ * 认出它们是**同一个文件**：实测在能建短名的卷上，`writeFile('MEMORY~1.MD')` 能改写索引、
+ * `deleteFile('MEMORY~2.MD')` 能把它删掉，而 `isReserved()` 一路放行。
+ *
+ * 返回集合在每次调用时现取（保留名就那两三个，一次目录写入的开销可忽略）。
+ */
+export async function reservedIdentitySet(dir = MEMORY_DIR) {
+  const ids = new Set()
+  for (const name of RESERVED_FILES) {
+    const info = await lstat(join(dir, name)).catch(() => null)
+    const id = identityOf(info)
+    if (id) ids.add(id)
+  }
+  return ids
+}
+
+/** 这个名字在磁盘上是不是某个保留名的另一个名字（8.3 短名 / 硬链接）。 */
+export async function shadowsReserved(full, dir = MEMORY_DIR) {
+  const ids = await reservedIdentitySet(dir)
+  if (!ids.size) return false
+  const info = await lstat(full).catch(() => null)
+  const id = identityOf(info)
+  return id !== null && ids.has(id)
+}
+
+/**
+ * 子目录闸门：`archive/` 这类**插件自己管理的目录**必须是真目录，不能是指向别处的联接。
+ *
+ * ⚠️ 只对 `archive/` 这类子目录用，**不**对记忆目录本身用：把 `SAGE_MEM_DIR` 指向一个
+ * 链接目录（例如网盘同步目录）是正当用法，拦掉它属于误伤。而 `archive/` 是归档动作的
+ * 落地处 —— 它若是联接，归档就等于把记忆搬出记忆目录，恢复则可能把外部文件搬进来。
+ *
+ * @returns {Promise<{ok:true}|{ok:false,code:string,error:string}>}
+ */
+export async function inspectDir(dir) {
+  let info
+  try {
+    info = await lstat(dir)
+  } catch (err) {
+    return {
+      ok: false,
+      code: err?.code === 'ENOENT' ? 'missing' : 'stat-failed',
+      error: `读不到目录属性（${err?.code ?? err}）`,
+    }
+  }
+  if (info.isSymbolicLink()) return { ok: false, code: 'symlink', error: '是指向别处的符号链接 / 目录联接' }
+  if (!info.isDirectory()) return { ok: false, code: 'not-dir', error: '不是目录' }
+  return { ok: true }
+}
+
 /** 扫 memory 目录，读回全部记忆文件（跳过索引与子目录），并解析 frontmatter 摘要。 */
 export async function scanMemoryFiles(ctx, sessionId) {
   try {
     const entries = await readdir(MEMORY_DIR, { withFileTypes: true })
+    /** 保留名的文件身份：8.3 短名与硬链接都得靠它才认得出（名字文本上它们毫无关系）。 */
+    const reservedIds = await reservedIdentitySet()
+    /**
+     * 链接条目在 `isFile()` 这一步就被滤掉了（`readdir` 的 Dirent 报的是链接本身），
+     * 也就是说**闸门根本没机会看到它们** —— 不在这里出声，用户只会看到「这条记忆不见了」。
+     */
+    for (const e of entries) {
+      if (e.isSymbolicLink() && /\.md$/i.test(e.name)) {
+        warnLog(ctx, `skip ${e.name}: 是指向别处的符号链接 / 目录联接`, sessionId)
+      }
+    }
     const names = entries
       .filter(e => e.isFile() && isMemoryEntry(e.name))
       .map(e => e.name)
     const loaded = await Promise.all(names.map(async (name) => {
+      const full = join(MEMORY_DIR, name)
+      // 先过闸门（lstat + 体积），再读：链接与超大文件都在**全量读之前**被挡下，
+      // 而不是读进来之后才发现不该读。mtime 由闸门一并给出，比原来少一跳 stat。
+      const gate = await inspectMemoryEntry(full)
+      /**
+       * 8.3 短名 / 硬链接都可能是「保留名的另一个名字」：`MEMORY~1.MD` 与 `MEMORY.md`
+       * 文本上毫无关系，inode 却是同一个。不按身份拦，索引就会以普通记忆的身份被读进上下文。
+       */
+      if (gate.ok && gate.id && reservedIds.has(gate.id)) {
+        warnLog(ctx, `skip ${name}: 这是某个保留名（索引 / 流水）的另一个名字，不当记忆读`, sessionId)
+        return null
+      }
+      // 硬链接**不拦**（见 inspectMemoryEntry 的取舍），但要让用户知道内容可能被外部改到。
+      if (gate.ok && gate.links > 1) {
+        warnLog(ctx, `note ${name}: 有 ${gate.links} 个硬链接名，内容可能被记忆目录之外改到`, sessionId)
+      }
+      if (!gate.ok) {
+        warnLog(ctx, `skip ${name}: ${gate.error}`, sessionId)
+        return null
+      }
       try {
-        const full = join(MEMORY_DIR, name)
-        // stat 与 readFile 并行 —— 多要一个 mtime 不该变成串行两跳。
-        const [content, info] = await Promise.all([readFile(full, 'utf8'), stat(full)])
+        const content = await readFile(full, 'utf8')
         const meta = parseFrontmatter(content)
         return {
           file: name,
@@ -134,7 +276,7 @@ export async function scanMemoryFiles(ctx, sessionId) {
           baselinePriority: meta.baselinePriority || 0,
           // 新鲜度的两个来源：frontmatter 的 updated（权威）与文件 mtime（退路）。
           updated: meta.updated || '',
-          mtimeMs: info.mtimeMs,
+          mtimeMs: gate.mtimeMs,
         }
       } catch (err) {
         // 只有 ENOENT 是正常状态（扫到读之间被删）。其余——权限错、编码坏、盘掉线——
@@ -159,7 +301,7 @@ export function extractTitle(content) {
 }
 
 /** 扫一个目录，读回星图要的轻量元数据（正文 + 体积 + 修改时间）。 */
-async function readStarDir(dir, ctx) {
+async function readStarDir(dir, ctx, opts = {}) {
   let entries
   try {
     entries = await readdir(dir, { withFileTypes: true })
@@ -170,11 +312,22 @@ async function readStarDir(dir, ctx) {
   const names = entries
     .filter(e => e.isFile() && isMemoryEntry(e.name))
     .map(e => e.name)
+  const reservedIds = await reservedIdentitySet()
   const loaded = await Promise.all(names.map(async (name) => {
+    const full = join(dir, name)
+    const gate = await inspectMemoryEntry(full, opts)
+    if (!gate.ok) {
+      warnLog(ctx, `skip ${full}: ${gate.error}`)
+      return null
+    }
+    // 星图同样不显示「保留名的另一个名字」（8.3 短名 / 硬链接）。
+    if (gate.id && reservedIds.has(gate.id)) {
+      warnLog(ctx, `skip ${full}: 这是某个保留名（索引 / 流水）的另一个名字`)
+      return null
+    }
     try {
-      const full = join(dir, name)
-      const [content, info] = await Promise.all([readFile(full, 'utf8'), stat(full)])
-      return { name, content, bytes: info.size, mtimeMs: info.mtimeMs }
+      const content = await readFile(full, 'utf8')
+      return { name, content, bytes: gate.size, mtimeMs: gate.mtimeMs }
     } catch (err) {
       if (err?.code !== 'ENOENT') warnLog(ctx, `cannot read ${full}: ${err?.message ?? err}`)
       return null
@@ -188,7 +341,21 @@ async function readStarDir(dir, ctx) {
  * 归档区不存在是正常状态（没人归档过）→ 空数组，不是错误。
  */
 export async function scanArchived(ctx) {
-  const rows = await readStarDir(MEMORY_ARCHIVE_DIR, ctx)
+  // 归档区是**插件自己建的子目录**，必须过目录闸门：它若被换成指向外部的联接，
+  // 「归档 = 搬进 archive/」就变成「把记忆搬出记忆目录」。
+  const gate = await inspectDir(MEMORY_ARCHIVE_DIR)
+  if (!gate.ok) {
+    // ENOENT 是正常状态（还没人归档过）→ 空数组；其余一律出声，绝不静默当成「没有归档」。
+    if (gate.code !== 'missing') warnLog(ctx, `归档区不可用，跳过：${gate.error}`)
+    return []
+  }
+  /**
+   * ⚠️ 归档区**不判体积**（`limitBytes: null`）：归档是「把这条记忆收起来」，
+   * 不是「新写一条记忆」—— 拿活动记忆的上限去卡归档区，会造出「能归档、列不出、
+   * 读不回」的半死状态（实测：600 KB 的记忆归档成功，却从馆里消失、又还能被覆盖）。
+   * 形状闸门（symlink）照旧生效。
+   */
+  const rows = await readStarDir(MEMORY_ARCHIVE_DIR, ctx, { limitBytes: null })
   return rows.map(f => ({ ...f, archived: true }))
 }
 

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.4",
   "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"
+  }
+}