@remnic/core 9.51.1 → 9.52.1

package/dist/{chunk-VBHPOWBJ.js → chunk-WD5B5AIE.js}

@@ -14,7 +14,7 @@ import {
   applyTombstoneResurrectionGate,
   buildRetiredFactTombstoneInputs,
   collectRetiredMemoriesForRebuild
-} from "./chunk-ENTCVTQR.js";
+} from "./chunk-JJRVPWFY.js";
 import {
   withholdToolScopedFromSharedNamespace
 } from "./chunk-S2V7RUCL.js";
@@ -61,7 +61,7 @@ import {
   isQueuedReviewMemory,
   parseTombstoneBlockedOfflineSyncMemory,
   tombstoneBlocked
-} from "./chunk-BHXYAVUM.js";
+} from "./chunk-DLG5V6ND.js";
 import {
   composeMemoryEnvelope,
   isSealedMemoryEnvelope,
@@ -83,7 +83,7 @@ import {
 } from "./chunk-G7D6GZ5J.js";
 import {
   createVersion
-} from "./chunk-OQAL6SIR.js";
+} from "./chunk-ZMSZVISA.js";
 import {
   attachInFlightReader,
   beginCoalescedScan,
@@ -105,12 +105,12 @@ import {
   requestEntityCanonicalIdReconcileSync,
   resolveHistoricalEntityCanonicalId,
   withEntityCanonicalMutationLock
-} from "./chunk-M4A44LUA.js";
+} from "./chunk-GSTIBXBW.js";
 import {
   computeSupersessionKey,
   normalizeSupersessionKey,
   supersessionKeysForFact
-} from "./chunk-EWMTOVMY.js";
+} from "./chunk-5WITETWU.js";
 import {
   clearMemoryCache,
   getCachedEntities,
@@ -204,7 +204,8 @@ import {
   raceAbort
 } from "./chunk-BTTPKDIL.js";
 import {
-  isPathInsideStorageRoot
+  isPathInsideStorageRoot,
+  resolveSafeStoragePath
 } from "./chunk-FF4KLI5W.js";
 import {
   MAGIC_HEADER_SIZE,
@@ -229,21 +230,20 @@ import {
 
 // src/storage.ts
 import {
-  lstat as lstat3,
-  readdir as readdir5,
-  readFile as readFile2,
+  lstat as lstat4,
+  readdir as readdir6,
+  readFile as readFile3,
   realpath as realpath3,
-  rename as rename2,
   stat as stat2,
   writeFile as writeFile2,
-  mkdir,
-  unlink as unlink4,
+  mkdir as mkdir2,
+  unlink as unlink5,
   appendFile,
-  open
+  open as open2
 } from "fs/promises";
 import { appendFileSync, createReadStream, mkdirSync, statSync } from "fs";
-import { createHash as createHash6, randomUUID as randomUUID2 } from "crypto";
-import path9 from "path";
+import { createHash as createHash7 } from "crypto";
+import path11 from "path";
 
 // src/storage/memory-read-store.ts
 import { lstat, readdir, realpath, stat } from "fs/promises";
@@ -762,6 +762,29 @@ var MemoryReadStore = class {
   }
 };
 
+// src/storage/committed-invalidation.ts
+async function clearProofFailOpen(callbacks) {
+  await callbacks.clearProof?.().catch((error) => {
+    log.warn(`failed to clear invalidation proof for ${callbacks.memoryId}: ${error}`);
+  });
+}
+async function runCommittedInvalidation(callbacks) {
+  let deletionCompleted = false;
+  try {
+    await callbacks.recordProof?.();
+    if (!await callbacks.deleteMemory()) {
+      await clearProofFailOpen(callbacks);
+      return false;
+    }
+    deletionCompleted = true;
+    await callbacks.afterDelete();
+    return true;
+  } catch (error) {
+    if (!deletionCompleted) await clearProofFailOpen(callbacks);
+    throw error;
+  }
+}
+
 // src/storage/profile-header.ts
 var LAST_UPDATED_HEADER = /^\*Last updated:[^*]*\*$/;
 var PROFILE_TITLE = /^ {0,3}#(?:[ \t]+|$)/;
@@ -2045,9 +2068,425 @@ ${rows.join("\n")}
   }
 };
 
+// src/storage/deletion-revision-store.ts
+import { createHash, randomUUID } from "crypto";
+import { lstat as lstat2, mkdir, open, readFile, rename, unlink as unlink2 } from "fs/promises";
+import path3 from "path";
+var DELETION_REVISION_MAX_MTIME_MS = 864e13;
+var DELETION_REVISION_LOCK_STALE_MS = 6e4;
+var DELETION_REVISION_LOCK_MAX_WAIT_MS = 12e4;
+var INVALIDATION_COMMIT_MAX_TIMESTAMP_MS = 864e13;
+var INVALIDATION_PROOF_QUARANTINE_MAX_IDS = 1024;
+function canonicalizeInvalidationEvidence(value) {
+  if (Array.isArray(value)) return value.map((item) => canonicalizeInvalidationEvidence(item));
+  if (value && typeof value === "object") {
+    const result = {};
+    for (const key of Object.keys(value).sort()) {
+      result[key] = canonicalizeInvalidationEvidence(value[key]);
+    }
+    return result;
+  }
+  return value;
+}
+function invalidationCommitFingerprint(memory) {
+  const frontmatter = { ...memory.frontmatter };
+  delete frontmatter.accessCount;
+  delete frontmatter.lastAccessed;
+  return createHash("sha256").update(
+    JSON.stringify(
+      canonicalizeInvalidationEvidence({
+        content: memory.content,
+        frontmatter
+      })
+    )
+  ).digest("hex");
+}
+function isValidInvalidationCommitTimestamp(value) {
+  return typeof value === "number" && Number.isFinite(value) && value >= 0 && value <= INVALIDATION_COMMIT_MAX_TIMESTAMP_MS;
+}
+function isValidInvalidationCommitFingerprint(value) {
+  return typeof value === "string" && /^[a-f0-9]{64}$/.test(value);
+}
+function isValidMemoryId(value) {
+  return typeof value === "string" && value.length > 0 && !value.includes("\0");
+}
+function isValidDeletionRevisionPath(value) {
+  return typeof value === "string" && value.length > 0 && !value.includes("\\") && !value.includes("\0") && !path3.posix.isAbsolute(value) && path3.posix.normalize(value) === value && value !== "." && value !== ".." && !value.startsWith("../");
+}
+function deletionRevisionPathIdentity(value) {
+  return value.normalize("NFC").toUpperCase().toLowerCase();
+}
+var DeletionRevisionStore = class {
+  options;
+  invalidationProofQuarantine = /* @__PURE__ */ new Set();
+  invalidationProofQuarantineFull = false;
+  invalidationProofQuarantineFullAt = null;
+  constructor(options) {
+    this.options = options;
+  }
+  quarantineInvalidationProof(memoryId) {
+    if (this.invalidationProofQuarantineFull) {
+      const nextBoundary = Date.now() + 1;
+      this.invalidationProofQuarantineFullAt = Math.max(
+        this.invalidationProofQuarantineFullAt ?? 0,
+        nextBoundary
+      );
+      return;
+    }
+    if (this.invalidationProofQuarantine.has(memoryId)) return;
+    if (this.invalidationProofQuarantine.size >= INVALIDATION_PROOF_QUARANTINE_MAX_IDS) {
+      this.invalidationProofQuarantineFull = true;
+      this.invalidationProofQuarantineFullAt = Date.now() + 1;
+      return;
+    }
+    this.invalidationProofQuarantine.add(memoryId);
+  }
+  async resolveConfiguredStoragePath(targetPath) {
+    const baseDir = path3.resolve(this.options.baseDir);
+    const relativePath = path3.relative(baseDir, path3.resolve(targetPath));
+    return resolveSafeStoragePath(baseDir, relativePath);
+  }
+  async resolveManagedStoragePath(filePath, method) {
+    const assertedPath = this.options.assertManagedStoragePath(filePath, method);
+    const target = await this.resolveConfiguredStoragePath(assertedPath);
+    const relativePath = path3.relative(path3.resolve(this.options.baseDir), target).split(path3.sep).join("/");
+    return { target, relativePath };
+  }
+  parseDeletionRevisionMetadata(raw) {
+    let parsed;
+    try {
+      parsed = JSON.parse(raw);
+    } catch {
+      throw new Error("Deletion revision metadata is invalid.");
+    }
+    if (!parsed || typeof parsed !== "object" || Array.isArray(parsed)) {
+      throw new Error("Deletion revision metadata is invalid.");
+    }
+    const root = parsed;
+    if (Object.keys(root).sort().join(",") !== "deletions,version" || root.version !== 1 || !Array.isArray(root.deletions)) {
+      throw new Error("Deletion revision metadata is invalid.");
+    }
+    const revisions = /* @__PURE__ */ new Map();
+    const pathByIdentity = /* @__PURE__ */ new Map();
+    for (const rawEntry of root.deletions) {
+      if (!rawEntry || typeof rawEntry !== "object" || Array.isArray(rawEntry)) {
+        throw new Error("Deletion revision metadata is invalid.");
+      }
+      const entry = rawEntry;
+      if (Object.keys(entry).sort().join(",") !== "mtimeMs,path" || !isValidDeletionRevisionPath(entry.path) || typeof entry.mtimeMs !== "number" || !Number.isFinite(entry.mtimeMs) || entry.mtimeMs < 0 || entry.mtimeMs > DELETION_REVISION_MAX_MTIME_MS || revisions.has(entry.path)) {
+        throw new Error("Deletion revision metadata is invalid.");
+      }
+      const identity = deletionRevisionPathIdentity(entry.path);
+      if (pathByIdentity.has(identity)) {
+        throw new Error("Deletion revision metadata is invalid.");
+      }
+      pathByIdentity.set(identity, entry.path);
+      revisions.set(entry.path, entry.mtimeMs);
+    }
+    return new Map([...revisions.entries()].sort(([left], [right]) => left < right ? -1 : left > right ? 1 : 0));
+  }
+  async readDeletionRevisionMetadata() {
+    const metadataPath = await this.resolveConfiguredStoragePath(this.options.deletionRevisionMetadataPath);
+    let raw;
+    try {
+      raw = await readFile(metadataPath, "utf8");
+    } catch (error) {
+      if (isErrnoCode(error, "ENOENT")) return /* @__PURE__ */ new Map();
+      throw new Error("Deletion revision metadata is unavailable.");
+    }
+    return this.parseDeletionRevisionMetadata(raw);
+  }
+  async writeDeletionRevisionMetadata(revisions, lock) {
+    const metadataPath = await this.resolveConfiguredStoragePath(this.options.deletionRevisionMetadataPath);
+    const deletions = [...revisions.entries()].sort(([left], [right]) => left < right ? -1 : left > right ? 1 : 0).map(([entryPath, mtimeMs]) => ({ path: entryPath, mtimeMs }));
+    const metadata = { version: 1, deletions };
+    const temporaryPath = await this.resolveConfiguredStoragePath(
+      `${metadataPath}.${process.pid}.${randomUUID()}.tmp`
+    );
+    let handle = null;
+    try {
+      handle = await open(temporaryPath, "wx", 384);
+      await handle.writeFile(`${JSON.stringify(metadata)}
+`, "utf8");
+      await handle.sync();
+      await handle.close();
+      handle = null;
+      if (!await lock.refresh()) {
+        throw new Error("Deletion revision metadata lock was lost.");
+      }
+      const renameTarget = await this.resolveConfiguredStoragePath(this.options.deletionRevisionMetadataPath);
+      await rename(temporaryPath, renameTarget);
+    } finally {
+      if (handle !== null) {
+        await handle.close().catch((error) => {
+          log.warn("failed to close deletion revision metadata temporary file", error);
+        });
+      }
+      const cleanupPath = await this.resolveConfiguredStoragePath(temporaryPath).catch((error) => {
+        log.warn("failed to resolve deletion revision metadata temporary file for cleanup", error);
+        return null;
+      });
+      if (cleanupPath !== null) {
+        await unlink2(cleanupPath).catch((error) => {
+          if (!isErrnoCode(error, "ENOENT")) {
+            log.warn("failed to clean up deletion revision metadata temporary file", error);
+          }
+        });
+      }
+    }
+  }
+  async withDeletionRevisionLock(task) {
+    const lockPath2 = await this.resolveConfiguredStoragePath(this.options.deletionRevisionLockPath);
+    return withHeldFileLock(
+      lockPath2,
+      {
+        staleMs: DELETION_REVISION_LOCK_STALE_MS,
+        maxWaitMs: DELETION_REVISION_LOCK_MAX_WAIT_MS
+      },
+      async (acquired, lock) => {
+        if (!acquired) throw new Error("Deletion revision metadata lock is unavailable.");
+        return task(lock);
+      }
+    );
+  }
+  async readDeletionRevisions() {
+    return this.withDeletionRevisionLock(async () => this.readDeletionRevisionMetadata());
+  }
+  parseInvalidationCommitMetadata(raw) {
+    let parsed;
+    try {
+      parsed = JSON.parse(raw);
+    } catch {
+      throw new Error("Invalidation commit metadata is invalid.");
+    }
+    if (!parsed || typeof parsed !== "object" || Array.isArray(parsed)) {
+      throw new Error("Invalidation commit metadata is invalid.");
+    }
+    const root = parsed;
+    if (Object.keys(root).sort().join(",") !== "commits,version" || root.version !== 1 || !Array.isArray(root.commits)) {
+      throw new Error("Invalidation commit metadata is invalid.");
+    }
+    const commits = /* @__PURE__ */ new Map();
+    for (const rawEntry of root.commits) {
+      if (!rawEntry || typeof rawEntry !== "object" || Array.isArray(rawEntry)) {
+        throw new Error("Invalidation commit metadata is invalid.");
+      }
+      const entry = rawEntry;
+      if (Object.keys(entry).sort().join(",") !== "committedAt,fingerprint,memoryId" || !isValidMemoryId(entry.memoryId) || !isValidInvalidationCommitFingerprint(entry.fingerprint) || !isValidInvalidationCommitTimestamp(entry.committedAt) || commits.has(entry.memoryId)) {
+        throw new Error("Invalidation commit metadata is invalid.");
+      }
+      commits.set(entry.memoryId, {
+        fingerprint: entry.fingerprint,
+        committedAt: entry.committedAt
+      });
+    }
+    return commits;
+  }
+  async readInvalidationCommitMetadata() {
+    const metadataPath = await this.resolveConfiguredStoragePath(this.options.invalidationCommitMetadataPath);
+    let raw;
+    try {
+      raw = await readFile(metadataPath, "utf8");
+    } catch (error) {
+      if (isErrnoCode(error, "ENOENT")) return /* @__PURE__ */ new Map();
+      throw new Error("Invalidation commit metadata is unavailable.");
+    }
+    return this.parseInvalidationCommitMetadata(raw);
+  }
+  async writeInvalidationCommitMetadata(commits, lock) {
+    const metadataPath = await this.resolveConfiguredStoragePath(this.options.invalidationCommitMetadataPath);
+    const entries = [...commits.entries()].sort(([left], [right]) => left < right ? -1 : left > right ? 1 : 0).map(([memoryId, value]) => ({
+      memoryId,
+      fingerprint: value.fingerprint,
+      committedAt: value.committedAt
+    }));
+    const metadata = { version: 1, commits: entries };
+    const temporaryPath = await this.resolveConfiguredStoragePath(
+      `${metadataPath}.${process.pid}.${randomUUID()}.tmp`
+    );
+    const metadataDir = await this.resolveConfiguredStoragePath(path3.dirname(metadataPath));
+    let handle = null;
+    let renamed = false;
+    try {
+      await mkdir(metadataDir, { recursive: true });
+      handle = await open(temporaryPath, "wx", 384);
+      await handle.writeFile(`${JSON.stringify(metadata)}
+`, "utf8");
+      await handle.sync();
+      await handle.close();
+      handle = null;
+      if (!await lock.refresh()) {
+        throw new Error("Invalidation commit metadata lock was lost.");
+      }
+      const renameTarget = await this.resolveConfiguredStoragePath(this.options.invalidationCommitMetadataPath);
+      await rename(temporaryPath, renameTarget);
+      renamed = true;
+    } finally {
+      if (handle !== null) {
+        await handle.close().catch((error) => {
+          log.warn("failed to close invalidation commit metadata temporary file", error);
+        });
+      }
+      const cleanupPath = await this.resolveConfiguredStoragePath(temporaryPath).catch((error) => {
+        log.warn("failed to resolve invalidation commit metadata temporary file for cleanup", error);
+        return null;
+      });
+      if (cleanupPath !== null) {
+        await unlink2(cleanupPath).catch((error) => {
+          if (!isErrnoCode(error, "ENOENT")) {
+            log.warn(
+              `failed to clean up invalidation commit metadata temporary file after ${renamed ? "commit" : "failure"}`,
+              error
+            );
+          }
+        });
+      }
+    }
+  }
+  async hasCommittedInvalidation(memory) {
+    const memoryId = memory.frontmatter.id;
+    const fingerprint = invalidationCommitFingerprint(memory);
+    return this.withDeletionRevisionLock(async () => {
+      const entry = (await this.readInvalidationCommitMetadata()).get(memoryId);
+      if (entry?.fingerprint !== fingerprint) return false;
+      if (this.invalidationProofQuarantine.has(memoryId)) return false;
+      if (!this.invalidationProofQuarantineFull) return true;
+      const fullAt = this.invalidationProofQuarantineFullAt;
+      return fullAt !== null && entry.committedAt >= fullAt;
+    });
+  }
+  async recordCommittedInvalidation(memory) {
+    const fingerprint = invalidationCommitFingerprint(memory);
+    await this.withDeletionRevisionLock(async (lock) => {
+      const fullAt = this.invalidationProofQuarantineFullAt;
+      const committedAt = fullAt === null ? Date.now() : Math.max(Date.now(), fullAt + 1);
+      const commits = await this.readInvalidationCommitMetadata();
+      commits.set(memory.frontmatter.id, {
+        fingerprint,
+        committedAt
+      });
+      await this.writeInvalidationCommitMetadata(commits, lock);
+      this.invalidationProofQuarantine.delete(memory.frontmatter.id);
+    });
+  }
+  async clearCommittedInvalidation(memory) {
+    const memoryId = memory.frontmatter.id;
+    this.quarantineInvalidationProof(memoryId);
+    const fingerprint = invalidationCommitFingerprint(memory);
+    let cleared = false;
+    try {
+      await this.withDeletionRevisionLock(async (lock) => {
+        const commits = await this.readInvalidationCommitMetadata();
+        const current = commits.get(memoryId);
+        if (current?.fingerprint !== fingerprint) return;
+        commits.delete(memoryId);
+        await this.writeInvalidationCommitMetadata(commits, lock);
+      });
+      cleared = true;
+    } finally {
+      if (cleared) this.invalidationProofQuarantine.delete(memoryId);
+    }
+  }
+  async recordReplicatedDeletionRevision(filePath, mtimeMs) {
+    const { relativePath } = await this.resolveManagedStoragePath(
+      filePath,
+      "storage.recordReplicatedDeletionRevision"
+    );
+    if (typeof mtimeMs !== "number" || !Number.isFinite(mtimeMs) || mtimeMs < 0 || mtimeMs > DELETION_REVISION_MAX_MTIME_MS) {
+      throw new Error("Deletion revision timestamp is invalid.");
+    }
+    if (!isValidDeletionRevisionPath(relativePath)) {
+      throw new Error("Deletion revision path is invalid.");
+    }
+    await this.withDeletionRevisionLock(async (lock) => {
+      const revisions = await this.readDeletionRevisionMetadata();
+      const identity = deletionRevisionPathIdentity(relativePath);
+      let existingPath;
+      for (const candidatePath of revisions.keys()) {
+        if (deletionRevisionPathIdentity(candidatePath) === identity) {
+          existingPath = candidatePath;
+          break;
+        }
+      }
+      const existingMtimeMs = existingPath === void 0 ? void 0 : revisions.get(existingPath);
+      if (existingMtimeMs !== void 0 && existingMtimeMs >= mtimeMs) return;
+      const updated = new Map(revisions);
+      if (existingPath !== void 0) updated.delete(existingPath);
+      updated.set(relativePath, mtimeMs);
+      await this.writeDeletionRevisionMetadata(updated, lock);
+    });
+  }
+  async writeManagedStorageFile(filePath, write) {
+    const { relativePath } = await this.resolveManagedStoragePath(filePath, "storage.writeManagedStorageFile");
+    if (!isValidDeletionRevisionPath(relativePath)) {
+      throw new Error("Deletion revision path is invalid.");
+    }
+    await this.withDeletionRevisionLock(async (lock) => {
+      const before = await this.readDeletionRevisionMetadata();
+      const identity = deletionRevisionPathIdentity(relativePath);
+      const existingPath = [...before.keys()].find(
+        (candidatePath) => deletionRevisionPathIdentity(candidatePath) === identity
+      );
+      await write();
+      if (existingPath === void 0) return;
+      const updated = new Map(before);
+      updated.delete(existingPath);
+      await this.writeDeletionRevisionMetadata(updated, lock);
+    });
+  }
+  async deleteManagedStorageFile(filePath, deletionMtimeMs) {
+    const { target, relativePath } = await this.resolveManagedStoragePath(
+      filePath,
+      "storage.deleteManagedStorageFile"
+    );
+    if (deletionMtimeMs !== void 0 && deletionMtimeMs !== null && (typeof deletionMtimeMs !== "number" || !Number.isFinite(deletionMtimeMs) || deletionMtimeMs < 0 || deletionMtimeMs > DELETION_REVISION_MAX_MTIME_MS)) {
+      throw new Error("Deletion revision timestamp is invalid.");
+    }
+    return this.withDeletionRevisionLock(async (lock) => {
+      const safeTarget = await this.resolveConfiguredStoragePath(target);
+      try {
+        await lstat2(safeTarget);
+      } catch (error) {
+        if (isErrnoCode(error, "ENOENT")) return false;
+        throw error;
+      }
+      if (!isValidDeletionRevisionPath(relativePath)) {
+        throw new Error("Deletion revision path is invalid.");
+      }
+      const revision = deletionMtimeMs === null ? void 0 : deletionMtimeMs ?? Date.now();
+      const before = await this.readDeletionRevisionMetadata();
+      const identity = deletionRevisionPathIdentity(relativePath);
+      let existingPath;
+      for (const candidatePath of before.keys()) {
+        if (deletionRevisionPathIdentity(candidatePath) === identity) {
+          existingPath = candidatePath;
+          break;
+        }
+      }
+      const existing = existingPath === void 0 ? void 0 : before.get(existingPath);
+      const changed = existingPath !== void 0 && existingPath !== relativePath || (revision === void 0 ? existing !== void 0 : existing !== revision);
+      if (changed) {
+        const updated = new Map(before);
+        if (existingPath !== void 0) updated.delete(existingPath);
+        if (revision !== void 0) updated.set(relativePath, revision);
+        await this.writeDeletionRevisionMetadata(updated, lock);
+      }
+      try {
+        const unlinkTarget = await this.resolveConfiguredStoragePath(target);
+        await unlink2(unlinkTarget);
+        return true;
+      } catch (error) {
+        if (changed) await this.writeDeletionRevisionMetadata(before, lock);
+        if (isErrnoCode(error, "ENOENT")) return false;
+        throw error;
+      }
+    });
+  }
+};
+
 // src/storage/identity-continuity-store.ts
 import { readdir as readdir3 } from "fs/promises";
