sage-mem 0.9.3 → 0.9.5

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

@@ -77,6 +77,8 @@ export class AutodreamEngine {
     this.phase = ''
     this.startedAt = 0
     this.runId = ''
+    /** 本次持锁凭据（`gate.js` 的 acquireLock 写入、releaseLock 校验）。 */
+    this.lockToken = ''
     this.stepLog = []
     this.lastScanAt = 0
     this.state = { config: { ...DEFAULT_CONFIG }, version: CONFIG_VERSION, lastRunAt: 0, lastResult: null, retryAfter: 0 }
@@ -238,6 +240,7 @@ export class AutodreamEngine {
         sessionsRoot: this.sessionsRoot,
         apply: !!cfg.apply,
         withSessions,
+        ctx: this.ctx,
       })
       const toolSchemas = autodreamToolSchemas({ apply: !!cfg.apply, withSessions })
 

package/lib/autodream/gate.js

@@ -7,8 +7,9 @@
  */
 
 import { LOCK_STALE_MS, SESSION_SCAN_INTERVAL_MS } from './config.js'
-import { countSessionsSince } from './util.js'
-import { mkdir, open, rm, stat } from 'node:fs/promises'
+import { countSessionsSince, readJson } from './util.js'
+import { link, mkdir, open, rename, rm, stat } from 'node:fs/promises'
+import { randomUUID } from 'node:crypto'
 
 /**
  * 三级门控（顺序即成本顺序）。
@@ -54,25 +55,89 @@ export async function acquireLock() {
   // 新鲜（未过期）就先拒绝——正常升级流程会重启进程，这条只兜「新旧并行」那一小段窗口。
   const legacy = await stat(this.legacyLockPath).catch(() => null)
   if (legacy && Date.now() - legacy.mtimeMs <= LOCK_STALE_MS) return false
+  /** 本次持有的凭据：释放时靠它认「这把锁还是我的吗」。 */
+  const token = randomUUID()
   try {
     const fh = await open(this.lockPath, 'wx')
-    await fh.write(JSON.stringify({ pid: process.pid, at: Date.now(), runId: this.runId }))
+    await fh.write(JSON.stringify({ pid: process.pid, at: Date.now(), runId: this.runId, token }))
     await fh.close()
+    this.lockToken = token
     return true
   } catch (err) {
     if (err?.code !== 'EEXIST') throw err
     const info = await stat(this.lockPath).catch(() => null)
     if (info && Date.now() - info.mtimeMs > LOCK_STALE_MS) {
-      // 上次进程崩了留下的锁：清掉重来（不然 autodream 永远回不来）。
-      await rm(this.lockPath, { force: true })
+      /**
+       * 上次进程崩了留下的锁：清掉重来（不然 autodream 永远回不来）。
+       *
+       * 「判断过期 → 删掉 → 重来」这三步之间有窗口：另一个进程可能在这中间**抢到了这把锁**。
+       * 所以改用 `rename` 抢占（原子，同一把锁只有一个进程能移走）。移走之后**两道复核**，
+       * 缺一不可：
+       *
+       *   ① `mtime` 仍然超期 —— 这是**真正的判据**。`stat` 判过期与读 `before` 之间还有一次
+       *      FS 操作的缝：若这期间别人已完成抢占并建了一把**新鲜**锁，我们读到的 `before`
+       *      就是它，token 比对会放行，于是两个实例都以为自己拿到了（实测能复现）。
+       *   ② `token` 与读到的 `before` 一致 —— 防「内容被换过」。
+       *
+       * 任一条不成立：说明我们移走的不是自己判定的那把过期锁，**还回去、认输**。
+       */
+      const before = await readJson(this.lockPath)
+      const grabbed = `${this.lockPath}.stale-${randomUUID().replace(/-/g, '')}`
+      const moved = await rename(this.lockPath, grabbed).then(
+        () => true,
+        () => false,
+      )
+      if (!moved) return this.acquireLock() // 别人抢先移走了，直接重来
+      const movedInfo = await stat(grabbed).catch(() => null)
+      const after = await readJson(grabbed)
+      const stillStale = movedInfo !== null && Date.now() - movedInfo.mtimeMs > LOCK_STALE_MS
+      if (!stillStale || after?.token !== before?.token) {
+        // 还回去**不能覆盖**已经存在的锁（Windows 的 rename 会直接盖掉别人刚建的新锁）。
+        // 用 `link` 还原：目标存在时它报 EEXIST，不会覆盖任何东西。
+        const restored = await link(grabbed, this.lockPath).then(
+          () => true,
+          () => false,
+        )
+        await rm(grabbed, { force: true }).catch((err) => {
+          this.log?.('warn', `锁抢占复核不通过且遗留文件清不掉：${grabbed}（${err?.message ?? err}）`)
+        })
+        if (!restored) {
+          this.log?.('warn', `锁抢占复核不通过，但锁位置已被占用，未覆盖它：${this.lockPath}`)
+        }
+        return false
+      }
+      await rm(grabbed, { force: true }).catch((err) => {
+        this.log?.('warn', `过期锁清理失败（残留 ${grabbed}）：${err?.message ?? err}`)
+      })
       return this.acquireLock()
     }
     return false
   }
 }
 
