@remnic/core 9.50.3 → 9.51.1

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

@@ -1,9 +1,3 @@
-import {
-  TombstoneStore,
-  applyTombstoneResurrectionGate,
-  buildRetiredFactTombstoneInputs,
-  collectRetiredMemoriesForRebuild
-} from "./chunk-ENTCVTQR.js";
 import {
   WEARABLES_DIR_NAME,
   escapeSegmentText,
@@ -15,6 +9,12 @@ import {
   unescapeSegmentText,
   unescapeSpeakerLabel
 } from "./chunk-UHVXE24Y.js";
+import {
+  TombstoneStore,
+  applyTombstoneResurrectionGate,
+  buildRetiredFactTombstoneInputs,
+  collectRetiredMemoriesForRebuild
+} from "./chunk-ENTCVTQR.js";
 import {
   withholdToolScopedFromSharedNamespace
 } from "./chunk-S2V7RUCL.js";
@@ -26,10 +26,7 @@ import {
 import {
   SPECULATIVE_TTL_DAYS,
   confidenceTier
-} from "./chunk-LAQ33B5D.js";
-import {
-  createMemorySnapshot
-} from "./chunk-S2HLHAZ4.js";
+} from "./chunk-UU3G6GUP.js";
 import {
   normalizeProjectionPreview,
   normalizeProjectionTags
@@ -38,6 +35,9 @@ import {
   rewriteProjectedEntityReferences,
   rewriteProjectedMemoryEntityReference
 } from "./chunk-WRJVB3C2.js";
+import {
+  createMemorySnapshot
+} from "./chunk-S2HLHAZ4.js";
 import {
   rotateMarkdownFileToArchive
 } from "./chunk-DM2T26WE.js";
@@ -61,7 +61,7 @@ import {
   isQueuedReviewMemory,
   parseTombstoneBlockedOfflineSyncMemory,
   tombstoneBlocked
-} from "./chunk-IXXABW5A.js";
+} from "./chunk-BHXYAVUM.js";
 import {
   composeMemoryEnvelope,
   isSealedMemoryEnvelope,
@@ -130,14 +130,20 @@ import {
   reconcileProvenanceRead,
   serializeProvenanceFields
 } from "./chunk-QBSFOKY6.js";
+import {
+  sanitizeMemoryContent
+} from "./chunk-5GKPFL3S.js";
 import {
   matchEntitySchemaSection,
   normalizeEntityStructuredSection,
   sortStructuredSectionsBySchema
 } from "./chunk-ZIKENA2C.js";
 import {
-  sanitizeMemoryContent
-} from "./chunk-5GKPFL3S.js";
+  archive_mutation_version_exports,
+  bumpArchiveMutationIfChanged,
+  getArchiveMutationVersionForDir,
+  recordArchiveDelete
+} from "./chunk-W5BIQOAJ.js";
 import {
   selectArtifactMatches
 } from "./chunk-Z7L72ZHL.js";
@@ -5064,6 +5070,66 @@ function stripCitationMarkersForHashRemoval(value, template) {
   return removed ? trimLeadingSpacesAndTabs(result) : value;
 }
 
+// src/storage/supersession-side-effects.ts
+async function runSupersessionSideEffects(options) {
+  const {
+    oldMemoryId,
+    newMemoryId,
+    reason,
+    now,
+    currentBefore,
+    updatedFm,
+    citationTemplate,
+    isColdOrArchiveTierPath,
+    invalidateColdMemoriesCache,
+    bumpMemoryCorpusVersion,
+    appendLifecycleEvent,
+    bumpMemoryStatusVersion,
+    appendTombstone,
+    writeSealedMemory
+  } = options;
+  try {
+    if (isColdOrArchiveTierPath(currentBefore.path)) invalidateColdMemoriesCache();
+    bumpMemoryCorpusVersion();
+    await appendLifecycleEvent();
+    bumpMemoryStatusVersion();
+    log.debug(`superseded memory ${oldMemoryId} by ${newMemoryId}: ${reason}`);
+    if (currentBefore.frontmatter.category === "fact") {
+      for (const input of buildRetiredFactTombstoneInputs(
+        {
+          id: oldMemoryId,
+          content: stripCitationForTemplate(currentBefore.content, citationTemplate),
+          contentHash: currentBefore.frontmatter.contentHash,
+          entityRef: updatedFm.entityRef,
+          structuredAttributes: currentBefore.frontmatter.structuredAttributes
+        },
+        {
+          reason: "contradiction_resolution",
+          createdBy: "contradiction_resolution",
+          createdAt: now,
+          supersessionKeysForFact
+        }
+      )) {
+        await appendTombstone(input);
+      }
+    }
+    const auditEnvelope = composeMemoryEnvelope(
+      {
+        content: `Superseded: ${currentBefore.content}
+
+Reason: ${reason}`,
+        category: "correction",
+        confidence: 1,
+        tags: ["supersession", "auto-resolved"]
+      },
+      { source: "contradiction-detection" }
+    );
+    await writeSealedMemory(auditEnvelope, { lineage: [oldMemoryId, newMemoryId] });
+  } catch (err) {
+    log.error(`failed to supersede memory ${oldMemoryId}:`, err);
+  }
+}
+
 // src/storage/entity-timeline.ts
 import { createHash as createHash5 } from "crypto";
 function parseEntityTimelineBullet(bullet, fallbackTimestamp) {
@@ -6992,10 +7058,17 @@ var StorageManager3 = class _StorageManager extends TombstoneBlockedCaptureIndex
   getMemoryCorpusVersion() {
     return this.readSharedVersion("memory-corpus", _StorageManager.memoryCorpusVersionByDir);
   }
+  /**
+   * Bump only — NOT invalidateAllForDir (that would drop the very hot
+   * entry the write path just patched).
+   */
   bumpMemoryCorpusVersion() {
     this.bumpSharedVersion("memory-corpus", _StorageManager.memoryCorpusVersionByDir);
     deleteInFlightReadsForDir(this.baseDir);
   }
+  getArchiveMutationVersion() {
+    return getArchiveMutationVersionForDir(this.baseDir);
+  }
   /**
    * Corpus bump reporting whether THIS process's append was the only one
    * since the pre-bump size (#1902, Codex P1): the `exclusive` flag lets
@@ -8695,16 +8768,19 @@ ${sanitized.text}
   invalidateMemoryCachesForTiers(tiers) {
     let hotChanged = false;
     let coldChanged = false;
+    let archiveChanged = false;
     for (const tier of tiers) {
       if (tier === "cold") {
         coldChanged = true;
-      } else if (tier === "hot" || tier === "archive") {
+      } else if (tier === "archive") {
+        hotChanged = true;
+        archiveChanged = true;
+      } else if (tier === "hot") {
         hotChanged = true;
       }
     }
-    if (hotChanged) {
-      this.invalidateAllMemoriesCache();
-    }
+    if (hotChanged) this.invalidateAllMemoriesCache();
+    bumpArchiveMutationIfChanged(this.baseDir, archiveChanged);
     if (coldChanged) {
       this.invalidateColdMemoriesCache();
     }
@@ -9106,6 +9182,7 @@ ${memory.content}
     this.notifyCatalogWrite();
   }
   async moveMemoryToPath(memory, targetPath) {
+    const { recordArchiveDelete: recordArchiveDelete2, recordArchiveWrite } = archive_mutation_version_exports;
     const changed = await this.withTombstoneBlockedMemoryPathLock(
       memory.path,
       async (current) => {
@@ -9126,12 +9203,12 @@ ${memory.content}
         let durable = false;
         try {
           if (destination?.frontmatter.id === current.frontmatter.id) {
-            await this.deleteManagedStorageFile(current.path);
+            await recordArchiveDelete2(this.baseDir, current.path, () => this.deleteManagedStorageFile(current.path));
             durable = true;
             this.invalidateAllMemoriesCache();
             updateProjectedMemoryPath(this.baseDir, current.frontmatter.id, projectedPath);
           } else {
-            await this.writeMemoryFileAtomic(targetPath, current);
+            await recordArchiveWrite(this.baseDir, targetPath, () => this.writeMemoryFileAtomic(targetPath, current));
             if (memory.frontmatter.entityRef !== current.frontmatter.entityRef) {
               memory.frontmatter.entityRef = current.frontmatter.entityRef;
             }
@@ -9139,7 +9216,7 @@ ${memory.content}
             const sourcePath = path9.resolve(current.path);
             const destPath = path9.resolve(targetPath);
             if (sourcePath !== destPath) {
-              await this.deleteManagedStorageFile(current.path);
+              await recordArchiveDelete2(this.baseDir, current.path, () => this.deleteManagedStorageFile(current.path));
               this.invalidateAllMemoriesCache();
               updateProjectedMemoryPath(this.baseDir, current.frontmatter.id, projectedPath);
             }
@@ -9180,6 +9257,7 @@ ${memory.content}
    * Returns the new file path on success, null on failure.
    */
   async archiveMemory(memory, lifecycle) {
+    const { recordArchiveDelete: recordArchiveDelete2, recordArchiveWrite } = archive_mutation_version_exports;
     const archiveCurrent = async (current, markDurable) => {
       try {
         const now = lifecycle?.at ?? /* @__PURE__ */ new Date();
@@ -9202,7 +9280,7 @@ ${current.content}
 `;
         const destPath = path9.join(destDir, path9.basename(current.path));
         const priorDest = await this.readStorageSecureFile(destPath).catch(() => null);
-        await this.writeStorageSecureFile(destPath, fileContent);
+        await recordArchiveWrite(this.baseDir, destPath, () => this.writeStorageSecureFile(destPath, fileContent));
         if (typeof current.frontmatter.entityRef === "string") {
           try {
             await this.entityRefRepair.repair(
@@ -9214,14 +9292,29 @@ ${current.content}
             );
           } catch (err) {
             if (priorDest === null) {
-              await unlink4(destPath).catch(() => void 0);
+              await recordArchiveDelete2(
+                this.baseDir,
+                destPath,
+                () => unlink4(destPath).then(
+                  () => true,
+                  () => false
+                )
+              );
             } else {
-              await this.writeStorageSecureFile(destPath, priorDest).catch(() => void 0);
+              await recordArchiveDelete2(
+                this.baseDir,
+                destPath,
+                () => this.writeStorageSecureFile(destPath, priorDest).then(
+                  () => true,
+                  () => false
+                )
+              );
             }
             throw err;
           }
         }
-        if (!await this.deleteManagedStorageFile(current.path)) return null;
+        const deleted = await recordArchiveDelete2(this.baseDir, current.path, () => this.deleteManagedStorageFile(current.path));
+        if (!deleted) return null;
         markDurable();
         markProjectedMemoryPathInvalid(this.baseDir, current.frontmatter.id);
         this.invalidateAllMemoriesCache();
@@ -9300,7 +9393,8 @@ ${current.content}
     const memory = memories.find((candidate) => candidate.frontmatter.id === id);
     if (!memory) return false;
     return await this.runTombstoneBlockedInvalidation(memory, async (current, rebuildMarker, markDurable) => {
-      if (!await this.deleteManagedStorageFile(current.path)) return false;
+      const deleted = await recordArchiveDelete(this.baseDir, current.path, () => this.deleteManagedStorageFile(current.path));
+      if (!deleted) return false;
       markDurable();
       markProjectedMemoryPathInvalid(this.baseDir, id);
       this.invalidateAllMemoriesCache();
@@ -10527,49 +10621,64 @@ ${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));
   }
-  // ---------------------------------------------------------------------------
-  // Contradiction Detection (Phase 2B)
-  // ---------------------------------------------------------------------------
-  /**
-   * Mark a memory as superseded by another.
-   * Updates the old memory's status and adds the supersededBy link.
-   */
   async supersedeMemory(oldMemoryId, newMemoryId, reason) {
     const memories = await this.readAllMemories();
-    const oldMemory = memories.find((m) => m.frontmatter.id === oldMemoryId);
+    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"
+      );
+    }
     if (!oldMemory) return false;
     const now = (/* @__PURE__ */ new Date()).toISOString();
     let currentBefore = oldMemory;
     let updatedFm = oldMemory.frontmatter;
-    try {
-      const written = await this.withTombstoneBlockedMemoryPathLock(oldMemory.path, async (current) => {
-        if (current?.frontmatter.id !== oldMemoryId) 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)}
+    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)}
 
 ${current.content}
 `;
-        await this.writeTombstoneBlockedFrontmatter(current, fileContent, updatedFm);
-        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;
-      this.bumpMemoryCorpusVersion();
-      await this.appendGeneratedMemoryLifecycleEventFailOpen("storage.supersedeMemory", {
+      await this.writeTombstoneBlockedFrontmatter(current, fileContent, updatedFm);
+      if (typeof current.frontmatter.entityRef === "string") {
+        await this.entityRefRepair.repair(
+          current.path,
+          updatedFm,
+          current.frontmatter.entityRef,
+          refIdsAtWrite,
+          current.content,
+          { onFailRestore: current }
+        );
+      }
+      return 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,
@@ -10578,44 +10687,12 @@ ${current.content}
         before: this.summarizeLifecycleState(currentBefore.frontmatter, currentBefore.path),
         after: this.summarizeLifecycleState(updatedFm, currentBefore.path),
         relatedMemoryIds: [newMemoryId]
-      });
-      this.bumpMemoryStatusVersion();
-      log.debug(`superseded memory ${oldMemoryId} by ${newMemoryId}: ${reason}`);
-      if (currentBefore.frontmatter.category === "fact") {
-        for (const input of buildRetiredFactTombstoneInputs(
-          {
-            id: oldMemoryId,
-            content: stripCitationForTemplate(currentBefore.content, this.citationTemplate),
-            contentHash: currentBefore.frontmatter.contentHash,
-            entityRef: updatedFm.entityRef,
-            structuredAttributes: currentBefore.frontmatter.structuredAttributes
-          },
-          {
-            reason: "contradiction_resolution",
-            createdBy: "contradiction_resolution",
-            createdAt: now,
-            supersessionKeysForFact
-          }
-        )) {
-          await this.appendTombstone(input);
-        }
-      }
-      const auditBody = `Superseded: ${currentBefore.content}
-
-Reason: ${reason}`;
-      const auditInput = {
-        content: auditBody,
-        category: "correction",
-        confidence: 1,
-        tags: ["supersession", "auto-resolved"]
-      };
-      const auditEnvelope = composeMemoryEnvelope(auditInput, { source: "contradiction-detection" });
-      await this.writeSealedMemory(auditEnvelope, { lineage: [oldMemoryId, newMemoryId] });
-      return true;
-    } catch (err) {
-      log.error(`failed to supersede memory ${oldMemoryId}:`, err);
-      return false;
-    }
+      }),
+      bumpMemoryStatusVersion: () => this.bumpMemoryStatusVersion(),
+      appendTombstone: (input) => this.appendTombstone(input),
+      writeSealedMemory: (envelope, extras) => this.writeSealedMemory(envelope, extras)
+    });
+    return true;
   }
   // ---------------------------------------------------------------------------
   // Memory Summarization (Phase 4A)
@@ -10850,4 +10927,4 @@ export {
   isValidBufferSurpriseEvent,
   StorageManager3 as StorageManager
 };
-//# sourceMappingURL=chunk-BOFVT6P3.js.map
+//# sourceMappingURL=chunk-VBHPOWBJ.js.map