sage-mem 0.9.4 → 0.9.5

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 }

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

@@ -151,18 +151,111 @@ async function scanEntries(memoryDir, ctx) {
   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) {
@@ -176,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 解压，无法读取会话记录）'
   }
 
@@ -205,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')}`

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