sage-mem 2.1.4 → 2.1.6

package/README.md

@@ -12,7 +12,7 @@
 
 **Cross-session memory for DeepSeek Harness — plain markdown files, no database, no worker.**
 
-**Current release: `2.1.4`** — the npm badge above is the dynamic source of truth. **Contract baseline: `1.0.0`** — the first stable release, whose public commitments, the capability boundaries and the list of things it explicitly cannot do are frozen in the
+**Current release: `2.1.6`** — the npm badge above is the dynamic source of truth. **Contract baseline: `1.0.0`** — the first stable release, whose public commitments, the capability boundaries and the list of things it explicitly cannot do are frozen in the
 [frozen contract](https://github.com/gezi-wen/sage-mem/blob/main/docs/1.0.0-contract.md).
 
 If it is useful to you, a Star is the most direct feedback.

package/README.zh.md

@@ -14,7 +14,7 @@
 
 > File-based cross-session memory for DeepSeek Harness — every memory is a plain markdown file you can open, edit and delete. No database, no worker, no port.
 
-**当前发布版本：`2.1.4`** —— 顶部 npm 徽章是动态权威。**契约基线：`1.0.0`** —— 第一个稳定版，公开承诺、能力边界与「明确做不到」的清单冻结在
+**当前发布版本：`2.1.6`** —— 顶部 npm 徽章是动态权威。**契约基线：`1.0.0`** —— 第一个稳定版，公开承诺、能力边界与「明确做不到」的清单冻结在
 [契约冻结](https://github.com/gezi-wen/sage-mem/blob/main/docs/1.0.0-contract.md)。
 
 如果它对你有用，给个 Star 是最直接的反馈。

package/lib/autodream/audit.js

@@ -33,15 +33,18 @@ import { warnLog } from '../memory/util.js'
 const INDEX_FILE = 'MEMORY.md'
 
 /**
- * 归档 / 恢复中途崩溃留下的**私有名残留**：`a.md.archiving-<hex>`。
+ * 归档 / 恢复中途崩溃留下的**私有名残留**：`a.md.archiving-<hex>` / `a.md.restoring-<hex>`。
  *
  * 为什么单列一类（2026-10-12 复审复核点出）：`memory/archive.js` 把源 `rename` 到这个
  * 私有名之后、复核完成之前若进程死掉，这份内容就留在了记忆目录里。它**不是** `.md`，
  * 所以扫描 / 注入 / 星图 / 快照 / 列表都不认它（这本来是对的，免得半成品被当成一条记忆）——
  * 但连体检也不认，就等于「可能装着用户唯一一份内容的东西」在界面上完全隐形，
  * 而它躺在用户会同步、会备份的记忆根目录里。审计负责把它报出来（纯只读，只报不删）。
+ *
+ * 2026-10-31 外部审查 Q06：恢复也改用同一套「接管到私有名」的事务原语，所以残留后缀
+ * 多了一个 `.restoring-` —— 两种都必须报，只加新不留旧（归档残留照样报）。
  */
-const STRAY_RE = /\.archiving-[0-9a-f]+$/i
+const STRAY_RE = /\.(?:archiving|restoring)-[0-9a-f]+$/i
 
 /**
  * 审计**整个跳过**的文件（不读、不当被审对象）。

package/lib/client.js

@@ -1555,6 +1555,9 @@ const StarmapRuntime = (function (require, _react) {
 		const archivedFileSchema = parseSchema({
 			"file": isStr, "type": isStr, "description": isStr, "size": isNum,
 			"archivedAt": isStr, "archivedReason": isStr,
+			// 2.1.6（外部审查 Q07）：内容身份（归档代次 + 正文 revision）。它不是装饰 ——
+			// 「彻底删除」必须把它原样交回宿主，否则只能按名字删，而名字不是身份。
+			"revision": isStr,
 		});
 		const archivedListSchema = {
 			parse(v) {
@@ -1567,9 +1570,11 @@ const StarmapRuntime = (function (require, _react) {
 		// 归档文件的读 / 写（B1b）：形状与活跃记忆那套的 readSchema / writeSchema 对称。
 		const archivedReadSchema = withOptional(parseSchema({ "name": isStr, "content": isStr }), ["revision"]);
 		const archivedWriteSchema = withOptional(parseSchema({ "ok": isBool, "file": isStr }), ["code", "revision"]);
-		// 「彻底删除」的入参：归档代次（`archivedAt`）。它不是装饰 —— 宿主拿它核对
-		// 「要删的是不是用户确认过的那一版」。老归档件没有留痕时传空串，所以只校类型。
+		// 「彻底删除」的入参：`archivedAt`（展示时间）+ `revision`（内容身份，见 archive.js 的
+		// archivedRevisionOf）。两个都不是装饰 —— 宿主拿它们核对「要删的是不是用户确认过的那一版」；
+		// 只有前者的旧确认在 2.1.6 起会被宿主拒绝（分钟精度的时间不是内容身份）。
 		const archiveStampSchema = strSchema;
+		const archiveRevisionSchema = { parse(v) { isStr(v); if (v.length === 0) throw new Error("sage-mem: expected revision"); return v; } };
 
 		// ── 2.1.2（Q02）写协议：读快照 revision / 写回执的 additive 字段 / 写选项 ──
 		/**
@@ -1844,8 +1849,9 @@ const StarmapRuntime = (function (require, _react) {
 					sourceLocation: { "file": "lib/index.js", "line": 1, "column": 1 },
 				},
 				{
-					// 彻底删除一条归档件（不可恢复）。第二个参数是归档代次：宿主拿它核对
+					// 彻底删除一条归档件（不可恢复）。第二、第三个参数是身份判据：宿主拿它们核对
 					// 「要删的是不是用户确认过的那一版」，传错（比如列表过期）会被拒绝。
+					// `archivedAt` 只是展示时间；`revision` 才是内容身份（2.1.6 起，外部审查 Q07）。
 					id: "sage-mem#memory/deleteArchived",
 					service: "memory",
 					namespace: "memory",
@@ -1854,6 +1860,7 @@ const StarmapRuntime = (function (require, _react) {
 					parameters: [
 						{ name: "name", wire: "name", source: "json", codec: { mode: "strict", typeSymbol: "sage-mem/types#ArchivedFileName", schema: strSchema, create: () => strSchema } },
 						{ name: "archivedAt", wire: "archivedAt", source: "json", codec: { mode: "strict", typeSymbol: "sage-mem/types#ArchiveStamp", schema: archiveStampSchema, create: () => archiveStampSchema } },
+						{ name: "revision", wire: "revision", source: "json", codec: { mode: "strict", typeSymbol: "sage-mem/types#ArchiveRevision", schema: archiveRevisionSchema, create: () => archiveRevisionSchema } },
 					],
 					result: { mode: "strict", typeSymbol: "sage-mem/types#ArchiveResult", schema: archiveSchema, create: () => archiveSchema },
 					sourceLocation: { "file": "lib/index.js", "line": 1, "column": 1 },
@@ -6247,8 +6254,10 @@ h("span", { key: "sep", className: "smem-actions-sep", "aria-hidden": "true" }),
 			/**
 			 * **彻底删除**一条归档件（不可恢复）。
 			 *
-			 * 第二个参数是归档代次（列表上看到的 `archivedAt`）：宿主拿它核对「要删的是不是
-			 * 我确认过的那一版」。不传它会变成「按名字删」—— 名字底下的内容刚才可能已经换人了。
+			 * 第二、第三个参数是身份判据：`archivedAt` 是展示时间，`revision` 是**内容身份**
+			 * （归档代次 + 正文 revision，2.1.6 起）。宿主拿它们核对「要删的是不是我看过的那一版」——
+			 * 只传时间的话，正文被改成同时间戳的另一版、或同一分钟内重新归档，旧确认都会删错。
+			 * 二次确认只是交互，服务端的版本核对才是判据。
 			 */
 			function deleteArchivedFile(file) {
 				if (typeof remote.deleteArchived !== "function") {
@@ -6257,8 +6266,9 @@ h("span", { key: "sep", className: "smem-actions-sep", "aria-hidden": "true" }),
 				}
 				const item = archiveItems.filter(function (x) { return x.file === file; })[0];
 				const stamp = (item && item.archivedAt) || "";
+				const revision = (item && item.revision) || "";
 				setBusy(true); setError(null); setNotice("");
-				remote.deleteArchived(file, stamp)
+				remote.deleteArchived(file, stamp, revision)
 					.then(function (r) {
 						if (r && r.ok === false) { setError(r.error || t("error.deleteRejected")); return; }
 						setArchDelete(null);

package/lib/index.js

@@ -24,7 +24,7 @@ import { MEMORY_ARCHIVE_DIR, addArchiveMeta, extractTitle, inspectDir, inspectMe
 import { listConflicts, patchConflict, readConflict, removeConflict, summarizeConflict } from './memory/conflicts.js'
 import { invalidateMemory, undoMemoryInvalidation } from './memory/arbitrate.js'
 import { readSnapshot, writeSnapshot } from './memory/write-protocol.js'
-import { archiveMemory, deleteArchivedMemory, restoreMemory } from './memory/archive.js'
+import { archiveMemory, archivedRevisionOf, deleteArchivedMemory, restoreMemory } from './memory/archive.js'
 import { flushAccess, pickArchiveCandidates, readAccessLedger } from './memory/access.js'
 import { warnLog, writeFileAtomic } from './memory/util.js'
 import { readLockSet, setLocked as setLockedImpl } from './memory/lock.js'
@@ -266,8 +266,12 @@ export class MemoryGateway extends TypertRemoteService {
    * 列出归档区的全部记忆（面板的「已归档」区）。
    *
    * 与 `listFiles()` 分开、形状也不同：`listFiles` 只列活动记忆、多一个字段都会破坏
-   * 界面与断言依赖的形状；归档条目额外带 `archivedAt` / `archivedReason`。
-   * 旧版 autodream 工具直接移文件、不写留痕，所以这两个字段可能是空串。
+   * 界面与断言依赖的形状；归档条目额外带 `archivedAt` / `archivedReason` / `revision`。
+   * 旧版 autodream 工具直接移文件、不写留痕，所以前两个字段可能是空串。
+   *
+   * `revision` 是**内容身份**（2026-10-31 外部审查 Q07）：归档代次 + 正文 revision。
+   * 删除确认必须把它交回来 —— `archivedAt` 只是展示时间，同一分钟内不可区分，
+   * 拿它当版本会让「A 改成同时间戳的 B」和「同分钟重新归档」的旧确认删掉新内容。
    */
   async listArchived() {
     const files = await scanArchived(this.ctx)
@@ -282,6 +286,7 @@ export class MemoryGateway extends TypertRemoteService {
         tags: meta.tags,
         archivedAt: archived.archivedAt,
         archivedReason: archived.archivedReason,
+        revision: archivedRevisionOf(f.content),
       }
     })
     return { count: out.length, files: out }
@@ -354,27 +359,32 @@ export class MemoryGateway extends TypertRemoteService {
     }
     const given = readArchivedMeta(content)
     let toWrite = content
-    if (!given.archivedAt && !given.archivedReason) {
+    /**
+     * 留痕按**盘上那份**补齐：正文被面板改过之后，`archived_at` / `archived_reason` /
+     * `archived_rev` 一个都不许丢（2026-10-31 外部审查 Q07 起 `archived_rev` 也是留痕，
+     * 丢了它删除确认的内容身份就少了一半）。任何一个缺了才重写整块 frontmatter。
+     */
+    if (!given.archivedAt || !given.archivedReason || !given.archivedRev) {
       const onDisk = readArchivedMeta(await readVerified(full, gate, 'utf8'))
-      if (onDisk.archivedAt || onDisk.archivedReason) {
-        toWrite = addArchiveMeta(content, onDisk.archivedReason, onDisk.archivedAt)
-      }
+      const at = given.archivedAt || onDisk.archivedAt
+      const reason = given.archivedReason || onDisk.archivedReason
+      const rev = given.archivedRev || onDisk.archivedRev
+      if (at || reason || rev) toWrite = addArchiveMeta(content, reason, at, rev)
     }
     // 2.1.2（Q02）：落盘也走写协议 —— 带 opts 时先比盘上版本，对不上就拒绝（正文逐字节不变）。
     return await writeSnapshot(full, toWrite, gate, opts, { ctx: this.ctx, name: safe, kind: 'writeArchived' })
   }
 
   /**
-   * **彻底删除**一条已归档记忆（不可恢复）。
-   *
-   * 与 `deleteFile` 的区别要在代码里就分开：那个删的是活动记忆，这个删的是档案馆里的退役件；
-   * 归档「只移不删」的承诺不变 —— 走进档案馆之后，删不删由人单独决定。
+   * **彻底删除**一条已归档记忆（不可恢复）。与 `deleteFile` 的区别在代码里就分开：那个删活动记忆，
+   * 这个删档案馆里的退役件；归档「只移不删」的承诺不变。
    *
-   * `archivedAt` 是**身份判据**（见 `memory/archive.js` 的头注）：调用方交回它当时看见的
-   * 归档时间，盘上那份对不上就拒绝。不传 / 传空串只对「本来就没有留痕的老归档件」成立。
+   * 两个身份判据（见 `memory/archive.js` 头注）：`archivedAt` 是展示时间（老归档件可空）；
+   * `revision` 是**内容身份**（归档代次 + 正文 revision，`listArchived` 给的那份）。2026-10-31
+   * 外部审查 Q07：没有它就必须拒绝 —— `archived_at` 是分钟精度的时间，拿它当版本会让旧确认删新内容。
    */
-  async deleteArchived(name, archivedAt) {
-    const res = await deleteArchivedMemory(MEMORY_DIR, name, archivedAt)
+  async deleteArchived(name, archivedAt, revision) {
+    const res = await deleteArchivedMemory(MEMORY_DIR, name, archivedAt, revision)
     if (!res.ok) return { ok: false, error: res.error }
     return { ok: true, file: res.file }
   }

package/lib/memory/archive.js

@@ -17,10 +17,11 @@
 
 import { ARCHIVE_DIR_NAME, addArchiveMeta, inspectDir, inspectMemoryEntry, localStamp, readArchivedMeta, stripArchiveMeta } from './scan.js'
 import { isReserved, nameKey, safeName } from './naming.js'
-import { writeFileAtomic, writeFileExclusive } from './util.js'
+import { revisionOf } from './chunks.js'
+import { retireTaken, returnSource, takeOverSource, writeFileAtomic, writeFileExclusive } from './util.js'
 import { isLocked } from './lock.js'
 import { ensureIndexEntry, dropIndexEntry } from './index-file.js'
-import { link, mkdir, readFile, rename, rm, stat, unlink } from 'node:fs/promises'
+import { mkdir, readFile, rm, stat } from 'node:fs/promises'
 import { basename, join } from 'node:path'
 import { randomUUID } from 'node:crypto'
 
@@ -91,7 +92,14 @@ export async function archiveMemory(memoryDir, name, reason, at = localStamp())
   const content = sourceBytes.toString('utf8')
   // 空理由给默认值：手动 remote 允许省略（工具那侧自己会先挡掉空理由，那是它自己的语义）。
   const why = String(reason ?? '').trim() || '手动归档'
-  const stamped = addArchiveMeta(content, why, at)
+  /**
+   * **归档代次**（2026-10-31 外部审查 Q07）：每次归档新生成的一次性随机标记，写进
+   * frontmatter 的 `archived_rev`。它解决的是「`archived_at` 是展示时间、不是身份」：
+   * 同一分钟内「恢复 → 再归档」会复用同一个时间戳，拿旧确认去删就会删掉新归档的那一版。
+   * 内容身份另有一半 —— 见本文件下方的 `archivedRevisionOf`。
+   */
+  const rev = randomUUID().replace(/-/g, '').slice(0, 16)
+  const stamped = addArchiveMeta(content, why, at, rev)
   await mkdir(archiveDirOf(memoryDir), { recursive: true })
   /**
    * 先落归档副本、再删原件：中途崩了最坏是两份都在（人工可收拾），不会一份都没有。
@@ -107,7 +115,9 @@ export async function archiveMemory(memoryDir, name, reason, at = localStamp())
     throw err
   }
   /**
-   * ⚠️ 收走原件这一步用 **`rename` 到私有名 + 复核内容**，不是 `unlink`（复审 R06 场景①）。
+   * ⚠️ 收走原件这一步交给 **`takeOverSource`**（`rename` 到私有名 → 逐字节复核 → 还回 /
+   * 退役），不是 `unlink`（复审 R06 场景①；2026-10-31 外部审查 Q06 起归档与恢复共用
+   * 同一份事务移动原语，见 `memory/util.js`）。
    *
    * 从上面那次 `inspectMemoryEntry(src)` 到现在，中间隔着读文件 + 写归档副本两次 IO；
    * 这期间若有人（面板保存、另一个进程、模型工具）把 `a.md` 写成了新版本，
@@ -125,18 +135,14 @@ export async function archiveMemory(memoryDir, name, reason, at = localStamp())
    * 于是**新版本被当成旧版本收走**，顶层与归档件里都不再有它。`ino` 在拿不到 inode 的卷上
    * 还会退化成 `null === null` 恒真，把判据进一步削弱成「体积 + 时间」。
    * 内容比对是精确判据，而且成本可忽略（归档本来就要把这份内容读进内存）。
-   *   · 与读到的字节完全相同 → 就是当初那一份，归档完成，删掉私有名；
-   *   · 不同（或读不回来）→ 是别人的新版本，用 `link()` 还回原名，放弃本次归档。
+   *   · 与读到的字节完全相同 → 就是当初那一份，归档完成，退役私有名；
+   *   · 不同（或读不回来）→ 是别人的新版本，原语用 `link()` 还回原名，放弃本次归档。
    *
    * 崩在中途的代价说清楚：私有名文件会留在记忆目录里（不是 `.md`，扫描与注入都不认它），
-   * 而归档副本已经写好 —— 不会出现「一份都没有」。
+   * 而归档副本已经写好 —— 不会出现「一份都没有」；体检会把 `.archiving-` 残留报出来。
    */
-  const taken = `${src}.archiving-${randomUUID().replace(/-/g, '')}`
-  const moveErr = await rename(src, taken).then(
-    () => null,
-    (err) => err,
-  )
-  if (moveErr) {
+  const takenRes = await takeOverSource(src, sourceBytes, 'archiving')
+  if (!takenRes.ok) {
     /**
      * ⚠️ `rename` 失败**不等于**「源不见了」（复审复核实测，真机 Windows）：
      * 另一进程只读占用（编辑器 / 杀软 / 同步工具）时 `rename` 报 **EBUSY** 而不是 ENOENT，
@@ -144,45 +150,37 @@ export async function archiveMemory(memoryDir, name, reason, at = localStamp())
      * 「错误：没有这个文件」—— 诊断是错的，人会去别处找。按真实错误码分流。
      */
     await rm(dst, { force: true }).catch(() => {})
-    if (moveErr?.code === 'ENOENT') {
+    if (takenRes.code === 'not-found') {
       return { ok: false, code: 'not-found', error: `sage-mem: file not found: ${safe}（归档途中源文件消失了）` }
     }
-    return {
-      ok: false,
-      code: 'move-failed',
-      error: `sage-mem: 归档 ${safe} 时移不动它（${moveErr?.code ?? moveErr}：${moveErr?.message ?? moveErr}）。文件仍在原处、一个字节没动，本次归档未完成 —— 可稍后重试（若是被其它程序占用，关掉它再来）。`,
+    if (takenRes.code === 'move-failed') {
+      const moveErr = takenRes.cause
+      return {
+        ok: false,
+        code: 'move-failed',
+        error: `sage-mem: 归档 ${safe} 时移不动它（${moveErr?.code ?? moveErr}：${moveErr?.message ?? moveErr}）。文件仍在原处、一个字节没动，本次归档未完成 —— 可稍后重试（若是被其它程序占用，关掉它再来）。`,
+      }
     }
-  }
-  const currentBytes = await readFile(taken).catch(() => null)
-  const sameOne = currentBytes !== null && Buffer.compare(currentBytes, sourceBytes) === 0
-  if (!sameOne) {
-    // 移走的是**别人**的新版本：还回去，一个字节都不动。
-    const restored = await link(taken, src).then(
-      () => true,
-      () => false,
-    )
-    await rm(dst, { force: true }).catch(() => {})
-    if (!restored) {
+    if (takenRes.keptAt) {
       /**
        * ⚠️ 归还失败时**绝不能删 `taken`**：它是这份新版本**唯一**的落身处
        * （原名此刻已被别人占着，link 才报的 EEXIST）。删掉它就是真的丢数据。
-       * 这里把它原样留下，并把路径如实写进错误里让人去捞 —— 名字带 `.archiving-`
-       * 后缀，不是 `.md`，扫描 / 注入 / 星图都不会把它当成一条记忆。
+       * 原语把它原样留下，这里把路径如实写进错误里让人去捞 —— 名字带 `.archiving-`
+       * 后缀，不是 `.md`，扫描 / 注入 / 星图都不会把它当成一条记忆，体检会报出来。
        */
       return {
         ok: false,
         code: 'changed',
-        error: `sage-mem: ${safe} 在归档过程中被改写，已放弃本次归档；归还时原名已被占用，**内容仍保留在 ${basename(taken)}**，请手工改回 ${safe}`,
+        error: `sage-mem: ${safe} 在归档过程中被改写，已放弃本次归档；归还时原名已被占用，**内容仍保留在 ${basename(takenRes.keptAt)}**，请手工改回 ${safe}`,
       }
     }
-    await rm(taken, { force: true }).catch(() => {})
     return {
       ok: false,
       code: 'changed',
       error: `sage-mem: ${safe} 在归档过程中被改写，已放弃本次归档（新版本保留在原处，请重试）`,
     }
   }
-  await rm(taken, { force: true }).catch(() => {})
+  await retireTaken(takenRes.taken)
   /**
    * **从索引里摘掉**（与恢复时补索引对称）：索引是「活动记忆的清单」，
    * 记忆归档了就该从清单里退出 —— 不摘的话审计会报「索引悬空」。
@@ -245,7 +243,54 @@ export async function restoreMemory(memoryDir, name) {
   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')
+  const sourceBytes = await readFile(src)
+  const content = sourceBytes.toString('utf8')
+  /**
+   * **事务接管源 + 目标排他落位**（2026-10-31 外部审查 Q06）。
+   *
+   * 旧写法是「先把 A 排他落位到顶层，再 `unlink(归档源)`」：落位确实保护了目标
+   * （复审 R06 场景②），但最后那步按名删除**没有绑定读取时的源版本** —— 落位与 unlink
+   * 之间另一路把归档源改写成 B，`unlink(名字)` 删的就是 B，新版本从两个位置一起消失，
+   * 而函数报 `ok:true`。
+   *
+   * 现在顺序反过来，用与归档同一份原语（`memory/util.js` 的 `takeOverSource`）：
+   *   ① 先把源原子 `rename` 成私有名，并逐字节核对它仍是当初读到的那一份；
+   *   ② 内容对不上 → 原语把 B 还回原名，本次放弃（一个字节都不丢）；
+   *   ③ 排他落位目标（`writeFileExclusive`：目标冒出来就 EEXIST，绝不覆盖）；
+   *   ④ 落位失败 → 把接管的那份**原样还回**归档区；还不动时留在私有名上并点名；
+   *   ⑤ 落位成功后才退役**私有副本** —— 不碰「当前叫 archive/a.md 的那个文件」，
+   *      所以落位之后被写进来的 B 会老老实实留在归档区。
+   *
+   * 崩在中途的代价：`.restoring-` 私有副本会留在归档区（不是 `.md`，扫描 / 注入都不认），
+   * 体检会把它报出来 —— 至少有一份可定位、可恢复的原文。
+   */
+  const takenRes = await takeOverSource(src, sourceBytes, 'restoring')
+  if (!takenRes.ok) {
+    if (takenRes.code === 'not-found') {
+      return { ok: false, code: 'not-archived', error: `sage-mem: not archived: ${safe}（恢复途中源文件消失了）` }
+    }
+    if (takenRes.code === 'move-failed') {
+      const moveErr = takenRes.cause
+      return {
+        ok: false,
+        code: 'move-failed',
+        error: `sage-mem: 恢复 ${safe} 时移不动它（${moveErr?.code ?? moveErr}：${moveErr?.message ?? moveErr}）。文件仍在 archive/ 里、一个字节没动 —— 可稍后重试（若是被其它程序占用，关掉它再来）。`,
+      }
+    }
+    if (takenRes.keptAt) {
+      // 核对时发现是别人的新版本，而原名已被再次占住 —— 新版本留在私有名上，点名给人捞。
+      return {
+        ok: false,
+        code: 'changed',
+        error: `sage-mem: ${safe} 在恢复过程中被改写，已放弃本次恢复；归还时原名已被占用，**内容（新版本）仍保留在 archive/${basename(takenRes.keptAt)}**，请手工改回 ${safe} 再试。`,
+      }
+    }
+    return {
+      ok: false,
+      code: 'changed',
+      error: `sage-mem: ${safe} 在恢复过程中被改写，已放弃本次恢复（新版本保留在归档区原处，请重试）`,
+    }
+  }
   /**
    * **排他落位**（复审 R06 场景②）：上面那句 `dstGate` 检查通过 ≠ 目标此刻仍不存在 ——
    * 检查与写入之间，用户完全可能在顶层新建一条同名记忆（实测用 IPC 固定交错即可复现）。
@@ -256,12 +301,21 @@ export async function restoreMemory(memoryDir, name) {
   try {
     await writeFileExclusive(dst, stripArchiveMeta(content))
   } catch (err) {
+    // 落位没成：接管的归档件必须先还回去 —— 它此刻是这个名字下唯一的一份内容。
+    const back = await returnSource(takenRes.taken, src)
+    if (!back.ok) {
+      return {
+        ok: false,
+        code: 'restore-failed',
+        error: `sage-mem: 恢复 ${safe} 落位失败（${err?.code ?? err}），且归还归档区原名时被占用 —— **内容仍保留在 archive/${basename(back.keptAt)}**，请手工改回 ${safe} 再试。`,
+      }
+    }
     if (err?.code === 'EEXIST') {
       return { ok: false, code: 'target-exists', error: `sage-mem: already exists, refusing to overwrite: ${safe}` }
     }
     throw err
   }
-  await unlink(src)
+  await retireTaken(takenRes.taken)
   /**
    * **注册回索引**：移回文件不等于这条记忆又存在了 —— 索引里没有它，
    * 面板与检索都看不见，体检会报「漏索引」（真实事故见 lib/memory/index-file.js 的头注）。
@@ -291,6 +345,31 @@ export async function restoreMemory(memoryDir, name) {
   }
 }
 
+/**
+ * **归档内容的身份**：一次性归档代次 + 当前正文的内容 revision。
+ *
+ * 为什么必须换成它（2026-10-31 外部审查 Q07）：`archived_at` 只是**展示时间**
+ * （`YYYY-MM-DD HH:mm`，同一分钟内不可区分），既不是内容身份、也不可复用 ——
+ * 归档 A 之后把正文改成 B 而 `archived_at` 不变，旧确认照样把 B 删掉；
+ * 同一分钟内「恢复 → 再归档」也会复用同一个时间戳。
+ *
+ * 身份由两半组成，缺一不可：
+ *   · `archived_rev`（每次归档新生成的随机标记）→ 同分钟重新归档也绝不复用；
+ *   · `revisionOf(去掉留痕的正文)`（sha256 前 12 位）→ 正文被改过（哪怕代次没变）立刻失配。
+ * 两半都在**盘上的字节**上算，调用方只能交回「它看见的那一份」的身份 ——
+ * 服务端拿它核对，界面上的二次确认只是交互，不是判据。
+ *
+ * 老数据没有 `archived_rev` 这一行时前半为空串；正文 revision 仍然把它钉在具体内容上。
+ *
+ * @param {string} content — 归档文件的全文（含 frontmatter）
+ * @returns {string} `<代次>@<内容 revision>`，如 `3f9ac1de4b7a2015@sha256:0123456789ab`
+ */
+export function archivedRevisionOf(content) {
+  const src = String(content ?? '')
+  const meta = readArchivedMeta(src)
+  return `${meta.archivedRev || ''}@${revisionOf(stripArchiveMeta(src))}`
+}
+
 /**
  * 从归档区**彻底删除**一条记忆（不可恢复）。
  *
@@ -301,22 +380,28 @@ export async function restoreMemory(memoryDir, name) {
  * 三道判据，缺一不可：
  *   1. **归档区的目录闸门**：它若被换成指向外部的联接，删掉的是别人的文件；
  *   2. **条目闸门**：链接 / 硬链接指向的可能是记忆目录之外的内容，删它等于替别人删文件；
- *   3. **代次（`archivedAt`）**：名字不是身份。用户从列表看到确认框、到请求到达之间，
- *      这条完全可能被恢复回顶层、又被另一版同名记忆归档进来 —— 按名删掉的就不再是他
- *      确认过的那一份。所以调用方必须交回它当时看见的 `archived_at`，对不上就拒绝。
- *      老数据没有留痕时两边都是空串，仍然一致（那是「同一份、只是没有时间戳」）。
+ *   3. **内容身份（revision = 归档代次 + 正文 revision）**：名字不是身份，`archived_at`
+ *      也不是（2026-10-31 外部审查 Q07）。用户从列表看到确认框、到请求到达之间，
+ *      这条完全可能被恢复回顶层、又被同一分钟内的另一版同名记忆归档进来；
+ *      归档正文也可能被改成了 B 而 `archived_at` 一个字没变。所以调用方必须交回
+ *      它当时看见的 `archived_at` **和** `revision`，服务端对着**接管到手的实物**
+ *      重新算一遍内容身份，对不上就拒绝。界面上的二次确认只是交互，不是判据。
  *
- * ⚠️ 删除本身用 **`rename` 到私有名 + `rm` 私有名**：`inspect` 与 `unlink` 之间隔着
- * 读文件，直接 `unlink(full)` 认的是**名字**而不是我们核对过的那份实物。`rename` 是原子的，
- * 之后删的一定是刚移走的那一个 inode。删失败时把名字 `link()` 还回去 —— 绝不让它
- * 以 `.deleting-` 的私有名留在盘上（扫描不认那个名字，等于文件凭空消失）。
+ * ⚠️ 删除本身是「**先接管、再核对、最后删私有名**」：
+ *   旧写法读完留痕比对通过后才 `rename(full, taken)`，两次调用之间另一路把归档件换成
+ *   另一版时，rename 移走的正是那一版、随后 rm 删掉，还返回 ok:true。
+ *   现在用与归档/恢复同一份原语 `takeOverSource`：先把盘上那份原子接管成 `.deleting-`
+ *   私有名（顺带核对它仍是刚读到的字节），再对**接管到的实物**算身份比对 ——
+ *   比对与删除之间不再有名字窗口。核对不通过时 `returnSource` 把原文还回 archive/，
+ *   还不动就留在私有名上并点名（内容绝不丢）。
  *
  * @param {string} memoryDir — 记忆根目录（调用方给，不许拿模块常量）
  * @param {string} name — 归档区里的文件名
- * @param {string} expectedArchivedAt — 调用方看见的 `archived_at`（没有留痕时传空串）
+ * @param {string} expectedArchivedAt — 调用方看见的 `archived_at`（老数据可能为空串）
+ * @param {string} expectedRevision — 调用方看见的 `revision`（`archivedRevisionOf` 的值）
  * @returns {Promise<{ok:true,file:string}|{ok:false,code:string,error:string}>}
  */
-export async function deleteArchivedMemory(memoryDir, name, expectedArchivedAt = '') {
+export async function deleteArchivedMemory(memoryDir, name, expectedArchivedAt = '', expectedRevision = '') {
   const gate = checkName(name, 'delete')
   if (!gate.ok) return gate
   const safe = gate.safe
@@ -337,52 +422,91 @@ export async function deleteArchivedMemory(memoryDir, name, expectedArchivedAt =
       error: `sage-mem: not archived: ${safe}（${srcGate.error}）`,
     }
   }
-  // 读全文只为取留痕：代次判据必须来自**盘上的那份**，不能信调用方一路传下来的展示值。
-  const onDisk = readArchivedMeta(await readFile(full, 'utf8'))
-  const expected = String(expectedArchivedAt ?? '')
-  if (expected !== onDisk.archivedAt) {
+  /**
+   * **先接管、再核对**：判据只能来自**接管到手的实物**，不能信调用方一路传下来的展示值，
+   * 也不能在「比对 → rename」之间留窗口（审查脚本正是在那段窗口里把文件换成 B 的）。
+   */
+  const sourceBytes = await readFile(full)
+  const takenRes = await takeOverSource(full, sourceBytes, 'deleting')
+  if (!takenRes.ok) {
+    if (takenRes.code === 'not-found') {
+      return { ok: false, code: 'not-archived', error: `sage-mem: not archived: ${safe}（删除途中它从归档区消失了）` }
+    }
+    if (takenRes.code === 'move-failed') {
+      const moveErr = takenRes.cause
+      return {
+        ok: false,
+        code: 'move-failed',
+        error: `sage-mem: 删除 ${safe} 时移不动它（${moveErr?.code ?? moveErr}：${moveErr?.message ?? moveErr}）。文件仍在 archive/ 里、一个字节没动 —— 可稍后重试（若是被其它程序占用，关掉它再来）。`,
+      }
+    }
+    // 接管时发现内容已经不是刚读到的那份：原语会把它还回原名（还不动则留私有名）。
+    if (takenRes.keptAt) {
+      return {
+        ok: false,
+        code: 'changed',
+        error: `sage-mem: ${safe} 在删除过程中被换成了另一版，已放弃本次删除；归还原名时被占用 —— **内容仍保留在 archive/${basename(takenRes.keptAt)}**，请手工改回 ${safe}。`,
+      }
+    }
     return {
       ok: false,
       code: 'changed',
-      error:
-        `sage-mem: ${safe} 在确认之后被换成了另一版（界面上是「${expected || '时间未知'}」，` +
-        `盘上是「${onDisk.archivedAt || '时间未知'}」），本次一个字节都没删 —— 请刷新列表再看一眼。`,
+      error: `sage-mem: ${safe} 在删除过程中被换成了另一版，本次一个字节都没删 —— 请刷新列表再看一眼。`,
     }
   }
-  const taken = join(archiveDirOf(memoryDir), `.${safe}.deleting-${randomUUID().replace(/-/g, '')}`)
-  const moveErr = await rename(full, taken).then(
-    () => null,
-    (err) => err,
-  )
-  if (moveErr) {
-    if (moveErr?.code === 'ENOENT') {
-      return { ok: false, code: 'not-archived', error: `sage-mem: not archived: ${safe}（删除途中它从归档区消失了）` }
-    }
-    return {
-      ok: false,
-      code: 'move-failed',
-      error: `sage-mem: 删除 ${safe} 时移不动它（${moveErr?.code ?? moveErr}：${moveErr?.message ?? moveErr}）。文件仍在 archive/ 里、一个字节没动 —— 可稍后重试（若是被其它程序占用，关掉它再来）。`,
+  const taken = takenRes.taken
+  const takenContent = await readFile(taken, 'utf8')
+  const onDisk = readArchivedMeta(takenContent)
+  const currentRev = archivedRevisionOf(takenContent)
+  const expectedAt = String(expectedArchivedAt ?? '')
+  const expectedRev = String(expectedRevision ?? '')
+
+  /** 拒绝并把接管的原文**还回 archive/**；还不动时把路径带进错误里（内容绝不丢）。 */
+  const rejectAndReturn = async (code, head) => {
+    const back = await returnSource(taken, full)
+    if (!back.ok) {
+      return {
+        ok: false,
+        code,
+        error: `${head}；归还原名时被占用 —— **内容仍保留在 archive/${basename(back.keptAt)}**，请手工改回 ${safe}。`,
+      }
     }
+    return { ok: false, code, error: head }
   }
+
+  /**
+   * 没带内容身份的老界面 / 老调用：**不许删**。放行它就等于退回「按名字删」——
+   * 用户确认过的到底是哪一版，服务端无从核对。
+   */
+  if (expectedRev === '') {
+    return rejectAndReturn(
+      'stale-confirm',
+      `sage-mem: ${safe} 的删除确认没有带内容代次（revision），宿主无法核对「删的是不是你看过的那一版」，本次一个字节都没删 —— 请刷新列表后重试（旧版面板需要升级）`,
+    )
+  }
+  if (expectedAt !== onDisk.archivedAt || expectedRev !== currentRev) {
+    return rejectAndReturn(
+      'changed',
+      `sage-mem: ${safe} 在确认之后被换成了另一版（界面上是「${expectedAt || '时间未知'}」/「${expectedRev}」，` +
+        `盘上是「${onDisk.archivedAt || '时间未知'}」/「${currentRev}」），本次一个字节都没删 —— 请刷新列表再看一眼`,
+    )
+  }
+  /** 到这里才删：删的是**核对过内容身份的私有副本**（名字底下的东西早就被接管走了）。 */
   const delErr = await rm(taken, { force: true }).then(
     () => null,
     (err) => err,
   )
   if (delErr) {
-    const restored = await link(taken, full).then(
-      () => true,
-      () => false,
-    )
-    if (!restored) {
+    const back = await returnSource(taken, full)
+    if (!back.ok) {
       return {
         ok: false,
         code: 'delete-failed',
         error:
           `sage-mem: 删除 ${safe} 失败（${delErr?.code ?? delErr}），且归还原名时被占用 —— ` +
-          `**内容仍保留在 archive/${basename(taken)}**，请手工改回 ${safe} 再试。`,
+          `**内容仍保留在 archive/${basename(back.keptAt)}**，请手工改回 ${safe} 再试。`,
       }
     }
-    await rm(taken, { force: true }).catch(() => {})
     return {
       ok: false,
       code: 'delete-failed',

package/lib/memory/scan.js

@@ -65,18 +65,25 @@ function unquoteYaml(raw) {
   return s
 }
 
-/** 读 frontmatter 里的归档留痕。没有 frontmatter / 没有这两个字段都回空串。 */
+/**
+ * 读 frontmatter 里的归档留痕。没有 frontmatter / 没有这些字段都回空串。
+ *
+ * `archivedRev` 是 2026-10-31 外部审查 Q07 补的**归档代次**：一次性随机标记，
+ * 每次归档新生成。`archived_at` 只是展示时间（`YYYY-MM-DD HH:mm`，同一分钟内不可区分），
+ * 既不是内容身份也不可复用 —— 删除确认必须带代次 + 内容 revision，见
+ * `memory/archive.js` 的 `archivedRevisionOf`。老数据没有这一行时回空串。
+ */
 export function readArchivedMeta(content) {
   const m = String(content ?? '').match(FRONTMATTER_RE)
-  if (!m) return { archivedAt: '', archivedReason: '' }
+  if (!m) return { archivedAt: '', archivedReason: '', archivedRev: '' }
   const grab = (key) => {
     const hit = m[1].match(new RegExp(`^${key}:[ \\t]*(.*?)[ \\t\\r]*$`, 'm'))
     return hit ? unquoteYaml(hit[1]) : ''
   }
-  return { archivedAt: grab('archived_at'), archivedReason: grab('archived_reason') }
+  return { archivedAt: grab('archived_at'), archivedReason: grab('archived_reason'), archivedRev: grab('archived_rev') }
 }
 
-/** 去掉归档留痕两行（恢复时用）。没有 frontmatter 就原样返回。 */
+/** 去掉归档留痕（恢复时用）。没有 frontmatter 就原样返回。 */
 export function stripArchiveMeta(content) {
   const src = String(content ?? '')
   const m = src.match(FRONTMATTER_RE)
@@ -84,22 +91,30 @@ export function stripArchiveMeta(content) {
   const eol = eolOf(src)
   const body = m[1]
     .split(/\r?\n/)
-    .filter((line) => !/^[ \t]*archived_(at|reason)[ \t]*:/.test(line))
+    .filter((line) => !/^[ \t]*archived_(at|reason|rev)[ \t]*:/.test(line))
   const block = ['---', ...body, '---'].join(eol)
   return block + src.slice(m.index + m[0].length)
 }
 
 /**
- * 写入归档留痕：`archived_at` + `archived_reason` 插在 frontmatter 末尾。
+ * 写入归档留痕：`archived_at` + `archived_reason`（+ 可选 `archived_rev`）插在
+ * frontmatter 末尾。
  *
  * 已经是归档态的文件再归档没有意义（上层会先拒绝），所以这里只做 upsert：
- * 先剥掉旧的两行再插，免得同一份文件里出现两个 `archived_at`。
+ * 先剥掉旧的行再插，免得同一份文件里出现两个 `archived_at`。
  * 没有 frontmatter 的文件补一个最小块 —— 归档信息必须有地方放。
+ *
+ * @param {string} content — 正文
+ * @param {string} reason — 归档缘由
+ * @param {string} at — 展示时间 `YYYY-MM-DD HH:mm`
+ * @param {string} [rev] — 归档代次（一次性；省略时不写这一行，老调用与老数据保持原样）
  */
-export function addArchiveMeta(content, reason, at) {
+export function addArchiveMeta(content, reason, at, rev = '') {
   const src = String(content ?? '')
   const eol = eolOf(src)
   const lines = [`archived_at: ${yamlScalar(at)}`, `archived_reason: ${yamlScalar(reason)}`]
+  const gen = String(rev ?? '')
+  if (gen) lines.push(`archived_rev: ${yamlScalar(gen)}`)
   const stripped = stripArchiveMeta(src)
   const m = stripped.match(FRONTMATTER_RE)
   if (!m) return ['---', ...lines, '---', '', stripped].join(eol)

package/lib/memory/util.js

@@ -2,7 +2,8 @@
  * sage-mem 记忆层 —— 通用小工具：统一日志出口与原子写。
  */
 
-import { link, open, rename, unlink, writeFile } from 'node:fs/promises'
+import { randomUUID } from 'node:crypto'
+import { link, open, readFile, rename, rm, unlink, writeFile } from 'node:fs/promises'
 
 /**
  * 统一告警出口。所有非 ENOENT 的失败都必须落到日志，绝不静默
@@ -124,6 +125,77 @@ export async function writeFileExclusive(target, content) {
   return { exclusive }
 }
 
+/**
+ * **事务式接管源文件**：把源 `rename` 到只有本次调用知道的私有名，再逐字节核对
+ * 它是不是调用方读到的那些字节。
+ *
+ * 为什么需要它（2026-10-31 外部审查 Q06 / 复审 R06）：`unlink(名字)` / `rm(名字)`
+ * 只认名字 —— 从「读到内容」到「动手删」之间隔着若干次 IO，别人完全可能在这段时间里
+ * 把那个名字换成新版本，按名删除就会把**从未被收走过的新版本**从唯一的位置抹掉。
+ * `rename` 是原子的：先把源移到私有名上，再对**移走的那份实物**核对内容，
+ * 「名字」与「身份」就解耦了（与 `autodream/gate.js`「抢占过期锁 + 复核 + 还回」同一套手法）。
+ *
+ * ⚠️ 判据必须是**内容**，不能是 `dev:ino + size + mtime`（复审复核实测：原地截断改写 +
+ * 体积刚好相同 + 回写 mtime 会让三元组全部命中，新版本被当成旧版本收走）。内容比对
+ * 成本可忽略 —— 归档 / 恢复本来就要把这份内容读进内存。
+ *
+ * 失败时**绝不直接丢掉**这份内容：
+ *   - 内容对不上 → 用 `link()` 还回原名；原名已被别人占住时，把它留在私有名上并带回路径；
+ *   - 移不动 → 源还在原处、一个字节没动（按真实错误码分流，别谎称「源不存在」）。
+ *
+ * @param {string} from — 源路径
+ * @param {Buffer} expected — 调用方读到的字节
+ * @param {string} tag — 私有名后缀（`archiving` / `restoring`）；体检按它认崩溃残留
+ * @returns {Promise<
+ *   {ok:true, taken:string} |
+ *   {ok:false, code:'not-found'|'move-failed'|'changed', cause?:Error, keptAt?:string}
+ * >}
+ */
+export async function takeOverSource(from, expected, tag) {
+  const taken = `${from}.${tag}-${randomUUID().replace(/-/g, '')}`
+  const moveErr = await rename(from, taken).then(
+    () => null,
+    (err) => err,
+  )
+  if (moveErr) {
+    return { ok: false, code: moveErr?.code === 'ENOENT' ? 'not-found' : 'move-failed', cause: moveErr }
+  }
+  const current = await readFile(taken).catch(() => null)
+  if (current !== null && Buffer.compare(current, expected) === 0) return { ok: true, taken }
+  // 移走的是**别人**的新版本：还回去，一个字节都不动。
+  const back = await returnSource(taken, from)
+  return { ok: false, code: 'changed', ...(back.ok ? {} : { keptAt: back.keptAt }) }
+}
+
+/**
+ * 把 `takeOverSource` 接管的那份**原样**还回原名。
+ *
+ * 还成功时删掉私有副本；原名已被别人占住（`link` 报 EEXIST）或其它原因还不动时，
+ * **绝不删它** —— 它是这份内容唯一的落身处，留在私有名上让人去捞。
+ *
+ * @returns {Promise<{ok:true}|{ok:false,keptAt:string}>}
+ */
+export async function returnSource(taken, to) {
+  const linked = await link(taken, to).then(
+    () => true,
+    () => false,
+  )
+  if (!linked) return { ok: false, keptAt: taken }
+  await rm(taken, { force: true }).catch(() => {})
+  return { ok: true }
+}
+
+/**
+ * 退役一份已经被**成功接管并落位**的私有副本。
+ *
+ * 调用者必须已经确认落位目标拿到了同一份内容：这里删的是私有名，不是任何可能
+ * 已经被别人改过的公开名字 —— 「目标落位后归档源又被写成 B」时，B 住在公开名上，
+ * 这里一个字节都碰不到它。
+ */
+export async function retireTaken(taken) {
+  await rm(taken, { force: true }).catch(() => {})
+}
+
 /**
  * 造一个**进程内串行队列**：同一个队列上的任务一个接一个跑，绝不并发。
  *

package/lib/typert.host.js

@@ -20,8 +20,7 @@ const fileNameSchema = z.string().min(1).max(255).regex(new RegExp(MD_NAME_PATTE
 // 到半兆量级基本是写错了目标（贴了日志/代码进来）。与 lib/index.js 的 MAX_FILE_BYTES 一致。
 const fileContentSchema = z.string().max(MAX_FILE_BYTES)
 
-// 2.1.2（Q02）：写协议第三参（expectedRevision / create）—— 字段与参数都 optional，旧调用方照旧过；
-// 不声明它的话 strictObject 会把新面板传的 revision 整个拒掉（不是弱化，是完全不通）。
+// 2.1.2（Q02）：写协议第三参（expectedRevision / create），都 optional；不声明的话 strictObject 会把新面板传的 revision 整个拒掉。
 const writeOptsSchema = z.object({ 'expectedRevision': z.string().max(128).readonly().optional(), 'create': z.boolean().readonly().optional() }).readonly()
 
 // autodream 报告引用：比 fileNameSchema 宽——旧版报告列表里的条目带 `dream/` 前缀
@@ -97,6 +96,8 @@ const archivedFileSchema = z.object({
 	'tags': z.array(z.string()).readonly(),
 	'archivedAt': z.string().readonly(),
 	'archivedReason': z.string().readonly(),
+	// 2.1.6（外部审查 Q07）：**内容身份**（归档代次 + 正文 revision）；strict 会把没声明的字段剥掉。
+	'revision': z.string().readonly(),
 }).readonly()
 const archivedListSchema = z.object({
 	'count': z.number().readonly(),
@@ -106,21 +107,19 @@ const archivedListSchema = z.object({
 // 归档缘由：用户输入的一句话。真正的 YAML 转义在 host 侧 yamlScalar（值里的「: 」「 #」），
 // 这里只兜长度 —— 缘由不该长到把 frontmatter 变成正文。
 const archiveReasonSchema = z.string().max(1000).optional()
-// 归档代次（`archived_at`，`YYYY-MM-DD HH:mm`）：面板把它交回「彻底删除」当**身份判据**
-// —— 用户确认过的是「这一版归档件」，名字不是身份。老归档件没有留痕时传空串，所以不设 min。
+// 归档代次（`archived_at`，`YYYY-MM-DD HH:mm`）：展示时间，老归档件没有留痕时传空串。
 const archiveStampSchema = z.string().max(64)
+// 归档内容身份（`归档代次@内容 revision`，见 archive.js 的 archivedRevisionOf）：2.1.6（Q07）起
+// 「彻底删除」必须带它 —— 没有它就只能按名字删，而名字不是身份；格式是不透明字符串。
+const archiveRevisionSchema = z.string().min(1).max(128)
 // starmap.listStars 的可选开关：不看归档星时行为与从前完全一致。
 const includeArchivedSchema = z.boolean().optional()
 
-// 归档 / 恢复的结果：成功 `{ ok: true, file, unindexed|indexed, indexError? }`，
-// 失败 `{ ok: false, error }` —— 失败分支**没有 file**（名字本身可能就是非法的）。
-// 所以不能复用 writeResultSchema：那边 `file` 是必填（writeFile 连失败都带着归一后的文件名），
-// strict 校验会把失败分支判成坏结果。
+// 归档 / 恢复的结果：成功 `{ ok, file, unindexed|indexed, indexError? }`，失败 `{ ok:false, error }`
+// —— 失败分支**没有 file**，不能复用 writeResultSchema（那边 file 必填，strict 会把失败判成坏结果）。
 //
-// ⚠️ `unindexed` / `indexed` / `indexError` 必须在这里声明（2026-10-12 复审 R11 的配套）：
-// strict codec 会把没声明的字段**整个剥掉**，于是「索引没摘掉 / 没补上」这件事在界面路径上
-// 永远不可见 —— 与 R01 漏掉四个配置字段是同一类错误，换了个字段名而已。
-// `archivedReason` 同理：面板要显示「它为什么被收起来」。
+// ⚠️ `unindexed` / `indexed` / `indexError` / `archivedReason` 必须在这里声明（2026-10-12 复审 R11）：
+// strict codec 会把没声明的字段整个剥掉，「索引没摘掉 / 没补上」在界面路径上就永远不可见。
 const archiveResultSchema = z.object({
 	'ok': z.boolean().readonly(),
 	'file': z.string().readonly().optional(),
@@ -736,8 +735,8 @@ export const TYPERT = {
 			sourceLocation: { "file": "lib/index.js", "line": 1, "column": 1 },
 		},
 		{
-			// **彻底删除**一条归档件（不可恢复）。第二个参数是身份判据，不是装饰：
-			// 名字在「用户确认」与「请求到达」之间可能已经被恢复＋重新归档成另一版。
+			// **彻底删除**一条归档件（不可恢复）。`archivedAt` 是展示时间，`revision` 才是内容身份
+			// （归档代次 + 正文 revision）—— 期间可能被恢复＋同分钟重新归档、或改成同时间戳另一版（Q07）。
 			id: 'sage-mem#memory/deleteArchived',
 			service: 'memory',
 			namespace: 'memory',
@@ -746,6 +745,7 @@ export const TYPERT = {
 			parameters: [
 				{ name: 'name', wire: 'name', source: 'json', codec: { mode: 'strict', typeSymbol: 'sage-mem/types#ArchivedFileName', schema: fileNameSchema, create: () => fileNameSchema } },
 				{ name: 'archivedAt', wire: 'archivedAt', source: 'json', codec: { mode: 'strict', typeSymbol: 'sage-mem/types#ArchiveStamp', schema: archiveStampSchema, create: () => archiveStampSchema } },
+				{ name: 'revision', wire: 'revision', source: 'json', codec: { mode: 'strict', typeSymbol: 'sage-mem/types#ArchiveRevision', schema: archiveRevisionSchema, create: () => archiveRevisionSchema } },
 			],
 			// 成功 `{ ok: true, file }`、失败 `{ ok: false, error }` —— 与归档 / 恢复同形，复用 ArchiveResult。
 			result: { mode: 'strict', typeSymbol: 'sage-mem/types#ArchiveResult', schema: archiveResultSchema, create: () => archiveResultSchema },

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "sage-mem",
   "description": "Cross-session memory for DeepSeek Harness — plain markdown files, no database, no worker.",
-  "version": "2.1.4",
+  "version": "2.1.6",
   "type": "module",
   "main": "lib/index.js",
   "icon": "./icon.png",