@remnic/core 9.52.1 → 9.53.0

package/src/reconcile/manifest.ts

@@ -1,6 +1,9 @@
 import { createHash } from "node:crypto";
+import { computeLegacyContentHash, normalizeLegacyContent } from "../content-hash.js";
 import { inferMemoryStatus } from "../memory-lifecycle-ledger-utils.js";
 import { ContentHashIndex, type ContentHashPathEntry } from "../storage/content-hash-index.js";
+import { DEFAULT_CITATION_FORMAT, stripCitationForTemplate } from "../source-attribution.js";
+import { storedContentIdentityCandidates } from "../structured-attributes.js";
 import type { MemoryFrontmatter, MemoryStatus } from "../types.js";
 import { RECALL_FALLBACK_DIRS } from "../utils/category-dir.js";
 import {
@@ -14,11 +17,13 @@ import {
 
 export const RECONCILE_MANIFEST_FORMAT = "remnic-reconcile-manifest";
 export const RECONCILE_MANIFEST_SCHEMA_VERSION = 1;
+const CONTENT_HASH_NORMALIZER_VERSION = 4;
 
 export interface ReconcileMemoryIdentity {
   id: string;
   category: string;
   contentHash: string;
+  normalizerVersion?: number;
   status: MemoryStatus;
 }
 
@@ -43,6 +48,7 @@ export interface BuildReconcileManifestOptions {
   readFile: (file: ReconcileFileState) => Promise<Buffer | string | null>;
   parseMemory: ReconcileMemoryParser;
   cachedFiles?: Iterable<ReconcileManifestFile>;
+  citationTemplate?: string;
 }
 
 const SHA256_PATTERN = /^[a-f0-9]{64}$/i;
@@ -61,19 +67,38 @@ function parsedMemoryIdentity(
   filePath: string,
   raw: Buffer | string,
   parseMemory: ReconcileMemoryParser,
+  citationTemplate: string,
 ): ReconcileMemoryIdentity | undefined {
   if (!isMemoryPath(filePath)) return undefined;
   const parsed = parseMemory(Buffer.isBuffer(raw) ? raw.toString("utf8") : raw);
   if (!parsed?.frontmatter.id) return undefined;
-  const storedHash = parsed.frontmatter.contentHash;
-  const contentHash =
-    storedHash && SHA256_PATTERN.test(storedHash)
-      ? storedHash.toLowerCase()
-      : ContentHashIndex.computeHash(parsed.content);
+
+  const storedHash =
+    parsed.frontmatter.contentHash &&
+    SHA256_PATTERN.test(parsed.frontmatter.contentHash)
+      ? parsed.frontmatter.contentHash.toLowerCase()
+      : undefined;
+  const candidates = storedContentIdentityCandidates(parsed.content, (content) =>
+    stripCitationForTemplate(content, citationTemplate)
+  );
+  const bodyHash = ContentHashIndex.computeHash(candidates[0] ?? "");
+  const currentMatch = candidates.find(
+    (content) => ContentHashIndex.computeHash(content) === storedHash
+  );
+  const legacyMatch = [...candidates].reverse().find(
+    (content) => computeLegacyContentHash(content) === storedHash
+  );
+  const contentHash = currentMatch
+    ? ContentHashIndex.computeHash(currentMatch)
+    : legacyMatch
+      ? ContentHashIndex.computeHash(legacyMatch)
+      : storedHash ?? bodyHash;
+
   return {
     id: parsed.frontmatter.id,
     category: parsed.frontmatter.category,
     contentHash,
+    normalizerVersion: CONTENT_HASH_NORMALIZER_VERSION,
     status: inferMemoryStatus(parsed.frontmatter, filePath),
   };
 }
@@ -82,6 +107,7 @@ export async function buildReconcileManifestFile(
   file: ReconcileFileState,
   readFile: (file: ReconcileFileState) => Promise<Buffer | string | null>,
   parseMemory: ReconcileMemoryParser,
+  citationTemplate = DEFAULT_CITATION_FORMAT,
 ): Promise<ReconcileManifestFile> {
   let raw: Buffer | string | null = null;
   if (isMemoryPath(file.path)) {
@@ -94,7 +120,7 @@ export async function buildReconcileManifestFile(
   if (raw !== null && createHash("sha256").update(raw).digest("hex") !== file.sha256.toLowerCase()) {
     raw = null;
   }
-  const memory = raw === null ? undefined : parsedMemoryIdentity(file.path, raw, parseMemory);
+  const memory = raw === null ? undefined : parsedMemoryIdentity(file.path, raw, parseMemory, citationTemplate);
   return { ...file, ...(memory ? { memory } : {}) };
 }
 
@@ -107,12 +133,21 @@ export async function buildReconcileManifest(options: BuildReconcileManifestOpti
   const files: ReconcileManifestFile[] = [];
   for (const file of options.files) {
     const cached = cachedByPath.get(file.path);
-    if (cached?.sha256.toLowerCase() === file.sha256.toLowerCase()) {
+    if (
+      cached?.sha256.toLowerCase() === file.sha256.toLowerCase() &&
+      (cached.memory === undefined ||
+        cached.memory.normalizerVersion === CONTENT_HASH_NORMALIZER_VERSION)
+    ) {
       files.push({ ...file, ...(cached.memory ? { memory: cached.memory } : {}) });
       continue;
     }
 
-    files.push(await buildReconcileManifestFile(file, options.readFile, options.parseMemory));
+    files.push(await buildReconcileManifestFile(
+      file,
+      options.readFile,
+      options.parseMemory,
+      options.citationTemplate,
+    ));
   }
   files.sort((left, right) => (left.path < right.path ? -1 : left.path > right.path ? 1 : 0));
   return {
@@ -132,10 +167,17 @@ function activeFactByPath(manifest: ReconcileManifest | undefined): Map<string,
   return result;
 }
 
-function contentHashRows(files: Iterable<ActiveFactManifestFile>): ContentHashPathEntry[] {
+function memoryIdentityHashes(memory: ReconcileMemoryIdentity): string[] {
+  return [memory.contentHash];
+}
+
+function contentHashRows(
+  files: Iterable<ActiveFactManifestFile>,
+  contentHash: string,
+): ContentHashPathEntry[] {
   const rows: ContentHashPathEntry[] = [];
   for (const file of files) {
-    rows.push({ path: file.path, contentHash: file.memory.contentHash });
+    rows.push({ path: file.path, contentHash });
   }
   return rows;
 }
@@ -194,35 +236,47 @@ export function collapseActiveFactDuplicates(
     const peerByHash = new Map<string, ActiveFactManifestFile[]>();
 
     for (const file of localByPath.values()) {
-      const hash = file.memory.contentHash;
-      const bucket = localByHash.get(hash) ?? [];
-      bucket.push(file);
-      localByHash.set(hash, bucket);
+      for (const hash of memoryIdentityHashes(file.memory)) {
+        const bucket = localByHash.get(hash) ?? [];
+        bucket.push(file);
+        localByHash.set(hash, bucket);
+      }
     }
     for (const file of peerByPath.values()) {
-      const hash = file.memory.contentHash;
-      const bucket = peerByHash.get(hash) ?? [];
-      bucket.push(file);
-      peerByHash.set(hash, bucket);
+      for (const hash of memoryIdentityHashes(file.memory)) {
+        const bucket = peerByHash.get(hash) ?? [];
+        bucket.push(file);
+        peerByHash.set(hash, bucket);
+      }
     }
 
     const removed = new Set<ReconcilePlanEntry>();
     const replacements: ReconcilePlanEntry[] = [];
+    const processedPathPairs = new Set<string>();
     for (const hash of new Set([...localByHash.keys(), ...peerByHash.keys()])) {
       const localCandidates = (localByHash.get(hash) ?? []).filter((file) => {
         const opposite = peerFilesByPath.get(file.path);
         const activeOpposite = peerByPath.get(file.path);
-        return opposite === undefined || activeOpposite?.memory.contentHash === hash;
+        return opposite === undefined || (
+          activeOpposite !== undefined &&
+          memoryIdentityHashes(activeOpposite.memory).includes(hash)
+        );
       });
       const peerCandidates = (peerByHash.get(hash) ?? []).filter((file) => {
         const opposite = localFilesByPath.get(file.path);
         const activeOpposite = localByPath.get(file.path);
-        return opposite === undefined || activeOpposite?.memory.contentHash === hash;
+        return opposite === undefined || (
+          activeOpposite !== undefined &&
+          memoryIdentityHashes(activeOpposite.memory).includes(hash)
+        );
       });
-      const localPath = ContentHashIndex.resolvePathByHash(hash, contentHashRows(localCandidates));
-      const peerPath = ContentHashIndex.resolvePathByHash(hash, contentHashRows(peerCandidates));
+      const localPath = ContentHashIndex.resolvePathByHash(hash, contentHashRows(localCandidates, hash));
+      const peerPath = ContentHashIndex.resolvePathByHash(hash, contentHashRows(peerCandidates, hash));
 
       if (localPath && peerPath && localPath !== peerPath) {
+        const pathPair = `${localPath}\0${peerPath}`;
+        if (processedPathPairs.has(pathPair)) continue;
+        processedPathPairs.add(pathPair);
         const localFile = localByPath.get(localPath);
         const peerFile = peerByPath.get(peerPath);
         if (!localFile || !peerFile) continue;

package/src/storage/content-hash-index.ts

@@ -5,15 +5,11 @@
 // part of its public API.
 import { mkdir, stat } from "node:fs/promises";
 import path from "node:path";
+import { computeContentHash, normalizeContent } from "../content-hash.js";
 import { log } from "../logger.js";
+import { SecureStoreLockedError, readMaybeEncryptedFile, writeMaybeEncryptedFile } from "../secure-store/secure-fs.js";
 import { isErrnoCode } from "../utils/errno.js";
 import { withHeldFileLock } from "../utils/serialize-mutations.js";
-import { normalizeContent, computeContentHash } from "../content-hash.js";
-import {
-  SecureStoreLockedError,
-  readMaybeEncryptedFile,
-  writeMaybeEncryptedFile,
-} from "../secure-store/secure-fs.js";
 
 /**
  * Stale threshold (ms) for the per-file advisory lock guarding a fact-hash
@@ -23,6 +19,23 @@ import {
  * without breaking a legitimately in-progress publish.
  */
 const CONTENT_HASH_INDEX_LOCK_STALE_MS = 30_000;
+/** Version marker for the normalized Unicode hash index format. */
+const CONTENT_HASH_INDEX_FORMAT_HEADER = "# remnic-content-hash-index:v2";
+
+function parseHashIndex(raw: string): { versioned: boolean; hashes: Set<string> } {
+  const lines = raw
+    .split("\n")
+    .map((line) => line.trim())
+    .filter((line) => line.length > 0);
+  if (lines[0] !== CONTENT_HASH_INDEX_FORMAT_HEADER) {
+    return { versioned: false, hashes: new Set() };
+  }
+  return { versioned: true, hashes: new Set(lines.slice(1)) };
+}
+
+function serializeHashIndex(hashes: Set<string>): string {
+  return `${CONTENT_HASH_INDEX_FORMAT_HEADER}\n${[...hashes].join("\n")}\n`;
+}
 
 /**
  * Durable-retry policy for a deferred content-hash reconcile save whose
@@ -70,7 +83,7 @@ export interface ContentHashIndexLockOptions {
 export class FactHashIndexNotAuthoritativeError extends Error {
   constructor(stateDir: string) {
     super(
-      `fact-hash index is not authoritative: the cross-process rebuild lock for ${stateDir} could not be acquired within the bounded retry budget`,
+      `fact-hash index is not authoritative: the cross-process rebuild lock for ${stateDir} could not be acquired within the bounded retry budget`
     );
     this.name = "FactHashIndexNotAuthoritativeError";
   }
@@ -98,6 +111,8 @@ export interface ContentHashPathEntry {
 export class ContentHashIndex {
   private hashes: Set<string> = new Set();
   private dirty = false;
+  /** True when load() found the pre-Unicode, markerless on-disk format. */
+  private formatMigrationRequired = false;
   /**
    * Hashes explicitly removed since the last successful save (issue #1909 review
    * round 8 thread 3). Tracked separately so `saveMergingWithDisk` can be
@@ -140,7 +155,6 @@ export class ContentHashIndex {
    * without an O(file-size) read on the hot path.
    */
   private lastSyncedFingerprint: DiskFingerprint | null = null;
-
   constructor(
     stateDir: string,
     secureStoreKeyProvider: () => Buffer | null = () => null,
@@ -154,16 +168,24 @@ export class ContentHashIndex {
     this.memoryDir = memoryDir;
     this.lockOptions = lockOptions;
   }
+  /** Whether a caller with an authoritative corpus must rebuild this legacy index. */
+  get requiresFormatMigration(): boolean {
+    return this.formatMigrationRequired;
+  }
 
   /** Load existing hashes from disk. Safe to call multiple times. */
   async load(): Promise<void> {
     try {
       const raw = await readMaybeEncryptedFile(this.filePath, this.secureStoreKeyProvider(), this.memoryDir);
-      for (const line of raw.split("\n")) {
-        const trimmed = line.trim();
-        if (trimmed.length > 0) {
-          this.hashes.add(trimmed);
-        }
+      const parsed = parseHashIndex(raw);
+      this.formatMigrationRequired = !parsed.versioned;
+      if (!parsed.versioned) {
+        // Hashes from the pre-NFC format are unsafe after normalization changes.
+        // Ignore them until an authoritative corpus rebuild publishes v2.
+        this.hashes.clear();
+        log.warn(`content-hash index: ignored legacy unversioned index at ${this.filePath}`);
+      } else {
+        for (const hash of parsed.hashes) this.hashes.add(hash);
       }
       log.debug(`content-hash index: loaded ${this.hashes.size} hashes`);
     } catch (err) {
@@ -292,14 +314,9 @@ export class ContentHashIndex {
     // what we published; late deltas stay pending. Mirrors saveMergingWithDisk.
     const publishedAdded = new Set<string>(this.added);
     const publishedRemoved = new Set<string>(this.removed);
-    const serialized = [...this.hashes].join("\n") + "\n";
-    await writeMaybeEncryptedFile(
-      this.filePath,
-      serialized,
-      this.secureStoreWriteKeyProvider(),
-      {},
-      this.memoryDir
-    );
+    const serialized = serializeHashIndex(this.hashes);
+    await writeMaybeEncryptedFile(this.filePath, serialized, this.secureStoreWriteKeyProvider(), {}, this.memoryDir);
+    this.formatMigrationRequired = false;
     // Consume ONLY the deltas this overwrite published; anything that arrived
     // during the awaits above remains pending for the next save.
     for (const h of publishedAdded) this.added.delete(h);
@@ -360,15 +377,16 @@ export class ContentHashIndex {
       const publishedRemoved = new Set<string>(this.removed);
       const merged = new Set<string>(publishedAdded);
       try {
-        const raw = await readMaybeEncryptedFile(
-          this.filePath,
-          this.secureStoreKeyProvider(),
-          this.memoryDir
-        );
-        for (const line of raw.split("\n")) {
-          const trimmed = line.trim();
-          // Keep prior/concurrent on-disk hashes EXCEPT the ones we removed.
-          if (trimmed.length > 0 && !publishedRemoved.has(trimmed)) merged.add(trimmed);
+        const raw = await readMaybeEncryptedFile(this.filePath, this.secureStoreKeyProvider(), this.memoryDir);
+        const parsed = parseHashIndex(raw);
+        if (parsed.versioned) {
+          for (const hash of parsed.hashes) {
+            // Keep prior/concurrent on-disk hashes EXCEPT the ones we removed.
+            if (!publishedRemoved.has(hash)) merged.add(hash);
+          }
+        } else {
+          // Do not carry hashes from the pre-NFC format into a v2 write.
+          log.warn(`content-hash index: discarded legacy unversioned entries from ${this.filePath}`);
         }
       } catch (err) {
         if (err instanceof SecureStoreLockedError) throw err;
@@ -378,11 +396,12 @@ export class ContentHashIndex {
       await mkdir(path.dirname(this.filePath), { recursive: true });
       await writeMaybeEncryptedFile(
         this.filePath,
-        [...merged].join("\n") + "\n",
+        serializeHashIndex(merged),
         this.secureStoreWriteKeyProvider(),
         {},
         this.memoryDir
       );
+      this.formatMigrationRequired = false;
       // Consume ONLY the deltas we just published; deltas that arrived during
       // the awaits above remain pending.
       for (const h of publishedAdded) this.added.delete(h);
@@ -415,7 +434,7 @@ export class ContentHashIndex {
           // the retry keeps re-attempting the locked publish until the addition
           // lands on disk.
           log.warn(
-            `content-hash index: lock not acquired for ${this.filePath}; deferring reconcile save (dirty retained, scheduling durable retry)`,
+            `content-hash index: lock not acquired for ${this.filePath}; deferring reconcile save (dirty retained, scheduling durable retry)`
           );
           this.scheduleReconcileRetry();
           return;
@@ -431,7 +450,7 @@ export class ContentHashIndex {
           // Published cleanly: any pending deferred retry is now satisfied.
           this.cancelReconcileRetry();
         }
-      },
+      }
     );
     log.debug(`content-hash index: reconcile-saved ${this.hashes.size} hashes`);
   }
@@ -479,7 +498,7 @@ export class ContentHashIndex {
           // so overwriting now could clobber its addition. Leave the index as-is
           // and let the caller retry the authoritative rebuild on next use.
           log.warn(
-            `content-hash index: lock not acquired for ${this.filePath}; deferring authoritative rebuild (index left non-authoritative, retried on next use)`,
+            `content-hash index: lock not acquired for ${this.filePath}; deferring authoritative rebuild (index left non-authoritative, retried on next use)`
           );
           return;
         }
@@ -488,7 +507,7 @@ export class ContentHashIndex {
         // is a full overwrite that supersedes any pending add/remove deltas.
         await this.save();
         published = true;
-      },
+      }
     );
     return published;
   }
@@ -572,7 +591,7 @@ export class ContentHashIndex {
     if (this.reconcileRetryAttempts >= maxAttempts) {
       log.warn(
         `content-hash index: exhausted ${maxAttempts} deferred reconcile-save retries for ${this.filePath}; ` +
-          `${this.added.size} addition(s) remain dirty in-memory (a process restart rebuilds the index from the durable corpus)`,
+          `${this.added.size} addition(s) remain dirty in-memory (a process restart rebuilds the index from the durable corpus)`
       );
       this.reconcileRetryAttempts = 0;
       this.settleReconcileRetry();
@@ -681,10 +700,7 @@ export class ContentHashIndex {
    * one hash per line and `has(content)` keeps its existing raw-content contract.
    * Reconciliation supplies short-lived manifest rows where hash and path coexist.
    */
-  static resolvePathByHash(
-    hash: string,
-    entries: Iterable<ContentHashPathEntry>,
-  ): string | undefined {
+  static resolvePathByHash(hash: string, entries: Iterable<ContentHashPathEntry>): string | undefined {
     const canonicalHash = hash.toLowerCase();
     if (!/^[a-f0-9]{64}$/.test(canonicalHash)) return undefined;
     let canonicalPath: string | undefined;

package/src/storage/entity-ref-repair.ts

@@ -60,7 +60,7 @@ export class EntityRefRepair {
    */
   async gate(
     fm: MemoryFrontmatter,
-    hashSource: string,
+    canonicalBody: string,
     structuredAttributes?: Record<string, string>,
   ): Promise<TombstoneMatch | null> {
     if (!this.deps.tombstonesEnabled()) return null;
@@ -73,7 +73,7 @@ export class EntityRefRepair {
           ? supersessionKeysForFact({ entityRef: fm.entityRef, structuredAttributes })
           : [];
       const match = applyTombstoneResurrectionGate(store, fm, {
-        normalizedText: ContentHashIndex.normalizeContent(hashSource),
+        normalizedText: ContentHashIndex.normalizeContent(canonicalBody),
         supersessionKeys,
         namespace: this.deps.tombstonesNamespace(),
       });
@@ -109,7 +109,7 @@ export class EntityRefRepair {
         frontmatter: fm,
         rewrite: async () => {
           if (opts.regateFact && fm.category === "fact") {
-            await this.gate(fm, body, undefined);
+            await this.gate(fm, body, fm.structuredAttributes);
           }
           // Blocked-capture surface: a repair rewrite of a tombstone-blocked
           // record must keep TombstoneBlockedCaptureIndex consistent.

package/src/storage/memory-read-store.ts

@@ -378,6 +378,15 @@ export class MemoryReadStore {
     );
   }
 
+  async collectTombstoneMigrationPaths(): Promise<string[]> {
+    const tiers = await Promise.all([
+      this.collectActiveMemoryPaths(),
+      this.collectColdMemoryPaths(),
+      this.collectContainedMarkdownPaths([path.join(this.deps.baseDir, "archive")]),
+    ]);
+    return tiers.flat();
+  }
+
   async readMemoriesWindow(options: {
     maxMemories?: number;
     batchSize?: number;

package/src/storage/tombstone-blocked-capture-index.ts

@@ -7,15 +7,15 @@ import { log } from "../logger.js";
 import type { MemoryFile, MemoryFrontmatter } from "../types.js";
 import { RECALL_FALLBACK_DIRS } from "../utils/category-dir.js";
 import { isErrnoCode } from "../utils/errno.js";
-import { withHeldFileLock } from "../utils/serialize-mutations.js";
+import type { withHeldFileLock } from "../utils/serialize-mutations.js";
 import {
   CONTENT_HASH_INDEX_RETRY_MAX_DELAY_MS,
   ContentHashIndex,
   type ContentHashIndexLockOptions,
 } from "./content-hash-index.js";
 import {
-  buildExplicitCaptureDedupKey,
   TombstoneBlockedCaptureWriteLock,
+  buildExplicitCaptureDedupKey,
 } from "./tombstone-blocked-capture-mutation.js";
 import type { OfflineSyncMemoryParser } from "./tombstone-blocked-capture-sync.js";
 export {
@@ -38,7 +38,6 @@ const MARKER_PROCESS_START_TOLERANCE_MS = 2_000;
 const DOTNET_UNIX_EPOCH_TICKS = 621_355_968_000_000_000;
 const MARKER_PROCESS_STARTED_AT_MS = Date.now() - process.uptime() * 1000;
 
-
 type RebuildMarker = {
   path: string;
   committed: boolean;
@@ -49,7 +48,6 @@ type RebuildMarker = {
   malformed?: boolean;
 };
 
-
 export type TombstoneBlockedCaptureIndexOptions = {
   readonly stateDir: string;
   readonly memoryDir: string;
@@ -326,7 +324,7 @@ export class TombstoneBlockedCaptureIndex {
         await index.load();
         const rebuildMarkers = await this.getRebuildMarkers();
         const clearableRebuildMarkers = await this.getClearableRebuildMarkerPaths(rebuildMarkers);
-        let persisted = true;
+        let persisted = !index.requiresFormatMigration;
         try {
           await stat(this.indexPath());
           if (rebuildMarkers.length > 0) persisted = false;
@@ -505,10 +503,7 @@ export class TombstoneBlockedCaptureIndex {
     if (rebuildMarker) await this.markRebuildCommitted(rebuildMarker);
     const rebuilt = await this.rebuild(await this.getIndex());
     if (rebuilt) {
-      await this.clearRebuildRequired([
-        ...clearableExistingMarkers,
-        marker,
-      ]);
+      await this.clearRebuildRequired([...clearableExistingMarkers, marker]);
     }
     await this.setAuthoritative(rebuilt);
   }

package/src/storage-contract/content-hash.test.ts

@@ -128,6 +128,19 @@ test("content-hash: normalizeContent produces stable text for equivalent inputs"
   assert.equal(a, b, "normalizeContent must collapse whitespace consistently");
 });
 
+test("content-hash: distinct Japanese facts keep distinct hashes", () => {
+  assert.notEqual(
+    ContentHashIndex.computeHash("利用者は紅茶を好む。"),
+    ContentHashIndex.computeHash("利用者は珈琲を好む。"),
+  );
+});
+
+test("content-hash: NFC and NFD forms share one hash", () => {
+  const nfc = "Café au lait";
+  const nfd = "Cafe\u0301 au lait";
+  assert.equal(ContentHashIndex.computeHash(nfc), ContentHashIndex.computeHash(nfd));
+});
+
 test("content-hash: the frontmatter contentHash matches computeHash of the raw content", async () => {
   const { storage, cleanup } = await makeStorage();
   try {

package/src/storage-fact-hash-index-defer.test.ts

@@ -900,7 +900,7 @@ test("#2016: rebuildUnderLock refuses to publish while a peer holds the lock (no
     await mkdir(stateDir, { recursive: true });
     // A peer already committed a hash to disk.
     const peerHash = ContentHashIndex.computeHash("peer-committed-fact");
-    await writeFile(path.join(stateDir, "fact-hashes.txt"), `${peerHash}\n`);
+    await writeFile(path.join(stateDir, "fact-hashes.txt"), `# remnic-content-hash-index:v2\n${peerHash}\n`);
     // The peer holds the advisory lock (fresh, non-stale, not stale-breakable).
     const lockPath = path.join(stateDir, "fact-hashes.txt.lock");
     await writeFile(lockPath, `99999 peer-owner ${new Date().toISOString()}\n`);