-import path3 from "path";
+import path4 from "path";
 var IdentityContinuityStore = class {
   constructor(deps) {
     this.deps = deps;
@@ -2072,7 +2511,7 @@ var IdentityContinuityStore = class {
     const date = nowIso.slice(0, 10);
     const id = this.deps.generateId("incident");
     const incident = createContinuityIncidentRecord(id, input, nowIso);
-    const filePath = path3.join(this.deps.identityIncidentsDir, `${date}-${id}.md`);
+    const filePath = path4.join(this.deps.identityIncidentsDir, `${date}-${id}.md`);
     await this.deps.writeStorageSecureFile(filePath, serializeContinuityIncident(incident));
     return { ...incident, filePath };
   }
@@ -2085,7 +2524,7 @@ var IdentityContinuityStore = class {
       const incidents = [];
       for (const file of candidates) {
         if (incidents.length >= cappedLimit) break;
-        const filePath = path3.join(this.deps.identityIncidentsDir, file);
+        const filePath = path4.join(this.deps.identityIncidentsDir, file);
         try {
           const raw = await this.deps.readStorageSecureFile(filePath);
           const parsed = parseContinuityIncident(raw);
@@ -2116,7 +2555,7 @@ var IdentityContinuityStore = class {
     await this.deps.ensureDirectories();
     const safeKey = this.sanitizeIdentityAuditKey(key);
     const dir = period === "weekly" ? this.deps.identityAuditsWeeklyDir : this.deps.identityAuditsMonthlyDir;
-    const filePath = path3.join(dir, `${safeKey}.md`);
+    const filePath = path4.join(dir, `${safeKey}.md`);
     await this.deps.writeStorageSecureFile(filePath, content);
     return filePath;
   }
@@ -2124,7 +2563,7 @@ var IdentityContinuityStore = class {
     try {
       const safeKey = this.sanitizeIdentityAuditKey(key);
       const dir = period === "weekly" ? this.deps.identityAuditsWeeklyDir : this.deps.identityAuditsMonthlyDir;
-      return await this.deps.readStorageSecureFile(path3.join(dir, `${safeKey}.md`));
+      return await this.deps.readStorageSecureFile(path4.join(dir, `${safeKey}.md`));
     } catch (err) {
       if (err instanceof Error && err.message === "Invalid identity audit key") return null;
       if (!isErrnoCode(err, "ENOENT")) throw err;
@@ -2180,12 +2619,12 @@ var IdentityContinuityStore = class {
     const fileNames = await this.readContinuityIncidentFileNames();
     const directMatch = fileNames.find((name) => name.endsWith(`-${id}.md`));
     if (directMatch) {
-      const directPath = path3.join(this.deps.identityIncidentsDir, directMatch);
+      const directPath = path4.join(this.deps.identityIncidentsDir, directMatch);
       const parsed = await this.readContinuityIncidentFile(directPath);
       if (parsed?.id === id) return directPath;
     }
     for (const fileName of fileNames) {
-      const filePath = path3.join(this.deps.identityIncidentsDir, fileName);
+      const filePath = path4.join(this.deps.identityIncidentsDir, fileName);
       const parsed = await this.readContinuityIncidentFile(filePath);
       if (parsed?.id === id) return filePath;
     }
@@ -2201,19 +2640,19 @@ var IdentityContinuityStore = class {
 };
 
 // src/storage/entity-canonical-id-migration.ts
-import { createHash, randomUUID } from "crypto";
+import { createHash as createHash2, randomUUID as randomUUID2 } from "crypto";
 import {
   access,
-  lstat as lstat2,
-  readFile,
+  lstat as lstat3,
+  readFile as readFile2,
   readdir as readdir4,
   realpath as realpath2,
-  rename,
+  rename as rename2,
   stat as statFile,
-  unlink as unlink2,
+  unlink as unlink3,
   writeFile
 } from "fs/promises";
-import path4 from "path";
+import path5 from "path";
 import { z } from "zod";
 var ENTITY_CANONICAL_ID_MIGRATION_VERSION = 1;
 var ENTITY_CANONICAL_ID_MIGRATION_LOCK_STALE_MS = 6e4;
@@ -2238,7 +2677,7 @@ var EntityCanonicalIdMigrationStateSchema = z.object({
 async function fingerprintPath(filePath) {
   let fileStat;
   try {
-    fileStat = await lstat2(filePath);
+    fileStat = await lstat3(filePath);
   } catch (error) {
     if (!isErrnoCode(error, "ENOENT")) throw error;
   }
@@ -2247,16 +2686,16 @@ async function fingerprintPath(filePath) {
 async function fingerprintEntityEntries(entitiesDir) {
   let names;
   try {
-    names = (await readdir4(entitiesDir)).filter((name) => path4.extname(name) === ".md").sort();
+    names = (await readdir4(entitiesDir)).filter((name) => path5.extname(name) === ".md").sort();
   } catch (error) {
     if (isErrnoCode(error, "ENOENT")) return "missing";
     throw error;
   }
-  const hash = createHash("sha256");
+  const hash = createHash2("sha256");
   for (const name of names) {
     hash.update(`${name.length}:${name}:`);
     try {
-      const entry = await lstat2(path4.join(entitiesDir, name), { bigint: true });
+      const entry = await lstat3(path5.join(entitiesDir, name), { bigint: true });
       hash.update(`${entry.dev}:${entry.ino}:${entry.size}:${entry.mtimeNs}:${entry.ctimeNs}`);
     } catch (error) {
       if (!isErrnoCode(error, "ENOENT")) throw error;
@@ -2276,9 +2715,9 @@ async function getFingerprint(baseDir, entitiesDir, getEntityMutationVersion) {
   ] = await Promise.all([
     fingerprintPath(entitiesDir),
     fingerprintEntityEntries(entitiesDir),
-    fingerprintPath(path4.join(baseDir, "config", "aliases.json")),
-    fingerprintPath(path4.join(baseDir, "state", ENTITY_CANONICAL_ID_RECONCILE_MARKER)),
-    fingerprintPath(path4.join(baseDir, "state", ENTITY_CANONICAL_ID_RECONCILE_CONSUMING_MARKER))
+    fingerprintPath(path5.join(baseDir, "config", "aliases.json")),
+    fingerprintPath(path5.join(baseDir, "state", ENTITY_CANONICAL_ID_RECONCILE_MARKER)),
+    fingerprintPath(path5.join(baseDir, "state", ENTITY_CANONICAL_ID_RECONCILE_CONSUMING_MARKER))
   ]);
   return [
     entityDirectoryFingerprint,
@@ -2292,7 +2731,7 @@ async function getFingerprint(baseDir, entitiesDir, getEntityMutationVersion) {
 async function validateRoots(baseDir, entitiesDir, stateDir, archiveDir) {
   let baseStat;
   try {
-    baseStat = await lstat2(baseDir);
+    baseStat = await lstat3(baseDir);
   } catch (error) {
     if (isErrnoCode(error, "ENOENT")) return;
     throw error;
@@ -2304,14 +2743,14 @@ async function validateRoots(baseDir, entitiesDir, stateDir, archiveDir) {
   const roots = [
     entitiesDir,
     stateDir,
-    ...RECALL_FALLBACK_DIRS.map((directory) => path4.join(baseDir, directory)),
-    path4.join(baseDir, "cold"),
+    ...RECALL_FALLBACK_DIRS.map((directory) => path5.join(baseDir, directory)),
+    path5.join(baseDir, "cold"),
     archiveDir
   ];
   for (const root of roots) {
     let rootStat;
     try {
-      rootStat = await lstat2(root);
+      rootStat = await lstat3(root);
     } catch (error) {
       if (isErrnoCode(error, "ENOENT")) continue;
       throw error;
@@ -2323,13 +2762,13 @@ async function validateRoots(baseDir, entitiesDir, stateDir, archiveDir) {
   }
 }
 function statePath(deps) {
-  return path4.join(deps.stateDir, ENTITY_CANONICAL_ID_MIGRATION_FILE);
+  return path5.join(deps.stateDir, ENTITY_CANONICAL_ID_MIGRATION_FILE);
 }
 async function assertSafeMigrationStateFile(deps) {
   const migrationStatePath = statePath(deps);
   let fileStat;
   try {
-    fileStat = await lstat2(migrationStatePath);
+    fileStat = await lstat3(migrationStatePath);
   } catch (error) {
     if (isErrnoCode(error, "ENOENT")) return;
     throw error;
@@ -2348,7 +2787,7 @@ async function assertSafeMigrationStateFile(deps) {
 async function assertSafeTombstoneFile(deps, tombstonePath) {
   let fileStat;
   try {
-    fileStat = await lstat2(tombstonePath);
+    fileStat = await lstat3(tombstonePath);
   } catch (error) {
     if (isErrnoCode(error, "ENOENT")) return false;
     throw error;
@@ -2366,13 +2805,13 @@ async function assertSafeTombstoneFile(deps, tombstonePath) {
   return true;
 }
 function lockPath(deps) {
-  return path4.join(deps.stateDir, "entity-canonical-id-migration.lock");
+  return path5.join(deps.stateDir, "entity-canonical-id-migration.lock");
 }
 async function readState(deps) {
   await assertSafeMigrationStateFile(deps);
   let raw;
   try {
-    raw = await readFile(statePath(deps), "utf-8");
+    raw = await readFile2(statePath(deps), "utf-8");
   } catch (error) {
     if (isErrnoCode(error, "ENOENT")) return null;
     throw error;
@@ -2395,13 +2834,13 @@ async function readState(deps) {
 }
 async function writeState(deps, state) {
   const destination = statePath(deps);
-  const temporary = `${destination}.${process.pid}.${randomUUID()}.tmp`;
+  const temporary = `${destination}.${process.pid}.${randomUUID2()}.tmp`;
   try {
     await writeFile(temporary, `${JSON.stringify(state, null, 2)}
 `, "utf-8");
-    await rename(temporary, destination);
+    await rename2(temporary, destination);
   } finally {
-    await unlink2(temporary).catch(() => void 0);
+    await unlink3(temporary).catch(() => void 0);
   }
 }
 async function publishState(deps, state) {
@@ -2430,7 +2869,7 @@ async function sameFileIdentity(leftPath, rightPath) {
 async function assertNotSymlink(filePath, label) {
   let stat3;
   try {
-    stat3 = await lstat2(filePath);
+    stat3 = await lstat3(filePath);
   } catch (error) {
     if (isErrnoCode(error, "ENOENT")) return;
     throw error;
@@ -2442,7 +2881,7 @@ async function assertNotSymlink(filePath, label) {
 async function assertNotMemorySymlink(filePath) {
   let stat3;
   try {
-    stat3 = await lstat2(filePath);
+    stat3 = await lstat3(filePath);
   } catch (error) {
     if (isErrnoCode(error, "ENOENT")) return;
     throw error;
@@ -2458,13 +2897,13 @@ async function assertEntityContentUnchanged(deps, filePath, expectedContent, leg
   }
 }
 async function readSafeEntityEntries(entitiesDir) {
-  const rootStat = await lstat2(entitiesDir);
+  const rootStat = await lstat3(entitiesDir);
   if (rootStat.isSymbolicLink() || !rootStat.isDirectory()) {
     throw new Error("Refusing entity canonical-id migration through a symlinked or non-directory entities root.");
   }
   const entries = await readdir4(entitiesDir);
   for (const entry of entries) {
-    await assertNotSymlink(path4.join(entitiesDir, entry), entry);
+    await assertNotSymlink(path5.join(entitiesDir, entry), entry);
   }
   return entries;
 }
@@ -2526,7 +2965,7 @@ async function rewriteReferences(deps, mappings, refreshLock) {
     const seenPaths = /* @__PURE__ */ new Set();
     let rewroteAny = false;
     for (const memory of [...hotMemories, ...coldMemories, ...archivedMemories]) {
-      const memoryPath = path4.resolve(memory.path);
+      const memoryPath = path5.resolve(memory.path);
       if (seenPaths.has(memoryPath)) continue;
       seenPaths.add(memoryPath);
       const previousEntityRef = memory.frontmatter.entityRef;
@@ -2558,7 +2997,7 @@ async function rewriteReferences(deps, mappings, refreshLock) {
         latestCanonicalId
       );
       rewroteAny = true;
-      rewroteColdMemory ||= latestMemory.path.includes(`${path4.sep}cold${path4.sep}`);
+      rewroteColdMemory ||= latestMemory.path.includes(`${path5.sep}cold${path5.sep}`);
     }
     if (!rewroteAny) return { rewroteColdMemory };
   }
@@ -2597,7 +3036,7 @@ function rewriteTombstoneLine(line, mappings, normalizedMappings) {
   return changed ? JSON.stringify(tombstone) : line;
 }
 async function rewriteTombstoneReferences(deps, mappings, refreshLock) {
-  const tombstonePath = path4.join(deps.stateDir, "tombstones.jsonl");
+  const tombstonePath = path5.join(deps.stateDir, "tombstones.jsonl");
   const normalizedMappings = /* @__PURE__ */ new Map();
   for (const [legacyId, canonicalId] of Object.entries(mappings)) {
     const normalizedLegacyId = normalizeSupersessionKey(legacyId);
@@ -2606,7 +3045,7 @@ async function rewriteTombstoneReferences(deps, mappings, refreshLock) {
     }
   }
   await withHeldFileLock(
-    path4.join(deps.stateDir, "tombstones.lock"),
+    path5.join(deps.stateDir, "tombstones.lock"),
     {
       staleMs: TOMBSTONE_LOCK_STALE_MS,
       maxWaitMs: TOMBSTONE_LOCK_MAX_WAIT_MS
@@ -2794,7 +3233,7 @@ async function migrateEntityFilePair(deps, legacyId, canonicalId, refreshMigrati
       await deps.snapshotBeforeWrite(legacyPath, "write");
       await assertNotSymlink(legacyPath, legacyId);
       await assertEntityContentUnchanged(deps, legacyPath, legacyContent, legacyId);
-      await unlink2(legacyPath);
+      await unlink3(legacyPath);
       return { deferred: false, progressed: true };
     }
     if (!legacyExists) return { deferred: false, progressed: false };
@@ -2818,13 +3257,13 @@ async function migrateEntityFilePair(deps, legacyId, canonicalId, refreshMigrati
       await deps.snapshotBeforeWrite(legacyPath, "write");
       await assertNotSymlink(legacyPath, legacyId);
       await assertEntityContentUnchanged(deps, legacyPath, entityContent, legacyId);
-      await unlink2(legacyPath);
+      await unlink3(legacyPath);
     } catch (error) {
       if (!canonicalExists && canonicalFingerprintAfterWrite !== null) {
         try {
           if (await fingerprintPath(canonicalPath) === canonicalFingerprintAfterWrite) {
             await assertNotSymlink(canonicalPath, canonicalId);
-            await unlink2(canonicalPath);
+            await unlink3(canonicalPath);
           }
         } catch {
         }
@@ -2845,12 +3284,12 @@ async function migrateLegacyEntityCanonicalIds(deps) {
       if (!acquired) throw new Error("Timed out waiting for active entity canonical-id migration.");
       await deps.validateMemoryScanRoots?.();
       await readSafeEntityEntries(deps.entitiesDir);
-      const reconcileMarkerPath = path4.join(deps.stateDir, ENTITY_CANONICAL_ID_RECONCILE_MARKER);
-      const consumingMarkerPath = path4.join(deps.stateDir, ENTITY_CANONICAL_ID_RECONCILE_CONSUMING_MARKER);
+      const reconcileMarkerPath = path5.join(deps.stateDir, ENTITY_CANONICAL_ID_RECONCILE_MARKER);
+      const consumingMarkerPath = path5.join(deps.stateDir, ENTITY_CANONICAL_ID_RECONCILE_CONSUMING_MARKER);
       let reconcileRequested = await fileExists(consumingMarkerPath);
       if (await fileExists(reconcileMarkerPath)) {
         try {
-          await rename(reconcileMarkerPath, consumingMarkerPath);
+          await rename2(reconcileMarkerPath, consumingMarkerPath);
           reconcileRequested = true;
         } catch (error) {
           if (!isErrnoCode(error, "ENOENT")) throw error;
@@ -2873,7 +3312,7 @@ async function migrateLegacyEntityCanonicalIds(deps) {
           );
         }
         if (reconcileRequested) {
-          await unlink2(consumingMarkerPath).catch((error) => {
+          await unlink3(consumingMarkerPath).catch((error) => {
             if (!isErrnoCode(error, "ENOENT")) throw error;
           });
         }
@@ -3019,7 +3458,7 @@ async function migrateLegacyEntityCanonicalIds(deps) {
 }
 
 // src/storage/entity-ref-repair.ts
-import { unlink as unlink3 } from "fs/promises";
+import { unlink as unlink4 } from "fs/promises";
 var EntityRefRepair = class {
   constructor(deps) {
     this.deps = deps;
@@ -3081,7 +3520,7 @@ ${body}
       if (opts.onFailRestore) {
         await this.restore(opts.onFailRestore);
       } else if (opts.onFailRemove) {
-        await unlink3(opts.onFailRemove).catch(() => void 0);
+        await unlink4(opts.onFailRemove).catch(() => void 0);
         this.deps.invalidateAllMemoriesCache();
       }
       throw err;
@@ -3242,7 +3681,7 @@ import {
   readFileSync,
   realpathSync
 } from "fs";
-import path5 from "path";
+import path6 from "path";
 function resolveSafeAliasRoots(baseDir, configDir) {
   let baseStat;
   try {
@@ -3269,8 +3708,8 @@ function resolveSafeAliasRoots(baseDir, configDir) {
   return memoryRoot;
 }
 function readEntityAliasConfigSync(baseDir) {
-  const configDir = path5.join(baseDir, "config");
-  const aliasPath = path5.join(configDir, "aliases.json");
+  const configDir = path6.join(baseDir, "config");
+  const aliasPath = path6.join(configDir, "aliases.json");
   let memoryRoot = resolveSafeAliasRoots(baseDir, configDir);
   if (memoryRoot === void 0) return void 0;
   let aliasPreflight;
@@ -3331,9 +3770,9 @@ function decodeYamlScalar(value) {
 }
 
 // src/orchestration/qmd-result-resolver.ts
-import path6 from "path";
+import path7 from "path";
 function qmdCollectionPathParts(resultPath) {
-  if (!resultPath || path6.isAbsolute(resultPath)) return null;
+  if (!resultPath || path7.isAbsolute(resultPath)) return null;
   const normalized = resultPath.replace(/\\/g, "/").replace(/^\/+/, "");
   const slashIndex = normalized.indexOf("/");
   if (slashIndex <= 0 || slashIndex >= normalized.length - 1) return null;
@@ -3346,9 +3785,9 @@ function qmdCollectionPathParts(resultPath) {
 }
 function qmdResultPathCandidates(storageDir, resultPath) {
   const candidates = /* @__PURE__ */ new Set();
-  const storageRoot = path6.resolve(storageDir);
+  const storageRoot = path7.resolve(storageDir);
   const addCandidate = (candidate) => {
-    const resolved = path6.resolve(candidate);
+    const resolved = path7.resolve(candidate);
     if (isPathInsideStorageRoot(storageRoot, resolved)) {
       candidates.add(resolved);
     }
@@ -3356,18 +3795,18 @@ function qmdResultPathCandidates(storageDir, resultPath) {
   const addRelativeCandidates = (relativePath) => {
     const normalized = relativePath.replace(/\\/g, "/").replace(/^\/+/, "");
     if (!normalized) return;
-    addCandidate(path6.join(storageRoot, normalized));
+    addCandidate(path7.join(storageRoot, normalized));
     if (/^\d{4}-\d{2}-\d{2}\//.test(normalized)) {
-      addCandidate(path6.join(storageRoot, "facts", normalized));
+      addCandidate(path7.join(storageRoot, "facts", normalized));
     }
   };
-  if (path6.isAbsolute(resultPath)) {
+  if (path7.isAbsolute(resultPath)) {
     addCandidate(resultPath);
-    const relative2 = path6.relative(storageRoot, path6.resolve(resultPath));
-    if (relative2 && !relative2.startsWith("..") && !path6.isAbsolute(relative2)) {
-      const normalized = relative2.split(path6.sep).join("/");
+    const relative2 = path7.relative(storageRoot, path7.resolve(resultPath));
+    if (relative2 && !relative2.startsWith("..") && !path7.isAbsolute(relative2)) {
+      const normalized = relative2.split(path7.sep).join("/");
       if (/^\d{4}-\d{2}-\d{2}\//.test(normalized)) {
-        addCandidate(path6.join(storageRoot, "facts", normalized));
+        addCandidate(path7.join(storageRoot, "facts", normalized));
       }
     }
   } else {
@@ -3402,7 +3841,7 @@ var QmdResultResolver = class {
       const seenStorageDirs = /* @__PURE__ */ new Set();
       const addStorage = (storage) => {
         const storageDir = storageDirOrNull(storage);
-        const storageKey = storageDir ? path6.resolve(storageDir) : `storage-without-dir-${storages.length}`;
+        const storageKey = storageDir ? path7.resolve(storageDir) : `storage-without-dir-${storages.length}`;
         if (seenStorageDirs.has(storageKey)) return;
         seenStorageDirs.add(storageKey);
         storages.push(storage);
@@ -3432,7 +3871,7 @@ var QmdResultResolver = class {
           continue;
         }
         try {
-          const coldRoot = path6.join(storageDir, "cold");
+          const coldRoot = path7.join(storageDir, "cold");
           for (const candidate of qmdResultPathCandidates(
             coldRoot,
             parts.relativePath
@@ -3491,9 +3930,9 @@ var QmdResultResolver = class {
           error: err.message
         });
       }
-      if (!path6.isAbsolute(resultPath)) return null;
+      if (!path7.isAbsolute(resultPath)) return null;
     }
-    if (path6.isAbsolute(resultPath)) {
+    if (path7.isAbsolute(resultPath)) {
       if (!fallbackStorageDir) {
         return await fallbackStorage.readMemoryByPath(resultPath);
       }
@@ -3533,7 +3972,7 @@ var QmdResultResolver = class {
     );
     if (!memory) return null;
     let ownerNamespace = null;
-    if (path6.isAbsolute(memory.path)) {
+    if (path7.isAbsolute(memory.path)) {
       const ownerStorage = await this.storageForAbsoluteQmdResultPath(
         memory.path,
         fallbackStorage,
@@ -3557,17 +3996,17 @@ var QmdResultResolver = class {
     };
   }
   async storageForAbsoluteQmdResultPath(resultPath, fallbackStorage, recallNamespaces = []) {
-    const resolvedPath = path6.resolve(resultPath);
+    const resolvedPath = path7.resolve(resultPath);
     const config = this.getConfig();
-    const memoryRoot = path6.resolve(config.memoryDir);
-    const namespacesRoot = path6.join(memoryRoot, "namespaces");
+    const memoryRoot = path7.resolve(config.memoryDir);
+    const namespacesRoot = path7.join(memoryRoot, "namespaces");
     const fallbackStorageDir = storageDirOrNull(fallbackStorage);
     const matches = [];
     const seenDirs = /* @__PURE__ */ new Set();
     const maybeAddStorage = (storage, namespace) => {
       const storageDir = storageDirOrNull(storage);
       if (!storageDir) return;
-      const candidateRoot = path6.resolve(storageDir);
+      const candidateRoot = path7.resolve(storageDir);
       if (seenDirs.has(candidateRoot)) return;
       if (!isPathInsideStorageRoot(candidateRoot, resolvedPath)) return;
       if (candidateRoot === memoryRoot && isPathInsideStorageRoot(namespacesRoot, resolvedPath)) {
@@ -3585,7 +4024,7 @@ var QmdResultResolver = class {
       candidateNamespaces.add(ns);
     }
     if (isPathInsideStorageRoot(namespacesRoot, resolvedPath)) {
-      const relativeToNamespaces = path6.relative(namespacesRoot, resolvedPath);
+      const relativeToNamespaces = path7.relative(namespacesRoot, resolvedPath);
       const [namespaceSegment] = relativeToNamespaces.split(/[\\/]/);
       if (namespaceSegment) {
         candidateNamespaces.add(
@@ -4129,7 +4568,7 @@ function collectSpeakers(tagged) {
 }
 
 // src/wearables/fusion/fuse.ts
-import { createHash as createHash2 } from "crypto";
+import { createHash as createHash3 } from "crypto";
 var FUSION_ID_PREFIX = "fusion";
 var FUSION_ALGO_VERSION = "2026-07-12-1";
 function canonicalInputsKey(date, inputs) {
@@ -4158,7 +4597,7 @@ function canonicalInputsKey(date, inputs) {
       ])
     ])
   ];
-  return createHash2("sha256").update(JSON.stringify(record), "utf-8").digest("hex");
+  return createHash3("sha256").update(JSON.stringify(record), "utf-8").digest("hex");
 }
 function configFingerprint(options, sources) {
   const proximityGapMs = options.proximityGapMs ?? DEFAULT_PROXIMITY_GAP_MS;
@@ -4173,7 +4612,7 @@ function canonicalDayKey(date, inputs, options, algoVersion = FUSION_ALGO_VERSIO
     options,
     inputs.map((conv) => conv.source)
   );
-  return createHash2("sha256").update(inputsKey).update("\n").update(fingerprint).update("\n").update(algoVersion).digest("hex");
+  return createHash3("sha256").update(inputsKey).update("\n").update(fingerprint).update("\n").update(algoVersion).digest("hex");
 }
 function buildProvenance(cluster, proximityGapMs, windowToleranceMs) {
   return {
@@ -4233,11 +4672,11 @@ function fuseDay(date, inputs, options = {}) {
 }
 
 // src/wearables/fusion/store.ts
-import { createHash as createHash3 } from "crypto";
-import * as path7 from "path";
+import { createHash as createHash4 } from "crypto";
+import * as path8 from "path";
 var FUSION_KIND = "wearable-fusion";
 function hashFusionBody(conversations) {
-  return createHash3("sha256").update(JSON.stringify(conversations), "utf-8").digest("hex");
+  return createHash4("sha256").update(JSON.stringify(conversations), "utf-8").digest("hex");
 }
 function composeFusionDayMeta(date, conversations, sources, contentHash, fusedAt) {
   return {
@@ -4421,7 +4860,7 @@ var FusionArtifactStore = class {
         `invalid wearable fusion date '${String(date)}' \u2014 expected YYYY-MM-DD`
       );
     }
-    return path7.join(this.wearablesDir, FUSION_DIR_NAME, `${date}.md`);
+    return path8.join(this.wearablesDir, FUSION_DIR_NAME, `${date}.md`);
   }
   async writeFusedDay(date, serialized) {
     const filePath = this.fusedDayPath(date);
@@ -4458,7 +4897,7 @@ var FusionArtifactStore = class {
   }
   /** List dates with stored fused artifacts, newest first. */
   async listFusedDays() {
-    const fusionDir = path7.join(this.wearablesDir, FUSION_DIR_NAME);
+    const fusionDir = path8.join(this.wearablesDir, FUSION_DIR_NAME);
     await this.assertPathContained(fusionDir);
     let entries;
     try {
@@ -4502,10 +4941,10 @@ var FusionArtifactStore = class {
     try {
       rootReal = await this.io.realpath(this.memoryDir);
     } catch {
-      rootReal = path7.resolve(this.memoryDir);
+      rootReal = path8.resolve(this.memoryDir);
     }
     await this.assertNoEscape(rootReal, this.wearablesDir);
-    await this.assertNoEscape(rootReal, path7.dirname(targetPath));
+    await this.assertNoEscape(rootReal, path8.dirname(targetPath));
     await this.assertNoEscape(rootReal, targetPath);
     await this.assertFusionDirNotSymlinked();
   }
@@ -4519,7 +4958,7 @@ var FusionArtifactStore = class {
    * (a fresh write creates a real directory lexically under the root).
    */
   async assertFusionDirNotSymlinked() {
-    const fusionDir = path7.join(this.wearablesDir, FUSION_DIR_NAME);
+    const fusionDir = path8.join(this.wearablesDir, FUSION_DIR_NAME);
     let stat3;
     try {
       stat3 = await this.io.lstat(fusionDir);
@@ -4654,8 +5093,8 @@ function reconstructFusionInputs(date, dayTranscripts) {
 }
 
 // src/meetings/store.ts
-import { createHash as createHash4 } from "crypto";
-import * as path8 from "path";
+import { createHash as createHash5 } from "crypto";
+import * as path9 from "path";
 var MEETINGS_DIR_NAME = "meetings";
 var MEETING_KIND = "meeting";
 var MEETING_FORMAT_VERSION = 1;
@@ -4685,7 +5124,7 @@ function canonicalContent(base, fused) {
   });
 }
 function composeMeetingRecord(base, fused) {
-  const contentHash = createHash4("sha256").update(canonicalContent(base, fused), "utf-8").digest("hex");
+  const contentHash = createHash5("sha256").update(canonicalContent(base, fused), "utf-8").digest("hex");
   return {
     ...base,
     ...fused,
@@ -4824,7 +5263,7 @@ var MeetingRecordStore = class {
   constructor(memoryDir, io) {
     this.memoryDir = memoryDir;
     this.io = io;
-    this.meetingsDir = path8.join(memoryDir, MEETINGS_DIR_NAME);
+    this.meetingsDir = path9.join(memoryDir, MEETINGS_DIR_NAME);
   }
   memoryDir;
   io;
@@ -4840,7 +5279,7 @@ var MeetingRecordStore = class {
     if (idDate !== date) {
       throw new Error(`meeting id '${id}' does not belong to date '${date}'`);
     }
-    return path8.join(this.meetingsDir, date, `${id}.md`);
+    return path9.join(this.meetingsDir, date, `${id}.md`);
   }
   /** Idempotently persist a record: skip the write when contentHash is unchanged. */
   async saveMeetingRecord(record) {
@@ -4871,7 +5310,7 @@ var MeetingRecordStore = class {
     if (!isValidTranscriptDate(date)) {
       throw new Error(`invalid meeting date '${String(date)}' \u2014 expected YYYY-MM-DD`);
     }
-    const dayDir = path8.join(this.meetingsDir, date);
+    const dayDir = path9.join(this.meetingsDir, date);
     await this.assertPathContained(dayDir);
     let entries;
     try {
@@ -4939,10 +5378,10 @@ var MeetingRecordStore = class {
     try {
       rootReal = await this.io.realpath(this.memoryDir);
     } catch {
-      rootReal = path8.resolve(this.memoryDir);
+      rootReal = path9.resolve(this.memoryDir);
     }
     await this.assertNoEscape(rootReal, this.meetingsDir);
-    await this.assertNoEscape(rootReal, path8.dirname(targetPath));
+    await this.assertNoEscape(rootReal, path9.dirname(targetPath));
     await this.assertNoEscape(rootReal, targetPath);
     await this.assertNotSymlink(this.meetingsDir, "directory");
     const dayDir = this.dayDirWithin(targetPath);
@@ -4952,11 +5391,11 @@ var MeetingRecordStore = class {
   /** The `<meetings>/<date>` directory on the path to `targetPath`, or null when
    *  `targetPath` is the meetings root itself. */
   dayDirWithin(targetPath) {
-    const rel = path8.relative(this.meetingsDir, targetPath);
-    if (rel === "" || rel.startsWith("..") || path8.isAbsolute(rel)) return null;
-    const first = rel.split(path8.sep)[0];
+    const rel = path9.relative(this.meetingsDir, targetPath);
+    if (rel === "" || rel.startsWith("..") || path9.isAbsolute(rel)) return null;
+    const first = rel.split(path9.sep)[0];
     if (first === void 0 || first.length === 0) return null;
-    return path8.join(this.meetingsDir, first);
+    return path9.join(this.meetingsDir, first);
   }
   async assertNotSymlink(target, kind) {
     let stat3;
@@ -4967,7 +5406,7 @@ var MeetingRecordStore = class {
       throw err;
     }
     if (stat3.isSymbolicLink) {
-      const label = path8.relative(this.memoryDir, target) || MEETINGS_DIR_NAME;
+      const label = path9.relative(this.memoryDir, target) || MEETINGS_DIR_NAME;
       throw new Error(
         `meetings ${kind} '${label}' is a symbolic link \u2014 refusing to follow it even when it resolves inside the memory dir (AGENTS.md pattern #3)`
       );
@@ -5011,15 +5450,15 @@ function citationTemplateLiteralParts(template) {
   const parts = [];
   let cursor = 0;
   while (cursor < template.length) {
-    const open2 = template.indexOf("{", cursor);
-    if (open2 === -1) {
+    const open3 = template.indexOf("{", cursor);
+    if (open3 === -1) {
       parts.push(template.slice(cursor));
       break;
     }
-    parts.push(template.slice(cursor, open2));
-    const close = template.indexOf("}", open2 + 1);
+    parts.push(template.slice(cursor, open3));
+    const close = template.indexOf("}", open3 + 1);
     if (close === -1) {
-      cursor = open2 + 1;
+      cursor = open3 + 1;
     } else {
       cursor = close + 1;
     }
@@ -5070,6 +5509,27 @@ function stripCitationMarkersForHashRemoval(value, template) {
   return removed ? trimLeadingSpacesAndTabs(result) : value;
 }
 
+// src/storage/supersession-audit.ts
+import { readdir as readdir5 } from "fs/promises";
+import path10 from "path";
+async function hasSupersessionAudit(lookup, oldMemoryId, newMemoryId, auditBody) {
+  let entries;
+  try {
+    entries = await readdir5(lookup.correctionsDir, { withFileTypes: true });
+  } catch (error) {
+    if (isErrnoCode(error, "ENOENT")) return false;
+    throw error;
+  }
+  for (const entry of entries) {
+    if (!entry.isFile() || !entry.name.endsWith(".md")) continue;
+    const memory = await lookup.readMemoryByPath(path10.join(lookup.correctionsDir, entry.name));
+    if (memory?.frontmatter.category === "correction" && (memory.frontmatter.sourceMemoryId === oldMemoryId || memory.frontmatter.sourceMemoryId === void 0 && memory.frontmatter.lineage?.includes(oldMemoryId)) && memory.frontmatter.lineage?.includes(newMemoryId) && memory.content === auditBody) {
+      return true;
+    }
+  }
+  return false;
+}
+
 // src/storage/supersession-side-effects.ts
 async function runSupersessionSideEffects(options) {
   const {
@@ -5077,22 +5537,18 @@ async function runSupersessionSideEffects(options) {
     newMemoryId,
     reason,
     now,
+    operationId,
+    exactReplay,
     currentBefore,
     updatedFm,
-    citationTemplate,
-    isColdOrArchiveTierPath,
-    invalidateColdMemoriesCache,
-    bumpMemoryCorpusVersion,
-    appendLifecycleEvent,
-    bumpMemoryStatusVersion,
-    appendTombstone,
-    writeSealedMemory
+    citationTemplate
   } = options;
   try {
-    if (isColdOrArchiveTierPath(currentBefore.path)) invalidateColdMemoriesCache();
-    bumpMemoryCorpusVersion();
-    await appendLifecycleEvent();
-    bumpMemoryStatusVersion();
+    if (options.isColdOrArchiveTierPath(currentBefore.path)) options.invalidateColdMemoriesCache();
+    if (exactReplay) options.invalidateAllMemoriesCache();
+    else options.bumpMemoryCorpusVersion();
+    await options.appendLifecycleEvent();
+    options.bumpMemoryStatusVersion();
     log.debug(`superseded memory ${oldMemoryId} by ${newMemoryId}: ${reason}`);
     if (currentBefore.frontmatter.category === "fact") {
       for (const input of buildRetiredFactTombstoneInputs(
@@ -5110,28 +5566,48 @@ async function runSupersessionSideEffects(options) {
           supersessionKeysForFact
         }
       )) {
-        await appendTombstone(input);
+        const exactInput = { ...input, operationKey: operationId };
+        const exists = await options.hasExactTombstone(exactInput) || await options.hasExactTombstone(input);
+        if (!exists) await options.appendTombstone(exactInput);
       }
     }
-    const auditEnvelope = composeMemoryEnvelope(
-      {
-        content: `Superseded: ${currentBefore.content}
+    const auditBody = `Superseded: ${currentBefore.content}
 
-Reason: ${reason}`,
-        category: "correction",
-        confidence: 1,
-        tags: ["supersession", "auto-resolved"]
+Reason: ${reason}`;
+    const auditExists = await hasSupersessionAudit(
+      {
+        correctionsDir: options.correctionsDir,
+        readMemoryByPath: options.readMemoryByPath
       },
-      { source: "contradiction-detection" }
+      oldMemoryId,
+      newMemoryId,
+      auditBody
     );
-    await writeSealedMemory(auditEnvelope, { lineage: [oldMemoryId, newMemoryId] });
+    if (!auditExists) {
+      const auditEnvelope = composeMemoryEnvelope(
+        {
+          content: auditBody,
+          category: "correction",
+          confidence: 1,
+          tags: ["supersession", "auto-resolved"]
+        },
+        { source: "contradiction-detection" }
+      );
+      await options.writeSealedMemory(auditEnvelope, {
+        lineage: [oldMemoryId, newMemoryId],
+        sourceMemoryId: oldMemoryId
+      });
+    }
+    options.invalidateAllMemoriesCache();
+    return true;
   } catch (err) {
-    log.error(`failed to supersede memory ${oldMemoryId}:`, err);
+    log.error(`supersession side effects failed for ${oldMemoryId}:`, err);
+    return false;
   }
 }
 
 // src/storage/entity-timeline.ts
-import { createHash as createHash5 } from "crypto";
+import { createHash as createHash6 } from "crypto";
 function parseEntityTimelineBullet(bullet, fallbackTimestamp) {
   const trimmed = bullet.trim();
   if (!trimmed) return null;
@@ -5503,7 +5979,7 @@ function fingerprintEntityStructuredFacts(entity) {
     (left, right) => left.key.localeCompare(right.key) || left.title.localeCompare(right.title) || left.facts.join("\n").localeCompare(right.facts.join("\n"))
   );
   if (normalizedSections.length === 0) return void 0;
-  return createHash5("sha256").update(JSON.stringify(normalizedSections)).digest("hex");
+  return createHash6("sha256").update(JSON.stringify(normalizedSections)).digest("hex");
 }
 function isEntitySynthesisStale(entity) {
   const structuredFactCount = countEntityStructuredFacts(entity);
@@ -5525,15 +6001,6 @@ function isEntitySynthesisStale(entity) {
 }
 
 // src/storage.ts
-var DELETION_REVISION_MAX_MTIME_MS = 864e13;
-var DELETION_REVISION_LOCK_STALE_MS = 6e4;
-var DELETION_REVISION_LOCK_MAX_WAIT_MS = 12e4;
-function isValidDeletionRevisionPath(value) {
-  return typeof value === "string" && value.length > 0 && !value.includes("\\") && !value.includes("\0") && !path9.posix.isAbsolute(value) && path9.posix.normalize(value) === value && value !== "." && value !== ".." && !value.startsWith("../");
-}
-function deletionRevisionPathIdentity(value) {
-  return value.normalize("NFC").toUpperCase().toLowerCase().replace(/\u00df/g, "ss");
-}
 function assertMemoryWorthCounter(field, value) {
   if (typeof value !== "number" || !Number.isFinite(value)) {
     throw new Error(`${field} must be a finite number, got ${String(value)}`);
@@ -6059,17 +6526,17 @@ function inferEntityTypeFromContent(content) {
 }
 var KNOWN_ENTITY_FILENAME_PREFIXES = /* @__PURE__ */ new Set(["company", "other", "person", "place", "project", "tool", "topic"]);
 function inferEntityTypeFromFilename(pathRel) {
-  const basename = path9.basename(pathRel, ".md").toLowerCase();
+  const basename = path11.basename(pathRel, ".md").toLowerCase();
   const separator = basename.indexOf("-");
   if (separator <= 0) return void 0;
   const candidate = basename.slice(0, separator);
   return KNOWN_ENTITY_FILENAME_PREFIXES.has(candidate) ? candidate : void 0;
 }
 function normalizeFrontmatterForPath(frontmatter, pathRel, content = "") {
-  const normalizedPath = pathRel.split(path9.sep).join("/");
+  const normalizedPath = pathRel.split(path11.sep).join("/");
   let normalizedFrontmatter = frontmatter;
   if (normalizedPath === "entities" || normalizedPath.startsWith("entities/") || normalizedPath.includes("/entities/")) {
-    const basename = path9.basename(pathRel, ".md");
+    const basename = path11.basename(pathRel, ".md");
     const inferredType = inferEntityTypeFromContent(content) || inferEntityTypeFromFilename(pathRel) || "entity";
     const existingTags = Array.isArray(frontmatter.tags) ? frontmatter.tags : [];
     normalizedFrontmatter = {
@@ -6534,12 +7001,20 @@ var StorageManager3 = class _StorageManager extends TombstoneBlockedCaptureIndex
     super();
     this.baseDir = baseDir;
     this.entitySchemas = entitySchemas;
+    this.deletionRevisionStore = new DeletionRevisionStore({
+      baseDir,
+      deletionRevisionMetadataPath: path11.join(baseDir, ".offline-sync", "deletion-revisions.v1.json"),
+      invalidationCommitMetadataPath: path11.join(baseDir, ".offline-sync", "invalidation-commits.v1.json"),
+      deletionRevisionLockPath: path11.join(baseDir, ".offline-sync", "deletion-revisions.v1.json.lock"),
+      assertManagedStoragePath: (filePath, method) => this.assertManagedStoragePath(filePath, method)
+    });
     this.hotMemoriesCacheEnabled = hotMemoriesCacheEnabledOverride ?? _StorageManager.hotMemoriesCacheDefaultByDir.get(baseDir) ?? _StorageManager.hotMemoriesCacheDefault;
     this.loadAliasesSync();
   }
   baseDir;
   entitySchemas;
   knowledgeIndexCache = null;
+  deletionRevisionStore;
   artifactIndexCache = null;
   projectionLedgerLagManager = new ProjectionLedgerLagManager();
   static loadedMemorySnapshots = /* @__PURE__ */ new WeakMap();
@@ -6718,8 +7193,8 @@ var StorageManager3 = class _StorageManager extends TombstoneBlockedCaptureIndex
   }
   /** Whether `filePath` resolves to `stateDir` itself or a path contained in it. */
   isStateFilePath(filePath) {
-    const rel = path9.relative(this.stateDir, path9.resolve(filePath));
-    return rel === "" || !rel.startsWith("..") && !path9.isAbsolute(rel);
+    const rel = path11.relative(this.stateDir, path11.resolve(filePath));
+    return rel === "" || !rel.startsWith("..") && !path11.isAbsolute(rel);
   }
   // ── Tombstone store (issue #1579) ───────────────────────────────────────
   // Instance-scoped (rule 11) + namespace-scoped (rule 42) tombstone index.
@@ -6834,8 +7309,8 @@ var StorageManager3 = class _StorageManager extends TombstoneBlockedCaptureIndex
    * /srv/cold/remnic), skipping the patch and stranding a stale hot entry.
    */
   isColdOrArchiveTierPath(p) {
-    const rel = path9.relative(this.baseDir, p);
-    return rel === "cold" || rel === "archive" || rel.startsWith(`cold${path9.sep}`) || rel.startsWith(`archive${path9.sep}`);
+    const rel = path11.relative(this.baseDir, p);
+    return rel === "cold" || rel === "archive" || rel.startsWith(`cold${path11.sep}`) || rel.startsWith(`archive${path11.sep}`);
   }
   /**
    * Mark the secure-store as required for this storage instance.
@@ -6922,7 +7397,7 @@ var StorageManager3 = class _StorageManager extends TombstoneBlockedCaptureIndex
         void 0,
         this.baseDir
       );
-      const rel = path9.relative(this.baseDir, filePath).split(path9.sep).join("/");
+      const rel = path11.relative(this.baseDir, filePath).split(path11.sep).join("/");
       return `${rel}:${version.versionId}`;
     } catch (err) {
       log.warn(
@@ -7002,12 +7477,12 @@ var StorageManager3 = class _StorageManager extends TombstoneBlockedCaptureIndex
   }
   identityFilePath(workspaceDir, namespace) {
     const rawNamespace = typeof namespace === "string" ? namespace.trim() : "";
-    if (!rawNamespace) return path9.join(workspaceDir, "IDENTITY.md");
+    if (!rawNamespace) return path11.join(workspaceDir, "IDENTITY.md");
     const safeNamespace = rawNamespace.replace(/[^a-zA-Z0-9._-]/g, "-");
-    return path9.join(workspaceDir, `IDENTITY.${safeNamespace}.md`);
+    return path11.join(workspaceDir, `IDENTITY.${safeNamespace}.md`);
   }
   versionFilePath(kind) {
-    return path9.join(this.stateDir, `.${kind}-version.log`);
+    return path11.join(this.stateDir, `.${kind}-version.log`);
   }
   bumpSharedVersion(kind, fallbackMap) {
     const filePath = this.versionFilePath(kind);
@@ -7111,7 +7586,7 @@ var StorageManager3 = class _StorageManager extends TombstoneBlockedCaptureIndex
   // memories.
   // -------------------------------------------------------------------------
   get wearablesDir() {
-    return path9.join(this.baseDir, WEARABLES_DIR_NAME);
+    return path11.join(this.baseDir, WEARABLES_DIR_NAME);
   }
   /**
    * Resolve the on-disk path for a source/day transcript. Throws on
@@ -7127,7 +7602,7 @@ var StorageManager3 = class _StorageManager extends TombstoneBlockedCaptureIndex
     if (!isValidTranscriptDate(date)) {
       throw new Error(`invalid wearable transcript date '${String(date)}' \u2014 expected YYYY-MM-DD`);
     }
-    return path9.join(this.wearablesDir, sourceId, `${date}.md`);
+    return path11.join(this.wearablesDir, sourceId, `${date}.md`);
   }
   async writeWearableDayTranscript(sourceId, date, serialized) {
     const targetPath = this.wearableTranscriptPath(sourceId, date);
@@ -7153,10 +7628,10 @@ var StorageManager3 = class _StorageManager extends TombstoneBlockedCaptureIndex
     return this._fusionStore = new FusionArtifactStore(this.wearablesDir, this.baseDir, {
       writeFile: (p, c) => this.writeStorageSecureFile(p, c),
       readFile: (p) => readMaybeEncryptedFile(p, this._secureStoreKey, this.baseDir),
-      readDir: (d) => readdir5(d),
-      deleteFile: (p) => unlink4(p),
+      readDir: (d) => readdir6(d),
+      deleteFile: (p) => unlink5(p),
       realpath: (p) => realpath3(p),
-      lstat: (p) => lstat3(p).then((st) => ({ isSymbolicLink: st.isSymbolicLink() }))
+      lstat: (p) => lstat4(p).then((st) => ({ isSymbolicLink: st.isSymbolicLink() }))
     });
   }
   _meetingRecordStore;
@@ -7171,10 +7646,10 @@ var StorageManager3 = class _StorageManager extends TombstoneBlockedCaptureIndex
     return this._meetingRecordStore = new MeetingRecordStore(this.baseDir, {
       writeFile: (p, c) => this.writeStorageSecureFile(p, c),
       readFile: (p) => readMaybeEncryptedFile(p, this._secureStoreKey, this.baseDir),
-      readDir: (d) => readdir5(d),
-      deleteFile: (p) => unlink4(p),
+      readDir: (d) => readdir6(d),
+      deleteFile: (p) => unlink5(p),
       realpath: (p) => realpath3(p),
-      lstat: (p) => lstat3(p).then((st) => ({ isSymbolicLink: st.isSymbolicLink() }))
+      lstat: (p) => lstat4(p).then((st) => ({ isSymbolicLink: st.isSymbolicLink() }))
     });
   }
   /**
@@ -7243,218 +7718,87 @@ var StorageManager3 = class _StorageManager extends TombstoneBlockedCaptureIndex
     });
   }
   get factsDir() {
-    return path9.join(this.baseDir, "facts");
-  }
-  get correctionsDir() {
-    return path9.join(this.baseDir, "corrections");
-  }
-  get proceduresDir() {
-    return path9.join(this.baseDir, "procedures");
-  }
-  get reasoningTracesDir() {
-    return path9.join(this.baseDir, "reasoning-traces");
-  }
-  get entitiesDir() {
-    return path9.join(this.baseDir, "entities");
+    return path11.join(this.baseDir, "facts");
   }
-  resolveEntityFilePath(name) {
-    if (typeof name !== "string") return null;
-    const filePath = path9.resolve(this.entitiesDir, `${name}.md`);
-    const relative2 = path9.relative(this.entitiesDir, filePath);
-    if (relative2 === "" || relative2.startsWith("..") || path9.isAbsolute(relative2)) {
-      return null;
-    }
-    return filePath;
-  }
-  readStorageSecureFile(filePath) {
-    return readMaybeEncryptedFile(filePath, this._secureStoreKey, this.baseDir);
-  }
-  writeStorageSecureFile(filePath, content, forceEncrypt = false) {
-    const writeKey = this.resolveWriteKey(forceEncrypt);
-    return writeMaybeEncryptedFile(filePath, content, writeKey, {}, this.baseDir).then(() => {
-      this.notifyCatalogWriteForPath(filePath);
-    });
-  }
-  assertManagedStoragePath(filePath, method) {
-    const resolved = path9.resolve(filePath);
-    const base = path9.resolve(this.baseDir);
-    const rel = path9.relative(base, resolved);
-    if (rel === "" || rel === ".." || rel.startsWith(`..${path9.sep}`) || path9.isAbsolute(rel)) {
-      throw new Error(`${method}: file path escapes memory dir`);
-    }
-    return resolved;
-  }
-  parseDeletionRevisionMetadata(raw) {
-    let parsed;
-    try {
-      parsed = JSON.parse(raw);
-    } catch {
-      throw new Error("Deletion revision metadata is invalid.");
-    }
-    if (!parsed || typeof parsed !== "object" || Array.isArray(parsed)) {
-      throw new Error("Deletion revision metadata is invalid.");
-    }
-    const root = parsed;
-    if (Object.keys(root).sort().join(",") !== "deletions,version" || root.version !== 1 || !Array.isArray(root.deletions)) {
-      throw new Error("Deletion revision metadata is invalid.");
-    }
-    const revisions = /* @__PURE__ */ new Map();
-    const pathByIdentity = /* @__PURE__ */ new Map();
-    for (const rawEntry of root.deletions) {
-      if (!rawEntry || typeof rawEntry !== "object" || Array.isArray(rawEntry)) {
-        throw new Error("Deletion revision metadata is invalid.");
-      }
-      const entry = rawEntry;
-      if (Object.keys(entry).sort().join(",") !== "mtimeMs,path" || !isValidDeletionRevisionPath(entry.path) || typeof entry.mtimeMs !== "number" || !Number.isFinite(entry.mtimeMs) || entry.mtimeMs < 0 || entry.mtimeMs > DELETION_REVISION_MAX_MTIME_MS || revisions.has(entry.path)) {
-        throw new Error("Deletion revision metadata is invalid.");
-      }
-      const identity = deletionRevisionPathIdentity(entry.path);
-      if (pathByIdentity.has(identity)) {
-        throw new Error("Deletion revision metadata is invalid.");
-      }
-      pathByIdentity.set(identity, entry.path);
-      revisions.set(entry.path, entry.mtimeMs);
-    }
-    return new Map([...revisions.entries()].sort(([left], [right]) => left < right ? -1 : left > right ? 1 : 0));
+  get correctionsDir() {
+    return path11.join(this.baseDir, "corrections");
   }
-  async readDeletionRevisionMetadata() {
-    let raw;
-    try {
-      raw = await readFile2(this.deletionRevisionMetadataPath, "utf8");
-    } catch (error) {
-      if (isErrnoCode(error, "ENOENT")) return /* @__PURE__ */ new Map();
-      throw new Error("Deletion revision metadata is unavailable.");
-    }
-    return this.parseDeletionRevisionMetadata(raw);
+  get proceduresDir() {
+    return path11.join(this.baseDir, "procedures");
   }
-  async writeDeletionRevisionMetadata(revisions, lock) {
-    const deletions = [...revisions.entries()].sort(([left], [right]) => left < right ? -1 : left > right ? 1 : 0).map(([entryPath, mtimeMs]) => ({ path: entryPath, mtimeMs }));
-    const metadata = { version: 1, deletions };
-    const temporaryPath = `${this.deletionRevisionMetadataPath}.${process.pid}.${randomUUID2()}.tmp`;
-    let handle = null;
-    try {
-      handle = await open(temporaryPath, "wx", 384);
-      await handle.writeFile(`${JSON.stringify(metadata)}
-`, "utf8");
-      await handle.sync();
-      await handle.close();
-      handle = null;
-      if (!await lock.refresh()) {
-        throw new Error("Deletion revision metadata lock was lost.");
-      }
-      await rename2(temporaryPath, this.deletionRevisionMetadataPath);
-    } finally {
-      if (handle !== null) await handle.close().catch(() => void 0);
-      await unlink4(temporaryPath).catch((error) => {
-        if (!isErrnoCode(error, "ENOENT")) throw error;
-      });
+  get reasoningTracesDir() {
+    return path11.join(this.baseDir, "reasoning-traces");
+  }
+  get entitiesDir() {
+    return path11.join(this.baseDir, "entities");
+  }
+  resolveEntityFilePath(name) {
+    if (typeof name !== "string") return null;
+    const filePath = path11.resolve(this.entitiesDir, `${name}.md`);
+    const relative2 = path11.relative(this.entitiesDir, filePath);
+    if (relative2 === "" || relative2.startsWith("..") || path11.isAbsolute(relative2)) {
+      return null;
     }
+    return filePath;
   }
-  async withDeletionRevisionLock(task) {
-    return withHeldFileLock(
-      this.deletionRevisionLockPath,
-      {
-        staleMs: DELETION_REVISION_LOCK_STALE_MS,
-        maxWaitMs: DELETION_REVISION_LOCK_MAX_WAIT_MS
-      },
-      async (acquired, lock) => {
-        if (!acquired) throw new Error("Deletion revision metadata lock is unavailable.");
-        return task(lock);
-      }
+  readStorageSecureFile(filePath) {
+    return readMaybeEncryptedFile(filePath, this._secureStoreKey, this.baseDir);
+  }
+  async readDependencyPropagationQueueFile(filePath) {
+    const target = await resolveSafeStoragePath(
+      this.baseDir,
+      path11.relative(
+        this.baseDir,
+        this.assertManagedStoragePath(filePath, "storage.readDependencyPropagationQueueFile")
+      )
+    );
+    return this.readStorageSecureFile(target);
+  }
+  async writeDependencyPropagationQueueFile(filePath, content) {
+    const target = await resolveSafeStoragePath(
+      this.baseDir,
+      path11.relative(
+        this.baseDir,
+        this.assertManagedStoragePath(filePath, "storage.writeDependencyPropagationQueueFile")
+      )
     );
+    return this.writeStorageSecureFile(target, content);
+  }
+  writeStorageSecureFile(filePath, content, forceEncrypt = false) {
+    const writeKey = this.resolveWriteKey(forceEncrypt);
+    return writeMaybeEncryptedFile(filePath, content, writeKey, {}, this.baseDir).then(() => {
+      this.notifyCatalogWriteForPath(filePath);
+    });
+  }
+  assertManagedStoragePath(filePath, method) {
+    const resolved = path11.resolve(filePath);
+    const base = path11.resolve(this.baseDir);
+    const rel = path11.relative(base, resolved);
+    if (rel === "" || rel === ".." || rel.startsWith(`..${path11.sep}`) || path11.isAbsolute(rel)) {
+      throw new Error(`${method}: file path escapes memory dir`);
+    }
+    return resolved;
   }
   async readDeletionRevisions() {
-    return this.withDeletionRevisionLock(async () => this.readDeletionRevisionMetadata());
+    return this.deletionRevisionStore.readDeletionRevisions();
+  }
+  async hasCommittedInvalidation(memory) {
+    return this.deletionRevisionStore.hasCommittedInvalidation(memory);
+  }
+  async recordCommittedInvalidation(memory) {
+    return this.deletionRevisionStore.recordCommittedInvalidation(memory);
+  }
+  async clearCommittedInvalidation(memory) {
+    return this.deletionRevisionStore.clearCommittedInvalidation(memory);
   }
   async recordReplicatedDeletionRevision(filePath, mtimeMs) {
-    const target = this.assertManagedStoragePath(filePath, "storage.recordReplicatedDeletionRevision");
-    if (typeof mtimeMs !== "number" || !Number.isFinite(mtimeMs) || mtimeMs < 0 || mtimeMs > DELETION_REVISION_MAX_MTIME_MS) {
-      throw new Error("Deletion revision timestamp is invalid.");
-    }
-    const relativePath = path9.relative(this.baseDir, target).split(path9.sep).join("/");
-    if (!isValidDeletionRevisionPath(relativePath)) {
-      throw new Error("Deletion revision path is invalid.");
-    }
-    await this.withDeletionRevisionLock(async (lock) => {
-      const revisions = await this.readDeletionRevisionMetadata();
-      const identity = deletionRevisionPathIdentity(relativePath);
-      let existingPath;
-      for (const candidatePath of revisions.keys()) {
-        if (deletionRevisionPathIdentity(candidatePath) === identity) {
-          existingPath = candidatePath;
-          break;
-        }
-      }
-      const existingMtimeMs = existingPath === void 0 ? void 0 : revisions.get(existingPath);
-      if (existingMtimeMs !== void 0 && existingMtimeMs >= mtimeMs) return;
-      const updated = new Map(revisions);
-      if (existingPath !== void 0) updated.delete(existingPath);
-      updated.set(relativePath, mtimeMs);
-      await this.writeDeletionRevisionMetadata(updated, lock);
-    });
+    return this.deletionRevisionStore.recordReplicatedDeletionRevision(filePath, mtimeMs);
   }
   async writeManagedStorageFile(filePath, write) {
-    const target = this.assertManagedStoragePath(filePath, "storage.writeManagedStorageFile");
-    const relativePath = path9.relative(this.baseDir, target).split(path9.sep).join("/");
-    if (!isValidDeletionRevisionPath(relativePath)) {
-      throw new Error("Deletion revision path is invalid.");
-    }
-    await this.withDeletionRevisionLock(async (lock) => {
-      const before = await this.readDeletionRevisionMetadata();
-      const identity = deletionRevisionPathIdentity(relativePath);
-      const existingPath = [...before.keys()].find(
-        (candidatePath) => deletionRevisionPathIdentity(candidatePath) === identity
-      );
-      await write();
-      if (existingPath === void 0) return;
-      const updated = new Map(before);
-      updated.delete(existingPath);
-      await this.writeDeletionRevisionMetadata(updated, lock);
-    });
+    return this.deletionRevisionStore.writeManagedStorageFile(filePath, write);
   }
   async deleteManagedStorageFile(filePath, deletionMtimeMs) {
-    const target = this.assertManagedStoragePath(filePath, "storage.deleteManagedStorageFile");
-    if (deletionMtimeMs !== void 0 && deletionMtimeMs !== null && (typeof deletionMtimeMs !== "number" || !Number.isFinite(deletionMtimeMs) || deletionMtimeMs < 0 || deletionMtimeMs > DELETION_REVISION_MAX_MTIME_MS)) {
-      throw new Error("Deletion revision timestamp is invalid.");
-    }
-    return this.withDeletionRevisionLock(async (lock) => {
-      try {
-        await lstat3(target);
-      } catch (error) {
-        if (isErrnoCode(error, "ENOENT")) return false;
-        throw error;
-      }
-      const relativePath = path9.relative(this.baseDir, target).split(path9.sep).join("/");
-      if (!isValidDeletionRevisionPath(relativePath)) {
-        throw new Error("Deletion revision path is invalid.");
-      }
-      const revision = deletionMtimeMs === null ? void 0 : deletionMtimeMs ?? Date.now();
-      const before = await this.readDeletionRevisionMetadata();
-      const identity = deletionRevisionPathIdentity(relativePath);
-      let existingPath;
-      for (const candidatePath of before.keys()) {
-        if (deletionRevisionPathIdentity(candidatePath) === identity) {
-          existingPath = candidatePath;
-          break;
-        }
-      }
-      const existing = existingPath === void 0 ? void 0 : before.get(existingPath);
-      const changed = existingPath !== void 0 && existingPath !== relativePath || (revision === void 0 ? existing !== void 0 : existing !== revision);
-      if (changed) {
-        const updated = new Map(before);
-        if (existingPath !== void 0) updated.delete(existingPath);
-        if (revision !== void 0) updated.set(relativePath, revision);
-        await this.writeDeletionRevisionMetadata(updated, lock);
-      }
-      try {
-        await unlink4(target);
-        return true;
-      } catch (error) {
-        if (changed) await this.writeDeletionRevisionMetadata(before, lock);
-        if (isErrnoCode(error, "ENOENT")) return false;
-        throw error;
-      }
-    });
+    return this.deletionRevisionStore.deleteManagedStorageFile(filePath, deletionMtimeMs);
   }
   async readOfflineSyncFile(filePath) {
     const target = this.assertManagedStoragePath(filePath, "storage.readOfflineSyncFile");
@@ -7463,7 +7807,7 @@ var StorageManager3 = class _StorageManager extends TombstoneBlockedCaptureIndex
   async digestOfflineSyncFile(filePath) {
     const target = this.assertManagedStoragePath(filePath, "storage.digestOfflineSyncFile");
     const st = await stat2(target);
-    const relPath = path9.relative(this.baseDir, target).split(path9.sep).join("/");
+    const relPath = path11.relative(this.baseDir, target).split(path11.sep).join("/");
     const cache = await this.loadOfflineSyncDigestCache();
     const cached = cache.get(relPath);
     if (cached && cached.statBytes === st.size && cached.mtimeMs === st.mtimeMs && cached.ctimeMs === st.ctimeMs && !cached.encrypted) {
@@ -7477,11 +7821,11 @@ var StorageManager3 = class _StorageManager extends TombstoneBlockedCaptureIndex
     if (encrypted) {
       const content = await readMaybeEncryptedFileBuffer(target, this._secureStoreKey, this.baseDir);
       digest = {
-        sha256: createHash6("sha256").update(content).digest("hex"),
+        sha256: createHash7("sha256").update(content).digest("hex"),
         bytes: content.byteLength
       };
     } else {
-      const hash = createHash6("sha256");
+      const hash = createHash7("sha256");
       let bytes = 0;
       for await (const rawChunk of createReadStream(target)) {
         const chunk = Buffer.isBuffer(rawChunk) ? rawChunk : Buffer.from(rawChunk);
@@ -7509,7 +7853,7 @@ var StorageManager3 = class _StorageManager extends TombstoneBlockedCaptureIndex
   async readOfflineSyncDigestCache() {
     const cache = /* @__PURE__ */ new Map();
     try {
-      const raw = await readFile2(this.offlineSyncDigestCachePath, "utf-8");
+      const raw = await readFile3(this.offlineSyncDigestCachePath, "utf-8");
       const parsed = JSON.parse(raw);
       if (!parsed || typeof parsed !== "object" || Array.isArray(parsed)) return cache;
       const entries = parsed.entries;
@@ -7524,7 +7868,7 @@ var StorageManager3 = class _StorageManager extends TombstoneBlockedCaptureIndex
         const bytes = typeof record.bytes === "number" ? record.bytes : NaN;
         const sha256 = typeof record.sha256 === "string" ? record.sha256 : "";
         const encrypted = record.encrypted === true;
-        if (cachePath.length === 0 || cachePath === ".." || cachePath.startsWith("../") || path9.isAbsolute(cachePath) || !Number.isFinite(statBytes) || !Number.isFinite(mtimeMs) || !Number.isFinite(ctimeMs) || !Number.isFinite(bytes) || !/^[a-f0-9]{64}$/i.test(sha256)) {
+        if (cachePath.length === 0 || cachePath === ".." || cachePath.startsWith("../") || path11.isAbsolute(cachePath) || !Number.isFinite(statBytes) || !Number.isFinite(mtimeMs) || !Number.isFinite(ctimeMs) || !Number.isFinite(bytes) || !/^[a-f0-9]{64}$/i.test(sha256)) {
           continue;
         }
         cache.set(cachePath, { statBytes, mtimeMs, ctimeMs, encrypted, sha256, bytes });
@@ -7566,7 +7910,7 @@ var StorageManager3 = class _StorageManager extends TombstoneBlockedCaptureIndex
       const cache = this.offlineSyncDigestCache;
       if (!cache) return;
       const entries = [...cache.entries()].sort(([a], [b]) => a.localeCompare(b)).map(([entryPath, entry]) => ({ path: entryPath, ...entry }));
-      await mkdir(path9.dirname(this.offlineSyncDigestCachePath), { recursive: true });
+      await mkdir2(path11.dirname(this.offlineSyncDigestCachePath), { recursive: true });
       await writeFile2(this.offlineSyncDigestCachePath, `${JSON.stringify({ version: 1, entries })}
 `, "utf-8");
     }).catch((err) => {
@@ -7576,7 +7920,7 @@ var StorageManager3 = class _StorageManager extends TombstoneBlockedCaptureIndex
     });
   }
   async offlineSyncFileIsEncrypted(filePath) {
-    const handle = await open(filePath, "r");
+    const handle = await open2(filePath, "r");
     try {
       const header = Buffer.alloc(MAGIC_HEADER_SIZE);
       const { bytesRead } = await handle.read(header, 0, header.length, 0);
@@ -7635,7 +7979,7 @@ var StorageManager3 = class _StorageManager extends TombstoneBlockedCaptureIndex
     }
     let handle;
     try {
-      handle = await open(filePath, "r");
+      handle = await open2(filePath, "r");
     } catch (err) {
       if (isErrnoCode(err, "ENOENT")) return false;
       throw err;
@@ -7655,7 +7999,7 @@ var StorageManager3 = class _StorageManager extends TombstoneBlockedCaptureIndex
   }
   async appendStorageSecureFileUnlocked(filePath, content) {
     const writeKey = this.resolveWriteKey();
-    await mkdir(path9.dirname(filePath), { recursive: true });
+    await mkdir2(path11.dirname(filePath), { recursive: true });
     if (writeKey === null) {
       try {
         if (await this.isEncryptedFileHeader(filePath)) {
@@ -7681,19 +8025,13 @@ var StorageManager3 = class _StorageManager extends TombstoneBlockedCaptureIndex
     this.notifyCatalogWriteForPath(filePath);
   }
   get stateDir() {
-    return path9.join(this.baseDir, "state");
+    return path11.join(this.baseDir, "state");
   }
   get offlineSyncDigestCachePath() {
-    return path9.join(this.baseDir, ".offline-sync", "digest-cache.v1.json");
-  }
-  get deletionRevisionMetadataPath() {
-    return path9.join(this.baseDir, ".offline-sync", "deletion-revisions.v1.json");
-  }
-  get deletionRevisionLockPath() {
-    return `${this.deletionRevisionMetadataPath}.lock`;
+    return path11.join(this.baseDir, ".offline-sync", "digest-cache.v1.json");
   }
   get entitySynthesisQueuePath() {
-    return path9.join(this.stateDir, "entity-synthesis-queue.json");
+    return path11.join(this.stateDir, "entity-synthesis-queue.json");
   }
   // ── Tombstone store access (issue #1579) ─────────────────────────────────
   /**
@@ -7703,7 +8041,7 @@ var StorageManager3 = class _StorageManager extends TombstoneBlockedCaptureIndex
    * helpers are injected into the store).
    */
   get tombstonesPath() {
-    return path9.join(this.stateDir, "tombstones.jsonl");
+    return path11.join(this.stateDir, "tombstones.jsonl");
   }
   /**
    * Configure the tombstone invariant for this storage instance. Installed
@@ -7800,6 +8138,16 @@ var StorageManager3 = class _StorageManager extends TombstoneBlockedCaptureIndex
       return null;
     }
   }
+  async hasExactTombstone(input) {
+    if (!this.tombstonesConfig.enabled) return false;
+    try {
+      const store = await this.getTombstoneStore();
+      return await store.hasExactEntry(input);
+    } catch (err) {
+      log.warn(`exact tombstone proof failed (memory=${input.sourceMemoryId}): ${err}`);
+      return false;
+    }
+  }
   /**
    * Revoke a tombstone (re-allow the content). Used by the review-queue
    * approval path when an operator approves a blocked memory.
@@ -8000,55 +8348,55 @@ var StorageManager3 = class _StorageManager extends TombstoneBlockedCaptureIndex
     return null;
   }
   get questionsDir() {
-    return path9.join(this.baseDir, "questions");
+    return path11.join(this.baseDir, "questions");
   }
   get artifactsDir() {
-    return path9.join(this.baseDir, "artifacts");
+    return path11.join(this.baseDir, "artifacts");
   }
   get identityDir() {
-    return path9.join(this.baseDir, "identity");
+    return path11.join(this.baseDir, "identity");
   }
   get identityAnchorPath() {
-    return path9.join(this.identityDir, "identity-anchor.md");
+    return path11.join(this.identityDir, "identity-anchor.md");
   }
   get identityIncidentsDir() {
-    return path9.join(this.identityDir, "incidents");
+    return path11.join(this.identityDir, "incidents");
   }
   get identityAuditsWeeklyDir() {
-    return path9.join(this.identityDir, "audits", "weekly");
+    return path11.join(this.identityDir, "audits", "weekly");
   }
   get identityAuditsMonthlyDir() {
-    return path9.join(this.identityDir, "audits", "monthly");
+    return path11.join(this.identityDir, "audits", "monthly");
   }
   get identityImprovementLoopsPath() {
-    return path9.join(this.identityDir, "improvement-loops.md");
+    return path11.join(this.identityDir, "improvement-loops.md");
   }
   get identityReflectionsPath() {
-    return path9.join(this.identityDir, "reflections.md");
+    return path11.join(this.identityDir, "reflections.md");
   }
   get profilePath() {
-    return path9.join(this.baseDir, "profile.md");
+    return path11.join(this.baseDir, "profile.md");
   }
   get memoryActionsPath() {
-    return path9.join(this.stateDir, "memory-actions.jsonl");
+    return path11.join(this.stateDir, "memory-actions.jsonl");
   }
   get memoryLifecycleLedgerPath() {
-    return path9.join(this.stateDir, "memory-lifecycle-ledger.jsonl");
+    return path11.join(this.stateDir, "memory-lifecycle-ledger.jsonl");
   }
   get compressionGuidelinesPath() {
-    return path9.join(this.stateDir, "compression-guidelines.md");
+    return path11.join(this.stateDir, "compression-guidelines.md");
   }
   get compressionGuidelineDraftPath() {
-    return path9.join(this.stateDir, "compression-guidelines.draft.md");
+    return path11.join(this.stateDir, "compression-guidelines.draft.md");
   }
   get compressionGuidelineStatePath() {
-    return path9.join(this.stateDir, "compression-guideline-state.json");
+    return path11.join(this.stateDir, "compression-guideline-state.json");
   }
   get compressionGuidelineDraftStatePath() {
-    return path9.join(this.stateDir, "compression-guideline-draft-state.json");
+    return path11.join(this.stateDir, "compression-guideline-draft-state.json");
   }
   get behaviorSignalsPath() {
-    return path9.join(this.stateDir, "behavior-signals.jsonl");
+    return path11.join(this.stateDir, "behavior-signals.jsonl");
   }
   /**
    * In-memory dedup key set for behavior-signals appends (issue #1909),
@@ -8080,7 +8428,7 @@ var StorageManager3 = class _StorageManager extends TombstoneBlockedCaptureIndex
    * governance sweeps can treat it uniformly.
    */
   get bufferSurpriseLedgerPath() {
-    return path9.join(this.stateDir, "buffer-surprise-ledger.jsonl");
+    return path11.join(this.stateDir, "buffer-surprise-ledger.jsonl");
   }
   /**
    * Entity alias table loaded from THIS store's config/aliases.json.
@@ -8141,7 +8489,7 @@ var StorageManager3 = class _StorageManager extends TombstoneBlockedCaptureIndex
     this.loadAliasesSync();
   }
   loadAliasesSync() {
-    const aliasPath = path9.join(this.baseDir, "config", "aliases.json");
+    const aliasPath = path11.join(this.baseDir, "config", "aliases.json");
     this.userAliases = {};
     const raw = readEntityAliasConfigSync(this.baseDir);
     if (raw === void 0) return;
@@ -8176,22 +8524,22 @@ var StorageManager3 = class _StorageManager extends TombstoneBlockedCaptureIndex
     return completionFingerprint;
   }
   async ensureDirectories() {
-    await mkdir(this.baseDir, { recursive: true });
+    await mkdir2(this.baseDir, { recursive: true });
     await validateRoots(this.baseDir, this.entitiesDir, this.stateDir, this.archiveDir);
     const today = (/* @__PURE__ */ new Date()).toISOString().slice(0, 10);
-    await mkdir(path9.join(this.factsDir, today), { recursive: true });
-    await mkdir(path9.join(this.proceduresDir, today), { recursive: true });
-    await mkdir(path9.join(this.reasoningTracesDir, today), { recursive: true });
-    await mkdir(this.correctionsDir, { recursive: true });
-    await mkdir(this.entitiesDir, { recursive: true });
-    await mkdir(this.stateDir, { recursive: true });
-    await mkdir(this.questionsDir, { recursive: true });
-    await mkdir(this.artifactsDir, { recursive: true });
-    await mkdir(this.identityDir, { recursive: true });
-    await mkdir(this.identityIncidentsDir, { recursive: true });
-    await mkdir(this.identityAuditsWeeklyDir, { recursive: true });
-    await mkdir(this.identityAuditsMonthlyDir, { recursive: true });
-    await mkdir(path9.join(this.baseDir, "config"), { recursive: true });
+    await mkdir2(path11.join(this.factsDir, today), { recursive: true });
+    await mkdir2(path11.join(this.proceduresDir, today), { recursive: true });
+    await mkdir2(path11.join(this.reasoningTracesDir, today), { recursive: true });
+    await mkdir2(this.correctionsDir, { recursive: true });
+    await mkdir2(this.entitiesDir, { recursive: true });
+    await mkdir2(this.stateDir, { recursive: true });
+    await mkdir2(this.questionsDir, { recursive: true });
+    await mkdir2(this.artifactsDir, { recursive: true });
+    await mkdir2(this.identityDir, { recursive: true });
+    await mkdir2(this.identityIncidentsDir, { recursive: true });
+    await mkdir2(this.identityAuditsWeeklyDir, { recursive: true });
+    await mkdir2(this.identityAuditsMonthlyDir, { recursive: true });
+    await mkdir2(path11.join(this.baseDir, "config"), { recursive: true });
     await this.entityCanonicalIdMigration.ensure();
     if (this.hotMemoriesCacheEnabled && this.getMemoryCorpusVersion() === 0) {
       this.bumpMemoryCorpusVersion();
@@ -8212,12 +8560,12 @@ var StorageManager3 = class _StorageManager extends TombstoneBlockedCaptureIndex
    */
   async resolveCategoryWritePath(category, id, today) {
     if (category === "correction") {
-      await mkdir(this.correctionsDir, { recursive: true });
-      return path9.join(this.correctionsDir, `${id}.md`);
+      await mkdir2(this.correctionsDir, { recursive: true });
+      return path11.join(this.correctionsDir, `${id}.md`);
     }
-    const datedDir = path9.join(getCategoryDir(this.baseDir, category), today);
-    await mkdir(datedDir, { recursive: true });
-    return path9.join(datedDir, `${id}.md`);
+    const datedDir = path11.join(getCategoryDir(this.baseDir, category), today);
+    await mkdir2(datedDir, { recursive: true });
+    return path11.join(datedDir, `${id}.md`);
   }
   async findExistingTombstoneBlockedMemory(content, category, sourceConnector) {
     const identity = buildExplicitCaptureDedupKey(content, category, sourceConnector);
@@ -8379,7 +8727,7 @@ ${sanitized.text}
             }
           });
         } catch (err) {
-          await unlink4(filePath).catch(() => void 0);
+          await unlink5(filePath).catch(() => void 0);
           this.invalidateAllMemoriesCache();
           await this.rebuildTombstoneBlockedCaptureAfterInvalidationForPath(filePath);
           throw err;
@@ -8584,8 +8932,8 @@ ${sanitized.text}
     await this.ensureDirectories();
     const now = /* @__PURE__ */ new Date();
     const day = now.toISOString().slice(0, 10);
-    const dir = path9.join(this.artifactsDir, day);
-    await mkdir(dir, { recursive: true });
+    const dir = path11.join(this.artifactsDir, day);
+    await mkdir2(dir, { recursive: true });
     const id = `artifact-${Date.now()}-${Math.random().toString(36).slice(2, 6)}`;
     const fm = {
       id,
@@ -8610,7 +8958,7 @@ ${sanitized.text}
       log.warn(`artifact content rejected for ${id}; violations=${sanitized.violations.join(", ")}`);
       return "";
     }
-    const filePath = path9.join(dir, `${id}.md`);
+    const filePath = path11.join(dir, `${id}.md`);
     await this.writeStorageSecureFile(filePath, `${serializeFrontmatter(fm)}
 
 ${sanitized.text}
@@ -8791,6 +9139,11 @@ ${sanitized.text}
     clearInFlightReads();
     _StorageManager.questionsCache.clear();
     _StorageManager.coldMemoriesCache.clear();
+    _StorageManager.artifactWriteVersionByDir.clear();
+    _StorageManager.memoryStatusVersionByDir.clear();
+    _StorageManager.memoryCorpusVersionByDir.clear();
+    _StorageManager.entityMutationVersionByDir.clear();
+    _StorageManager.coldWriteVersionByDir.clear();
     clearMemoryCache();
     _StorageManager.hotMemoriesCacheDefaultByDir.clear();
     _StorageManager.hotMemoriesCacheTtlByDir.clear();
@@ -8893,7 +9246,7 @@ ${sanitized.text}
    * per-process in-memory cache safe across process boundaries.
    */
   invalidateColdMemoriesCache() {
-    const coldRoot = path9.join(this.baseDir, "cold");
+    const coldRoot = path11.join(this.baseDir, "cold");
     _StorageManager.coldMemoriesCache.delete(coldRoot);
     this.bumpColdWriteVersion();
     invalidateAllForDir(this.baseDir);
@@ -9013,7 +9366,7 @@ ${sanitized.text}
     const correctionPaths = [];
     const factPaths = [];
     for (const filePath of filePaths) {
-      if (filePath === this.correctionsDir || filePath.startsWith(`${this.correctionsDir}${path9.sep}`)) {
+      if (filePath === this.correctionsDir || filePath.startsWith(`${this.correctionsDir}${path11.sep}`)) {
         correctionPaths.push(filePath);
       } else {
         factPaths.push(filePath);
@@ -9074,9 +9427,9 @@ ${sanitized.text}
     const root = this.archiveDir;
     const readDir = async (dir) => {
       try {
-        const entries = await readdir5(dir, { withFileTypes: true });
+        const entries = await readdir6(dir, { withFileTypes: true });
         for (const entry of entries) {
-          const fullPath = path9.join(dir, entry.name);
+          const fullPath = path11.join(dir, entry.name);
           if (entry.isDirectory()) {
             await readDir(fullPath);
           } else if (entry.name.endsWith(".md")) {
@@ -9101,10 +9454,15 @@ ${sanitized.text}
               }
             } catch (err) {
               if (err instanceof SecureStoreLockedError) throw err;
+              if (!isErrnoCode(err, "ENOENT")) {
+                log.warn(`skipping unreadable archived memory ${fullPath}: ${err}`);
+              }
             }
           }
         }
-      } catch {
+      } catch (error) {
+        if (error instanceof SecureStoreLockedError) throw error;
+        if (!isErrnoCode(error, "ENOENT")) throw error;
       }
     };
     await readDir(root);
@@ -9114,7 +9472,7 @@ ${sanitized.text}
     return this.rememberMemorySnapshot(await this.memoryReadStore.readMemoryByPath(filePath));
   }
   resolveTierRootDir(tier) {
-    return tier === "cold" ? path9.join(this.baseDir, "cold") : this.baseDir;
+    return tier === "cold" ? path11.join(this.baseDir, "cold") : this.baseDir;
   }
   resolveMemoryDateDir(memory) {
     const preferred = memory.frontmatter.created || memory.frontmatter.updated;
@@ -9129,13 +9487,13 @@ ${sanitized.text}
   buildTierMemoryPath(memory, tier) {
     const root = this.resolveTierRootDir(tier);
     if (this.isArtifactMemory(memory)) {
-      return path9.join(root, "artifacts", this.resolveMemoryDateDir(memory), `${memory.frontmatter.id}.md`);
+      return path11.join(root, "artifacts", this.resolveMemoryDateDir(memory), `${memory.frontmatter.id}.md`);
     }
     if (memory.frontmatter.category === "correction") {
-      return path9.join(root, "corrections", `${memory.frontmatter.id}.md`);
+      return path11.join(root, "corrections", `${memory.frontmatter.id}.md`);
     }
     const dir = categoryDirName(memory.frontmatter.category);
-    return path9.join(root, dir, this.resolveMemoryDateDir(memory), `${memory.frontmatter.id}.md`);
+    return path11.join(root, dir, this.resolveMemoryDateDir(memory), `${memory.frontmatter.id}.md`);
   }
   async writeMemoryFileAtomic(targetPath, memory) {
     const refIdsAtWrite = this.currentHistoricalIds();
@@ -9151,7 +9509,7 @@ ${memory.content}
       {},
       this.baseDir
     );
-    const priorDest = await readFile2(targetPath).catch(() => null);
+    const priorDest = await readFile3(targetPath).catch(() => null);
     await persist();
     if (typeof rawRef === "string") {
       const refBeforeRepair = frontmatter.entityRef;
@@ -9166,7 +9524,7 @@ ${memory.content}
         });
       } catch (err) {
         if (priorDest === null) {
-          await unlink4(targetPath).catch(() => void 0);
+          await unlink5(targetPath).catch(() => void 0);
         } else {
           await writeFile2(targetPath, priorDest).catch(() => void 0);
         }
@@ -9213,8 +9571,8 @@ ${memory.content}
               memory.frontmatter.entityRef = current.frontmatter.entityRef;
             }
             durable = true;
-            const sourcePath = path9.resolve(current.path);
-            const destPath = path9.resolve(targetPath);
+            const sourcePath = path11.resolve(current.path);
+            const destPath = path11.resolve(targetPath);
             if (sourcePath !== destPath) {
               await recordArchiveDelete2(this.baseDir, current.path, () => this.deleteManagedStorageFile(current.path));
               this.invalidateAllMemoriesCache();
@@ -9238,8 +9596,8 @@ ${memory.content}
   }
   async migrateMemoryToTier(memory, targetTier) {
     const targetPath = this.buildTierMemoryPath(memory, targetTier);
-    const sourcePath = path9.resolve(memory.path);
-    const destPath = path9.resolve(targetPath);
+    const sourcePath = path11.resolve(memory.path);
+    const destPath = path11.resolve(targetPath);
     if (sourcePath === destPath) {
       return { changed: false, targetPath };
     }
@@ -9249,7 +9607,7 @@ ${memory.content}
     return { changed, targetPath };
   }
   get archiveDir() {
-    return path9.join(this.baseDir, "archive");
+    return path11.join(this.baseDir, "archive");
   }
   /**
    * Archive a memory by moving it from facts/ to archive/YYYY-MM-DD/.
@@ -9262,8 +9620,8 @@ ${memory.content}
       try {
         const now = lifecycle?.at ?? /* @__PURE__ */ new Date();
         const today = now.toISOString().slice(0, 10);
-        const destDir = path9.join(this.archiveDir, today);
-        await mkdir(destDir, { recursive: true });
+        const destDir = path11.join(this.archiveDir, today);
+        await mkdir2(destDir, { recursive: true });
         const refIdsAtWrite = this.currentHistoricalIds();
         const updatedFm = canonicalizeEntityRefOption(
           {
@@ -9278,7 +9636,7 @@ ${memory.content}
 
 ${current.content}
 `;
-        const destPath = path9.join(destDir, path9.basename(current.path));
+        const destPath = path11.join(destDir, path11.basename(current.path));
         const priorDest = await this.readStorageSecureFile(destPath).catch(() => null);
         await recordArchiveWrite(this.baseDir, destPath, () => this.writeStorageSecureFile(destPath, fileContent));
         if (typeof current.frontmatter.entityRef === "string") {
@@ -9295,7 +9653,7 @@ ${current.content}
               await recordArchiveDelete2(
                 this.baseDir,
                 destPath,
-                () => unlink4(destPath).then(
+                () => unlink5(destPath).then(
                   () => true,
                   () => false
                 )
@@ -9388,26 +9746,31 @@ ${current.content}
     }
     return null;
   }
-  async invalidateMemory(id) {
-    const memories = await this.readAllMemories();
-    const memory = memories.find((candidate) => candidate.frontmatter.id === id);
-    if (!memory) return false;
+  async invalidateMemory(id, expectedSnapshot, options) {
+    const memory = expectedSnapshot?.path ? await this.readMemoryByPath(expectedSnapshot.path) : (await this.readAllMemories()).find((candidate) => candidate.frontmatter.id === id) ?? null;
+    if (!memory || memory.frontmatter.id !== id) return false;
     return await this.runTombstoneBlockedInvalidation(memory, async (current, rebuildMarker, markDurable) => {
-      const deleted = await recordArchiveDelete(this.baseDir, current.path, () => this.deleteManagedStorageFile(current.path));
-      if (!deleted) return false;
-      markDurable();
-      markProjectedMemoryPathInvalid(this.baseDir, id);
-      this.invalidateAllMemoriesCache();
-      await this.rebuildTombstoneBlockedCaptureAfterInvalidation(rebuildMarker);
-      this.bumpMemoryStatusVersion();
-      log.debug(`invalidated memory ${id}`);
-      return true;
+      if (expectedSnapshot && invalidationCommitFingerprint(current) !== invalidationCommitFingerprint(expectedSnapshot)) {
+        return false;
+      }
+      return runCommittedInvalidation({
+        memoryId: id,
+        recordProof: options?.recordCommitProof === true ? () => this.recordCommittedInvalidation(current) : void 0,
+        clearProof: options?.recordCommitProof === true ? () => this.clearCommittedInvalidation(current) : void 0,
+        deleteMemory: () => recordArchiveDelete(this.baseDir, current.path, () => this.deleteManagedStorageFile(current.path)),
+        afterDelete: async () => {
+          markDurable();
+          markProjectedMemoryPathInvalid(this.baseDir, id);
+          this.invalidateAllMemoriesCache();
+          if (this.isColdOrArchiveTierPath(current.path)) this.invalidateColdMemoriesCache();
+          await this.rebuildTombstoneBlockedCaptureAfterInvalidation(rebuildMarker);
+          this.bumpMemoryStatusVersion();
+          log.debug(`invalidated memory ${id}`);
+        }
+      });
     });
   }
-  async updateMemory(id, newContent, options) {
-    const memories = await this.readAllMemories();
-    const memory = memories.find((m) => m.frontmatter.id === id);
-    if (!memory) return false;
+  async updateMemoryFromCurrent(memory, newContent, options) {
     const mergedLineage = [...memory.frontmatter.lineage ?? [], ...options?.lineage ?? []].filter(
       (v, i, a) => a.indexOf(v) === i
     );
@@ -9424,7 +9787,7 @@ ${current.content}
     );
     const sanitized = sanitizeMemoryContent(newContent);
     if (!sanitized.clean) {
-      log.warn(`updated memory content sanitized for ${id}; violations=${sanitized.violations.join(", ")}`);
+      log.warn(`updated memory content sanitized for ${memory.frontmatter.id}; violations=${sanitized.violations.join(", ")}`);
     }
     const fileContent = `${serializeFrontmatter(updated)}
 
@@ -9432,6 +9795,7 @@ ${sanitized.text}
 `;
     await this.writeTombstoneBlockedUpdate(memory, fileContent, updated, sanitized.text, async () => {
       this.invalidateAllMemoriesCache();
+      if (this.isColdOrArchiveTierPath(memory.path)) this.invalidateColdMemoriesCache();
     });
     if (typeof memory.frontmatter.entityRef === "string") {
       await this.entityRefRepair.repair(
@@ -9445,7 +9809,7 @@ ${sanitized.text}
     }
     await this.patchHotMemoriesCache({ addedPath: memory.path });
     await this.appendGeneratedMemoryLifecycleEventFailOpen("storage.updateMemory", {
-      memoryId: id,
+      memoryId: memory.frontmatter.id,
       eventType: "updated",
       timestamp: updated.updated,
       actor: options?.actor ?? "storage.updateMemory",
@@ -9456,9 +9820,36 @@ ${sanitized.text}
         ...(updated.lineage ?? []).filter(Boolean)
       ]
     });
-    log.debug(`updated memory ${id}`);
+    log.debug(`updated memory ${memory.frontmatter.id}`);
     return true;
   }
+  async updateMemory(id, newContent, options) {
+    const memory = (await this.readAllMemories()).find((candidate) => candidate.frontmatter.id === id);
+    if (!memory) return false;
+    return await this.updateMemoryFromCurrent(memory, newContent, options);
+  }
+  async updateMemoryIfUnchanged(expected, newContent, options) {
+    const sanitized = sanitizeMemoryContent(newContent);
+    const oldIdentity = buildExplicitCaptureDedupKey(
+      expected.content,
+      expected.frontmatter.category,
+      expected.frontmatter.sourceConnector
+    );
+    const newIdentity = buildExplicitCaptureDedupKey(
+      sanitized.text,
+      expected.frontmatter.category,
+      expected.frontmatter.sourceConnector
+    );
+    return await this.withTombstoneBlockedCaptureWriteLock(
+      async () => {
+        const current = await this.readMemoryByPath(expected.path);
+        if (!current || current.frontmatter.id !== expected.frontmatter.id) return false;
+        if (invalidationCommitFingerprint(current) !== invalidationCommitFingerprint(expected)) return false;
+        return await this.updateMemoryFromCurrent(current, newContent, options);
+      },
+      [buildCapturePathLockIdentity(expected.path), oldIdentity, newIdentity]
+    );
+  }
   /**
    * Update frontmatter fields without changing memory content.
    * Returns false when the memory is not found.
@@ -9478,7 +9869,7 @@ ${memory.content}
 `;
     await this.writeTombstoneBlockedFrontmatter(memory, fileContent, updated, async () => {
       this.invalidateAllMemoriesCache();
-      if (memory.path.includes(`${path9.sep}cold${path9.sep}`)) {
+      if (memory.path.includes(`${path11.sep}cold${path11.sep}`)) {
         this.invalidateColdMemoriesCache();
       }
     });
@@ -9489,7 +9880,7 @@ ${memory.content}
       });
     }
     await this.patchHotMemoriesCache({ addedPath: memory.path });
-    if (memory.path.includes(`${path9.sep}cold${path9.sep}`)) {
+    if (memory.path.includes(`${path11.sep}cold${path11.sep}`)) {
       this.invalidateColdMemoriesCache();
     }
     try {
@@ -9524,6 +9915,17 @@ ${memory.content}
     }
     return true;
   }
+  /**
+   * Update frontmatter only when the persisted memory still matches the
+   * expected semantic snapshot.
+   */
+  async writeMemoryFrontmatterIfUnchanged(expected, patch, lifecycle) {
+    return await this.withTombstoneBlockedMemoryPathLock(expected.path, async (current) => {
+      if (!current) return false;
+      if (invalidationCommitFingerprint(current) !== invalidationCommitFingerprint(expected)) return false;
+      return await this.writeMemoryFrontmatter(current, patch, lifecycle);
+    });
+  }
   /**
    * Update frontmatter by memory ID.
    * Prefer writeMemoryFrontmatter(memory, patch) in batch loops to avoid full-corpus rescans.
@@ -9559,7 +9961,7 @@ ${memory.content}
     return deleted;
   }
   async loadBuffer() {
-    const bufferPath = path9.join(this.stateDir, "buffer.json");
+    const bufferPath = path11.join(this.stateDir, "buffer.json");
     try {
       const raw = await this.readStorageSecureFile(bufferPath);
       return JSON.parse(raw);
@@ -9571,11 +9973,11 @@ ${memory.content}
   }
   async saveBuffer(state) {
     await this.ensureDirectories();
-    const bufferPath = path9.join(this.stateDir, "buffer.json");
+    const bufferPath = path11.join(this.stateDir, "buffer.json");
     await this.writeStorageSecureFile(bufferPath, JSON.stringify(state, null, 2));
   }
   async loadMeta() {
-    const metaPath = path9.join(this.stateDir, "meta.json");
+    const metaPath = path11.join(this.stateDir, "meta.json");
     try {
       const raw = await this.readStorageSecureFile(metaPath);
       const parsed = JSON.parse(raw);
@@ -9608,7 +10010,7 @@ ${memory.content}
   }
   async saveMeta(state) {
     await this.ensureDirectories();
-    const metaPath = path9.join(this.stateDir, "meta.json");
+    const metaPath = path11.join(this.stateDir, "meta.json");
     await this.writeStorageSecureFile(metaPath, JSON.stringify(state, null, 2));
   }
   async appendMemoryActionEvents(events) {
@@ -9672,7 +10074,7 @@ ${memory.content}
       },
       (payload) => this.appendStorageSecureFile(target, payload),
       async () => {
-        await mkdir(path9.dirname(target), { recursive: true });
+        await mkdir2(path11.dirname(target), { recursive: true });
       }
     );
   }
@@ -9770,7 +10172,7 @@ ${memory.content}
   async appendReextractJobs(events) {
     if (events.length === 0) return 0;
     await this.ensureDirectories();
-    const filePath = path9.join(this.stateDir, "reextract-jobs.jsonl");
+    const filePath = path11.join(this.stateDir, "reextract-jobs.jsonl");
     const lines = events.map((event) => JSON.stringify(event)).join("\n") + "\n";
     try {
       await this.appendStorageSecureFile(filePath, lines);
@@ -9783,7 +10185,7 @@ ${memory.content}
   }
   async readReextractJobs(limit = 200) {
     const safeLimit = Number.isFinite(limit) ? Math.max(1, Math.min(1e3, Math.floor(limit))) : 200;
-    const filePath = path9.join(this.stateDir, "reextract-jobs.jsonl");
+    const filePath = path11.join(this.stateDir, "reextract-jobs.jsonl");
     try {
       const raw = await this.readStorageSecureFile(filePath);
       const lines = raw.split("\n").filter((line) => line.trim().length > 0);
@@ -9932,7 +10334,7 @@ ${memory.content}
       return false;
     }
     if (draftState.contentHash) {
-      const contentHash = createHash6("sha256").update(draftContent).digest("hex");
+      const contentHash = createHash7("sha256").update(draftContent).digest("hex");
       if (contentHash !== draftState.contentHash) return false;
     }
     await this.writeCompressionGuidelines(draftContent);
@@ -9941,8 +10343,8 @@ ${memory.content}
       activationState: "active"
     });
     await Promise.all([
-      unlink4(this.compressionGuidelineDraftPath).catch(() => void 0),
-      unlink4(this.compressionGuidelineDraftStatePath).catch(() => void 0)
+      unlink5(this.compressionGuidelineDraftPath).catch(() => void 0),
+      unlink5(this.compressionGuidelineDraftStatePath).catch(() => void 0)
     ]);
     return true;
   }
@@ -9994,7 +10396,7 @@ ${memory.content}
     return `${prefix}-${ts}-${rand}`;
   }
   async writeQuestion(question, context, priority) {
-    await mkdir(this.questionsDir, { recursive: true });
+    await mkdir2(this.questionsDir, { recursive: true });
     const id = this.generateId("q");
     const frontmatter = {
       id,
@@ -10010,7 +10412,7 @@ ${question}
 
 **Context:** ${context}
 `;
-    const filePath = path9.join(this.questionsDir, `${id}.md`);
+    const filePath = path11.join(this.questionsDir, `${id}.md`);
     await this.writeStorageSecureFile(filePath, content);
     log.debug(`wrote question ${id} to ${filePath}`);
     this.invalidateQuestionsCache();
@@ -10028,7 +10430,7 @@ ${question}
     if (!match) return null;
     const frontmatterStr = match[1];
     const body = match[2].trim();
-    const id = this.extractFrontmatterValue(frontmatterStr, "id") ?? path9.basename(filePath, ".md");
+    const id = this.extractFrontmatterValue(frontmatterStr, "id") ?? path11.basename(filePath, ".md");
     const created = this.extractFrontmatterValue(frontmatterStr, "created") ?? "";
     const priority = parseFloat(this.extractFrontmatterValue(frontmatterStr, "priority") ?? "0.5");
     const resolved = this.extractFrontmatterValue(frontmatterStr, "resolved") === "true";
@@ -10062,7 +10464,7 @@ ${question}
   async readIdentity(workspaceDir, namespace) {
     const identityPath = this.identityFilePath(workspaceDir, namespace);
     try {
-      return await readFile2(identityPath, "utf-8");
+      return await readFile3(identityPath, "utf-8");
     } catch {
       return "";
     }
@@ -10080,15 +10482,15 @@ ${question}
     const identityPath = this.identityFilePath(workspaceDir, opts?.namespace);
     let existing = "";
     try {
-      existing = await readFile2(identityPath, "utf-8");
+      existing = await readFile3(identityPath, "utf-8");
     } catch {
     }
     const hygiene = opts?.hygiene;
-    const rotateEnabled = hygiene?.enabled === true && hygiene.rotateEnabled === true && Array.isArray(hygiene.rotatePaths) && hygiene.rotatePaths.includes(path9.basename(identityPath));
+    const rotateEnabled = hygiene?.enabled === true && hygiene.rotateEnabled === true && Array.isArray(hygiene.rotatePaths) && hygiene.rotatePaths.includes(path11.basename(identityPath));
     if (rotateEnabled) {
       const maxBytes = hygiene.rotateMaxBytes;
       if (existing.length > maxBytes) {
-        const archiveDir = path9.join(workspaceDir, hygiene.archiveDir);
+        const archiveDir = path11.join(workspaceDir, hygiene.archiveDir);
         const { newContent } = await rotateMarkdownFileToArchive({
           filePath: identityPath,
           archiveDir,
@@ -10140,7 +10542,7 @@ ${reflection}
     }
   }
   async writeIdentityReflections(content) {
-    await mkdir(this.identityDir, { recursive: true });
+    await mkdir2(this.identityDir, { recursive: true });
     await this.writeStorageSecureFile(this.identityReflectionsPath, content);
   }
   async appendIdentityReflection(reflection) {
@@ -10172,7 +10574,7 @@ ${reflection}
 
 ${reflection}
 `;
-    await mkdir(this.identityDir, { recursive: true });
+    await mkdir2(this.identityDir, { recursive: true });
     await this.writeStorageSecureFile(this.identityReflectionsPath, `${existing.trimEnd()}${section}`);
     log.debug(`appended namespace-local reflection to ${this.identityReflectionsPath}`);
   }
@@ -10228,7 +10630,7 @@ ${reflection}
       const rightTs = latestEntityTimelineTimestamp(right.entity) ?? "";
       return compareEntityTimestamps(rightTs, leftTs);
     }).map(({ entityName }) => entityName);
-    await mkdir(this.stateDir, { recursive: true });
+    await mkdir2(this.stateDir, { recursive: true });
     await this.writeStorageSecureFile(
       this.entitySynthesisQueuePath,
       JSON.stringify(
@@ -10248,7 +10650,7 @@ ${reflection}
     if (queue.length === 0) return;
     const removals = new Set(entityNames);
     const nextQueue = queue.filter((name) => !removals.has(name));
-    await mkdir(this.stateDir, { recursive: true });
+    await mkdir2(this.stateDir, { recursive: true });
     await this.writeStorageSecureFile(
       this.entitySynthesisQueuePath,
       JSON.stringify(
@@ -10348,14 +10750,14 @@ ${reflection}
     if (entries.length === 0) return 0;
     const memories = await this.readAllMemories();
     const memoryMap = new Map(memories.map((m) => [m.frontmatter.id, m]));
-    const memoryPathMap = new Map(memories.map((m) => [path9.resolve(m.path), m]));
+    const memoryPathMap = new Map(memories.map((m) => [path11.resolve(m.path), m]));
     let updated = 0;
     const prevVersion = this.getMemoryCorpusVersion();
     const keyId = this.hotCacheKeyId();
     const warm = this.hotMemoriesCacheEnabled && getCachedMemories(this.baseDir, prevVersion, keyId, this.hotCacheTtlMs()) !== null;
     const appliedPatches = /* @__PURE__ */ new Map();
     for (const entry of entries) {
-      const memory = entry.memoryPath ? memoryPathMap.get(path9.resolve(entry.memoryPath)) : memoryMap.get(entry.memoryId);
+      const memory = entry.memoryPath ? memoryPathMap.get(path11.resolve(entry.memoryPath)) : memoryMap.get(entry.memoryId);
       if (!memory) continue;
       try {
         const applied = await this.withTombstoneBlockedMemoryPathLock(memory.path, async (current) => {
@@ -10386,7 +10788,7 @@ ${current.content}
         if (warm) {
           updateCacheOnWrite(this.baseDir, { ...applied.current, frontmatter: applied.newFm }, keyId);
         }
-        appliedPatches.set(path9.resolve(memory.path), {
+        appliedPatches.set(path11.resolve(memory.path), {
           accessCount: entry.newCount,
           lastAccessed: entry.lastAccessed
         });
@@ -10402,7 +10804,7 @@ ${current.content}
         const cur = getCachedMemories(this.baseDir, prevVersion, keyId);
         if (cur) {
           const reapplied = cur.map((m) => {
-            const patch = appliedPatches.get(path9.resolve(m.path));
+            const patch = appliedPatches.get(path11.resolve(m.path));
             return patch ? {
               ...m,
               frontmatter: { ...m.frontmatter, accessCount: patch.accessCount, lastAccessed: patch.lastAccessed }
@@ -10437,7 +10839,7 @@ ${current.content}
     const pathsById = /* @__PURE__ */ new Map();
     const filePathsById = /* @__PURE__ */ new Map();
     for (const filePath of filePaths) {
-      const memoryId = path9.basename(filePath, ".md");
+      const memoryId = path11.basename(filePath, ".md");
       if (!wantedIds.has(memoryId)) continue;
       const paths = filePathsById.get(memoryId) ?? [];
       paths.push(filePath);
@@ -10449,7 +10851,7 @@ ${current.content}
       const preferredMatches = [];
       for (const preferredPath of preferred) {
         const directCandidates = new Set(qmdResultPathCandidates(this.baseDir, preferredPath));
-        const directMatch = existingPaths.find((filePath) => directCandidates.has(path9.resolve(filePath)));
+        const directMatch = existingPaths.find((filePath) => directCandidates.has(path11.resolve(filePath)));
         if (directMatch) {
           preferredMatches.push(directMatch);
           continue;
@@ -10461,7 +10863,7 @@ ${current.content}
             candidates.add(candidate);
           }
         }
-        const match = existingPaths.find((filePath) => candidates.has(path9.resolve(filePath)));
+        const match = existingPaths.find((filePath) => candidates.has(path11.resolve(filePath)));
         if (match) preferredMatches.push(match);
       }
       if (preferredMatches.length > 0) {
@@ -10621,104 +11023,177 @@ ${sanitized.text}
     const memories = await this.readAllMemories();
     return memories.filter((m) => m.frontmatter.parentId === parentId).sort((a, b) => (a.frontmatter.chunkIndex ?? 0) - (b.frontmatter.chunkIndex ?? 0));
   }
-  async supersedeMemory(oldMemoryId, newMemoryId, reason) {
-    const memories = await this.readAllMemories();
-    let oldMemory = memories.find(
-      (memory) => memory.frontmatter.id === oldMemoryId && inferMemoryStatus(memory.frontmatter, toMemoryPathRel(this.baseDir, memory.path)) === "active"
-    );
-    if (!oldMemory) {
-      oldMemory = (await this.readAllColdMemories()).find(
-        (memory) => memory.frontmatter.id === oldMemoryId && inferMemoryStatus(memory.frontmatter, toMemoryPathRel(this.baseDir, memory.path)) === "active"
-      );
+  async supersedeMemory(oldMemoryId, newMemoryId, reason, supersessionMetadata, options = {}) {
+    const matchesSupersession = (memory) => memory.frontmatter.status === "superseded" && memory.frontmatter.supersededBy === newMemoryId && (supersessionMetadata === void 0 || memory.frontmatter.supersessionCause === supersessionMetadata.supersessionCause && memory.frontmatter.invalidatedBy === supersessionMetadata.invalidatedBy);
+    const isExactReplay = (memory) => options.acceptExactReplay === true && matchesSupersession(memory);
+    let oldMemory;
+    if (options.expectedSnapshot?.path) {
+      const selected = await this.readMemoryByPath(options.expectedSnapshot.path);
+      if (!selected || selected.frontmatter.id !== oldMemoryId) {
+        return false;
+      }
+      if (invalidationCommitFingerprint(selected) !== invalidationCommitFingerprint(options.expectedSnapshot) && !isExactReplay(selected)) {
+        return false;
+      }
+      oldMemory = selected;
+    } else {
+      const memories = [
+        ...await this.readAllMemories(),
+        ...await this.readAllColdMemories(),
+        ...await this.readArchivedMemories()
+      ];
+      const candidates = memories.filter((memory) => memory.frontmatter.id === oldMemoryId);
+      oldMemory = candidates.find(
+        (memory) => inferMemoryStatus(memory.frontmatter, toMemoryPathRel(this.baseDir, memory.path)) === "active"
+      ) ?? candidates.find(isExactReplay) ?? candidates[0];
+      if (oldMemory && options.expectedSnapshot && invalidationCommitFingerprint(oldMemory) !== invalidationCommitFingerprint(options.expectedSnapshot) && !isExactReplay(oldMemory)) {
+        return false;
+      }
     }
     if (!oldMemory) return false;
-    const now = (/* @__PURE__ */ new Date()).toISOString();
+    const requireActiveAtWrite = options.requireActive === true || inferMemoryStatus(oldMemory.frontmatter, toMemoryPathRel(this.baseDir, oldMemory.path)) === "active";
+    const operationId = createHash7("sha256").update(
+      JSON.stringify({
+        oldMemoryId,
+        newMemoryId,
+        reason,
+        supersessionMetadata: supersessionMetadata ?? null
+      })
+    ).digest("hex");
+    const initialNow = (/* @__PURE__ */ new Date()).toISOString();
     let currentBefore = oldMemory;
     let updatedFm = oldMemory.frontmatter;
-    const written = await this.withTombstoneBlockedMemoryPathLock(oldMemory.path, async (current) => {
-      if (current?.frontmatter.id !== oldMemoryId) return false;
-      if (current.frontmatter.supersededBy !== void 0 || inferMemoryStatus(current.frontmatter, toMemoryPathRel(this.baseDir, current.path)) !== "active") {
-        return false;
-      }
-      currentBefore = current;
-      const refIdsAtWrite = this.currentHistoricalIds();
-      updatedFm = canonicalizeEntityRefOption(
-        { ...current.frontmatter, status: "superseded", supersededBy: newMemoryId, supersededAt: now, updated: now },
-        refIdsAtWrite
-      );
-      const fileContent = `${serializeFrontmatter(updatedFm)}
+    let exactReplay = false;
+    try {
+      const written = await this.withTombstoneBlockedMemoryPathLock(oldMemory.path, async (current) => {
+        if (current?.frontmatter.id !== oldMemoryId) return false;
+        if (matchesSupersession(current)) {
+          currentBefore = current;
+          updatedFm = current.frontmatter;
+          return options.acceptExactReplay === true ? "exact-replay" : false;
+        }
+        if (options.expectedSnapshot && invalidationCommitFingerprint(current) !== invalidationCommitFingerprint(options.expectedSnapshot)) {
+          return false;
+        }
+        if (current.frontmatter.supersededBy !== void 0 || requireActiveAtWrite && inferMemoryStatus(current.frontmatter, toMemoryPathRel(this.baseDir, current.path)) !== "active") {
+          return false;
+        }
+        currentBefore = current;
+        const refIdsAtWrite = this.currentHistoricalIds();
+        updatedFm = canonicalizeEntityRefOption(
+          {
+            ...current.frontmatter,
+            ...supersessionMetadata,
+            status: "superseded",
+            supersededBy: newMemoryId,
+            supersededAt: initialNow,
+            updated: initialNow
+          },
+          refIdsAtWrite
+        );
+        const fileContent = `${serializeFrontmatter(updatedFm)}
 
 ${current.content}
 `;
-      await this.writeTombstoneBlockedFrontmatter(current, fileContent, updatedFm);
-      if (typeof current.frontmatter.entityRef === "string") {
+        await this.writeTombstoneBlockedFrontmatter(current, fileContent, updatedFm);
+        if (this.isColdOrArchiveTierPath(current.path)) this.invalidateColdMemoriesCache();
+        if (typeof current.frontmatter.entityRef === "string") {
+          await this.entityRefRepair.repair(
+            current.path,
+            updatedFm,
+            current.frontmatter.entityRef,
+            refIdsAtWrite,
+            current.content,
+            { onFailRestore: current }
+          );
+        }
+        return true;
+      });
+      if (!written) return false;
+      exactReplay = written === "exact-replay";
+      if (exactReplay && typeof updatedFm.entityRef === "string") {
         await this.entityRefRepair.repair(
-          current.path,
+          currentBefore.path,
           updatedFm,
-          current.frontmatter.entityRef,
-          refIdsAtWrite,
-          current.content,
-          { onFailRestore: current }
+          updatedFm.entityRef,
+          this.currentHistoricalIds(),
+          currentBefore.content,
+          { onFailRestore: currentBefore }
         );
       }
-      return true;
-    }).catch((err) => {
+      const supersededAt = updatedFm.supersededAt ?? initialNow;
+      const beforeState = this.summarizeLifecycleState(
+        currentBefore.frontmatter,
+        currentBefore.path
+      );
+      const afterState = this.summarizeLifecycleState(updatedFm, currentBefore.path);
+      const sideEffectsComplete = await runSupersessionSideEffects({
+        oldMemoryId,
+        newMemoryId,
+        reason,
+        now: supersededAt,
+        operationId,
+        exactReplay,
+        currentBefore,
+        updatedFm,
+        citationTemplate: this.citationTemplate,
+        correctionsDir: this.correctionsDir,
+        readMemoryByPath: (filePath) => this.readMemoryByPath(filePath),
+        isColdOrArchiveTierPath: (memoryPath) => this.isColdOrArchiveTierPath(memoryPath),
+        invalidateColdMemoriesCache: () => this.invalidateColdMemoriesCache(),
+        invalidateAllMemoriesCache: () => this.invalidateAllMemoriesCache(),
+        bumpMemoryCorpusVersion: () => this.bumpMemoryCorpusVersion(),
+        appendLifecycleEvent: async () => {
+          let lifecycleEvents = [];
+          try {
+            lifecycleEvents = await this.getMemoryTimeline(oldMemoryId, 200);
+          } catch (error) {
+            log.warn(`supersession lifecycle replay check failed for ${oldMemoryId}: ${error}`);
+          }
+          if (lifecycleEvents.some(
+            (event) => event.memoryId === oldMemoryId && event.eventType === "superseded" && (event.correlationId === operationId || event.correlationId === void 0 && event.reasonCode === reason && event.timestamp === supersededAt && event.relatedMemoryIds?.includes(newMemoryId))
+          )) {
+            return;
+          }
+          await this.appendGeneratedMemoryLifecycleEventFailOpen("storage.supersedeMemory", {
+            memoryId: oldMemoryId,
+            eventType: "superseded",
+            timestamp: supersededAt,
+            actor: "storage.supersedeMemory",
+            reasonCode: reason,
+            before: exactReplay ? { ...beforeState, status: "active" } : beforeState,
+            after: afterState,
+            relatedMemoryIds: [newMemoryId],
+            correlationId: operationId
+          });
+        },
+        bumpMemoryStatusVersion: () => this.bumpMemoryStatusVersion(),
+        hasExactTombstone: (input) => this.hasExactTombstone(input),
+        appendTombstone: (input) => this.appendTombstone(input),
+        writeSealedMemory: (envelope, extras) => this.writeSealedMemory(envelope, extras)
+      });
+      return sideEffectsComplete || options.acceptExactReplay !== true;
+    } catch (err) {
       log.error(`failed to supersede memory ${oldMemoryId}:`, err);
       return false;
-    });
-    if (!written) return false;
-    await runSupersessionSideEffects({
-      oldMemoryId,
-      newMemoryId,
-      reason,
-      now,
-      currentBefore,
-      updatedFm,
-      citationTemplate: this.citationTemplate,
-      isColdOrArchiveTierPath: (memoryPath) => this.isColdOrArchiveTierPath(memoryPath),
-      invalidateColdMemoriesCache: () => this.invalidateColdMemoriesCache(),
-      bumpMemoryCorpusVersion: () => this.bumpMemoryCorpusVersion(),
-      appendLifecycleEvent: () => this.appendGeneratedMemoryLifecycleEventFailOpen("storage.supersedeMemory", {
-        memoryId: oldMemoryId,
-        eventType: "superseded",
-        timestamp: now,
-        actor: "storage.supersedeMemory",
-        reasonCode: reason,
-        before: this.summarizeLifecycleState(currentBefore.frontmatter, currentBefore.path),
-        after: this.summarizeLifecycleState(updatedFm, currentBefore.path),
-        relatedMemoryIds: [newMemoryId]
-      }),
-      bumpMemoryStatusVersion: () => this.bumpMemoryStatusVersion(),
-      appendTombstone: (input) => this.appendTombstone(input),
-      writeSealedMemory: (envelope, extras) => this.writeSealedMemory(envelope, extras)
-    });
-    return true;
+    }
   }
-  // ---------------------------------------------------------------------------
-  // Memory Summarization (Phase 4A)
-  // ---------------------------------------------------------------------------
   get summariesDir() {
-    return path9.join(this.baseDir, "summaries");
+    return path11.join(this.baseDir, "summaries");
   }
-  /**
-   * Write a memory summary.
-   */
   async writeSummary(summary) {
-    await mkdir(this.summariesDir, { recursive: true });
-    const filePath = path9.join(this.summariesDir, `${summary.id}.json`);
+    await mkdir2(this.summariesDir, { recursive: true });
+    const filePath = path11.join(this.summariesDir, `${summary.id}.json`);
     await this.writeStorageSecureFile(filePath, JSON.stringify(summary, null, 2));
     log.debug(`wrote summary ${summary.id}`);
   }
-  /**
-   * Get all summaries.
-   */
   async readSummaries() {
     try {
-      const files = await readdir5(this.summariesDir);
+      const files = await readdir6(this.summariesDir);
       const summaries = [];
       for (const file of files) {
         if (!file.endsWith(".json")) continue;
-        const filePath = path9.join(this.summariesDir, file);
+        const filePath = path11.join(this.summariesDir, file);
         const raw = await this.readStorageSecureFile(filePath);
         summaries.push(JSON.parse(raw));
       }
@@ -10729,9 +11204,6 @@ ${current.content}
       return [];
     }
   }
-  /**
-   * Archive memories (mark as archived, not delete).
-   */
   async archiveMemories(memoryIds, summaryId) {
     const memories = await this.readAllMemories();
     const memoryMap = new Map(memories.map((m) => [m.frontmatter.id, m]));
@@ -10790,26 +11262,17 @@ ${current.content}
     }
     return archived;
   }
-  // ---------------------------------------------------------------------------
-  // Topic Extraction (Phase 4B)
-  // ---------------------------------------------------------------------------
-  /**
-   * Save topic scores to meta.json.
-   */
   async saveTopics(topics) {
-    const metaPath = path9.join(this.stateDir, "topics.json");
-    await mkdir(this.stateDir, { recursive: true });
+    const metaPath = path11.join(this.stateDir, "topics.json");
+    await mkdir2(this.stateDir, { recursive: true });
     await this.writeStorageSecureFile(
       metaPath,
       JSON.stringify({ topics, updatedAt: (/* @__PURE__ */ new Date()).toISOString() }, null, 2)
     );
     log.debug(`saved ${topics.length} topic scores`);
   }
-  /**
-   * Load topic scores from meta.json.
-   */
   async loadTopics() {
-    const metaPath = path9.join(this.stateDir, "topics.json");
+    const metaPath = path11.join(this.stateDir, "topics.json");
     try {
       const raw = await this.readStorageSecureFile(metaPath);
       return JSON.parse(raw);
@@ -10819,9 +11282,6 @@ ${current.content}
       return { topics: [], updatedAt: null };
     }
   }
-  /**
-   * Add links to an existing memory.
-   */
   async addLinksToMemory(memoryId, links, lifecycle) {
     const memories = await this.readAllMemories();
     const memory = memories.find((m) => m.frontmatter.id === memoryId);
@@ -10927,4 +11387,4 @@ export {
   isValidBufferSurpriseEvent,
   StorageManager3 as StorageManager
 };
-//# sourceMappingURL=chunk-VBHPOWBJ.js.map
+//# sourceMappingURL=chunk-WD5B5AIE.js.map