sage-mem 0.9.3 → 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

@@ -238,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-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

@@ -29,7 +29,8 @@ 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'
+import { writeFileAtomic, warnLog } from './memory/util.js'
+import { inspectMemoryEntry, reservedIdentitySet } from './memory/scan.js'
 
 /** 单次 read_memory 返回的正文上限（字符）。超过就截断并明确告诉模型。 */
 const READ_LIMIT = 20000
@@ -103,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 })
@@ -111,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)
@@ -126,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 || '',
       })
@@ -327,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 = []
@@ -396,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) : ''}`,
@@ -408,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

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/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.3",
+  "version": "0.9.4",
   "type": "module",
   "main": "lib/index.js",
   "exports": {