@remnic/core 9.52.2 → 9.53.0

package/dist/{chunk-WD5B5AIE.js → chunk-6R4G7N4S.js}

@@ -14,15 +14,10 @@ import {
   applyTombstoneResurrectionGate,
   buildRetiredFactTombstoneInputs,
   collectRetiredMemoriesForRebuild
-} from "./chunk-JJRVPWFY.js";
+} from "./chunk-MLPTFODV.js";
 import {
   withholdToolScopedFromSharedNamespace
 } from "./chunk-S2V7RUCL.js";
-import {
-  DEFAULT_CITATION_FORMAT,
-  hasCitation,
-  stripCitationForTemplate
-} from "./chunk-J6A3CX5N.js";
 import {
   SPECULATIVE_TTL_DAYS,
   confidenceTier
@@ -61,16 +56,12 @@ import {
   isQueuedReviewMemory,
   parseTombstoneBlockedOfflineSyncMemory,
   tombstoneBlocked
-} from "./chunk-DLG5V6ND.js";
+} from "./chunk-K4QS7LXU.js";
 import {
   composeMemoryEnvelope,
   isSealedMemoryEnvelope,
   sealedWriteToLegacyArgs
-} from "./chunk-5V6IXHPI.js";
-import {
-  assemblePersistedBody,
-  stripAttributesSuffix
-} from "./chunk-R3DJVOSM.js";
+} from "./chunk-NSVDUN76.js";
 import {
   normalizeEntityName
 } from "./chunk-YXZG5TVN.js";
