@remnic/core 10.0.28 → 10.0.29

package/dist/{chunk-XALR4DOQ.js → chunk-TTIEXXL3.js}

@@ -15,9 +15,14 @@ import {
   buildRetiredFactTombstoneInputs,
   collectRetiredMemoriesForRebuild
 } from "./chunk-TRMJ6BYC.js";
+import {
+  getFingerprint,
+  migrateLegacyEntityCanonicalIds,
+  validateRoots
+} from "./chunk-DNIG3JME.js";
 import {
   normalizeQmdResultPath
-} from "./chunk-MWWAQXZ6.js";
+} from "./chunk-7HFTCBCZ.js";
 import {
   withholdToolScopedFromSharedNamespace
 } from "./chunk-S2V7RUCL.js";
@@ -64,7 +69,7 @@ import {
   invalidationCommitFingerprint,
   parseTombstoneBlockedOfflineSyncMemory,
   withCasCommitReceipt
-} from "./chunk-JNIVZNIB.js";
+} from "./chunk-WKVL2G7X.js";
 import {
   normalizeEntityName
 } from "./chunk-YXZG5TVN.js";
@@ -97,7 +102,7 @@ import {
 } from "./chunk-G7D6GZ5J.js";
 import {
   createVersion
-} from "./chunk-3GYSZHMT.js";
+} from "./chunk-3CZRBTJK.js";
 import {
   attachInFlightReader,
   beginCoalescedScan,
@@ -106,23 +111,19 @@ import {
   deleteInFlightReadsForDir
 } from "./chunk-RBOJCG4T.js";
 import {
-  ENTITY_CANONICAL_ID_MIGRATION_FILE,
-  ENTITY_CANONICAL_ID_RECONCILE_CONSUMING_MARKER,
-  ENTITY_CANONICAL_ID_RECONCILE_MARKER,
   HistoricalEntityCanonicalIdCache,
   appendCanonicalizedTombstone,
   assertSafeEntityId,
   canonicalizeEntityRefFrontmatter,
   canonicalizeEntityRefOption,
+  memoizedJournalCompletion,
   reconcileIfJournalMovedSync,
   repairEntityRefAfterJournalMove,
   requestEntityCanonicalIdReconcileSync,
   resolveHistoricalEntityCanonicalId,
   withEntityCanonicalMutationLock
-} from "./chunk-NZFFGO5O.js";
+} from "./chunk-VXWOJPSY.js";
 import {
-  computeSupersessionKey,
-  normalizeSupersessionKey,
   supersessionKeysForFact
 } from "./chunk-5WITETWU.js";
 import {
@@ -167,7 +168,7 @@ import {
   composeMemoryEnvelope,
   isSealedMemoryEnvelope,
   sealedWriteToLegacyArgs
-} from "./chunk-5LRV557D.js";
+} from "./chunk-2FIJQNL7.js";
 import {
   DEFAULT_CITATION_FORMAT,
   hasCitationForTemplate,
@@ -188,7 +189,7 @@ import {
   readMemoryActionEventRowsFromLines,
   readProjectionRebuiltAt,
   serializeLifecycleAppendPayload
-} from "./chunk-P55FACBG.js";
+} from "./chunk-3BOQPLCF.js";
 import {
   assertMemoryFrontmatterId,
   warnProjectionFallback
@@ -209,15 +210,11 @@ import {
 import {
   isSupportPassportPrivateMemory
 } from "./chunk-PWPIERBM.js";
-import {
-  assertPathInsideRoot,
-  pathIsInside
-} from "./chunk-C7HJ3NEI.js";
 import {
   CONTENT_HASH_INDEX_RETRY_MAX_DELAY_MS,
   ContentHashIndex,
   FactHashIndexNotAuthoritativeError
-} from "./chunk-DEY7B77Y.js";
+} from "./chunk-AHCELJMH.js";
 import {
   computeLegacyContentHash
 } from "./chunk-5FVVY2EB.js";
@@ -229,9 +226,6 @@ import {
 import {
   sanitizeMemoryContent
 } from "./chunk-5GKPFL3S.js";
-import {
-  withHeldFileLock
-} from "./chunk-5B5WYAHQ.js";
 import {
   parseFlexibleIsoTimestamp
 } from "./chunk-P7FMDTKL.js";
@@ -256,13 +250,18 @@ import {
 } from "./chunk-LDPPTPO5.js";
 import {
   MAGIC_HEADER_SIZE,
+  SecureStoreDecryptError,
   SecureStoreLockedError,
   isEncryptedFile,
   probeEncryptedRegularFileHeader,
   readMaybeEncryptedFile,
   readMaybeEncryptedFileBuffer,
   writeMaybeEncryptedFile
-} from "./chunk-MAAL6OZV.js";
+} from "./chunk-ZG3HZZ6K.js";
+import {
+  assertPathInsideRoot,
+  pathIsInside
+} from "./chunk-C7HJ3NEI.js";
 import {
   ALL_CATEGORY_DIRS,
   RECALL_FALLBACK_DIRS,
@@ -278,19 +277,19 @@ import {
 
 // src/storage.ts
 import {
-  lstat as lstat4,
-  readdir as readdir6,
-  readFile as readFile2,
-  realpath as realpath4,
+  lstat as lstat3,
+  readdir as readdir5,
+  readFile,
+  realpath as realpath3,
   stat as stat3,
-  writeFile as writeFile2,
+  writeFile,
   mkdir,
-  unlink as unlink4,
+  unlink as unlink3,
   appendFile,
   open
 } from "fs/promises";
 import { appendFileSync, createReadStream, mkdirSync, statSync as statSync2 } from "fs";
-import { createHash as createHash6 } from "crypto";
+import { createHash as createHash5 } from "crypto";
 
 // src/preferences/drift-types.ts
 function serializeDriftProvenance(fm) {
@@ -314,7 +313,7 @@ function parseDriftProvenance(fm) {
 }
 
 // src/storage.ts
-import path13 from "path";
+import path12 from "path";
 
 // src/storage/tombstone-migration-sources.ts
 import { statSync } from "fs";
@@ -1975,18 +1974,49 @@ var EntityStore = class {
     log.debug(`wrote entity ${normalized}`);
     return normalized;
   }
-  async readEntity(name) {
-    const filePath = this.deps.resolveEntityFilePath(name);
-    if (filePath === null) {
-      return "";
-    }
+  async readEntityFileResolvingRename(firstPath, entityId) {
     try {
-      return await this.deps.readStorageSecureFile(filePath);
+      return { id: entityId, content: await this.deps.readStorageSecureFile(firstPath) };
     } catch (err) {
       if (err instanceof SecureStoreLockedError) throw err;
+      if (isErrnoCode(err, "ELOOP")) return null;
       if (!isErrnoCode(err, "ENOENT")) throw err;
+    }
+    const historicalIds = this.deps.currentHistoricalIds();
+    const canonical = resolveHistoricalEntityCanonicalId(entityId, historicalIds);
+    const candidates = /* @__PURE__ */ new Set([canonical]);
+    for (const legacy of Object.keys(historicalIds)) {
+      if (resolveHistoricalEntityCanonicalId(legacy, historicalIds) === canonical) candidates.add(legacy);
+    }
+    candidates.delete(entityId);
+    for (const candidate of candidates) {
+      try {
+        return { id: candidate, content: await this.deps.readStorageSecureFile(
+          path5.join(this.deps.entitiesDir, `${candidate}.md`)
+        ) };
+      } catch (err) {
+        if (err instanceof SecureStoreLockedError) throw err;
+        if (isErrnoCode(err, "ENOENT") || isErrnoCode(err, "ELOOP")) continue;
+        throw err;
+      }
+    }
+    return null;
+  }
+  async readEntity(name) {
+    const filePath = this.deps.resolveEntityFilePath(name);
+    if (filePath === null) {
       return "";
     }
+    if (this.deps.entityCanonicalMigrationComplete()) {
+      try {
+        return await this.deps.readStorageSecureFile(filePath);
+      } catch (err) {
+        if (err instanceof SecureStoreLockedError) throw err;
+        if (isErrnoCode(err, "ENOENT") || isErrnoCode(err, "ELOOP")) return "";
+        throw err;
+      }
+    }
+    return (await this.readEntityFileResolvingRename(filePath, name))?.content ?? "";
   }
   /**
    * True when `entities/` is a real directory inside this memory root.
@@ -2033,6 +2063,15 @@ var EntityStore = class {
    * Symlinks, FIFOs, and devices are skipped before any read. The entities
    * root is refused separately, before the directory is listed.
    */
+  async isMissingEntry(file) {
+    try {
+      await lstat2(path5.join(this.deps.entitiesDir, file));
+      return false;
+    } catch (err) {
+      if (isErrnoCode(err, "ENOENT")) return true;
+      throw err;
+    }
+  }
   async isContainedRegularEntityFile(file) {
     const filePath = path5.join(this.deps.entitiesDir, file);
     let entryStat;
@@ -2086,23 +2125,40 @@ var EntityStore = class {
       const names = [];
       const batchSize = 100;
       for (let i = 0; i < mdFiles.length; i += batchSize) {
+        const historicalIds = this.deps.currentHistoricalIds();
+        const snapshotIds = new Set(mdFiles.map((file) => file.slice(0, -3)));
+        const journalComplete = this.deps.entityCanonicalMigrationComplete();
+        const resolveCanonical = (entityId) => {
+          const canonical = resolveHistoricalEntityCanonicalId(entityId, historicalIds);
+          if (canonical === entityId) return entityId;
+          if (journalComplete) return entityId;
+          if (snapshotIds.has(canonical)) return entityId;
+          return canonical;
+        };
         const resolved = await Promise.all(mdFiles.slice(i, i + batchSize).map(async (file) => {
+          const entityId = file.slice(0, -3);
           try {
-            if (!await this.isIndexableEntityMarkdown(file)) return null;
+            if (await this.isIndexableEntityMarkdown(file)) {
+              return resolveCanonical(entityId);
+            }
           } catch (err) {
-            if (err instanceof SecureStoreLockedError) throw err;
-            return null;
+            if (err instanceof SecureStoreLockedError || err instanceof SecureStoreDecryptError) throw err;
+          }
+          try {
+            if (await this.isMissingEntry(file)) {
+              const canonical = resolveHistoricalEntityCanonicalId(entityId, this.deps.currentHistoricalIds());
+              if (canonical !== entityId) return canonical;
+            }
+          } catch (err) {
+            if (err instanceof SecureStoreLockedError || err instanceof SecureStoreDecryptError) throw err;
           }
-          return file.slice(0, -3);
+          return null;
         }));
-        for (const name of resolved) {
-          if (name) names.push(name);
-        }
+        names.push(...resolved.filter((name) => name !== null));
       }
-      names.sort();
-      return names;
+      return [...new Set(names)].sort();
     } catch (err) {
-      if (err instanceof SecureStoreLockedError) throw err;
+      if (err instanceof SecureStoreLockedError || err instanceof SecureStoreDecryptError) throw err;
       return [];
     }
   }
@@ -2190,9 +2246,16 @@ var EntityStore = class {
     const cached = getCachedEntities(this.deps.baseDir, currentVersion, cacheKey);
     if (cached) return cached;
     try {
-      const entries = await this.readEntityDirectoryNames();
+      if (!await this.isTrustedEntitiesRoot()) return [];
+      const listed = await readdir2(this.deps.entitiesDir);
+      const { kept: entries, ignored } = withoutMacOsReplicationJunk(listed, (name) => name);
+      warnIgnoredMacOsReplicationJunk(this.deps.entitiesDir, ignored, (message) => {
+        log.warn(`entity load ${message}`);
+      });
       const mdFiles = entries.filter((e) => e.endsWith(".md"));
       if (mdFiles.length === 0) return [];
+      const historicalIds = this.deps.currentHistoricalIds();
+      const seen = /* @__PURE__ */ new Map();
       const BATCH_SIZE = 100;
       const entities = [];
       for (let i = 0; i < mdFiles.length; i += BATCH_SIZE) {
@@ -2200,19 +2263,34 @@ var EntityStore = class {
         const batch = mdFiles.slice(i, i + BATCH_SIZE);
         const results = await Promise.all(
           batch.map(async (entry) => {
+            const entityId = entry.slice(0, -".md".length);
+            const entryPath = path5.join(this.deps.entitiesDir, entry);
             try {
-              if (!await this.isContainedRegularEntityFile(entry)) return null;
-              return await this.deps.readStorageSecureFile(path5.join(this.deps.entitiesDir, entry));
+              if (!await this.isContainedRegularEntityFile(entry)) {
+                if (await this.isMissingEntry(entry)) {
+                  return await this.readEntityFileResolvingRename(entryPath, entityId);
+                }
+                return null;
+              }
+              return await this.readEntityFileResolvingRename(entryPath, entityId);
             } catch (err) {
-              if (err instanceof SecureStoreLockedError) throw err;
-              if (!isErrnoCode(err, "ENOENT")) throw err;
+              if (err instanceof SecureStoreLockedError || err instanceof SecureStoreDecryptError) throw err;
+              log.warn(`entity read isolated failure for ${entry}: ${err instanceof Error ? err.message : String(err)}`);
               return null;
             }
           })
         );
-        for (const content of results) {
-          if (content === null) continue;
-          const entity = parseEntityFile(content, this.deps.entitySchemas);
+        for (const result of results) {
+          if (result === null) continue;
+          const canonical = resolveHistoricalEntityCanonicalId(result.id, historicalIds);
+          let contents = seen.get(canonical);
+          if (contents?.has(result.content)) continue;
+          if (!contents) {
+            contents = /* @__PURE__ */ new Set();
+            seen.set(canonical, contents);
+          }
+          contents.add(result.content);
+          const entity = parseEntityFile(result.content, this.deps.entitySchemas);
           if (!entity.name.trim() || !entity.type.trim()) continue;
           entities.push(entity);
         }
@@ -2679,859 +2757,8 @@ var IdentityContinuityStore = class {
   }
 };
 
-// src/storage/entity-canonical-id-migration.ts
-import { createHash, randomUUID } from "crypto";
-import {
-  access,
-  lstat as lstat3,
-  readFile,
-  readdir as readdir4,
-  realpath as realpath3,
-  rename,
-  stat as statFile,
-  unlink as unlink2,
-  writeFile
-} from "fs/promises";
-import path7 from "path";
-import { z } from "zod";
-var ENTITY_CANONICAL_ID_MIGRATION_VERSION = 1;
-var ENTITY_CANONICAL_ID_MIGRATION_LOCK_STALE_MS = 6e4;
-var ENTITY_CANONICAL_ID_MIGRATION_LOCK_MAX_WAIT_MS = 3e5;
-var TOMBSTONE_LOCK_STALE_MS = 3e4;
-var TOMBSTONE_LOCK_MAX_WAIT_MS = 5e3;
-var MEMORY_REWRITE_MAX_PASSES = 3;
-var ENTITY_MAPPING_RESCAN_MAX_PASSES = 3;
-var EntityCanonicalIdMigrationStateSchema = z.object({
-  version: z.literal(ENTITY_CANONICAL_ID_MIGRATION_VERSION),
-  complete: z.boolean(),
-  mappings: z.record(z.string().min(1)),
-  /**
-   * Pairs the migration refused to resolve, PARKED rather than dropped.
-   * Deleting the record would strand the collision: once an operator removes
-   * the legacy file, no later scan can rediscover the mapping, so references
-   * still naming the legacy id would never be rewritten. Optional so a journal
-   * written by an older build still parses.
-   */
-  blocked: z.record(z.string().min(1)).optional()
-});
-async function fingerprintPath(filePath) {
-  let fileStat;
-  try {
-    fileStat = await lstat3(filePath);
-  } catch (error) {
-    if (!isErrnoCode(error, "ENOENT")) throw error;
-  }
-  return fileStat ? `${fileStat.dev}:${fileStat.ino}:${fileStat.mtimeMs}:${fileStat.ctimeMs}:${fileStat.size}` : "missing";
-}
-async function fingerprintEntityEntries(entitiesDir) {
-  let names;
-  try {
-    names = (await readdir4(entitiesDir)).filter((name) => path7.extname(name) === ".md" && !isMacOsReplicationJunkBasename(name)).sort();
-  } catch (error) {
-    if (isErrnoCode(error, "ENOENT")) return "missing";
-    throw error;
-  }
-  const hash = createHash("sha256");
-  for (const name of names) {
-    hash.update(`${name.length}:${name}:`);
-    try {
-      const entry = await lstat3(path7.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;
-      hash.update("missing");
-    }
-    hash.update("\n");
-  }
-  return hash.digest("hex");
-}
-async function getFingerprint(baseDir, entitiesDir, getEntityMutationVersion) {
-  const [
-    entityDirectoryFingerprint,
-    entityEntriesFingerprint,
-    aliasFingerprint,
-    reconcileFingerprint,
-    consumingFingerprint
-  ] = await Promise.all([
-    fingerprintPath(entitiesDir),
-    fingerprintEntityEntries(entitiesDir),
-    fingerprintPath(path7.join(baseDir, "config", "aliases.json")),
-    fingerprintPath(path7.join(baseDir, "state", ENTITY_CANONICAL_ID_RECONCILE_MARKER)),
-    fingerprintPath(path7.join(baseDir, "state", ENTITY_CANONICAL_ID_RECONCILE_CONSUMING_MARKER))
-  ]);
-  return [
-    entityDirectoryFingerprint,
-    entityEntriesFingerprint,
-    aliasFingerprint,
-    reconcileFingerprint,
-    consumingFingerprint,
-    getEntityMutationVersion()
-  ].join(":");
-}
-async function validateRoots(baseDir, entitiesDir, stateDir, archiveDir) {
-  let baseStat;
-  try {
-    baseStat = await lstat3(baseDir);
-  } catch (error) {
-    if (isErrnoCode(error, "ENOENT")) return;
-    throw error;
-  }
-  if (baseStat.isSymbolicLink() || !baseStat.isDirectory()) {
-    throw new Error(`Refusing entity canonical-id migration through unsafe memory root: ${baseDir}.`);
-  }
-  const memoryRoot = await realpath3(baseDir);
-  const roots = [
-    entitiesDir,
-    stateDir,
-    ...RECALL_FALLBACK_DIRS.map((directory) => path7.join(baseDir, directory)),
-    path7.join(baseDir, "cold"),
-    archiveDir
-  ];
-  for (const root of roots) {
-    let rootStat;
-    try {
-      rootStat = await lstat3(root);
-    } catch (error) {
-      if (isErrnoCode(error, "ENOENT")) continue;
-      throw error;
-    }
-    if (rootStat.isSymbolicLink() || !rootStat.isDirectory()) {
-      throw new Error(`Refusing entity canonical-id migration through unsafe memory root: ${root}.`);
-    }
-    assertPathInsideRoot(memoryRoot, await realpath3(root), root);
-  }
-}
-function statePath(deps) {
-  return path7.join(deps.stateDir, ENTITY_CANONICAL_ID_MIGRATION_FILE);
-}
-async function assertSafeMigrationStateFile(deps) {
-  const migrationStatePath = statePath(deps);
-  let fileStat;
-  try {
-    fileStat = await lstat3(migrationStatePath);
-  } catch (error) {
-    if (isErrnoCode(error, "ENOENT")) return;
-    throw error;
-  }
-  if (fileStat.isSymbolicLink() || !fileStat.isFile()) {
-    throw new Error(
-      `Refusing entity canonical-id migration through unsafe migration state file: ${migrationStatePath}.`
-    );
-  }
-  const [stateRoot, stateFile] = await Promise.all([
-    realpath3(deps.stateDir),
-    realpath3(migrationStatePath)
-  ]);
-  assertPathInsideRoot(stateRoot, stateFile, migrationStatePath);
-}
-async function assertSafeTombstoneFile(deps, tombstonePath) {
-  let fileStat;
-  try {
-    fileStat = await lstat3(tombstonePath);
-  } catch (error) {
-    if (isErrnoCode(error, "ENOENT")) return false;
-    throw error;
-  }
-  if (fileStat.isSymbolicLink() || !fileStat.isFile()) {
-    throw new Error(
-      `Refusing entity canonical-id migration through unsafe tombstone ledger: ${tombstonePath}.`
-    );
-  }
-  const [stateRoot, tombstoneFile] = await Promise.all([
-    realpath3(deps.stateDir),
-    realpath3(tombstonePath)
-  ]);
-  assertPathInsideRoot(stateRoot, tombstoneFile, tombstonePath);
-  return true;
-}
-function lockPath(deps) {
-  return path7.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");
-  } catch (error) {
-    if (isErrnoCode(error, "ENOENT")) return null;
-    throw error;
-  }
-  let parsed;
-  try {
-    parsed = JSON.parse(raw);
-  } catch {
-    throw new Error("Invalid entity canonical-id migration state.");
-  }
-  const result = EntityCanonicalIdMigrationStateSchema.safeParse(parsed);
-  if (!result.success) throw new Error("Invalid entity canonical-id migration state.");
-  for (const mappings of [result.data.mappings, result.data.blocked ?? {}]) {
-    for (const [legacyId, canonicalId] of Object.entries(mappings)) {
-      assertSafeEntityId(legacyId);
-      assertSafeEntityId(canonicalId);
-    }
-  }
-  return result.data;
-}
-async function writeState(deps, state) {
-  const destination = statePath(deps);
-  const temporary = `${destination}.${process.pid}.${randomUUID()}.tmp`;
-  try {
-    await writeFile(temporary, `${JSON.stringify(state, null, 2)}
-`, "utf-8");
-    await rename(temporary, destination);
-  } finally {
-    await unlink2(temporary).catch(() => void 0);
-  }
-}
-async function publishState(deps, state) {
-  await withEntityCanonicalMutationLock(deps.stateDir, async () => {
-    await writeState(deps, state);
-  });
-}
-async function fileExists(filePath) {
-  try {
-    await access(filePath);
-    return true;
-  } catch (error) {
-    if (isErrnoCode(error, "ENOENT")) return false;
-    throw error;
-  }
-}
-async function sameFileIdentity(leftPath, rightPath) {
-  try {
-    const [left, right] = await Promise.all([statFile(leftPath), statFile(rightPath)]);
-    return left.dev === right.dev && left.ino === right.ino;
-  } catch (error) {
-    if (isErrnoCode(error, "ENOENT")) return false;
-    throw error;
-  }
-}
-async function assertNotSymlink(filePath, label) {
-  let stat4;
-  try {
-    stat4 = await lstat3(filePath);
-  } catch (error) {
-    if (isErrnoCode(error, "ENOENT")) return;
-    throw error;
-  }
-  if (stat4.isSymbolicLink()) {
-    throw new Error(`Refusing entity canonical-id migration through symlink: ${label}.`);
-  }
-}
-async function assertNotMemorySymlink(filePath) {
-  let stat4;
-  try {
-    stat4 = await lstat3(filePath);
-  } catch (error) {
-    if (isErrnoCode(error, "ENOENT")) return;
-    throw error;
-  }
-  if (stat4.isSymbolicLink()) {
-    throw new Error(`Refusing entity canonical-id migration through symlinked memory: ${filePath}.`);
-  }
-}
-async function assertEntityContentUnchanged(deps, filePath, expectedContent, legacyId) {
-  const latestContent = await deps.readStorageSecureFile(filePath);
-  if (latestContent !== expectedContent) {
-    throw new Error(`Legacy entity id ${legacyId} changed while migration was running; retry migration.`);
-  }
-}
-async function readSafeEntityEntries(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(path7.join(entitiesDir, entry), entry);
-  }
-  return entries;
-}
-async function discoverMappings(deps, knownMappings = {}, blocked = /* @__PURE__ */ new Map(), scanNotes) {
-  const mappings = {};
-  const canonicalOwners = /* @__PURE__ */ new Map();
-  blocked.clear();
-  const entityEntries = await readSafeEntityEntries(deps.entitiesDir);
-  for (const entry of entityEntries) {
-    if (isMacOsReplicationJunkBasename(entry)) {
-      scanNotes?.junk.add(entry);
-      continue;
-    }
-    if (!entry.endsWith(".md")) continue;
-    const legacyId = entry.slice(0, -".md".length);
-    assertSafeEntityId(legacyId);
-    const legacyPath = deps.resolveEntityFilePath(legacyId);
-    if (legacyPath === null) continue;
-    const entityContent = await deps.readStorageSecureFile(legacyPath);
-    if (isMalformedEntityRecord(entityContent)) {
-      scanNotes?.malformed.add(entry);
-      continue;
-    }
-    const entity = deps.parseEntityFile(entityContent);
-    if (!entity.name.trim() || !entity.type.trim()) {
-      scanNotes?.malformed.add(entry);
-      continue;
-    }
-    const canonicalId = deps.normalizeEntityName(entity.name, entity.type);
-    assertSafeEntityId(canonicalId);
-    if (legacyId === canonicalId) continue;
-    const canonicalPath = deps.resolveEntityFilePath(canonicalId);
-    if (canonicalPath === null) continue;
-    const canonicalExists = await fileExists(canonicalPath);
-    if (canonicalExists && await sameFileIdentity(legacyPath, canonicalPath) && knownMappings[legacyId] === canonicalId) continue;
-    if (canonicalExists) {
-      const canonicalContent2 = await deps.readStorageSecureFile(canonicalPath);
-      if (entityContent !== canonicalContent2) {
-        blocked.set(legacyId, canonicalId);
-        continue;
-      }
-    }
-    canonicalOwners.set(canonicalId, [...canonicalOwners.get(canonicalId) ?? [], legacyId]);
-    mappings[legacyId] = canonicalId;
-  }
-  for (const [canonicalId, claimants] of canonicalOwners) {
-    if (claimants.length < 2) continue;
-    for (const legacyId of claimants) {
-      blocked.set(legacyId, canonicalId);
-      delete mappings[legacyId];
-    }
-  }
-  return mappings;
-}
-async function rewriteReferences(deps, mappings, refreshLock) {
-  let rewroteColdMemory = false;
-  for (let pass = 0; pass < MEMORY_REWRITE_MAX_PASSES; pass += 1) {
-    deps.invalidateAllMemoriesCache();
-    deps.invalidateColdMemoriesCache();
-    const [hotMemories, coldMemories, archivedMemories] = await Promise.all([
-      deps.readAllMemories(),
-      deps.readAllColdMemories(),
-      deps.readArchivedMemories()
-    ]);
-    const seenPaths = /* @__PURE__ */ new Set();
-    let rewroteAny = false;
-    for (const memory of [...hotMemories, ...coldMemories, ...archivedMemories]) {
-      const memoryPath = path7.resolve(memory.path);
-      if (seenPaths.has(memoryPath)) continue;
-      seenPaths.add(memoryPath);
-      const previousEntityRef = memory.frontmatter.entityRef;
-      const canonicalId = previousEntityRef ? mappings[previousEntityRef] : void 0;
-      if (!previousEntityRef || !canonicalId) continue;
-      await assertNotMemorySymlink(memory.path);
-      const observedMemoryFingerprint = await fingerprintPath(memory.path);
-      if (observedMemoryFingerprint === "missing") continue;
-      if (!await refreshLock()) throw new Error("Lost entity canonical-id migration lock.");
-      const latestMemory = await deps.readMemoryByPath(memory.path);
-      if (!latestMemory) continue;
-      const latestMemoryFingerprint = await fingerprintPath(latestMemory.path);
-      if (latestMemoryFingerprint !== observedMemoryFingerprint) continue;
-      const latestPreviousEntityRef = latestMemory.frontmatter.entityRef;
-      const latestCanonicalId = latestPreviousEntityRef ? mappings[latestPreviousEntityRef] : void 0;
-      if (!latestPreviousEntityRef || !latestCanonicalId) continue;
-      const memoryEncrypted = await deps.isEncryptedStorageFile(latestMemory.path);
-      if (await fingerprintPath(latestMemory.path) !== latestMemoryFingerprint) continue;
-      await deps.snapshotBeforeWrite(latestMemory.path, "write");
-      if (await fingerprintPath(latestMemory.path) !== latestMemoryFingerprint) continue;
-      await deps.writeStorageSecureFile(
-        latestMemory.path,
-        deps.serializeMemoryWithEntityRef(latestMemory, latestCanonicalId),
-        memoryEncrypted
-      );
-      await deps.rewriteProjectedMemoryEntityReference(
-        latestMemory.frontmatter.id,
-        latestPreviousEntityRef,
-        latestCanonicalId
-      );
-      rewroteAny = true;
-      rewroteColdMemory ||= latestMemory.path.includes(`${path7.sep}cold${path7.sep}`);
-    }
-    if (!rewroteAny) return { rewroteColdMemory };
-  }
-  throw new Error("Memory references changed while entity canonical-id migration was running; retry migration.");
-}
-function rewriteTombstoneLine(line, mappings, normalizedMappings) {
-  let parsed;
-  try {
-    parsed = JSON.parse(line);
-  } catch {
-    return line;
-  }
-  if (!parsed || typeof parsed !== "object" || Array.isArray(parsed)) return line;
-  const tombstone = parsed;
-  let changed = false;
-  if (typeof tombstone.entityRef === "string") {
-    const canonicalId = mappings[tombstone.entityRef];
-    if (canonicalId) {
-      tombstone.entityRef = canonicalId;
-      changed = true;
-    }
-  }
-  if (typeof tombstone.supersessionKey === "string") {
-    const separator = tombstone.supersessionKey.indexOf("::");
-    if (separator < 0) return changed ? JSON.stringify(tombstone) : line;
-    const normalizedLegacyId = normalizeSupersessionKey(tombstone.supersessionKey.slice(0, separator));
-    const canonicalId = normalizedMappings.get(normalizedLegacyId);
-    if (canonicalId) {
-      const canonicalKey = computeSupersessionKey(canonicalId, tombstone.supersessionKey.slice(separator + 2));
-      if (canonicalKey) {
-        tombstone.supersessionKey = canonicalKey;
-        changed = true;
-      }
-    }
-  }
-  return changed ? JSON.stringify(tombstone) : line;
-}
-async function rewriteTombstoneReferences(deps, mappings, refreshLock) {
-  const tombstonePath = path7.join(deps.stateDir, "tombstones.jsonl");
-  const normalizedMappings = /* @__PURE__ */ new Map();
-  for (const [legacyId, canonicalId] of Object.entries(mappings)) {
-    const normalizedLegacyId = normalizeSupersessionKey(legacyId);
-    if (normalizedLegacyId && !normalizedMappings.has(normalizedLegacyId)) {
-      normalizedMappings.set(normalizedLegacyId, canonicalId);
-    }
-  }
-  await withHeldFileLock(
-    path7.join(deps.stateDir, "tombstones.lock"),
-    {
-      staleMs: TOMBSTONE_LOCK_STALE_MS,
-      maxWaitMs: TOMBSTONE_LOCK_MAX_WAIT_MS
-    },
-    async (acquired, tombstoneLock) => {
-      if (!acquired) throw new Error("Timed out waiting for active tombstone migration.");
-      if (!await assertSafeTombstoneFile(deps, tombstonePath)) return;
-      const tombstoneEncrypted = await deps.isEncryptedStorageFile(tombstonePath);
-      const original = await deps.readStorageSecureFile(tombstonePath);
-      let changed = false;
-      const rewritten = original.split("\n").map((line) => {
-        const next = rewriteTombstoneLine(line, mappings, normalizedMappings);
-        changed ||= next !== line;
-        return next;
-      }).join("\n");
-      if (!changed) return;
-      if (!await refreshLock()) throw new Error("Lost entity canonical-id migration lock.");
-      if (!await tombstoneLock.refresh()) throw new Error("Lost tombstone migration lock.");
-      await deps.snapshotBeforeWrite(tombstonePath, "write");
-      await deps.writeStorageSecureFile(tombstonePath, rewritten, tombstoneEncrypted);
-    }
-  );
-}
-async function rewriteRelationshipTargets(deps, mappings, refreshLock) {
-  let rewritten = false;
-  const entries = await readSafeEntityEntries(deps.entitiesDir);
-  for (const entry of entries) {
-    if (!entry.endsWith(".md") || isMacOsReplicationJunkBasename(entry)) continue;
-    const entityPath = deps.resolveEntityFilePath(entry.slice(0, -".md".length));
-    if (entityPath === null) continue;
-    const observedEntityFingerprint = await fingerprintPath(entityPath);
-    if (observedEntityFingerprint === "missing") continue;
-    const entityRaw = await deps.readStorageSecureFile(entityPath);
-    if (isMalformedEntityRecord(entityRaw)) continue;
-    const entity = deps.parseEntityFile(entityRaw);
-    const relationships = entity.relationships.map((relationship) => {
-      const target = mappings[relationship.target];
-      return target ? { ...relationship, target } : relationship;
-    });
-    if (relationships.every((relationship, index) => relationship === entity.relationships[index])) continue;
-    const rewroteEntity = await withEntityCanonicalMutationLock(
-      deps.stateDir,
-      async (refreshEntityLock) => {
-        if (!await refreshLock()) throw new Error("Lost entity canonical-id migration lock.");
-        const latestRaw = await deps.readStorageSecureFile(entityPath);
-        if (isMalformedEntityRecord(latestRaw)) return false;
-        const latestEntity = deps.parseEntityFile(latestRaw);
-        if (await fingerprintPath(entityPath) !== observedEntityFingerprint) return false;
-        const latestRelationships = latestEntity.relationships.map((relationship) => {
-          const target = mappings[relationship.target];
-          return target ? { ...relationship, target } : relationship;
-        });
-        if (latestRelationships.every((relationship, index) => relationship === latestEntity.relationships[index])) {
-          return false;
-        }
-        const entityEncrypted = await deps.isEncryptedStorageFile(entityPath);
-        if (!await refreshEntityLock()) throw new Error("Lost entity mutation lock.");
-        if (await fingerprintPath(entityPath) !== observedEntityFingerprint) return false;
-        await deps.snapshotBeforeWrite(entityPath, "write");
-        if (await fingerprintPath(entityPath) !== observedEntityFingerprint) return false;
-        await deps.writeStorageSecureFile(
-          entityPath,
-          deps.serializeEntityFile({ ...latestEntity, relationships: latestRelationships }),
-          entityEncrypted
-        );
-        return true;
-      }
-    );
-    rewritten ||= rewroteEntity;
-  }
-  return rewritten;
-}
-async function rewriteKnownReferences(deps, mappings, refreshLock) {
-  await rewriteRelationshipTargets(deps, mappings, refreshLock);
-  let rewroteColdMemory = (await rewriteReferences(deps, mappings, refreshLock)).rewroteColdMemory;
-  await rewriteTombstoneReferences(deps, mappings, refreshLock);
-  await deps.rewriteProjectedEntityReferences(mappings);
-  const finalMemoryPass = await rewriteReferences(deps, mappings, refreshLock);
-  rewroteColdMemory ||= finalMemoryPass.rewroteColdMemory;
-  return rewroteColdMemory;
-}
-function wouldCreateMappingCycle(mappings, legacyId, canonicalId) {
-  let current = canonicalId;
-  const seen = /* @__PURE__ */ new Set();
-  while (true) {
-    if (current === legacyId) return true;
-    if (seen.has(current)) return false;
-    seen.add(current);
-    const next = mappings[current];
-    if (!next || next === current) return false;
-    current = next;
-  }
-}
-function rejectMappingCycles(existing, discovered) {
-  const accepted = {};
-  const merged = { ...existing };
-  for (const [legacyId, canonicalId] of Object.entries(discovered)) {
-    if (merged[legacyId] === void 0 && wouldCreateMappingCycle(merged, legacyId, canonicalId)) continue;
-    accepted[legacyId] = canonicalId;
-    merged[legacyId] = canonicalId;
-  }
-  return accepted;
-}
-function mergeDiscoveredMappings(existing, discovered) {
-  const merged = { ...existing };
-  const canonicalOwners = /* @__PURE__ */ new Map();
-  for (const [legacyId, canonicalId] of Object.entries(discovered)) {
-    const previousMapping = merged[legacyId];
-    if (previousMapping !== void 0 && previousMapping !== canonicalId) {
-      continue;
-    }
-    if (previousMapping === void 0 && wouldCreateMappingCycle(merged, legacyId, canonicalId)) continue;
-    const previousOwner = canonicalOwners.get(canonicalId);
-    if (previousOwner !== void 0 && previousOwner !== legacyId) {
-      throw new Error(
-        `Cannot migrate legacy entity ids ${previousOwner} and ${legacyId}: both normalize to ${canonicalId}.`
-      );
-    }
-    merged[legacyId] = canonicalId;
-    canonicalOwners.set(canonicalId, legacyId);
-  }
-  return merged;
-}
-function collapseMappings(mappings) {
-  const collapsed = {};
-  for (const legacyId of Object.keys(mappings)) {
-    let current = legacyId;
-    const seen = /* @__PURE__ */ new Set();
-    while (true) {
-      const next = mappings[current];
-      if (!next || next === current) break;
-      if (seen.has(current)) {
-        throw new Error(`Entity canonical-id migration mapping cycle includes ${legacyId}.`);
-      }
-      seen.add(current);
-      current = next;
-    }
-    if (current !== legacyId) collapsed[legacyId] = current;
-  }
-  return collapsed;
-}
-async function migrateEntityFilePair(deps, legacyId, canonicalId, refreshMigrationLock) {
-  return withEntityCanonicalMutationLock(deps.stateDir, async (refreshEntityLock) => {
-    assertSafeEntityId(legacyId);
-    assertSafeEntityId(canonicalId);
-    const legacyPath = deps.resolveEntityFilePath(legacyId);
-    const canonicalPath = deps.resolveEntityFilePath(canonicalId);
-    if (legacyPath === null || canonicalPath === null) {
-      throw new Error("Invalid entity canonical-id migration path.");
-    }
-    await assertNotSymlink(legacyPath, legacyId);
-    await assertNotSymlink(canonicalPath, canonicalId);
-    const legacyExists = await fileExists(legacyPath);
-    const canonicalExists = await fileExists(canonicalPath);
-    if (!legacyExists && !canonicalExists) return { deferred: true, progressed: false };
-    if (legacyExists && canonicalExists) {
-      if (await sameFileIdentity(legacyPath, canonicalPath)) return { deferred: false, progressed: false };
-      const [legacyContent, canonicalContent2, legacyEncrypted, canonicalEncrypted] = await Promise.all([
-        deps.readStorageSecureFile(legacyPath),
-        deps.readStorageSecureFile(canonicalPath),
-        deps.isEncryptedStorageFile(legacyPath),
-        deps.isEncryptedStorageFile(canonicalPath)
-      ]);
-      if (legacyContent !== canonicalContent2) {
-        return { deferred: false, progressed: false, blocked: true };
-      }
-      if (legacyEncrypted && !canonicalEncrypted) {
-        if (!await refreshMigrationLock() || !await refreshEntityLock()) {
-          throw new Error("Lost entity canonical-id migration lock.");
-        }
-        await deps.snapshotBeforeWrite(canonicalPath, "write");
-        await deps.writeStorageSecureFile(canonicalPath, legacyContent, true);
-        if (await deps.readStorageSecureFile(canonicalPath) !== legacyContent) {
-          throw new Error(`Cannot verify migrated entity id ${canonicalId}.`);
-        }
-      }
-      if (!await refreshMigrationLock() || !await refreshEntityLock()) {
-        throw new Error("Lost entity canonical-id migration lock.");
-      }
-      await deps.snapshotBeforeWrite(legacyPath, "write");
-      await assertNotSymlink(legacyPath, legacyId);
-      await assertEntityContentUnchanged(deps, legacyPath, legacyContent, legacyId);
-      await unlink2(legacyPath);
-      return { deferred: false, progressed: true };
-    }
-    if (!legacyExists) return { deferred: false, progressed: false };
-    if (!await refreshMigrationLock() || !await refreshEntityLock()) {
-      throw new Error("Lost entity canonical-id migration lock.");
-    }
-    const entityEncrypted = await deps.isEncryptedStorageFile(legacyPath);
-    const entityContent = await deps.readStorageSecureFile(legacyPath);
-    await assertNotSymlink(legacyPath, legacyId);
-    await assertEntityContentUnchanged(deps, legacyPath, entityContent, legacyId);
-    if (isMacOsReplicationJunkBasename(path7.basename(legacyPath)) || isMalformedEntityRecord(entityContent)) {
-      return { deferred: false, progressed: false };
-    }
-    let canonicalFingerprintAfterWrite = null;
-    try {
-      await deps.writeStorageSecureFile(canonicalPath, entityContent, entityEncrypted);
-      canonicalFingerprintAfterWrite = await fingerprintPath(canonicalPath);
-      if (await deps.readStorageSecureFile(canonicalPath) !== entityContent) {
-        throw new Error(`Cannot verify migrated entity id ${canonicalId}.`);
-      }
-      if (!await refreshMigrationLock() || !await refreshEntityLock()) {
-        throw new Error("Lost entity canonical-id migration lock.");
-      }
-      await deps.snapshotBeforeWrite(legacyPath, "write");
-      await assertNotSymlink(legacyPath, legacyId);
-      await assertEntityContentUnchanged(deps, legacyPath, entityContent, legacyId);
-      await unlink2(legacyPath);
-    } catch (error) {
-      if (!canonicalExists && canonicalFingerprintAfterWrite !== null) {
-        try {
-          if (await fingerprintPath(canonicalPath) === canonicalFingerprintAfterWrite) {
-            await assertNotSymlink(canonicalPath, canonicalId);
-            await unlink2(canonicalPath);
-          }
-        } catch {
-        }
-      }
-      throw error;
-    }
-    return { deferred: false, progressed: true };
-  });
-}
-async function migrateLegacyEntityCanonicalIds(deps) {
-  return withHeldFileLock(
-    lockPath(deps),
-    {
-      staleMs: ENTITY_CANONICAL_ID_MIGRATION_LOCK_STALE_MS,
-      maxWaitMs: ENTITY_CANONICAL_ID_MIGRATION_LOCK_MAX_WAIT_MS
-    },
-    async (acquired, lock) => {
-      if (!acquired) throw new Error("Timed out waiting for active entity canonical-id migration.");
-      await deps.validateMemoryScanRoots?.();
-      await readSafeEntityEntries(deps.entitiesDir);
-      const reconcileMarkerPath = path7.join(deps.stateDir, ENTITY_CANONICAL_ID_RECONCILE_MARKER);
-      const consumingMarkerPath = path7.join(deps.stateDir, ENTITY_CANONICAL_ID_RECONCILE_CONSUMING_MARKER);
-      let reconcileRequested = await fileExists(consumingMarkerPath);
-      if (await fileExists(reconcileMarkerPath)) {
-        try {
-          await rename(reconcileMarkerPath, consumingMarkerPath);
-          reconcileRequested = true;
-        } catch (error) {
-          if (!isErrnoCode(error, "ENOENT")) throw error;
-        }
-      }
-      let state = await readState(deps);
-      if (!state) {
-        state = {
-          version: ENTITY_CANONICAL_ID_MIGRATION_VERSION,
-          complete: false,
-          mappings: {}
-        };
-      }
-      const blocked = /* @__PURE__ */ new Map();
-      const scanNotes = { junk: /* @__PURE__ */ new Set(), malformed: /* @__PURE__ */ new Set() };
-      const staleParked = /* @__PURE__ */ new Map();
-      const finish = async () => {
-        if (blocked.size > 0) {
-          const pairs = [...blocked].map(([legacyId, canonicalId]) => `${legacyId} -> ${canonicalId}`).join(", ");
-          log.warn(
-            `entity canonical-id migration skipped ${blocked.size} unresolvable pair(s): ${pairs}. Both files were kept and the legacy id still resolves; merge or delete one side to migrate it.`
-          );
-        }
-        if (staleParked.size > 0) {
-          const pairs = [...staleParked].map(([legacyId, canonicalId]) => `${legacyId} -> ${canonicalId}`).join(", ");
-          log.warn(
-            `entity canonical-id migration dropped ${staleParked.size} mapping(s) whose entity files are gone: ${pairs}. The stale journal entries were removed; references to those legacy ids do not resolve either way.`
-          );
-        }
-        warnIgnoredMacOsReplicationJunk(deps.entitiesDir, scanNotes.junk.size, (message) => {
-          log.warn(`entity canonical-id migration ${message}`);
-        });
-        if (scanNotes.malformed.size > 0) {
-          const names = [...scanNotes.malformed].sort().join(", ");
-          log.warn(
-            `entity canonical-id migration skipped ${scanNotes.malformed.size} malformed entity file(s): ${names}. Each file was left in place; startup continues. Fix or remove the file to migrate it.`
-          );
-        }
-        if (reconcileRequested) {
-          await unlink2(consumingMarkerPath).catch((error) => {
-            if (!isErrnoCode(error, "ENOENT")) throw error;
-          });
-        }
-        const completionFingerprint = await deps.readMigrationFingerprint?.();
-        if (await fileExists(reconcileMarkerPath)) return void 0;
-        return completionFingerprint;
-      };
-      const pruneBlocked = async () => {
-        const current = state;
-        if (!current) return false;
-        let revived = false;
-        const parked = { ...current.blocked ?? {} };
-        const active = {};
-        for (const [legacyId, canonicalId] of Object.entries(current.mappings)) {
-          if (!blocked.has(legacyId)) active[legacyId] = canonicalId;
-        }
-        for (const [legacyId, canonicalId] of blocked) parked[legacyId] = canonicalId;
-        for (const [legacyId, canonicalId] of Object.entries(parked)) {
-          if (blocked.has(legacyId)) continue;
-          delete parked[legacyId];
-          if (active[legacyId] !== void 0) continue;
-          const legacyPath = deps.resolveEntityFilePath(legacyId);
-          if (legacyPath !== null && await fileExists(legacyPath)) continue;
-          let target = canonicalId;
-          const seenTargets = /* @__PURE__ */ new Set();
-          while (active[target] !== void 0 && !seenTargets.has(target)) {
-            seenTargets.add(target);
-            target = active[target];
-          }
-          const targetPath = deps.resolveEntityFilePath(target);
-          if (targetPath === null || !await fileExists(targetPath)) {
-            staleParked.set(legacyId, canonicalId);
-            continue;
-          }
-          active[legacyId] = target;
-          revived = true;
-        }
-        const collapsed = collapseMappings(active);
-        for (const [legacyId, canonicalId] of Object.entries(parked)) {
-          const moved = collapsed[canonicalId];
-          if (moved !== void 0 && moved !== legacyId) parked[legacyId] = moved;
-        }
-        const same = (a, b) => Object.keys(a).length === Object.keys(b).length && Object.entries(a).every(([key, value]) => b[key] === value);
-        if (same(collapsed, current.mappings) && same(parked, current.blocked ?? {})) return revived;
-        state = { ...current, mappings: collapsed, blocked: parked };
-        await publishState(deps, state);
-        return revived;
-      };
-      const previousMappings = state.mappings;
-      const collapsedMappings = collapseMappings(previousMappings);
-      const mappingsChanged = Object.keys(collapsedMappings).length !== Object.keys(previousMappings).length || Object.entries(collapsedMappings).some(
-        ([legacyId, canonicalId]) => previousMappings[legacyId] !== canonicalId
-      );
-      state = { ...state, mappings: collapsedMappings };
-      for (let migrationPass = 0; migrationPass < ENTITY_MAPPING_RESCAN_MAX_PASSES; migrationPass += 1) {
-        if (!await lock.refresh()) throw new Error("Lost entity canonical-id migration lock.");
-        const discoveredBefore = rejectMappingCycles(
-          state.mappings,
-          await discoverMappings(deps, state.mappings, blocked, scanNotes)
-        );
-        const revivedBefore = await pruneBlocked();
-        const mergedBefore = collapseMappings(mergeDiscoveredMappings(state.mappings, discoveredBefore));
-        if (state.complete && Object.keys(discoveredBefore).length === 0 && !mappingsChanged && !revivedBefore) {
-          if (reconcileRequested && Object.keys(state.mappings).length > 0) {
-            const rewroteColdMemory2 = await rewriteKnownReferences(
-              deps,
-              state.mappings,
-              () => lock.refresh()
-            );
-            deps.invalidateKnowledgeIndexCache();
-            deps.invalidateAllMemoriesCache();
-            if (rewroteColdMemory2) deps.invalidateColdMemoriesCache();
-            deps.bumpMemoryStatusVersion();
-          }
-          return finish();
-        }
-        if (state.complete || Object.keys(discoveredBefore).length > 0 || Object.keys(mergedBefore).length !== Object.keys(state.mappings).length) {
-          state = { ...state, complete: false, mappings: mergedBefore };
-          await publishState(deps, state);
-        }
-        if (Object.keys(state.mappings).length === 0) {
-          if (!await lock.refresh()) throw new Error("Lost entity canonical-id migration lock.");
-          const discoveredAfter2 = rejectMappingCycles(
-            state.mappings,
-            await discoverMappings(deps, state.mappings, blocked, scanNotes)
-          );
-          const revivedInRescan = await pruneBlocked();
-          if (Object.keys(discoveredAfter2).length === 0 && !revivedInRescan) {
-            await publishState(deps, { ...state, complete: true });
-            return finish();
-          }
-          state = {
-            ...state,
-            complete: false,
-            mappings: collapseMappings(mergeDiscoveredMappings(state.mappings, discoveredAfter2))
-          };
-          await publishState(deps, state);
-          continue;
-        }
-        let pendingMappings = Object.entries(state.mappings);
-        while (pendingMappings.length > 0) {
-          const deferredMappings = [];
-          let progressed = false;
-          for (const [legacyId, canonicalId] of pendingMappings) {
-            const result = await migrateEntityFilePair(
-              deps,
-              legacyId,
-              canonicalId,
-              () => lock.refresh()
-            );
-            if (result.blocked) blocked.set(legacyId, canonicalId);
-            else if (result.deferred) deferredMappings.push([legacyId, canonicalId]);
-            progressed ||= result.progressed;
-          }
-          if (deferredMappings.length === 0) break;
-          if (!progressed) {
-            for (const [legacyId, canonicalId] of deferredMappings) {
-              blocked.set(legacyId, canonicalId);
-              staleParked.set(legacyId, canonicalId);
-            }
-            break;
-          }
-          pendingMappings = deferredMappings;
-        }
-        await pruneBlocked();
-        const rewroteColdMemory = await rewriteKnownReferences(
-          deps,
-          state.mappings,
-          () => lock.refresh()
-        );
-        deps.invalidateKnowledgeIndexCache();
-        deps.invalidateAllMemoriesCache();
-        if (rewroteColdMemory) deps.invalidateColdMemoriesCache();
-        deps.bumpMemoryStatusVersion();
-        if (!await lock.refresh()) throw new Error("Lost entity canonical-id migration lock.");
-        const discoveredAfter = rejectMappingCycles(
-          state.mappings,
-          await discoverMappings(deps, state.mappings, blocked, scanNotes)
-        );
-        const revivedAfterRewrite = await pruneBlocked();
-        if (Object.keys(discoveredAfter).length === 0 && !revivedAfterRewrite) {
-          await publishState(deps, { ...state, complete: true });
-          return finish();
-        }
-        state = {
-          ...state,
-          complete: false,
-          mappings: collapseMappings(mergeDiscoveredMappings(state.mappings, discoveredAfter))
-        };
-        await publishState(deps, state);
-      }
-      throw new Error("Entity canonical-id migration mappings changed while migration was running; retry migration.");
-    }
-  );
-}
-
 // src/storage/entity-ref-repair.ts
-import { unlink as unlink3 } from "fs/promises";
+import { unlink as unlink2 } from "fs/promises";
 var EntityRefRepair = class {
   constructor(deps) {
     this.deps = deps;
@@ -3593,7 +2820,7 @@ ${body}
       if (opts.onFailRestore) {
         await this.restore(opts.onFailRestore);
       } else if (opts.onFailRemove) {
-        await unlink3(opts.onFailRemove).catch(() => void 0);
+        await unlink2(opts.onFailRemove).catch(() => void 0);
         this.deps.invalidateAllMemoriesCache();
       }
       throw err;
@@ -3679,6 +2906,33 @@ var EntityCanonicalIdMigrationRunner = class {
   directoriesInitialized = false;
   migrationComplete = false;
   completedFingerprint = null;
+  /**
+   * First half of deferred startup: when waiting, ensure the migration runs;
+   * when deferring, pre-read the entity entries the store serves instead and
+   * let the migration start later (finishBegin detaches it).
+   */
+  async begin(wait, entitiesDir) {
+    if (wait) {
+      await this.ensure();
+      return;
+    }
+    const { readSafeEntityEntries } = await import("./entity-canonical-id-migration-GD5MPFUF.js");
+    await readSafeEntityEntries(entitiesDir);
+  }
+  /**
+   * Second half: return the directory-initialized barrier when waiting, or
+   * detach it with a warning when the caller deferred the migration.
+   */
+  finishBegin(wait) {
+    const barrier = this.markDirectoriesInitialized();
+    if (wait) return barrier;
+    const describeDeferredFailure = (failure) => failure instanceof Error ? failure.message : failure;
+    void barrier.catch(describeDeferredFailureAndWarn);
+    function describeDeferredFailureAndWarn(failure) {
+      console.warn(`entity canonical-id migration deferred at startup failed: ${describeDeferredFailure(failure)}`);
+    }
+    return Promise.resolve();
+  }
   async markDirectoriesInitialized() {
     this.directoriesInitialized = true;
     await this.ensure();
@@ -3698,6 +2952,9 @@ var EntityCanonicalIdMigrationRunner = class {
     if (!this.directoriesInitialized) return Promise.resolve();
     return this.ensure();
   }
+  async drain() {
+    while (this.inFlight) await this.inFlight.catch(() => void 0);
+  }
   async runOrReuse() {
     let fingerprintAtStart = await this.readFingerprint();
     if (this.migrationComplete && fingerprintAtStart === this.completedFingerprint) return;
@@ -3754,7 +3011,7 @@ import {
   readFileSync,
   realpathSync
 } from "fs";
-import path8 from "path";
+import path7 from "path";
 function resolveSafeAliasRoots(baseDir, configDir) {
   let baseStat;
   try {
@@ -3781,8 +3038,8 @@ function resolveSafeAliasRoots(baseDir, configDir) {
   return memoryRoot;
 }
 function readEntityAliasConfigSync(baseDir) {
-  const configDir = path8.join(baseDir, "config");
-  const aliasPath = path8.join(configDir, "aliases.json");
+  const configDir = path7.join(baseDir, "config");
+  const aliasPath = path7.join(configDir, "aliases.json");
   let memoryRoot = resolveSafeAliasRoots(baseDir, configDir);
   if (memoryRoot === void 0) return void 0;
   let aliasPreflight;
@@ -3843,7 +3100,7 @@ function decodeYamlScalar(value) {
 }
 
 // src/orchestration/qmd-result-resolver.ts
-import path9 from "path";
+import path8 from "path";
 var INTERNAL_QMD_ROOTS = /* @__PURE__ */ new Set([
   ...ALL_CATEGORY_DIRS,
   "activity",
@@ -3865,7 +3122,7 @@ var INTERNAL_QMD_ROOTS = /* @__PURE__ */ new Set([
 ]);
 var PRIVATE_RESULT_RESOLUTION_CONCURRENCY = 16;
 function qmdCollectionPathParts(resultPath) {
-  if (!resultPath || path9.isAbsolute(resultPath)) return null;
+  if (!resultPath || path8.isAbsolute(resultPath)) return null;
   if (resultPath.trim().startsWith("qmd://")) {
     try {
       const parsed = new URL(resultPath.trim());
@@ -3890,9 +3147,9 @@ function qmdCollectionPathParts(resultPath) {
 }
 function qmdResultPathCandidates(storageDir, resultPath) {
   const candidates = /* @__PURE__ */ new Set();
-  const storageRoot = path9.resolve(storageDir);
+  const storageRoot = path8.resolve(storageDir);
   const addCandidate = (candidate) => {
-    const resolved = path9.resolve(candidate);
+    const resolved = path8.resolve(candidate);
     if (isPathInsideStorageRoot(storageRoot, resolved)) {
       candidates.add(resolved);
     }
@@ -3900,18 +3157,18 @@ function qmdResultPathCandidates(storageDir, resultPath) {
   const addRelativeCandidates = (relativePath) => {
     const normalized = relativePath.replace(/\\/g, "/").replace(/^\/+/, "");
     if (!normalized) return;
-    addCandidate(path9.join(storageRoot, normalized));
+    addCandidate(path8.join(storageRoot, normalized));
     if (/^\d{4}-\d{2}-\d{2}\//.test(normalized)) {
-      addCandidate(path9.join(storageRoot, "facts", normalized));
+      addCandidate(path8.join(storageRoot, "facts", normalized));
     }
   };
-  if (path9.isAbsolute(resultPath)) {
+  if (path8.isAbsolute(resultPath)) {
     addCandidate(resultPath);
-    const relative2 = path9.relative(storageRoot, path9.resolve(resultPath));
-    if (relative2 && !relative2.startsWith("..") && !path9.isAbsolute(relative2)) {
-      const normalized = relative2.split(path9.sep).join("/");
+    const relative2 = path8.relative(storageRoot, path8.resolve(resultPath));
+    if (relative2 && !relative2.startsWith("..") && !path8.isAbsolute(relative2)) {
+      const normalized = relative2.split(path8.sep).join("/");
       if (/^\d{4}-\d{2}-\d{2}\//.test(normalized)) {
-        addCandidate(path9.join(storageRoot, "facts", normalized));
+        addCandidate(path8.join(storageRoot, "facts", normalized));
       }
     }
   } else {
@@ -3947,7 +3204,7 @@ var QmdResultResolver = class {
       const seenStorageDirs = /* @__PURE__ */ new Set();
       const addStorage = (storage) => {
         const storageDir = storageDirOrNull(storage);
-        const storageKey = storageDir ? path9.resolve(storageDir) : `storage-without-dir-${storages.length}`;
+        const storageKey = storageDir ? path8.resolve(storageDir) : `storage-without-dir-${storages.length}`;
         if (seenStorageDirs.has(storageKey)) return;
         seenStorageDirs.add(storageKey);
         storages.push(storage);
@@ -3977,7 +3234,7 @@ var QmdResultResolver = class {
           continue;
         }
         try {
-          const coldRoot = path9.join(storageDir, "cold");
+          const coldRoot = path8.join(storageDir, "cold");
           for (const candidate of qmdResultPathCandidates(coldRoot, parts.relativePath)) {
             const memory = await storage.readMemoryByPath(candidate);
             if (memory) return memory;
@@ -4027,9 +3284,9 @@ var QmdResultResolver = class {
           error: err.message
         });
       }
-      if (!path9.isAbsolute(fallbackResultPath)) return null;
+      if (!path8.isAbsolute(fallbackResultPath)) return null;
     }
-    if (path9.isAbsolute(fallbackResultPath)) {
+    if (path8.isAbsolute(fallbackResultPath)) {
       if (!fallbackStorageDir) {
         return await fallbackStorage.readMemoryByPath(fallbackResultPath);
       }
@@ -4086,17 +3343,17 @@ var QmdResultResolver = class {
     if (!memory && parts && !collectionIsKnownInternal && !collectionIsConfigured) {
       memory = await this.readQmdResultMemory(parts.relativePath, fallbackStorage, namespaces, result.namespace);
     }
-    const absoluteInsideMemoryRoot = path9.isAbsolute(result.path) && isPathInsideStorageRoot(path9.resolve(config.memoryDir), path9.resolve(result.path));
+    const absoluteInsideMemoryRoot = path8.isAbsolute(result.path) && isPathInsideStorageRoot(path8.resolve(config.memoryDir), path8.resolve(result.path));
     const hasExplicitQmdCollection = result.path.trim().startsWith("qmd://");
     const unresolvedInternalPath = !memory && (absoluteInsideMemoryRoot || collectionIsKnownInternal && (!preserveUnresolved || hasExplicitQmdCollection) || hasExplicitQmdCollection && collectionIsConfigured);
-    const unresolvedExternalCollection = !memory && (parts !== null && !collectionIsKnownInternal && !collectionIsConfigured || path9.isAbsolute(result.path) && !isPathInsideStorageRoot(path9.resolve(config.memoryDir), path9.resolve(result.path)));
+    const unresolvedExternalCollection = !memory && (parts !== null && !collectionIsKnownInternal && !collectionIsConfigured || path8.isAbsolute(result.path) && !isPathInsideStorageRoot(path8.resolve(config.memoryDir), path8.resolve(result.path)));
     return memory !== null && !isSupportPassportPrivateMemory(memory) || !memory && !unresolvedInternalPath && (preserveUnresolved || unresolvedExternalCollection);
   }
   async resolveColdQmdResultForRecall(result, fallbackStorage, recallNamespaces = []) {
     const memory = await this.readQmdResultMemory(result.path, fallbackStorage, recallNamespaces, result.namespace);
     if (!memory) return null;
     let ownerNamespace = null;
-    if (path9.isAbsolute(memory.path)) {
+    if (path8.isAbsolute(memory.path)) {
       const ownerStorage = await this.storageForAbsoluteQmdResultPath(memory.path, fallbackStorage, recallNamespaces);
       ownerNamespace = ownerStorage?.namespace ?? null;
       if (!ownerNamespace && resolveNamespaceCapabilities(this.getConfig()).namespaces) return null;
@@ -4117,17 +3374,17 @@ var QmdResultResolver = class {
     };
   }
   async storageForAbsoluteQmdResultPath(resultPath, fallbackStorage, recallNamespaces = []) {
-    const resolvedPath = path9.resolve(resultPath);
+    const resolvedPath = path8.resolve(resultPath);
     const config = this.getConfig();
-    const memoryRoot = path9.resolve(config.memoryDir);
-    const namespacesRoot = path9.join(memoryRoot, "namespaces");
+    const memoryRoot = path8.resolve(config.memoryDir);
+    const namespacesRoot = path8.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 = path9.resolve(storageDir);
+      const candidateRoot = path8.resolve(storageDir);
       if (seenDirs.has(candidateRoot)) return;
       if (!isPathInsideStorageRoot(candidateRoot, resolvedPath)) return;
       if (candidateRoot === memoryRoot && isPathInsideStorageRoot(namespacesRoot, resolvedPath)) {
@@ -4145,7 +3402,7 @@ var QmdResultResolver = class {
       candidateNamespaces.add(ns);
     }
     if (isPathInsideStorageRoot(namespacesRoot, resolvedPath)) {
-      const relativeToNamespaces = path9.relative(namespacesRoot, resolvedPath);
+      const relativeToNamespaces = path8.relative(namespacesRoot, resolvedPath);
       const [namespaceSegment] = relativeToNamespaces.split(/[\\/]/);
       if (namespaceSegment) {
         candidateNamespaces.add(namespaceIdentityFromToken(namespaceSegment) ?? namespaceSegment);
@@ -4702,7 +3959,7 @@ function collectSpeakers(tagged) {
 }
 
 // src/wearables/fusion/fuse.ts
-import { createHash as createHash2 } from "crypto";
+import { createHash } from "crypto";
 var FUSION_ID_PREFIX = "fusion";
 var FUSION_ALGO_VERSION = "2026-07-12-1";
 function canonicalInputsKey(date, inputs) {
@@ -4731,7 +3988,7 @@ function canonicalInputsKey(date, inputs) {
       ])
     ])
   ];
-  return createHash2("sha256").update(JSON.stringify(record), "utf-8").digest("hex");
+  return createHash("sha256").update(JSON.stringify(record), "utf-8").digest("hex");
 }
 function configFingerprint(options, sources) {
   const proximityGapMs = options.proximityGapMs ?? DEFAULT_PROXIMITY_GAP_MS;
@@ -4746,7 +4003,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 createHash("sha256").update(inputsKey).update("\n").update(fingerprint).update("\n").update(algoVersion).digest("hex");
 }
 function buildProvenance(cluster, proximityGapMs, windowToleranceMs) {
   return {
@@ -4806,11 +4063,11 @@ function fuseDay(date, inputs, options = {}) {
 }
 
 // src/wearables/fusion/store.ts
-import { createHash as createHash3 } from "crypto";
-import * as path10 from "path";
+import { createHash as createHash2 } from "crypto";
+import * as path9 from "path";
 var FUSION_KIND = "wearable-fusion";
 function hashFusionBody(conversations) {
-  return createHash3("sha256").update(JSON.stringify(conversations), "utf-8").digest("hex");
+  return createHash2("sha256").update(JSON.stringify(conversations), "utf-8").digest("hex");
 }
 function composeFusionDayMeta(date, conversations, sources, contentHash, fusedAt) {
   return {
@@ -4994,7 +4251,7 @@ var FusionArtifactStore = class {
         `invalid wearable fusion date '${String(date)}' \u2014 expected YYYY-MM-DD`
       );
     }
-    return path10.join(this.wearablesDir, FUSION_DIR_NAME, `${date}.md`);
+    return path9.join(this.wearablesDir, FUSION_DIR_NAME, `${date}.md`);
   }
   async writeFusedDay(date, serialized) {
     const filePath = this.fusedDayPath(date);
@@ -5031,7 +4288,7 @@ var FusionArtifactStore = class {
   }
   /** List dates with stored fused artifacts, newest first. */
   async listFusedDays() {
-    const fusionDir = path10.join(this.wearablesDir, FUSION_DIR_NAME);
+    const fusionDir = path9.join(this.wearablesDir, FUSION_DIR_NAME);
     await this.assertPathContained(fusionDir);
     let entries;
     try {
@@ -5075,10 +4332,10 @@ var FusionArtifactStore = class {
     try {
       rootReal = await this.io.realpath(this.memoryDir);
     } catch {
-      rootReal = path10.resolve(this.memoryDir);
+      rootReal = path9.resolve(this.memoryDir);
     }
     await this.assertNoEscape(rootReal, this.wearablesDir);
-    await this.assertNoEscape(rootReal, path10.dirname(targetPath));
+    await this.assertNoEscape(rootReal, path9.dirname(targetPath));
     await this.assertNoEscape(rootReal, targetPath);
     await this.assertFusionDirNotSymlinked();
   }
@@ -5092,7 +4349,7 @@ var FusionArtifactStore = class {
    * (a fresh write creates a real directory lexically under the root).
    */
   async assertFusionDirNotSymlinked() {
-    const fusionDir = path10.join(this.wearablesDir, FUSION_DIR_NAME);
+    const fusionDir = path9.join(this.wearablesDir, FUSION_DIR_NAME);
     let stat4;
     try {
       stat4 = await this.io.lstat(fusionDir);
@@ -5227,8 +4484,8 @@ function reconstructFusionInputs(date, dayTranscripts) {
 }
 
 // src/meetings/store.ts
-import { createHash as createHash4 } from "crypto";
-import * as path11 from "path";
+import { createHash as createHash3 } from "crypto";
+import * as path10 from "path";
 var MEETINGS_DIR_NAME = "meetings";
 var MEETING_KIND = "meeting";
 var MEETING_FORMAT_VERSION = 1;
@@ -5258,7 +4515,7 @@ function canonicalContent(base, fused) {
   });
 }
 function composeMeetingRecord(base, fused) {
-  const contentHash = createHash4("sha256").update(canonicalContent(base, fused), "utf-8").digest("hex");
+  const contentHash = createHash3("sha256").update(canonicalContent(base, fused), "utf-8").digest("hex");
   return {
     ...base,
     ...fused,
@@ -5397,7 +4654,7 @@ var MeetingRecordStore = class {
   constructor(memoryDir, io) {
     this.memoryDir = memoryDir;
     this.io = io;
-    this.meetingsDir = path11.join(memoryDir, MEETINGS_DIR_NAME);
+    this.meetingsDir = path10.join(memoryDir, MEETINGS_DIR_NAME);
   }
   memoryDir;
   io;
@@ -5413,7 +4670,7 @@ var MeetingRecordStore = class {
     if (idDate !== date) {
       throw new Error(`meeting id '${id}' does not belong to date '${date}'`);
     }
-    return path11.join(this.meetingsDir, date, `${id}.md`);
+    return path10.join(this.meetingsDir, date, `${id}.md`);
   }
   /** Idempotently persist a record: skip the write when contentHash is unchanged. */
   async saveMeetingRecord(record) {
@@ -5444,7 +4701,7 @@ var MeetingRecordStore = class {
     if (!isValidTranscriptDate(date)) {
       throw new Error(`invalid meeting date '${String(date)}' \u2014 expected YYYY-MM-DD`);
     }
-    const dayDir = path11.join(this.meetingsDir, date);
+    const dayDir = path10.join(this.meetingsDir, date);
     await this.assertPathContained(dayDir);
     let entries;
     try {
@@ -5512,10 +4769,10 @@ var MeetingRecordStore = class {
     try {
       rootReal = await this.io.realpath(this.memoryDir);
     } catch {
-      rootReal = path11.resolve(this.memoryDir);
+      rootReal = path10.resolve(this.memoryDir);
     }
     await this.assertNoEscape(rootReal, this.meetingsDir);
-    await this.assertNoEscape(rootReal, path11.dirname(targetPath));
+    await this.assertNoEscape(rootReal, path10.dirname(targetPath));
     await this.assertNoEscape(rootReal, targetPath);
     await this.assertNotSymlink(this.meetingsDir, "directory");
     const dayDir = this.dayDirWithin(targetPath);
@@ -5525,11 +4782,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 = path11.relative(this.meetingsDir, targetPath);
-    if (rel === "" || rel.startsWith("..") || path11.isAbsolute(rel)) return null;
-    const first = rel.split(path11.sep)[0];
+    const rel = path10.relative(this.meetingsDir, targetPath);
+    if (rel === "" || rel.startsWith("..") || path10.isAbsolute(rel)) return null;
+    const first = rel.split(path10.sep)[0];
     if (first === void 0 || first.length === 0) return null;
-    return path11.join(this.meetingsDir, first);
+    return path10.join(this.meetingsDir, first);
   }
   async assertNotSymlink(target, kind) {
     let stat4;
@@ -5540,7 +4797,7 @@ var MeetingRecordStore = class {
       throw err;
     }
     if (stat4.isSymbolicLink) {
-      const label = path11.relative(this.memoryDir, target) || MEETINGS_DIR_NAME;
+      const label = path10.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)`
       );
@@ -5563,12 +4820,12 @@ var MeetingRecordStore = class {
 var SORT_STR = (a, b) => a < b ? -1 : a > b ? 1 : 0;
 
 // src/storage/supersession-audit.ts
-import { readdir as readdir5 } from "fs/promises";
-import path12 from "path";
+import { readdir as readdir4 } from "fs/promises";
+import path11 from "path";
 async function hasSupersessionAudit(lookup, oldMemoryId, newMemoryId, auditBody, structuredAttributes) {
   let entries;
   try {
-    entries = await readdir5(lookup.correctionsDir, { withFileTypes: true });
+    entries = await readdir4(lookup.correctionsDir, { withFileTypes: true });
   } catch (error) {
     if (isErrnoCode(error, "ENOENT")) return false;
     throw error;
@@ -5576,7 +4833,7 @@ async function hasSupersessionAudit(lookup, oldMemoryId, newMemoryId, auditBody,
   for (const entry of entries) {
     if (isMacOsReplicationJunkBasename(entry.name)) continue;
     if (!entry.isFile() || !entry.name.endsWith(".md")) continue;
-    const memory = await lookup.readMemoryByPath(path12.join(lookup.correctionsDir, entry.name));
+    const memory = await lookup.readMemoryByPath(path11.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) && stripAttributesSuffix(memory.content) === auditBody && (structuredAttributes === void 0 || Object.entries(structuredAttributes).every(
       ([key, value]) => memory.frontmatter.structuredAttributes?.[key] === value
     ))) {
@@ -5666,7 +4923,7 @@ Reason: ${reason}`;
 }
 
 // src/storage/entity-timeline.ts
-import { createHash as createHash5 } from "crypto";
+import { createHash as createHash4 } from "crypto";
 var ENTITY_TIMELINE_METADATA_MARKER = "remnic-meta-v1";
 function parseEntityTimelineBullet(bullet, fallbackTimestamp) {
   const trimmed = bullet.trim();
@@ -6108,7 +5365,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 createHash4("sha256").update(JSON.stringify(normalizedSections)).digest("hex");
 }
 function isEntitySynthesisStale(entity) {
   const structuredFactCount = countEntityStructuredFacts(entity);
@@ -6665,17 +5922,17 @@ function inferEntityTypeFromContent(content) {
 }
 var KNOWN_ENTITY_FILENAME_PREFIXES = /* @__PURE__ */ new Set(["company", "other", "person", "place", "project", "tool", "topic"]);
 function inferEntityTypeFromFilename(pathRel) {
-  const basename = path13.basename(pathRel, ".md").toLowerCase();
+  const basename = path12.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(path13.sep).join("/");
+  const normalizedPath = pathRel.split(path12.sep).join("/");
   let normalizedFrontmatter = frontmatter;
   if (normalizedPath === "entities" || normalizedPath.startsWith("entities/") || normalizedPath.includes("/entities/")) {
-    const basename = path13.basename(pathRel, ".md");
+    const basename = path12.basename(pathRel, ".md");
     const inferredType = inferEntityTypeFromContent(content) || inferEntityTypeFromFilename(pathRel) || "entity";
     const existingTags = Array.isArray(frontmatter.tags) ? frontmatter.tags : [];
     normalizedFrontmatter = {
@@ -7148,9 +6405,9 @@ var StorageManager3 = class _StorageManager extends TombstoneBlockedCaptureIndex
     this.entitySchemas = entitySchemas;
     this.deletionRevisionStore = new DeletionRevisionStore({
       baseDir,
-      deletionRevisionMetadataPath: path13.join(baseDir, ".offline-sync", "deletion-revisions.v1.json"),
-      invalidationCommitMetadataPath: path13.join(baseDir, ".offline-sync", "invalidation-commits.v1.json"),
-      deletionRevisionLockPath: path13.join(baseDir, ".offline-sync", "deletion-revisions.v1.json.lock"),
+      deletionRevisionMetadataPath: path12.join(baseDir, ".offline-sync", "deletion-revisions.v1.json"),
+      invalidationCommitMetadataPath: path12.join(baseDir, ".offline-sync", "invalidation-commits.v1.json"),
+      deletionRevisionLockPath: path12.join(baseDir, ".offline-sync", "deletion-revisions.v1.json.lock"),
       assertManagedStoragePath: (filePath, method) => this.assertManagedStoragePath(filePath, method)
     });
     this.casRevisions = new CasRevisionHost(baseDir);
@@ -7336,8 +6593,8 @@ var StorageManager3 = class _StorageManager extends TombstoneBlockedCaptureIndex
   }
   /** Whether `filePath` resolves to `stateDir` itself or a path contained in it. */
   isStateFilePath(filePath) {
-    const rel = path13.relative(this.stateDir, path13.resolve(filePath));
-    return rel === "" || !rel.startsWith("..") && !path13.isAbsolute(rel);
+    const rel = path12.relative(this.stateDir, path12.resolve(filePath));
+    return rel === "" || !rel.startsWith("..") && !path12.isAbsolute(rel);
   }
   // ── Tombstone store (issue #1579) ───────────────────────────────────────
   // Instance-scoped (rule 11) + namespace-scoped (rule 42) tombstone index.
@@ -7452,8 +6709,8 @@ var StorageManager3 = class _StorageManager extends TombstoneBlockedCaptureIndex
    * /srv/cold/remnic), skipping the patch and stranding a stale hot entry.
    */
   isColdOrArchiveTierPath(p) {
-    const rel = path13.relative(this.baseDir, p);
-    return rel === "cold" || rel === "archive" || rel.startsWith(`cold${path13.sep}`) || rel.startsWith(`archive${path13.sep}`);
+    const rel = path12.relative(this.baseDir, p);
+    return rel === "cold" || rel === "archive" || rel.startsWith(`cold${path12.sep}`) || rel.startsWith(`archive${path12.sep}`);
   }
   /**
    * Mark the secure-store as required for this storage instance.
@@ -7540,7 +6797,7 @@ var StorageManager3 = class _StorageManager extends TombstoneBlockedCaptureIndex
         void 0,
         this.baseDir
       );
-      const rel = path13.relative(this.baseDir, filePath).split(path13.sep).join("/");
+      const rel = path12.relative(this.baseDir, filePath).split(path12.sep).join("/");
       return `${rel}:${version.versionId}`;
     } catch (err) {
       log.warn(
@@ -7585,10 +6842,10 @@ var StorageManager3 = class _StorageManager extends TombstoneBlockedCaptureIndex
     _StorageManager.okfConformanceByDir.set(memoryDir, enabled !== false);
   }
   okfConformanceEnabled() {
-    for (let dir = this.baseDir; ; dir = path13.dirname(dir)) {
+    for (let dir = this.baseDir; ; dir = path12.dirname(dir)) {
       const registered = _StorageManager.okfConformanceByDir.get(dir);
       if (registered !== void 0) return registered;
-      if (dir === path13.dirname(dir)) return true;
+      if (dir === path12.dirname(dir)) return true;
     }
   }
   /**
@@ -7615,10 +6872,7 @@ var StorageManager3 = class _StorageManager extends TombstoneBlockedCaptureIndex
   /** EntityStore (storage.ts decomposition). Lazy; selfDeps live wiring. */
   _entityStore;
   get entityStore() {
-    if (!this._entityStore) {
-      this._entityStore = new EntityStore(selfDeps(this));
-    }
-    return this._entityStore;
+    return this._entityStore ??= new EntityStore(selfDeps(this));
   }
   /** IdentityContinuityStore (storage.ts decomposition). Lazy; selfDeps live wiring. */
   _identityContinuityStore;
@@ -7635,12 +6889,12 @@ var StorageManager3 = class _StorageManager extends TombstoneBlockedCaptureIndex
   }
   identityFilePath(workspaceDir, namespace) {
     const rawNamespace = typeof namespace === "string" ? namespace.trim() : "";
-    if (!rawNamespace) return path13.join(workspaceDir, "IDENTITY.md");
+    if (!rawNamespace) return path12.join(workspaceDir, "IDENTITY.md");
     const safeNamespace = rawNamespace.replace(/[^a-zA-Z0-9._-]/g, "-");
-    return path13.join(workspaceDir, `IDENTITY.${safeNamespace}.md`);
+    return path12.join(workspaceDir, `IDENTITY.${safeNamespace}.md`);
   }
   versionFilePath(kind) {
-    return path13.join(this.stateDir, `.${kind}-version.log`);
+    return path12.join(this.stateDir, `.${kind}-version.log`);
   }
   bumpSharedVersion(kind, fallbackMap) {
     const filePath = this.versionFilePath(kind);
@@ -7747,7 +7001,7 @@ var StorageManager3 = class _StorageManager extends TombstoneBlockedCaptureIndex
   // memories.
   // -------------------------------------------------------------------------
   get wearablesDir() {
-    return path13.join(this.baseDir, WEARABLES_DIR_NAME);
+    return path12.join(this.baseDir, WEARABLES_DIR_NAME);
   }
   /**
    * Resolve the on-disk path for a source/day transcript. Throws on
@@ -7763,7 +7017,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 path13.join(this.wearablesDir, sourceId, `${date}.md`);
+    return path12.join(this.wearablesDir, sourceId, `${date}.md`);
   }
   async writeWearableDayTranscript(sourceId, date, serialized) {
     const targetPath = this.wearableTranscriptPath(sourceId, date);
@@ -7789,10 +7043,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) => readdir6(d),
-      deleteFile: (p) => unlink4(p),
-      realpath: (p) => realpath4(p),
-      lstat: (p) => lstat4(p).then((st) => ({ isSymbolicLink: st.isSymbolicLink() }))
+      readDir: (d) => readdir5(d),
+      deleteFile: (p) => unlink3(p),
+      realpath: (p) => realpath3(p),
+      lstat: (p) => lstat3(p).then((st) => ({ isSymbolicLink: st.isSymbolicLink() }))
     });
   }
   _meetingRecordStore;
@@ -7807,10 +7061,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) => readdir6(d),
-      deleteFile: (p) => unlink4(p),
-      realpath: (p) => realpath4(p),
-      lstat: (p) => lstat4(p).then((st) => ({ isSymbolicLink: st.isSymbolicLink() }))
+      readDir: (d) => readdir5(d),
+      deleteFile: (p) => unlink3(p),
+      realpath: (p) => realpath3(p),
+      lstat: (p) => lstat3(p).then((st) => ({ isSymbolicLink: st.isSymbolicLink() }))
     });
   }
   /**
@@ -7877,25 +7131,25 @@ var StorageManager3 = class _StorageManager extends TombstoneBlockedCaptureIndex
     });
   }
   get factsDir() {
-    return path13.join(this.baseDir, "facts");
+    return path12.join(this.baseDir, "facts");
   }
   get correctionsDir() {
-    return path13.join(this.baseDir, "corrections");
+    return path12.join(this.baseDir, "corrections");
   }
   get proceduresDir() {
-    return path13.join(this.baseDir, "procedures");
+    return path12.join(this.baseDir, "procedures");
   }
   get reasoningTracesDir() {
-    return path13.join(this.baseDir, "reasoning-traces");
+    return path12.join(this.baseDir, "reasoning-traces");
   }
   get entitiesDir() {
-    return path13.join(this.baseDir, "entities");
+    return path12.join(this.baseDir, "entities");
   }
   resolveEntityFilePath(name) {
     if (typeof name !== "string") return null;
-    const filePath = path13.resolve(this.entitiesDir, `${name}.md`);
-    const relative2 = path13.relative(this.entitiesDir, filePath);
-    if (relative2 === "" || relative2.startsWith("..") || path13.isAbsolute(relative2)) {
+    const filePath = path12.resolve(this.entitiesDir, `${name}.md`);
+    const relative2 = path12.relative(this.entitiesDir, filePath);
+    if (relative2 === "" || relative2.startsWith("..") || path12.isAbsolute(relative2)) {
       return null;
     }
     return filePath;
@@ -7906,7 +7160,7 @@ var StorageManager3 = class _StorageManager extends TombstoneBlockedCaptureIndex
   async readDependencyPropagationQueueFile(filePath) {
     const target = await resolveSafeStoragePath(
       this.baseDir,
-      path13.relative(
+      path12.relative(
         this.baseDir,
         this.assertManagedStoragePath(filePath, "storage.readDependencyPropagationQueueFile")
       )
@@ -7916,7 +7170,7 @@ var StorageManager3 = class _StorageManager extends TombstoneBlockedCaptureIndex
   async writeDependencyPropagationQueueFile(filePath, content) {
     const target = await resolveSafeStoragePath(
       this.baseDir,
-      path13.relative(
+      path12.relative(
         this.baseDir,
         this.assertManagedStoragePath(filePath, "storage.writeDependencyPropagationQueueFile")
       )
@@ -7931,10 +7185,10 @@ var StorageManager3 = class _StorageManager extends TombstoneBlockedCaptureIndex
     });
   }
   assertManagedStoragePath(filePath, method) {
-    const resolved = path13.resolve(filePath);
-    const base = path13.resolve(this.baseDir);
-    const rel = path13.relative(base, resolved);
-    if (rel === "" || rel === ".." || rel.startsWith(`..${path13.sep}`) || path13.isAbsolute(rel)) {
+    const resolved = path12.resolve(filePath);
+    const base = path12.resolve(this.baseDir);
+    const rel = path12.relative(base, resolved);
+    if (rel === "" || rel === ".." || rel.startsWith(`..${path12.sep}`) || path12.isAbsolute(rel)) {
       throw new Error(`${method}: file path escapes memory dir`);
     }
     return resolved;
@@ -7971,7 +7225,7 @@ var StorageManager3 = class _StorageManager extends TombstoneBlockedCaptureIndex
   async digestOfflineSyncFile(filePath) {
     const target = this.assertManagedStoragePath(filePath, "storage.digestOfflineSyncFile");
     const st = await stat3(target);
-    const relPath = path13.relative(this.baseDir, target).split(path13.sep).join("/");
+    const relPath = path12.relative(this.baseDir, target).split(path12.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) {
@@ -7985,11 +7239,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: createHash5("sha256").update(content).digest("hex"),
         bytes: content.byteLength
       };
     } else {
-      const hash = createHash6("sha256");
+      const hash = createHash5("sha256");
       let bytes = 0;
       for await (const rawChunk of createReadStream(target)) {
         const chunk = Buffer.isBuffer(rawChunk) ? rawChunk : Buffer.from(rawChunk);
@@ -8017,7 +7271,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 readFile(this.offlineSyncDigestCachePath, "utf-8");
       return parseOfflineSyncDigestCache(raw);
     } catch (err) {
       if (!isErrnoCode(err, "ENOENT")) {
@@ -8056,8 +7310,8 @@ 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(path13.dirname(this.offlineSyncDigestCachePath), { recursive: true });
-      await writeFile2(this.offlineSyncDigestCachePath, `${JSON.stringify({ version: 1, entries })}
+      await mkdir(path12.dirname(this.offlineSyncDigestCachePath), { recursive: true });
+      await writeFile(this.offlineSyncDigestCachePath, `${JSON.stringify({ version: 1, entries })}
 `, "utf-8");
     }).catch((err) => {
       log.warn(
@@ -8157,7 +7411,7 @@ var StorageManager3 = class _StorageManager extends TombstoneBlockedCaptureIndex
   }
   async appendStorageSecureFileUnlocked(filePath, content) {
     const writeKey = this.resolveWriteKey();
-    await mkdir(path13.dirname(filePath), { recursive: true });
+    await mkdir(path12.dirname(filePath), { recursive: true });
     if (writeKey === null) {
       try {
         if (await this.isEncryptedFileHeader(filePath)) {
@@ -8183,13 +7437,13 @@ var StorageManager3 = class _StorageManager extends TombstoneBlockedCaptureIndex
     this.notifyCatalogWriteForPath(filePath);
   }
   get stateDir() {
-    return path13.join(this.baseDir, "state");
+    return path12.join(this.baseDir, "state");
   }
   get offlineSyncDigestCachePath() {
-    return path13.join(this.baseDir, ".offline-sync", "digest-cache.v1.json");
+    return path12.join(this.baseDir, ".offline-sync", "digest-cache.v1.json");
   }
   get entitySynthesisQueuePath() {
-    return path13.join(this.stateDir, "entity-synthesis-queue.json");
+    return path12.join(this.stateDir, "entity-synthesis-queue.json");
   }
   // ── Tombstone store access (issue #1579) ─────────────────────────────────
   /**
@@ -8199,7 +7453,7 @@ var StorageManager3 = class _StorageManager extends TombstoneBlockedCaptureIndex
    * helpers are injected into the store).
    */
   get tombstonesPath() {
-    return path13.join(this.stateDir, "tombstones.jsonl");
+    return path12.join(this.stateDir, "tombstones.jsonl");
   }
   /**
    * Configure the tombstone invariant for this storage instance. Installed
@@ -8512,55 +7766,55 @@ var StorageManager3 = class _StorageManager extends TombstoneBlockedCaptureIndex
     return legacyMatches.length > 0 ? [...new Set(legacyMatches.map((content) => ContentHashIndex.computeHash(content)))] : [persistedHash];
   }
   get questionsDir() {
-    return path13.join(this.baseDir, "questions");
+    return path12.join(this.baseDir, "questions");
   }
   get artifactsDir() {
-    return path13.join(this.baseDir, "artifacts");
+    return path12.join(this.baseDir, "artifacts");
   }
   get identityDir() {
-    return path13.join(this.baseDir, "identity");
+    return path12.join(this.baseDir, "identity");
   }
   get identityAnchorPath() {
-    return path13.join(this.identityDir, "identity-anchor.md");
+    return path12.join(this.identityDir, "identity-anchor.md");
   }
   get identityIncidentsDir() {
-    return path13.join(this.identityDir, "incidents");
+    return path12.join(this.identityDir, "incidents");
   }
   get identityAuditsWeeklyDir() {
-    return path13.join(this.identityDir, "audits", "weekly");
+    return path12.join(this.identityDir, "audits", "weekly");
   }
   get identityAuditsMonthlyDir() {
-    return path13.join(this.identityDir, "audits", "monthly");
+    return path12.join(this.identityDir, "audits", "monthly");
   }
   get identityImprovementLoopsPath() {
-    return path13.join(this.identityDir, "improvement-loops.md");
+    return path12.join(this.identityDir, "improvement-loops.md");
   }
   get identityReflectionsPath() {
-    return path13.join(this.identityDir, "reflections.md");
+    return path12.join(this.identityDir, "reflections.md");
   }
   get profilePath() {
-    return path13.join(this.baseDir, "profile.md");
+    return path12.join(this.baseDir, "profile.md");
   }
   get memoryActionsPath() {
-    return path13.join(this.stateDir, "memory-actions.jsonl");
+    return path12.join(this.stateDir, "memory-actions.jsonl");
   }
   get memoryLifecycleLedgerPath() {
-    return path13.join(this.stateDir, "memory-lifecycle-ledger.jsonl");
+    return path12.join(this.stateDir, "memory-lifecycle-ledger.jsonl");
   }
   get compressionGuidelinesPath() {
-    return path13.join(this.stateDir, "compression-guidelines.md");
+    return path12.join(this.stateDir, "compression-guidelines.md");
   }
   get compressionGuidelineDraftPath() {
-    return path13.join(this.stateDir, "compression-guidelines.draft.md");
+    return path12.join(this.stateDir, "compression-guidelines.draft.md");
   }
   get compressionGuidelineStatePath() {
-    return path13.join(this.stateDir, "compression-guideline-state.json");
+    return path12.join(this.stateDir, "compression-guideline-state.json");
   }
   get compressionGuidelineDraftStatePath() {
-    return path13.join(this.stateDir, "compression-guideline-draft-state.json");
+    return path12.join(this.stateDir, "compression-guideline-draft-state.json");
   }
   get behaviorSignalsPath() {
-    return path13.join(this.stateDir, "behavior-signals.jsonl");
+    return path12.join(this.stateDir, "behavior-signals.jsonl");
   }
   /**
    * In-memory dedup key set for behavior-signals appends (issue #1909),
@@ -8592,7 +7846,7 @@ var StorageManager3 = class _StorageManager extends TombstoneBlockedCaptureIndex
    * governance sweeps can treat it uniformly.
    */
   get bufferSurpriseLedgerPath() {
-    return path13.join(this.stateDir, "buffer-surprise-ledger.jsonl");
+    return path12.join(this.stateDir, "buffer-surprise-ledger.jsonl");
   }
   /**
    * Entity alias table loaded from THIS store's config/aliases.json.
@@ -8606,6 +7860,14 @@ var StorageManager3 = class _StorageManager extends TombstoneBlockedCaptureIndex
   currentHistoricalIds() {
     return this.historicalEntityCanonicalIds.get(this.stateDir);
   }
+  /** Journal completion for EntityStore's legacy-id retry gate (live view). */
+  entityCanonicalMigrationComplete = memoizedJournalCompletion(this.historicalEntityCanonicalIds, () => this.stateDir);
+  normalizeEntityName(raw, type) {
+    return resolveHistoricalEntityCanonicalId(
+      this.entityStore.normalizeEntityName(raw, type),
+      this.currentHistoricalIds()
+    );
+  }
   /** Post-persist repair subsystem (issue #2213) — storage/entity-ref-repair.ts. */
   _entityRefRepair;
   get entityRefRepair() {
@@ -8629,12 +7891,6 @@ var StorageManager3 = class _StorageManager extends TombstoneBlockedCaptureIndex
     () => this.runLegacyEntityCanonicalIdMigration(),
     () => getFingerprint(this.baseDir, this.entitiesDir, () => String(this.getEntityMutationVersion()))
   );
-  normalizeEntityName(raw, type) {
-    return resolveHistoricalEntityCanonicalId(
-      this.entityStore.normalizeEntityName(raw, type),
-      this.currentHistoricalIds()
-    );
-  }
   /**
    * Read-only view of this store's user alias table, for call sites that
    * normalize outside the manager (pass it to the free `normalizeEntityName`).
@@ -8653,7 +7909,7 @@ var StorageManager3 = class _StorageManager extends TombstoneBlockedCaptureIndex
     this.loadAliasesSync();
   }
   loadAliasesSync() {
-    const aliasPath = path13.join(this.baseDir, "config", "aliases.json");
+    const aliasPath = path12.join(this.baseDir, "config", "aliases.json");
     this.userAliases = {};
     const raw = readEntityAliasConfigSync(this.baseDir);
     if (raw === void 0) return;
@@ -8687,13 +7943,13 @@ var StorageManager3 = class _StorageManager extends TombstoneBlockedCaptureIndex
     );
     return completionFingerprint;
   }
-  async ensureDirectories() {
+  async ensureDirectories(options = {}) {
     await mkdir(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(path13.join(this.factsDir, today), { recursive: true });
-    await mkdir(path13.join(this.proceduresDir, today), { recursive: true });
-    await mkdir(path13.join(this.reasoningTracesDir, today), { recursive: true });
+    await mkdir(path12.join(this.factsDir, today), { recursive: true });
+    await mkdir(path12.join(this.proceduresDir, today), { recursive: true });
+    await mkdir(path12.join(this.reasoningTracesDir, today), { recursive: true });
     await mkdir(this.correctionsDir, { recursive: true });
     await mkdir(this.entitiesDir, { recursive: true });
     await mkdir(this.stateDir, { recursive: true });
@@ -8703,13 +7959,14 @@ var StorageManager3 = class _StorageManager extends TombstoneBlockedCaptureIndex
     await mkdir(this.identityIncidentsDir, { recursive: true });
     await mkdir(this.identityAuditsWeeklyDir, { recursive: true });
     await mkdir(this.identityAuditsMonthlyDir, { recursive: true });
-    await mkdir(path13.join(this.baseDir, "config"), { recursive: true });
-    await this.entityCanonicalIdMigration.ensure();
+    await mkdir(path12.join(this.baseDir, "config"), { recursive: true });
+    await this.entityCanonicalIdMigration.begin(options.waitForEntityMigration !== false, this.entitiesDir);
     if (this.hotMemoriesCacheEnabled && this.getMemoryCorpusVersion() === 0) {
       this.bumpMemoryCorpusVersion();
     }
-    await this.entityCanonicalIdMigration.markDirectoriesInitialized();
+    return this.entityCanonicalIdMigration.finishBegin(options.waitForEntityMigration !== false);
   }
+  drainEntityCanonicalIdMigration = () => this.entityCanonicalIdMigration.drain();
   /**
    * Resolve the on-disk write path for a memory of the given category, creating
    * the target directory. Category routing goes through the shared
@@ -8725,11 +7982,11 @@ var StorageManager3 = class _StorageManager extends TombstoneBlockedCaptureIndex
   async resolveCategoryWritePath(category, id, today) {
     if (category === "correction") {
       await mkdir(this.correctionsDir, { recursive: true });
-      return path13.join(this.correctionsDir, `${id}.md`);
+      return path12.join(this.correctionsDir, `${id}.md`);
     }
-    const datedDir = path13.join(getCategoryDir(this.baseDir, category), today);
+    const datedDir = path12.join(getCategoryDir(this.baseDir, category), today);
     await mkdir(datedDir, { recursive: true });
-    return path13.join(datedDir, `${id}.md`);
+    return path12.join(datedDir, `${id}.md`);
   }
   async findExistingTombstoneBlockedMemory(content, category, sourceConnector) {
     const identity = buildExplicitCaptureDedupKey(content, category, sourceConnector);
@@ -8900,7 +8157,7 @@ ${sanitized.text}
             }
           });
         } catch (err) {
-          await unlink4(filePath).catch(() => void 0);
+          await unlink3(filePath).catch(() => void 0);
           this.invalidateAllMemoriesCache();
           await this.rebuildTombstoneBlockedCaptureAfterInvalidationForPath(filePath);
           throw err;
@@ -9108,7 +8365,7 @@ ${sanitized.text}
     await this.ensureDirectories();
     const now = /* @__PURE__ */ new Date();
     const day = now.toISOString().slice(0, 10);
-    const dir = path13.join(this.artifactsDir, day);
+    const dir = path12.join(this.artifactsDir, day);
     await mkdir(dir, { recursive: true });
     const id = `artifact-${Date.now()}-${Math.random().toString(36).slice(2, 6)}`;
     const fm = {
@@ -9135,7 +8392,7 @@ ${sanitized.text}
       log.warn(`artifact content rejected for ${id}; violations=${sanitized.violations.join(", ")}`);
       return "";
     }
-    const filePath = path13.join(dir, `${id}.md`);
+    const filePath = path12.join(dir, `${id}.md`);
     await this.writeStorageSecureFile(filePath, `${serializeFrontmatter(this.withOkfType(fm))}
 
 ${sanitized.text}
@@ -9429,7 +8686,7 @@ ${sanitized.text}
    * per-process in-memory cache safe across process boundaries.
    */
   invalidateColdMemoriesCache() {
-    const coldRoot = path13.join(this.baseDir, "cold");
+    const coldRoot = path12.join(this.baseDir, "cold");
     _StorageManager.coldMemoriesCache.delete(coldRoot);
     this.bumpColdWriteVersion();
     invalidateAllForDir(this.baseDir);
@@ -9547,7 +8804,7 @@ ${sanitized.text}
     const correctionPaths = [];
     const factPaths = [];
     for (const filePath of filePaths) {
-      if (filePath === this.correctionsDir || filePath.startsWith(`${this.correctionsDir}${path13.sep}`)) {
+      if (filePath === this.correctionsDir || filePath.startsWith(`${this.correctionsDir}${path12.sep}`)) {
         correctionPaths.push(filePath);
       } else {
         factPaths.push(filePath);
@@ -9610,10 +8867,10 @@ ${sanitized.text}
     const root = this.archiveDir;
     const readDir = async (dir) => {
       try {
-        const entries = (await readdir6(dir, { withFileTypes: true })).filter((e) => !isMacOsReplicationJunkBasename(e.name));
+        const entries = (await readdir5(dir, { withFileTypes: true })).filter((e) => !isMacOsReplicationJunkBasename(e.name));
         for (const entry of entries) {
           checkCorpusReadAbort(options);
-          const fullPath = path13.join(dir, entry.name);
+          const fullPath = path12.join(dir, entry.name);
           if (entry.isDirectory()) {
             await readDir(fullPath);
           } else if (entry.name.endsWith(".md")) {
@@ -9653,7 +8910,7 @@ ${sanitized.text}
     return this.rememberMemorySnapshot(await this.memoryReadStore.readMemoryByPath(filePath));
   }
   resolveTierRootDir(tier) {
-    return tier === "cold" ? path13.join(this.baseDir, "cold") : this.baseDir;
+    return tier === "cold" ? path12.join(this.baseDir, "cold") : this.baseDir;
   }
   resolveMemoryDateDir(memory) {
     const preferred = memory.frontmatter.created || memory.frontmatter.updated;
@@ -9668,13 +8925,13 @@ ${sanitized.text}
   buildTierMemoryPath(memory, tier) {
     const root = this.resolveTierRootDir(tier);
     if (this.isArtifactMemory(memory)) {
-      return path13.join(root, "artifacts", this.resolveMemoryDateDir(memory), `${memory.frontmatter.id}.md`);
+      return path12.join(root, "artifacts", this.resolveMemoryDateDir(memory), `${memory.frontmatter.id}.md`);
     }
     if (memory.frontmatter.category === "correction") {
-      return path13.join(root, "corrections", `${memory.frontmatter.id}.md`);
+      return path12.join(root, "corrections", `${memory.frontmatter.id}.md`);
     }
     const dir = categoryDirName(memory.frontmatter.category);
-    return path13.join(root, dir, this.resolveMemoryDateDir(memory), `${memory.frontmatter.id}.md`);
+    return path12.join(root, dir, this.resolveMemoryDateDir(memory), `${memory.frontmatter.id}.md`);
   }
   async writeMemoryFileAtomic(targetPath, memory) {
     assertNotOkfReservedBasename(targetPath);
@@ -9691,7 +8948,7 @@ ${memory.content}
       {},
       this.baseDir
     );
-    const priorDest = await readFile2(targetPath).catch(() => null);
+    const priorDest = await readFile(targetPath).catch(() => null);
     await persist();
     if (typeof rawRef === "string") {
       const refBeforeRepair = frontmatter.entityRef;
@@ -9706,9 +8963,9 @@ ${memory.content}
         });
       } catch (err) {
         if (priorDest === null) {
-          await unlink4(targetPath).catch(() => void 0);
+          await unlink3(targetPath).catch(() => void 0);
         } else {
-          await writeFile2(targetPath, priorDest).catch(() => void 0);
+          await writeFile(targetPath, priorDest).catch(() => void 0);
         }
         this.invalidateAllMemoriesCache();
         throw err;
@@ -9753,8 +9010,8 @@ ${memory.content}
               memory.frontmatter.entityRef = current.frontmatter.entityRef;
             }
             durable = true;
-            const sourcePath = path13.resolve(current.path);
-            const destPath = path13.resolve(targetPath);
+            const sourcePath = path12.resolve(current.path);
+            const destPath = path12.resolve(targetPath);
             if (sourcePath !== destPath) {
               await recordArchiveDelete2(this.baseDir, current.path, () => this.deleteManagedStorageFile(current.path));
               this.invalidateAllMemoriesCache();
@@ -9778,8 +9035,8 @@ ${memory.content}
   }
   async migrateMemoryToTier(memory, targetTier) {
     const targetPath = this.buildTierMemoryPath(memory, targetTier);
-    const sourcePath = path13.resolve(memory.path);
-    const destPath = path13.resolve(targetPath);
+    const sourcePath = path12.resolve(memory.path);
+    const destPath = path12.resolve(targetPath);
     if (sourcePath === destPath) {
       return { changed: false, targetPath };
     }
@@ -9789,7 +9046,7 @@ ${memory.content}
     return { changed, targetPath };
   }
   get archiveDir() {
-    return path13.join(this.baseDir, "archive");
+    return path12.join(this.baseDir, "archive");
   }
   /**
    * Archive a memory by moving it from facts/ to archive/YYYY-MM-DD/.
@@ -9802,7 +9059,7 @@ ${memory.content}
       try {
         const now = lifecycle?.at ?? /* @__PURE__ */ new Date();
         const today = now.toISOString().slice(0, 10);
-        const destDir = path13.join(this.archiveDir, today);
+        const destDir = path12.join(this.archiveDir, today);
         await mkdir(destDir, { recursive: true });
         const refIdsAtWrite = this.currentHistoricalIds();
         const updatedFm = canonicalizeEntityRefOption(
@@ -9818,7 +9075,7 @@ ${memory.content}
 
 ${current.content}
 `;
-        const destPath = path13.join(destDir, path13.basename(current.path));
+        const destPath = path12.join(destDir, path12.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") {
@@ -9835,7 +9092,7 @@ ${current.content}
               await recordArchiveDelete2(
                 this.baseDir,
                 destPath,
-                () => unlink4(destPath).then(
+                () => unlink3(destPath).then(
                   () => true,
                   () => false
                 )
@@ -10052,7 +9309,7 @@ ${memory.content}
 `;
     await this.writeTombstoneBlockedFrontmatter(memory, fileContent, updated, async () => {
       this.invalidateAllMemoriesCache();
-      if (memory.path.includes(`${path13.sep}cold${path13.sep}`)) {
+      if (memory.path.includes(`${path12.sep}cold${path12.sep}`)) {
         this.invalidateColdMemoriesCache();
       }
     });
@@ -10064,7 +9321,7 @@ ${memory.content}
     }
     if (mentionReentry && !entityMentionEpoch.neutral(memory.frontmatter, updated)) entityMentionEpoch.bump(this.baseDir);
     await this.patchHotMemoriesCache({ addedPath: memory.path });
-    if (memory.path.includes(`${path13.sep}cold${path13.sep}`)) {
+    if (memory.path.includes(`${path12.sep}cold${path12.sep}`)) {
       this.invalidateColdMemoriesCache();
     }
     try {
@@ -10145,7 +9402,7 @@ ${memory.content}
     return deleted;
   }
   async loadBuffer() {
-    const bufferPath = path13.join(this.stateDir, "buffer.json");
+    const bufferPath = path12.join(this.stateDir, "buffer.json");
     try {
       const raw = await this.readStorageSecureFile(bufferPath);
       return JSON.parse(raw);
@@ -10157,11 +9414,11 @@ ${memory.content}
   }
   async saveBuffer(state) {
     await this.ensureDirectories();
-    const bufferPath = path13.join(this.stateDir, "buffer.json");
+    const bufferPath = path12.join(this.stateDir, "buffer.json");
     await this.writeStorageSecureFile(bufferPath, JSON.stringify(state, null, 2));
   }
   async loadMeta() {
-    const metaPath = path13.join(this.stateDir, "meta.json");
+    const metaPath = path12.join(this.stateDir, "meta.json");
     try {
       const raw = await this.readStorageSecureFile(metaPath);
       const parsed = JSON.parse(raw);
@@ -10194,7 +9451,7 @@ ${memory.content}
   }
   async saveMeta(state) {
     await this.ensureDirectories();
-    const metaPath = path13.join(this.stateDir, "meta.json");
+    const metaPath = path12.join(this.stateDir, "meta.json");
     await this.writeStorageSecureFile(metaPath, JSON.stringify(state, null, 2));
   }
   async appendMemoryActionEvents(events) {
@@ -10264,7 +9521,7 @@ ${memory.content}
       },
       (payload) => this.appendStorageSecureFile(target, payload),
       async () => {
-        await mkdir(path13.dirname(target), { recursive: true });
+        await mkdir(path12.dirname(target), { recursive: true });
       }
     );
   }
@@ -10362,7 +9619,7 @@ ${memory.content}
   async appendReextractJobs(events) {
     if (events.length === 0) return 0;
     await this.ensureDirectories();
-    const filePath = path13.join(this.stateDir, "reextract-jobs.jsonl");
+    const filePath = path12.join(this.stateDir, "reextract-jobs.jsonl");
     const lines = events.map((event) => JSON.stringify(event)).join("\n") + "\n";
     try {
       await this.appendStorageSecureFile(filePath, lines);
@@ -10375,7 +9632,7 @@ ${memory.content}
   }
   async readReextractJobs(limit = 200) {
     const safeLimit = Number.isFinite(limit) ? Math.max(1, Math.min(1e3, Math.floor(limit))) : 200;
-    const filePath = path13.join(this.stateDir, "reextract-jobs.jsonl");
+    const filePath = path12.join(this.stateDir, "reextract-jobs.jsonl");
     try {
       const raw = await this.readStorageSecureFile(filePath);
       const lines = raw.split("\n").filter((line) => line.trim().length > 0);
@@ -10531,7 +9788,7 @@ ${memory.content}
       return false;
     }
     if (draftState.contentHash) {
-      const contentHash = createHash6("sha256").update(draftContent).digest("hex");
+      const contentHash = createHash5("sha256").update(draftContent).digest("hex");
       if (contentHash !== draftState.contentHash) return false;
     }
     await this.writeCompressionGuidelines(draftContent);
@@ -10540,8 +9797,8 @@ ${memory.content}
       activationState: "active"
     });
     await Promise.all([
-      unlink4(this.compressionGuidelineDraftPath).catch(() => void 0),
-      unlink4(this.compressionGuidelineDraftStatePath).catch(() => void 0)
+      unlink3(this.compressionGuidelineDraftPath).catch(() => void 0),
+      unlink3(this.compressionGuidelineDraftStatePath).catch(() => void 0)
     ]);
     return true;
   }
@@ -10610,7 +9867,7 @@ ${question}
 
 **Context:** ${context}
 `;
-    const filePath = path13.join(this.questionsDir, `${id}.md`);
+    const filePath = path12.join(this.questionsDir, `${id}.md`);
     await this.writeStorageSecureFile(filePath, content);
     log.debug(`wrote question ${id} to ${filePath}`);
     this.invalidateQuestionsCache();
@@ -10647,14 +9904,14 @@ ${question}
   async readIdentity(workspaceDir, namespace) {
     const identityPath = this.identityFilePath(workspaceDir, namespace);
     try {
-      return await readFile2(identityPath, "utf-8");
+      return await readFile(identityPath, "utf-8");
     } catch {
       return "";
     }
   }
   async writeIdentity(workspaceDir, content, namespace) {
     const identityPath = this.identityFilePath(workspaceDir, namespace);
-    await writeFile2(identityPath, content, "utf-8");
+    await writeFile(identityPath, content, "utf-8");
     log.debug(`wrote consolidated IDENTITY.md (${content.length} chars)`);
   }
   /** Max size for IDENTITY.md before we stop appending reflections (15KB leaves room under 20KB gateway limit) */
@@ -10665,22 +9922,22 @@ ${question}
     const identityPath = this.identityFilePath(workspaceDir, opts?.namespace);
     let existing = "";
     try {
-      existing = await readFile2(identityPath, "utf-8");
+      existing = await readFile(identityPath, "utf-8");
     } catch {
     }
     const hygiene = opts?.hygiene;
-    const rotateEnabled = hygiene?.enabled === true && hygiene.rotateEnabled === true && Array.isArray(hygiene.rotatePaths) && hygiene.rotatePaths.includes(path13.basename(identityPath));
+    const rotateEnabled = hygiene?.enabled === true && hygiene.rotateEnabled === true && Array.isArray(hygiene.rotatePaths) && hygiene.rotatePaths.includes(path12.basename(identityPath));
     if (rotateEnabled) {
       const maxBytes = hygiene.rotateMaxBytes;
       if (existing.length > maxBytes) {
-        const archiveDir = path13.join(workspaceDir, hygiene.archiveDir);
+        const archiveDir = path12.join(workspaceDir, hygiene.archiveDir);
         const { newContent } = await rotateMarkdownFileToArchive({
           filePath: identityPath,
           archiveDir,
           archivePrefix: "IDENTITY",
           keepTailChars: hygiene.rotateKeepTailChars
         });
-        await writeFile2(identityPath, newContent, "utf-8");
+        await writeFile(identityPath, newContent, "utf-8");
         existing = newContent;
         log.info(`rotated IDENTITY.md to archive (size=${existing.length} chars, maxBytes=${maxBytes})`);
       }
@@ -10713,7 +9970,7 @@ ${question}
 
 ${reflection}
 `;
-    await writeFile2(identityPath, existing + section, "utf-8");
+    await writeFile(identityPath, existing + section, "utf-8");
     log.debug(`appended reflection to ${identityPath}`);
   }
   async readIdentityReflections() {
@@ -10933,7 +10190,7 @@ ${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) => [path13.resolve(m.path), m]));
+    const memoryPathMap = new Map(memories.map((m) => [path12.resolve(m.path), m]));
     let updated = 0;
     const prevVersion = this.getMemoryCorpusVersion();
     let entityRefMoved = false;
@@ -10941,7 +10198,7 @@ ${reflection}
     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(path13.resolve(entry.memoryPath)) : memoryMap.get(entry.memoryId);
+      const memory = entry.memoryPath ? memoryPathMap.get(path12.resolve(entry.memoryPath)) : memoryMap.get(entry.memoryId);
       if (!memory) continue;
       try {
         const applied = await this.withTombstoneBlockedMemoryPathLock(memory.path, async (current) => {
@@ -10973,7 +10230,7 @@ ${current.content}
         if (warm) {
           updateCacheOnWrite(this.baseDir, { ...applied.current, frontmatter: applied.newFm }, keyId);
         }
-        appliedPatches.set(path13.resolve(memory.path), {
+        appliedPatches.set(path12.resolve(memory.path), {
           accessCount: entry.newCount,
           lastAccessed: entry.lastAccessed
         });
@@ -10991,7 +10248,7 @@ ${current.content}
         const cur = getCachedMemories(this.baseDir, prevVersion, keyId);
         if (cur) {
           const reapplied = cur.map((m) => {
-            const patch = appliedPatches.get(path13.resolve(m.path));
+            const patch = appliedPatches.get(path12.resolve(m.path));
             return patch ? {
               ...m,
               frontmatter: { ...m.frontmatter, accessCount: patch.accessCount, lastAccessed: patch.lastAccessed }
@@ -11021,7 +10278,7 @@ ${current.content}
     const pathsById = /* @__PURE__ */ new Map();
     const filePathsById = /* @__PURE__ */ new Map();
     for (const filePath of filePaths) {
-      const memoryId = path13.basename(filePath, ".md");
+      const memoryId = path12.basename(filePath, ".md");
       if (!wantedIds.has(memoryId)) continue;
       const paths = filePathsById.get(memoryId) ?? [];
       paths.push(filePath);
@@ -11033,7 +10290,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(path13.resolve(filePath)));
+        const directMatch = existingPaths.find((filePath) => directCandidates.has(path12.resolve(filePath)));
         if (directMatch) {
           preferredMatches.push(directMatch);
           continue;
@@ -11045,7 +10302,7 @@ ${current.content}
             candidates.add(candidate);
           }
         }
-        const match = existingPaths.find((filePath) => candidates.has(path13.resolve(filePath)));
+        const match = existingPaths.find((filePath) => candidates.has(path12.resolve(filePath)));
         if (match) preferredMatches.push(match);
       }
       if (preferredMatches.length > 0) {
@@ -11236,7 +10493,7 @@ ${sanitized.text}
     }
     if (!oldMemory) return false;
     const requireActiveAtWrite = options.requireActive === true || inferMemoryStatus(oldMemory.frontmatter, toMemoryPathRel(this.baseDir, oldMemory.path)) === "active";
-    const operationId = createHash6("sha256").update(
+    const operationId = createHash5("sha256").update(
       JSON.stringify({
         oldMemoryId,
         newMemoryId,
@@ -11367,21 +10624,21 @@ ${current.content}
     }
   }
   get summariesDir() {
-    return path13.join(this.baseDir, "summaries");
+    return path12.join(this.baseDir, "summaries");
   }
   async writeSummary(summary) {
     await mkdir(this.summariesDir, { recursive: true });
-    const filePath = path13.join(this.summariesDir, `${summary.id}.json`);
+    const filePath = path12.join(this.summariesDir, `${summary.id}.json`);
     await this.writeStorageSecureFile(filePath, JSON.stringify(summary, null, 2));
     log.debug(`wrote summary ${summary.id}`);
   }
   async readSummaries() {
     try {
-      const files = await readdir6(this.summariesDir);
+      const files = await readdir5(this.summariesDir);
       const summaries = [];
       for (const file of files) {
         if (isMacOsReplicationJunkBasename(file) || !file.endsWith(".json")) continue;
-        const filePath = path13.join(this.summariesDir, file);
+        const filePath = path12.join(this.summariesDir, file);
         const raw = await this.readStorageSecureFile(filePath);
         summaries.push(JSON.parse(raw));
       }
@@ -11451,7 +10708,7 @@ ${current.content}
     return archived;
   }
   async saveTopics(topics) {
-    const metaPath = path13.join(this.stateDir, "topics.json");
+    const metaPath = path12.join(this.stateDir, "topics.json");
     await mkdir(this.stateDir, { recursive: true });
     await this.writeStorageSecureFile(
       metaPath,
@@ -11460,7 +10717,7 @@ ${current.content}
     log.debug(`saved ${topics.length} topic scores`);
   }
   async loadTopics() {
-    const metaPath = path13.join(this.stateDir, "topics.json");
+    const metaPath = path12.join(this.stateDir, "topics.json");
     try {
       const raw = await this.readStorageSecureFile(metaPath);
       return JSON.parse(raw);
@@ -11579,4 +10836,4 @@ export {
   isValidBufferSurpriseEvent,
   StorageManager3 as StorageManager
 };
-//# sourceMappingURL=chunk-XALR4DOQ.js.map
+//# sourceMappingURL=chunk-TTIEXXL3.js.map