+/**
+ * 释放锁 —— **只删自己那一把**。
+ *
+ * 旧实现是无条件 `rm`：一个慢下来的持有者（比如刚跑完两小时的整理）释放时，
+ * 会把**别人中途抢到的新锁**删掉 —— 于是两个整理进程同时往里写，而两边都以为自己独占。
+ * 判据落在锁文件里的 `token` 上：不是自己的，一个字都不动。
+ *
+ * ⚠️ 边界说清楚：`token` 明文躺在锁文件里，**它不是秘密**，防的是「协作的两个实例各跑各的」
+ * 这类误删，不防「能读这个目录的对手」—— 那种对手本来就能直接删锁文件。
+ */
 export async function releaseLock() {
-  await rm(this.lockPath, { force: true }).catch(() => {})
+  const token = this.lockToken
+  // 没持有过（acquireLock 从没成功过）→ 什么都不做。旧实现会在这里删掉别人的锁。
+  if (!token) return
+  const held = await readJson(this.lockPath)
+  if (!held || held.token !== token) {
+    this.lockToken = ''
+    return
+  }
+  await rm(this.lockPath, { force: true }).catch((err) => {
+    this.log?.('warn', `释放锁失败：${err?.message ?? err}`)
+  })
+  this.lockToken = ''
 }
 
 // ────────────────────────────── 回滚点（快照） ──────────────────────────────

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 || '',
       })
@@ -139,18 +151,111 @@ async function scanEntries(memoryDir) {
   return out
 }
 
