sage-mem 2.1.5 → 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.5`** — 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.5`** —— 顶部 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/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 { 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 } 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 })
   /**
    * 先落归档副本、再删原件：中途崩了最坏是两份都在（人工可收拾），不会一份都没有。
@@ -337,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))}`
+}
+
 /**
  * 从归档区**彻底删除**一条记忆（不可恢复）。
  *
@@ -347,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
@@ -383,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/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.5",
+  "version": "2.1.6",
   "type": "module",
   "main": "lib/index.js",
   "icon": "./icon.png",