@@ -129,10 +120,7 @@ import {
   parseProvenanceTag,
   reconcileProvenanceRead,
   serializeProvenanceFields
-} from "./chunk-QBSFOKY6.js";
-import {
-  sanitizeMemoryContent
-} from "./chunk-5GKPFL3S.js";
+} from "./chunk-VOELBUS4.js";
 import {
   matchEntitySchemaSection,
   normalizeEntityStructuredSection,
@@ -147,6 +135,11 @@ import {
 import {
   selectArtifactMatches
 } from "./chunk-Z7L72ZHL.js";
+import {
+  DEFAULT_CITATION_FORMAT,
+  hasCitationForTemplate,
+  stripCitationForTemplate
+} from "./chunk-J6A3CX5N.js";
 import {
   ProjectionLedgerLagManager,
   appendLifecycleEventsSerialized,
@@ -181,7 +174,7 @@ import {
   CONTENT_HASH_INDEX_RETRY_MAX_DELAY_MS,
   ContentHashIndex,
   FactHashIndexNotAuthoritativeError
-} from "./chunk-BQIFZ2MP.js";
+} from "./chunk-CX5SW2EW.js";
 import {
   markProjectedMemoryPathInvalid,
   readProjectedGovernanceRecord,
@@ -190,9 +183,20 @@ import {
   readProjectedMemoryTimeline,
   updateProjectedMemoryPath
 } from "./chunk-3CSX3ETE.js";
+import {
+  assemblePersistedBody,
+  storedContentIdentityCandidates,
+  stripAttributesSuffix
+} from "./chunk-JDSVLVCG.js";
 import {
   withHeldFileLock
 } from "./chunk-FFAZ2XFU.js";
+import {
+  computeLegacyContentHash
+} from "./chunk-5FVVY2EB.js";
+import {
+  sanitizeMemoryContent
+} from "./chunk-5GKPFL3S.js";
 import {
   parseFlexibleIsoTimestamp
 } from "./chunk-P7FMDTKL.js";
@@ -448,6 +452,14 @@ var MemoryReadStore = class {
       options
     );
   }
+  async collectTombstoneMigrationPaths() {
+    const tiers = await Promise.all([
+      this.collectActiveMemoryPaths(),
+      this.collectColdMemoryPaths(),
+      this.collectContainedMarkdownPaths([path.join(this.deps.baseDir, "archive")])
+    ]);
+    return tiers.flat();
+  }
   async readMemoriesWindow(options = {}) {
     const allPaths = await this.deps.collectActiveMemoryPaths();
     const sortedPaths = this.deps.orderWindowPaths(allPaths);
@@ -3469,13 +3481,13 @@ var EntityRefRepair = class {
    * #2213): fail-open, add-only; writeMemory's gate + chunk-repair re-gate
    * consult this one implementation (rule 43).
    */
-  async gate(fm, hashSource, structuredAttributes) {
+  async gate(fm, canonicalBody, structuredAttributes) {
     if (!this.deps.tombstonesEnabled()) return null;
     try {
       const store = await this.deps.getTombstoneStore();
       const supersessionKeys = fm.entityRef && structuredAttributes ? supersessionKeysForFact({ entityRef: fm.entityRef, structuredAttributes }) : [];
       const match = applyTombstoneResurrectionGate(store, fm, {
-        normalizedText: ContentHashIndex.normalizeContent(hashSource),
+        normalizedText: ContentHashIndex.normalizeContent(canonicalBody),
         supersessionKeys,
         namespace: this.deps.tombstonesNamespace()
       });
@@ -3502,7 +3514,7 @@ var EntityRefRepair = class {
         frontmatter: fm,
         rewrite: async () => {
           if (opts.regateFact && fm.category === "fact") {
-            await this.gate(fm, body, void 0);
+            await this.gate(fm, body, fm.structuredAttributes);
           }
           await this.deps.writeTombstoneBlockedMemory(
             filePath,
@@ -5428,87 +5440,6 @@ var MeetingRecordStore = class {
 };
 var SORT_STR = (a, b) => a < b ? -1 : a > b ? 1 : 0;
 
-// src/storage/citation-hash-source.ts
-function trimTrailingSpacesAndTabs(value) {
-  let end = value.length;
-  while (end > 0 && (value[end - 1] === " " || value[end - 1] === "	")) {
-    end -= 1;
-  }
-  return end === value.length ? value : value.slice(0, end);
-}
-function trimLeadingSpacesAndTabs(value) {
-  let start = 0;
-  while (start < value.length && (value[start] === " " || value[start] === "	")) {
-    start += 1;
-  }
-  return start === 0 ? value : value.slice(start);
-}
-function stripDefaultCitationMarkersWithoutRegex(value) {
-  return stripCitationMarkersForHashRemoval(value, DEFAULT_CITATION_FORMAT);
-}
-function citationTemplateLiteralParts(template) {
-  const parts = [];
-  let cursor = 0;
-  while (cursor < template.length) {
-    const open3 = template.indexOf("{", cursor);
-    if (open3 === -1) {
-      parts.push(template.slice(cursor));
-      break;
-    }
-    parts.push(template.slice(cursor, open3));
-    const close = template.indexOf("}", open3 + 1);
-    if (close === -1) {
-      cursor = open3 + 1;
-    } else {
-      cursor = close + 1;
-    }
-  }
-  return parts.filter((part) => part.length > 0);
-}
-function stripCitationMarkersForHashRemoval(value, template) {
-  const parts = citationTemplateLiteralParts(template);
-  if (parts.length === 0) return value;
-  const first = parts[0];
-  const lowerValue = value.toLowerCase();
-  const lowerFirst = first.toLowerCase();
-  const lowerParts = parts.map((part) => part.toLowerCase());
-  if (!lowerValue.includes(lowerFirst)) return value;
-  let result = "";
-  let cursor = 0;
-  let removed = false;
-  while (cursor < value.length) {
-    const markerStart = lowerValue.indexOf(lowerFirst, cursor);
-    if (markerStart === -1) {
-      result += value.slice(cursor);
-      break;
-    }
-    const boundedEnd = first.startsWith("[") ? value.indexOf("]", markerStart + first.length) : -1;
-    if (first.startsWith("[") && boundedEnd === -1) {
-      result += value.slice(cursor);
-      break;
-    }
-    const searchLimit = boundedEnd === -1 ? value.length : boundedEnd + 1;
-    let markerEnd = markerStart + first.length;
-    let matched = true;
-    for (let i = 1; i < lowerParts.length; i += 1) {
-      const partIndex = lowerValue.indexOf(lowerParts[i], markerEnd);
-      if (partIndex === -1 || partIndex + parts[i].length > searchLimit) {
-        matched = false;
-        break;
-      }
-      markerEnd = partIndex + parts[i].length;
-    }
-    if (!matched) {
-      result += value.slice(cursor);
-      break;
-    }
-    result += trimTrailingSpacesAndTabs(value.slice(cursor, markerStart));
-    cursor = markerEnd;
-    removed = true;
-  }
-  return removed ? trimLeadingSpacesAndTabs(result) : value;
-}
-
 // src/storage/supersession-audit.ts
 import { readdir as readdir5 } from "fs/promises";
 import path10 from "path";
@@ -8059,22 +7990,50 @@ var StorageManager3 = class _StorageManager extends TombstoneBlockedCaptureIndex
     }
   }
   buildTombstoneStore() {
+    let sourcePathsPromise;
+    let sourceContentsByIdPromise;
     const options = {
       enabled: this.tombstonesConfig.enabled,
       semanticMatch: this.tombstonesConfig.semanticMatch,
       semanticThreshold: this.tombstonesConfig.semanticThreshold,
-      // Wire the SAME helpers the dedup index uses (rule 23 / checklist §13):
-      // hashContent = ContentHashIndex.computeHash, normalizeText =
-      // ContentHashIndex.normalizeContent. Importing them here (not copying)
-      // guarantees the tombstone tiers can never drift from dedup.
       hashContent: ContentHashIndex.computeHash,
-      normalizeText: ContentHashIndex.normalizeContent
+      normalizeText: ContentHashIndex.normalizeContent,
+      sourceContentsForMemoryIds: async (sourceMemoryIds) => {
+        const requested = new Set(sourceMemoryIds);
+        const sourcePaths = await (sourcePathsPromise ??= this.memoryReadStore.collectTombstoneMigrationPaths());
+        const directPaths = sourcePaths.filter(
+          (filePath) => requested.has(path11.basename(filePath, ".md"))
+        );
+        const contents = /* @__PURE__ */ new Map();
+        for (const memory of await this.readParsedMemoriesFromPaths(directPaths, 50)) {
+          const id = memory.frontmatter.id;
+          if (requested.has(id) && !contents.has(id)) {
+            contents.set(id, this.storedContentIdentityCandidates(memory.content));
+          }
+        }
+        if (contents.size === requested.size) return contents;
+        sourceContentsByIdPromise ??= (async () => {
+          const allContents2 = /* @__PURE__ */ new Map();
+          for (const memory of await this.readParsedMemoriesFromPaths(sourcePaths, 50)) {
+            const id = memory.frontmatter.id;
+            if (!allContents2.has(id)) {
+              allContents2.set(id, this.storedContentIdentityCandidates(memory.content));
+            }
+          }
+          return allContents2;
+        })();
+        const allContents = await sourceContentsByIdPromise;
+        for (const id of requested) {
+          const content = allContents.get(id);
+          if (content !== void 0) contents.set(id, content);
+        }
+        return contents;
+      }
     };
     const io = {
       read: (filePath) => this.readStorageSecureFile(filePath),
       append: (filePath, content) => this.appendStorageSecureFile(filePath, content),
       write: (filePath, content) => this.writeStorageSecureFile(filePath, content),
-      // stat lets the store own its cross-process staleness probe (#1579).
       stat: (filePath) => statSync(filePath)
     };
     return new TombstoneStore(this.tombstonesPath, this.tombstonesConfig.namespace, options, io);
@@ -8270,7 +8229,9 @@ var StorageManager3 = class _StorageManager extends TombstoneBlockedCaptureIndex
       const baseMs = this.factHashIndexLockOptions.retryBaseMs ?? FACT_HASH_INDEX_REBUILD_RETRY_BASE_MS;
       let published = false;
       for (let attempt = 0; attempt < maxAttempts; attempt += 1) {
-        published = await factHashIndex.rebuildUnderLock(() => this.rebuildFactHashIndexFromCorpus(factHashIndex));
+        published = await factHashIndex.rebuildUnderLock(
+          () => this.rebuildFactHashIndexFromCorpus(factHashIndex)
+        );
         if (published || attempt === maxAttempts - 1) break;
         const wait = Math.min(baseMs * 2 ** attempt, CONTENT_HASH_INDEX_RETRY_MAX_DELAY_MS);
         await new Promise((resolve3) => setTimeout(resolve3, wait));
@@ -8300,13 +8261,15 @@ var StorageManager3 = class _StorageManager extends TombstoneBlockedCaptureIndex
     let legacyRecovered = 0;
     for (const memory of existing) {
       if (inferMemoryStatus(memory.frontmatter, memory.path) !== "active") continue;
-      const hash = this.corpusRegisteredHash(memory);
-      if (hash === null) {
+      const hashes = this.corpusRegisteredHashes(memory);
+      if (hashes.length === 0) {
         legacyRecovered++;
         continue;
       }
-      factHashIndex.addByHash(hash);
-      if (memory.frontmatter.category === "fact") this.factOnlyHashes.add(hash);
+      for (const hash of hashes) {
+        factHashIndex.addByHash(hash);
+        if (memory.frontmatter.category === "fact") this.factOnlyHashes.add(hash);
+      }
     }
     if (legacyRecovered > 0) {
       log.info(
@@ -8314,38 +8277,23 @@ var StorageManager3 = class _StorageManager extends TombstoneBlockedCaptureIndex
       );
     }
   }
-  /**
-   * The content-hash the corpus rebuild registers for `memory`, or null when the
-   * body carries a citation from an unknown/custom template that cannot be
-   * safely stripped. Shared by the authoritative rebuild and the fact-only
-   * corpus confirmation (`hasFactContentHash`) so both derive the identical
-   * hash for a given stored body.
-   *
-   * Preference order:
-   *  1. frontmatter.contentHash — the raw pre-citation hash writeMemory records
-   *     for facts (issue #369 round 8); matches hasFactContentHash(rawFact).
-   *  2. Reconstruct from the stored body: strip the "[Attributes: …]" suffix
-   *     writeMemory appends for structuredAttributes (registration hashed the
-   *     raw canonical content WITHOUT it — a no-op when absent), then strip a
-   *     recognised citation and hash the bare body, or hash a citation-free
-   *     body as-is.
-   *  3. A body with a citation from an unknown/custom template → null: a
-   *     false-negative miss beats a wrong hash that would permanently suppress
-   *     legitimate duplicate writes.
-   */
-  corpusRegisteredHash(memory) {
-    if (memory.frontmatter.contentHash) {
-      return memory.frontmatter.contentHash;
-    }
-    const content = stripAttributesSuffix(memory.content);
-    const stripped = stripCitationForTemplate(content, this.citationTemplate);
-    if (stripped !== content) {
-      return ContentHashIndex.computeHash(sanitizeMemoryContent(stripped).text);
-    }
-    if (!hasCitation(content)) {
-      return ContentHashIndex.computeHash(sanitizeMemoryContent(content).text);
-    }
-    return null;
+  storedContentIdentityCandidates(content) {
+    return storedContentIdentityCandidates(
+      content,
+      (value) => hasCitationForTemplate(value, this.citationTemplate) ? stripCitationForTemplate(value, this.citationTemplate) : value
+    );
+  }
+  /** Returns the current body identity while preserving explicit external identities. */
+  corpusRegisteredHashes(memory) {
+    const persistedHash = memory.frontmatter.contentHash;
+    const candidates = this.storedContentIdentityCandidates(memory.content).map((content) => sanitizeMemoryContent(content).text);
+    const currentHashes = candidates.map((content) => ContentHashIndex.computeHash(content));
+    if (persistedHash && currentHashes.includes(persistedHash)) return [persistedHash];
+    if (!persistedHash) return [currentHashes[0] ?? ContentHashIndex.computeHash("")];
+    const legacyMatches = candidates.filter(
+      (content) => computeLegacyContentHash(content) === persistedHash
+    );
+    return legacyMatches.length > 0 ? [...new Set(legacyMatches.map((content) => ContentHashIndex.computeHash(content)))] : [persistedHash];
   }
   get questionsDir() {
     return path11.join(this.baseDir, "questions");
@@ -8680,7 +8628,7 @@ var StorageManager3 = class _StorageManager extends TombstoneBlockedCaptureIndex
       }
       if (category !== "fact" || factHashSourceForTombstone === null) return;
       const statusBefore = fm.status;
-      const match = await this.entityRefRepair.gate(fm, factHashSourceForTombstone, options.structuredAttributes);
+      const match = await this.entityRefRepair.gate(fm, sanitized.text, options.structuredAttributes);
       if (match) {
         gateRef = fm.entityRef;
         statusBeforeBlock = statusBefore;
@@ -8820,28 +8768,25 @@ ${sanitized.text}
     for (const memory of existing) {
       if (memory.frontmatter.category !== "fact") continue;
       if (inferMemoryStatus(memory.frontmatter, memory.path) !== "active") continue;
-      if (this.corpusRegisteredHash(memory) === targetHash) return true;
+      if (this.corpusRegisteredHashes(memory).includes(targetHash)) return true;
     }
     return false;
   }
-  factContentHashForRemoval(memory) {
-    if (memory.frontmatter.category !== "fact") return null;
-    if (typeof memory.frontmatter.contentHash === "string" && memory.frontmatter.contentHash.length > 0) {
-      return memory.frontmatter.contentHash;
-    }
-    const configuredHashSource = stripCitationMarkersForHashRemoval(memory.content, this.citationTemplate);
-    const hashSource = configuredHashSource !== memory.content ? configuredHashSource : stripDefaultCitationMarkersWithoutRegex(memory.content);
-    return ContentHashIndex.computeHash(sanitizeMemoryContent(hashSource).text);
+  factContentHashesForRemoval(memory) {
+    if (memory.frontmatter.category !== "fact") return [];
+    return this.corpusRegisteredHashes(memory);
   }
   async addActiveFactContentHash(memory) {
     if (memory.frontmatter.category !== "fact") return;
     if (inferMemoryStatus(memory.frontmatter, memory.path) !== "active") return;
-    const hash = this.factContentHashForRemoval(memory);
-    if (!hash) return;
+    const hashes = this.factContentHashesForRemoval(memory);
+    if (hashes.length === 0) return;
     await this.ensureFactHashIndexAuthoritative();
     const factHashIndex = await this.getFactHashIndex();
-    factHashIndex.addByHash(hash);
-    this.factOnlyHashes.add(hash);
+    for (const hash of hashes) {
+      factHashIndex.addByHash(hash);
+      this.factOnlyHashes.add(hash);
+    }
     await factHashIndex.saveMergingWithDisk();
     await factHashIndex.flushReconcileRetry();
   }
@@ -8863,15 +8808,16 @@ ${sanitized.text}
   }
   async syncFactHashIndexAfterRewrite(before, after) {
     if (before.frontmatter.category !== "fact" && after.frontmatter.category !== "fact") return;
-    const beforeHash = this.factContentHashForRemoval(before);
-    const afterHash = this.factContentHashForRemoval(after);
+    const beforeHashes = this.factContentHashesForRemoval(before);
+    const afterHashes = this.factContentHashesForRemoval(after);
     const beforeStatus = inferMemoryStatus(before.frontmatter, before.path);
     const afterStatus = inferMemoryStatus(after.frontmatter, after.path);
-    if (beforeHash === afterHash && beforeStatus === afterStatus) return;
-    if (beforeStatus === "active" && beforeHash && (beforeHash !== afterHash || afterStatus !== "active")) {
+    const hashesChanged = beforeHashes.length !== afterHashes.length || beforeHashes.some((hash, index) => hash !== afterHashes[index]);
+    if (!hashesChanged && beforeStatus === afterStatus) return;
+    if (beforeStatus === "active" && beforeHashes.length > 0 && (hashesChanged || afterStatus !== "active")) {
       await this.removeFactContentHashesForMemories([before]);
     }
-    if (afterStatus === "active" && afterHash && (beforeHash !== afterHash || beforeStatus !== "active")) {
+    if (afterStatus === "active" && afterHashes.length > 0 && (hashesChanged || beforeStatus !== "active")) {
       await this.addActiveFactContentHash(after);
     }
   }
@@ -8881,11 +8827,10 @@ ${sanitized.text}
     const removedIds = new Set(
       memories.map((memory) => memory.frontmatter.id).filter((id) => typeof id === "string" && id.length > 0)
     );
-    const removedHashes = /* @__PURE__ */ new Map();
+    const removedHashes = /* @__PURE__ */ new Set();
     for (const memory of memories) {
-      const hash = this.factContentHashForRemoval(memory);
-      if (hash) {
-        removedHashes.set(memory, hash);
+      for (const hash of this.factContentHashesForRemoval(memory)) {
+        removedHashes.add(hash);
       }
     }
     if (removedHashes.size === 0) return;
@@ -8895,12 +8840,11 @@ ${sanitized.text}
       if (memory.frontmatter.category !== "fact") continue;
       if (removedIds.has(memory.frontmatter.id)) continue;
       if (inferMemoryStatus(memory.frontmatter, memory.path) !== "active") continue;
-      const hash = this.factContentHashForRemoval(memory);
-      if (hash) {
+      for (const hash of this.factContentHashesForRemoval(memory)) {
         remainingActiveHashes.add(hash);
       }
     }
-    for (const hash of removedHashes.values()) {
+    for (const hash of removedHashes) {
       if (!remainingActiveHashes.has(hash)) {
         factHashIndex.removeByHash(hash);
         this.factOnlyHashes.delete(hash);
@@ -8922,8 +8866,9 @@ ${sanitized.text}
    */
   removeFactOnlyHashForMemory(memory) {
     if (memory.frontmatter.category !== "fact") return;
-    const hash = this.factContentHashForRemoval(memory);
-    if (hash) this.factOnlyHashes.delete(hash);
+    for (const hash of this.factContentHashesForRemoval(memory)) {
+      this.factOnlyHashes.delete(hash);
+    }
   }
   async isFactContentHashAuthoritative() {
     return await this.ensureFactHashIndexAuthoritative();
@@ -11387,4 +11332,4 @@ export {
   isValidBufferSurpriseEvent,
   StorageManager3 as StorageManager
 };
-//# sourceMappingURL=chunk-WD5B5AIE.js.map
+//# sourceMappingURL=chunk-6R4G7N4S.js.map