+/** zstd 帧魔数（小端读出来的值）。 */
+const ZSTD_MAGIC = 0xfd2fb528
+/** 同一个魔数的字节形态：认不出帧头时要靠它找下一个帧的起点。 */
+const ZSTD_MAGIC_BYTES = Buffer.from([0x28, 0xb5, 0x2f, 0xfd])
+
+/**
+ * 量一个 zstd 帧占多少字节（从 `off` 开始）。不是合法帧头、或帧被截断，返回 0。
+ *
+ * 为什么要自己量：会话记录是**逐行一个帧**拼起来的，而 Node 的解码器都只认第一个帧 ——
+ *   - `zstdDecompressSync(buf)`：实测只解出第一帧（4.44 MB / 3148 帧的文件只出 266 字符）
+ *   - `zstdDecompress(buf)`：**单参数调用直接抛** `ERR_INVALID_ARG_TYPE`（它要 callback，
+ *     不是 promise 版）—— 旧代码正是这么调的，于是每个会话都在 `catch` 里被静默跳过，
+ *     整条 `search_sessions` 实际上**一次都没成功过**
+ * 所以只能沿帧头走一遍：Magic → Frame_Header_Descriptor → （Window / DictID / ContentSize）
+ * → 逐块 Block_Header 直到 Last_Block → 可选 checksum。
+ */
+function zstdFrameLength(buf, off) {
+  if (off + 5 > buf.length) return 0
+  if (buf.readUInt32LE(off) !== ZSTD_MAGIC) return 0
+  let p = off + 4
+  const fhd = buf[p++]
+  const fcsFlag = fhd >> 6
+  const singleSegment = (fhd >> 5) & 1
+  const checksum = (fhd >> 2) & 1
+  const dictIdFlag = fhd & 3
+  if (!singleSegment) p += 1 // Window_Descriptor
+  p += [0, 1, 2, 4][dictIdFlag] // Dictionary_ID
+  p += singleSegment ? [1, 2, 4, 8][fcsFlag] : [0, 2, 4, 8][fcsFlag] // Frame_Content_Size
+  if (p > buf.length) return 0
+  for (;;) {
+    if (p + 3 > buf.length) return 0
+    const h = buf[p] | (buf[p + 1] << 8) | (buf[p + 2] << 16)
+    p += 3
+    const last = h & 1
+    const type = (h >> 1) & 3
+    const size = h >>> 3
+    if (type === 3) return 0 // Reserved：不是我们能认的帧
+    p += type === 1 ? 1 : size // RLE 块只存 1 字节
+    if (last) break
+    if (p > buf.length) return 0
+  }
+  if (checksum) p += 4
+  return p <= buf.length ? p - off : 0
+}
+
+/**
+ * 把「可能由多个帧拼成」的 zstd 缓冲解成文本。
+ *
+ * 逐帧解、**一帧坏掉不影响后面的帧**；连帧头都认不出时跳到下一个魔数继续。
+ * 解不出来的帧会被跳过（可能返回空串），整个缓冲里一帧都没解出来则返回 `null`
+ * —— 由调用方决定怎么记账。
+ */
+function decodeZstdFrames(zlib, buf) {
+  const parts = []
+  let off = 0
+  let frames = 0
+  let decoded = 0
+  while (off < buf.length) {
+    const len = zstdFrameLength(buf, off)
+    if (len <= 0) {
+      /**
+       * 认不出帧头：**跳到下一个魔数**继续，而不是停下。
+       *
+       * 停下的代价是「这一帧之后的内容全部静默丢失」—— 而那些帧本来是好的
+       * （实测：5 帧里第 3 帧的块头被改成 Reserved，后面两帧就再也搜不到了）。
+       * 未对齐的魔数也可能落在压缩数据里，那时的帧长多半解析不通，由下面的 catch 兜住。
+       */
+      const next = buf.indexOf(ZSTD_MAGIC_BYTES, off + 1)
+      if (next < 0) break
+      off = next
+      continue
+    }
+    try {
+      parts.push(zlib.zstdDecompressSync(buf.subarray(off, off + len)))
+      decoded += 1
+    } catch {
+      // 单帧坏掉：跳过它，继续后面的帧
+    }
+    off += len
+    frames += 1
+  }
+  if (frames === 0) {
+    try {
+      return zlib.zstdDecompressSync(buf).toString('utf8')
+    } catch {
+      return null
+    }
+  }
+  if (decoded === 0) return null
+  return Buffer.concat(parts).toString('utf8')
+}
+
 /**
  * 在 DSH 会话记录里做定向搜索。
  *
- * 会话正文是 zstd 压缩的（`session.v4.jsonl.zstd`），Node 24 的
- * `zlib.zstdDecompress` 能直接解 —— 不需要外部 zstd 可执行文件。
+ * 会话正文是 zstd 压缩的（`session.v4.jsonl.zstd`），而且是**逐行一个帧** ——
+ * 所以解压必须逐帧走（见 `decodeZstdFrames`），不需要外部 zstd 可执行文件。
  * 只按 mtime 从新到旧扫，命中够数就停：这是「找昨天的报错原文」这类
  * 定向问题的用法，不是全量索引。
  *
  * @param {string} sessionsRoot — `$DSH_HOME/sessions`
- * @param {string} query
- * @param {number} limit
- * @param {number} sinceMs — 只看这个时间之后改过的会话
+ * @param {string} query — 关键词（≥2 字符）
+ * @param {number} limit — 最多返回多少段
+ * @param {number} sinceMs — 只看这个时间之后改过的会话。工具层**有意传 0**：
+ *   模型搜的是全部会话，不限于上次整理之后（这个参数留给按需过滤的调用方）
  * @returns {Promise<string>}
  */
 async function searchSessions(sessionsRoot, query, limit, sinceMs) {
@@ -164,7 +269,7 @@ async function searchSessions(sessionsRoot, query, limit, sinceMs) {
   } catch {
     return '（当前 Node 不支持 zstd 解压，无法读取会话记录）'
   }
-  if (typeof zlib.zstdDecompress !== 'function') {
+  if (typeof zlib.zstdDecompressSync !== 'function') {
     return '（当前 Node 不支持 zstd 解压，无法读取会话记录）'
   }
 
@@ -193,19 +298,21 @@ async function searchSessions(sessionsRoot, query, limit, sinceMs) {
   for (const d of dirs.slice(0, 40)) {
     try {
       const raw = await readFile(d.file)
-      const text = zlib.zstdDecompress(raw).toString('utf8')
+      const text = decodeZstdFrames(zlib, raw)
+      if (text === null) continue
       const lines = text.split(/\r?\n/)
       for (const line of lines) {
         if (line.length < 8) continue
         if (!line.toLowerCase().includes(needle)) continue
         hits.push(`[${localStamp(d.mtimeMs)}] ${line.length > 500 ? line.slice(0, 500) + '…' : line}`)
         total += line.length
-        if (total > SEARCH_LIMIT || hits.length > limit) break
+        // `>= limit`：判据是「已经攒够 limit 段了」，不是「超过了」——后者每次多返回一段。
+        if (total > SEARCH_LIMIT || hits.length >= limit) break
       }
     } catch {
       // 单个会话读不动就跳过：autodream 不该因为一个坏文件整体失败。
     }
-    if (total > SEARCH_LIMIT || hits.length > limit) break
+    if (total > SEARCH_LIMIT || hits.length >= limit) break
   }
   if (!hits.length) return `（在 ${sinceMs ? '上次整理之后' : '全部'}的会话记录里没找到含「${query}」的内容）`
   return `命中 ${hits.length} 段（按 mtime 由新到旧）：\n\n${hits.join('\n')}`
@@ -327,7 +434,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 +503,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 +515,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.5",
   "type": "module",
   "main": "lib/index.js",
   "exports": {