@remnic/core 10.0.48 → 10.0.50

package/dist/{chunk-L46MG2GE.js → chunk-GQIYL7OD.js}

@@ -19,11 +19,11 @@ import {
   getFingerprint,
   migrateLegacyEntityCanonicalIds,
   validateRoots
-} from "./chunk-VY6BD5KB.js";
+} from "./chunk-ZMO2S5RT.js";
 import {
   normalizeQmdResultPath,
   resolveNamespaceResultPath
-} from "./chunk-PJBYVJKO.js";
+} from "./chunk-LXXIV7Y2.js";
 import {
   withholdToolScopedFromSharedNamespace
 } from "./chunk-S2V7RUCL.js";
@@ -34,13 +34,16 @@ import {
 import {
   parseOfflineSyncDigestCache
 } from "./chunk-X3724WL4.js";
+import {
+  createMemorySnapshot
+} from "./chunk-S2HLHAZ4.js";
 import {
   rewriteProjectedEntityReferences,
   rewriteProjectedMemoryEntityReference
 } from "./chunk-MRPOZBJC.js";
 import {
-  createMemorySnapshot
-} from "./chunk-S2HLHAZ4.js";
+  rotateMarkdownFileToArchive
+} from "./chunk-DM2T26WE.js";
 import {
   closeContinuityIncidentRecord,
   createContinuityIncidentRecord,
@@ -50,9 +53,6 @@ import {
   serializeContinuityIncident,
   upsertContinuityLoopInMarkdown
 } from "./chunk-LDXUBPMO.js";
-import {
-  rotateMarkdownFileToArchive
-} from "./chunk-DM2T26WE.js";
 import {
   parseProvenanceSources,
   parseProvenanceTag,
@@ -70,15 +70,12 @@ import {
   invalidationCommitFingerprint,
   parseTombstoneBlockedOfflineSyncMemory,
   withCasCommitReceipt
-} from "./chunk-MPJDQC4G.js";
+} from "./chunk-WJCXUE2J.js";
 import {
   matchEntitySchemaSection,
   normalizeEntityStructuredSection,
   sortStructuredSectionsBySchema
 } from "./chunk-ZIKENA2C.js";
-import {
-  normalizeEntityName
-} from "./chunk-YXZG5TVN.js";
 import {
   OKF_QUESTION_TYPE,
   assertNotOkfReservedBasename,
@@ -92,18 +89,17 @@ import {
   normalizeProjectionTags
 } from "./chunk-SCU65EZI.js";
 import {
-  checkCorpusReadAbort
-} from "./chunk-P4GUQSK3.js";
+  normalizeEntityName
+} from "./chunk-YXZG5TVN.js";
 import {
   detectLanguageHint
 } from "./chunk-3WU7XOFN.js";
 import {
-  isConsolidationOperator,
-  isValidDerivedFromEntry
-} from "./chunk-G7D6GZ5J.js";
+  checkCorpusReadAbort
+} from "./chunk-P4GUQSK3.js";
 import {
   createVersion
-} from "./chunk-2NLCDNGA.js";
+} from "./chunk-564YP3DW.js";
 import {
   attachInFlightReader,
   beginCoalescedScan,
@@ -112,24 +108,41 @@ 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,
+  entityCanonicalIdMigrationCompleted,
   memoizedJournalCompletion,
   reconcileIfJournalMovedSync,
   repairEntityRefAfterJournalMove,
   requestEntityCanonicalIdReconcileSync,
   resolveHistoricalEntityCanonicalId,
   withEntityCanonicalMutationLock
-} from "./chunk-LWRIGKFM.js";
+} from "./chunk-A5L5KGDI.js";
 import {
   supersessionKeysForFact
 } from "./chunk-5WITETWU.js";
 import {
   entityMentionEpoch
 } from "./chunk-7CT3AI52.js";
+import {
+  isConsolidationOperator,
+  isValidDerivedFromEntry
+} from "./chunk-G7D6GZ5J.js";
+import {
+  scopedCaptureWriteLockLimits
+} from "./chunk-7VLBZKNB.js";
+import {
+  buildCapturePathLockIdentity,
+  buildExplicitCaptureDedupKey,
+  isQueuedReviewMemory,
+  tombstoneBlocked
+} from "./chunk-UUZ7KZAO.js";
 import {
   parseOriginClass
 } from "./chunk-23G5P7TA.js";
@@ -146,12 +159,6 @@ import {
   updateCacheOnDelete,
   updateCacheOnWrite
 } from "./chunk-C64XATK7.js";
-import {
-  buildCapturePathLockIdentity,
-  buildExplicitCaptureDedupKey,
-  isQueuedReviewMemory,
-  tombstoneBlocked
-} from "./chunk-UUZ7KZAO.js";
 import {
   selectArtifactMatches
 } from "./chunk-HADD45AR.js";
@@ -238,7 +245,8 @@ import {
 } from "./chunk-C5LWPYS3.js";
 import {
   isAbortError,
-  raceAbort
+  raceAbort,
+  throwIfAborted
 } from "./chunk-R2MBW2S4.js";
 import {
   isMacOsReplicationJunkBasename,
@@ -278,7 +286,7 @@ import {
 
 // src/storage.ts
 import {
-  lstat as lstat4,
+  lstat as lstat5,
   readdir as readdir6,
   readFile,
   realpath as realpath3,
@@ -314,7 +322,7 @@ function parseDriftProvenance(fm) {
 }
 
 // src/storage.ts
-import path14 from "path";
+import path15 from "path";
 
 // src/storage/tombstone-migration-sources.ts
 import { statSync } from "fs";
@@ -406,6 +414,7 @@ async function readWindowedMemories(store, options, hotCache, rememberMemorySnap
           return timestampMs === null || timestampMs >= updatedAfterMs ? memory : null;
         })
       )).filter((memory) => memory !== null);
+      throwIfAborted(options.abortSignal, "windowed memory read aborted");
       const memories = orderWindowMemories(selected, hotCache.baseDir);
       return { memories: rememberMemorySnapshots(memories), filePaths: memories.map((memory) => memory.path) };
     }
@@ -648,7 +657,8 @@ var MemoryReadStore = class {
     return tiers.flat();
   }
   async readMemoriesWindow(options = {}) {
-    const allPaths = await this.deps.collectActiveMemoryPaths();
+    const readOptions = { abortSignal: options.abortSignal };
+    const allPaths = await this.deps.collectActiveMemoryPaths(readOptions);
     const sortedPaths = this.deps.orderWindowPaths(allPaths);
     const maxMemories = typeof options.maxMemories === "number" && Number.isFinite(options.maxMemories) ? Math.max(1, Math.floor(options.maxMemories)) : void 0;
     const maxCandidatePaths = maxMemories === void 0 ? void 0 : maxMemories * 2;
@@ -657,6 +667,7 @@ var MemoryReadStore = class {
     const memories = [];
     const selectedPaths = [];
     for (let i = 0; i < sortedPaths.length; i += normalizedBatchSize) {
+      checkCorpusReadAbort(readOptions);
       if (maxMemories !== void 0 && (memories.length >= maxMemories || maxCandidatePaths !== void 0 && selectedPaths.length >= maxCandidatePaths)) {
         return { memories, filePaths: selectedPaths };
       }
@@ -665,13 +676,14 @@ var MemoryReadStore = class {
       const remainingSlots = maxMemories === void 0 ? void 0 : Math.max(0, maxMemories - memories.length);
       const remainingInspectionBudget = maxCandidatePaths === void 0 ? void 0 : Math.max(0, maxCandidatePaths - selectedPaths.length);
       const { memories: batchMemories, filePaths: parsedCandidatePaths } = remainingSlots === void 0 ? {
-        memories: await this.deps.readParsedMemoriesFromPaths(candidateBatchPaths, normalizedBatchSize),
+        memories: await this.deps.readParsedMemoriesFromPaths(candidateBatchPaths, normalizedBatchSize, readOptions),
         filePaths: candidateBatchPaths
       } : await this.deps.readWindowBoundedBatch(
         candidateBatchPaths,
         remainingSlots,
         remainingInspectionBudget ?? remainingSlots,
-        normalizedBatchSize
+        normalizedBatchSize,
+        readOptions
       );
       selectedPaths.push(...parsedCandidatePaths);
       for (const memory of batchMemories) {
@@ -1755,8 +1767,110 @@ function selfDeps(self) {
 }
 
 // src/storage/entity-store.ts
-import { lstat as lstat2, readdir as readdir2, realpath as realpath2, unlink } from "fs/promises";
+import { lstat as lstat3, readdir as readdir2, unlink } from "fs/promises";
+import path6 from "path";
+
+// src/storage/entity-migration-completion-cache.ts
+import { lstat as lstat2, realpath as realpath2 } from "fs/promises";
 import path5 from "path";
+async function isTrustedEntitiesRoot(baseDir, entitiesDir) {
+  let rootStat;
+  try {
+    rootStat = await lstat2(entitiesDir);
+  } catch (err) {
+    if (isErrnoCode(err, "ENOENT")) return false;
+    throw err;
+  }
+  if (rootStat.isSymbolicLink() || !rootStat.isDirectory()) return false;
+  let memoryRoot;
+  let entitiesReal;
+  try {
+    memoryRoot = await realpath2(baseDir);
+    entitiesReal = await realpath2(entitiesDir);
+  } catch (err) {
+    if (isErrnoCode(err, "ENOENT")) return false;
+    throw err;
+  }
+  return pathIsInside(memoryRoot, entitiesReal);
+}
+var EntityMigrationCompletionCache = class {
+  cache;
+  /** lstat identity for one fingerprint input path; nofollow; missing → stable token. */
+  async inputPathSig(filePath) {
+    try {
+      const s = await lstat2(filePath);
+      return `${s.dev}:${s.ino}:${s.mtimeMs}:${s.ctimeMs}:${s.size}:${s.isSymbolicLink() ? "L" : s.isDirectory() ? "D" : "F"}`;
+    } catch {
+      return "missing";
+    }
+  }
+  /**
+   * Cheap coherence key. entities/ absence is uncacheable (random suffix) so
+   * we never pin a false complete.
+   */
+  async inputSig(deps) {
+    const stateDir = path5.join(deps.baseDir, "state");
+    const entitiesSig = await this.inputPathSig(deps.entitiesDir);
+    if (entitiesSig === "missing") return `entities-missing:${Math.random()}`;
+    const [aliasesSig, journalSig, reconcileSig, consumingSig] = await Promise.all([
+      this.inputPathSig(path5.join(deps.baseDir, "config", "aliases.json")),
+      this.inputPathSig(path5.join(stateDir, ENTITY_CANONICAL_ID_MIGRATION_FILE)),
+      this.inputPathSig(path5.join(stateDir, ENTITY_CANONICAL_ID_RECONCILE_MARKER)),
+      this.inputPathSig(path5.join(stateDir, ENTITY_CANONICAL_ID_RECONCILE_CONSUMING_MARKER))
+    ]);
+    return [entitiesSig, aliasesSig, journalSig, reconcileSig, consumingSig].join("|");
+  }
+  /**
+   * True when journal completion attests to live fingerprint inputs.
+   * Untrusted entities roots (symlink / outside base) never reach getFingerprint.
+   */
+  async isCompleted(deps) {
+    const version = deps.getEntityMutationVersion();
+    const inputSig = await this.inputSig(deps);
+    const cached = this.cache;
+    if (cached && cached.version === version && cached.inputSig === inputSig) return cached.completed;
+    if (!await isTrustedEntitiesRoot(deps.baseDir, deps.entitiesDir)) {
+      this.cache = { version, inputSig, completed: false };
+      return false;
+    }
+    const completed = await entityCanonicalIdMigrationCompleted(path5.join(deps.baseDir, "state"), () => getFingerprint(deps.baseDir, deps.entitiesDir, () => String(version)));
+    this.cache = { version, inputSig, completed };
+    return completed;
+  }
+};
+async function readEntityFileResolvingRename(deps, firstPath, entityId) {
+  try {
+    return { id: entityId, content: await 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 = 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 deps.readStorageSecureFile(
+          path5.join(deps.entitiesDir, `${candidate}.md`)
+        )
+      };
+    } catch (err) {
+      if (err instanceof SecureStoreLockedError) throw err;
+      if (isErrnoCode(err, "ENOENT") || isErrnoCode(err, "ELOOP")) continue;
+      throw err;
+    }
+  }
+  return null;
+}
+
+// src/storage/entity-store.ts
 var EntityStore = class {
   constructor(deps) {
     this.deps = deps;
@@ -1764,6 +1878,7 @@ var EntityStore = class {
   deps;
   /** Filename → file identity of the last indexable check. Unchanged files are not reread. */
   entityIndexableCache = /* @__PURE__ */ new Map();
+  migrationCompletion = new EntityMigrationCompletionCache();
   /** Normalize an entity name using this store's alias table. */
   normalizeEntityName(raw, type) {
     return normalizeEntityName(raw, type, this.deps.userAliases);
@@ -1776,9 +1891,10 @@ var EntityStore = class {
    * resolving only the canonical path silently drops the mutation.
    */
   async readEntityForMutation(name, method, historicalIds) {
+    assertSafeEntityId(name);
     const canonical = resolveHistoricalEntityCanonicalId(name, historicalIds);
     for (const candidate of canonical === name ? [name] : [canonical, name]) {
-      const filePath = path5.join(this.deps.entitiesDir, `${candidate}.md`);
+      const filePath = path6.join(this.deps.entitiesDir, `${candidate}.md`);
       try {
         const entity = parseEntityFile(await this.deps.readStorageSecureFile(filePath), this.deps.entitySchemas);
         return { filePath, entity };
@@ -1803,7 +1919,8 @@ var EntityStore = class {
    * `mutate` returns false to skip the write. Resolves true when written.
    */
   async mutateEntityFile(name, method, mutate) {
-    const stateDir = path5.join(this.deps.baseDir, "state");
+    await this.deps.ensureDirectories();
+    const stateDir = path6.join(this.deps.baseDir, "state");
     return withEntityCanonicalMutationLock(stateDir, async () => {
       for (let attempt = 0; attempt < 3; attempt += 1) {
         const idsAtResolve = this.deps.currentHistoricalIds();
@@ -1858,7 +1975,7 @@ var EntityStore = class {
   async writeEntity(name, type, facts, options = {}) {
     await this.deps.ensureDirectories();
     return withEntityCanonicalMutationLock(
-      path5.join(this.deps.baseDir, "state"),
+      path6.join(this.deps.baseDir, "state"),
       () => this.writeEntityUnlocked(name, type, facts, options)
     );
   }
@@ -1879,7 +1996,7 @@ var EntityStore = class {
       log.debug(`fuzzy match: "${normalized}" \u2192 existing "${match}"`);
       normalized = match;
     }
-    const filePath = path5.join(this.deps.entitiesDir, `${normalized}.md`);
+    const filePath = path6.join(this.deps.entitiesDir, `${normalized}.md`);
     let entity = {
       name,
       type,
@@ -1975,75 +2092,42 @@ var EntityStore = class {
     log.debug(`wrote entity ${normalized}`);
     return normalized;
   }
-  async readEntityFileResolvingRename(firstPath, entityId) {
-    try {
-      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) {
+  async readEntity(name) {
+    const filePath = this.deps.resolveEntityFilePath(name);
+    if (filePath === null) return "";
+    const readDirect = async () => {
       try {
-        return { id: candidate, content: await this.deps.readStorageSecureFile(
-          path5.join(this.deps.entitiesDir, `${candidate}.md`)
-        ) };
+        return await this.deps.readStorageSecureFile(filePath);
       } catch (err) {
         if (err instanceof SecureStoreLockedError) throw err;
-        if (isErrnoCode(err, "ENOENT") || isErrnoCode(err, "ELOOP")) continue;
+        if (isErrnoCode(err, "ENOENT") || isErrnoCode(err, "ELOOP")) return void 0;
         throw err;
       }
-    }
-    return null;
-  }
-  async readEntity(name) {
-    const filePath = this.deps.resolveEntityFilePath(name);
-    if (filePath === null) {
-      return "";
-    }
-    if (this.deps.entityCanonicalMigrationComplete()) {
+    };
+    const direct = await readDirect();
+    if (direct !== void 0) return direct;
+    if (await this.migrationCompletion.isCompleted(this.deps)) return "";
+    const renamed = await readEntityFileResolvingRename(this.deps, filePath, name);
+    if (renamed !== null) return renamed.content;
+    let legacy;
+    for (const file of await this.readEntityDirectoryNames()) {
+      if (!file.endsWith(".md") || !await this.isContainedRegularEntityFile(file)) continue;
+      let content;
       try {
-        return await this.deps.readStorageSecureFile(filePath);
+        content = await this.deps.readStorageSecureFile(path6.join(this.deps.entitiesDir, file));
       } catch (err) {
         if (err instanceof SecureStoreLockedError) throw err;
-        if (isErrnoCode(err, "ENOENT") || isErrnoCode(err, "ELOOP")) return "";
+        if (isErrnoCode(err, "ENOENT") || isErrnoCode(err, "ELOOP")) continue;
         throw err;
       }
+      if (isMalformedEntityRecord(content)) continue;
+      const entity = parseEntityFile(content, this.deps.entitySchemas);
+      if (!entity.name.trim() || !entity.type.trim()) continue;
+      if (this.deps.normalizeEntityName(entity.name, entity.type) !== name) continue;
+      if (legacy !== void 0) throw new Error(`Ambiguous legacy entity id: ${name}`);
+      legacy = content;
     }
-    return (await this.readEntityFileResolvingRename(filePath, name))?.content ?? "";
-  }
-  /**
-   * True when `entities/` is a real directory inside this memory root.
-   * `realpath` on a symlinked root would treat the link target as trusted,
-   * so the check uses `lstat` first and refuses the scan when the root
-   * itself is a symlink.
-   */
-  async isTrustedEntitiesRoot() {
-    let rootStat;
-    try {
-      rootStat = await lstat2(this.deps.entitiesDir);
-    } catch (err) {
-      if (isErrnoCode(err, "ENOENT")) return false;
-      throw err;
-    }
-    if (rootStat.isSymbolicLink() || !rootStat.isDirectory()) return false;
-    let memoryRoot;
-    let entitiesReal;
-    try {
-      memoryRoot = await realpath2(this.deps.baseDir);
-      entitiesReal = await realpath2(this.deps.entitiesDir);
-    } catch (err) {
-      if (isErrnoCode(err, "ENOENT")) return false;
-      throw err;
-    }
-    return pathIsInside(memoryRoot, entitiesReal);
+    return await readDirect() ?? legacy ?? "";
   }
   /**
    * Entity directory listing with macOS replication junk removed.
@@ -2051,7 +2135,7 @@ var EntityStore = class {
    * A symlinked entities root yields an empty list and is not read.
    */
   async readEntityDirectoryNames() {
-    if (!await this.isTrustedEntitiesRoot()) return [];
+    if (!await isTrustedEntitiesRoot(this.deps.baseDir, this.deps.entitiesDir)) return [];
     const entries = await readdir2(this.deps.entitiesDir);
     const { kept, ignored } = withoutMacOsReplicationJunk(entries, (name) => name);
     warnIgnoredMacOsReplicationJunk(this.deps.entitiesDir, ignored, (message) => {
@@ -2066,7 +2150,7 @@ var EntityStore = class {
    */
   async isMissingEntry(file) {
     try {
-      await lstat2(path5.join(this.deps.entitiesDir, file));
+      await lstat3(path6.join(this.deps.entitiesDir, file));
       return false;
     } catch (err) {
       if (isErrnoCode(err, "ENOENT")) return true;
@@ -2074,10 +2158,10 @@ var EntityStore = class {
     }
   }
   async isContainedRegularEntityFile(file) {
-    const filePath = path5.join(this.deps.entitiesDir, file);
+    const filePath = path6.join(this.deps.entitiesDir, file);
     let entryStat;
     try {
-      entryStat = await lstat2(filePath);
+      entryStat = await lstat3(filePath);
     } catch (err) {
       if (isErrnoCode(err, "ENOENT")) return false;
       throw err;
@@ -2091,10 +2175,10 @@ var EntityStore = class {
    * reread the whole directory on every extraction write.
    */
   async isIndexableEntityMarkdown(file) {
-    const filePath = path5.join(this.deps.entitiesDir, file);
+    const filePath = path6.join(this.deps.entitiesDir, file);
     let entryStat;
     try {
-      entryStat = await lstat2(filePath);
+      entryStat = await lstat3(filePath);
     } catch (err) {
       if (isErrnoCode(err, "ENOENT")) return false;
       throw err;
@@ -2165,19 +2249,26 @@ var EntityStore = class {
   }
   /** Re-serialize every entity file into the compiled-truth timeline shape. */
   async migrateEntityFilesToCompiledTruthTimeline() {
+    await this.deps.ensureDirectories();
     const entityNames = await this.listEntityNames();
-    const stateDir = path5.join(this.deps.baseDir, "state");
+    const stateDir = path6.join(this.deps.baseDir, "state");
     let migrated = 0;
     for (const entityName of entityNames) {
       const wrote = await withEntityCanonicalMutationLock(stateDir, async () => {
-        const raw = await this.readEntity(entityName);
+        const filePath = this.deps.resolveEntityFilePath(entityName);
+        if (filePath === null) return false;
+        let raw;
+        try {
+          raw = await this.deps.readStorageSecureFile(filePath);
+        } catch (err) {
+          if (err instanceof SecureStoreLockedError || !isErrnoCode(err, "ENOENT")) throw err;
+          return false;
+        }
         if (!raw || isMalformedEntityRecord(raw)) return false;
         const parsed = parseEntityFile(raw, this.deps.entitySchemas);
         if (!parsed.name.trim() || !parsed.type.trim()) return false;
         const serialized = serializeEntityFile(parsed, this.deps.entitySchemas, this.deps.okfConformanceEnabled());
         if (raw.trimEnd() === serialized.trimEnd()) return false;
-        const filePath = this.deps.resolveEntityFilePath(entityName);
-        if (filePath === null) return false;
         await this.deps.writeStorageSecureFile(filePath, serialized);
         this.deps.bumpEntityMutationVersion();
         return true;
@@ -2194,23 +2285,16 @@ var EntityStore = class {
    * Set or rewrite the synthesis layer of an entity file.
    */
   async updateEntitySynthesis(name, synthesis, options = {}) {
+    await this.deps.ensureDirectories();
     return withEntityCanonicalMutationLock(
-      path5.join(this.deps.baseDir, "state"),
+      path6.join(this.deps.baseDir, "state"),
       () => this.updateEntitySynthesisUnlocked(name, synthesis, options)
     );
   }
   async updateEntitySynthesisUnlocked(name, synthesis, options = {}) {
-    const filePath = path5.join(this.deps.entitiesDir, `${name}.md`);
-    let entity;
-    try {
-      const content = await this.deps.readStorageSecureFile(filePath);
-      entity = parseEntityFile(content, this.deps.entitySchemas);
-    } catch (err) {
-      if (err instanceof SecureStoreLockedError) throw err;
-      if (!isErrnoCode(err, "ENOENT")) throw err;
-      log.debug(`updateEntitySynthesis: entity file ${name}.md not found`);
-      return;
-    }
+    const located = await this.readEntityForMutation(name, "updateEntitySynthesis", this.deps.currentHistoricalIds());
+    if (!located) return;
+    const { filePath, entity } = located;
     const updatedAt = options.updatedAt?.trim() || entity.synthesisUpdatedAt?.trim() || void 0;
     const entityUpdatedAt = options.entityUpdatedAt?.trim() || updatedAt || entity.updated || (/* @__PURE__ */ new Date()).toISOString();
     const synthesisTimelineCount = Number.isInteger(options.synthesisTimelineCount) && (options.synthesisTimelineCount ?? 0) >= 0 ? options.synthesisTimelineCount : void 0;
@@ -2247,7 +2331,7 @@ var EntityStore = class {
     const cached = getCachedEntities(this.deps.baseDir, currentVersion, cacheKey);
     if (cached) return cached;
     try {
-      if (!await this.isTrustedEntitiesRoot()) return [];
+      if (!await isTrustedEntitiesRoot(this.deps.baseDir, this.deps.entitiesDir)) return [];
       const listed = await readdir2(this.deps.entitiesDir);
       const { kept: entries, ignored } = withoutMacOsReplicationJunk(listed, (name) => name);
       warnIgnoredMacOsReplicationJunk(this.deps.entitiesDir, ignored, (message) => {
@@ -2265,15 +2349,15 @@ var EntityStore = class {
         const results = await Promise.all(
           batch.map(async (entry) => {
             const entityId = entry.slice(0, -".md".length);
-            const entryPath = path5.join(this.deps.entitiesDir, entry);
+            const entryPath = path6.join(this.deps.entitiesDir, entry);
             try {
               if (!await this.isContainedRegularEntityFile(entry)) {
                 if (await this.isMissingEntry(entry)) {
-                  return await this.readEntityFileResolvingRename(entryPath, entityId);
+                  return await readEntityFileResolvingRename(this.deps, entryPath, entityId);
                 }
                 return null;
               }
-              return await this.readEntityFileResolvingRename(entryPath, entityId);
+              return await readEntityFileResolvingRename(this.deps, entryPath, entityId);
             } catch (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)}`);
@@ -2358,8 +2442,9 @@ ${rows.join("\n")}
    * Returns count of files merged.
    */
   async mergeFragmentedEntities() {
+    await this.deps.ensureDirectories();
     return withEntityCanonicalMutationLock(
-      path5.join(this.deps.baseDir, "state"),
+      path6.join(this.deps.baseDir, "state"),
       () => this.mergeFragmentedEntitiesUnlocked()
     );
   }
@@ -2387,7 +2472,7 @@ ${rows.join("\n")}
       const canonicalDestinationOccupied = async (canonicalName, members) => {
         if (members.includes(canonicalName)) return false;
         try {
-          await lstat2(path5.join(this.deps.entitiesDir, canonicalName));
+          await lstat3(path6.join(this.deps.entitiesDir, canonicalName));
           return true;
         } catch (err) {
           if (isErrnoCode(err, "ENOENT")) return false;
@@ -2424,7 +2509,7 @@ ${rows.join("\n")}
           extraSections: []
         };
         for (const file of files) {
-          const filePath = path5.join(this.deps.entitiesDir, file);
+          const filePath = path6.join(this.deps.entitiesDir, file);
           try {
             const content = await this.deps.readStorageSecureFile(filePath);
             const parsed = parseEntityFile(content, this.deps.entitySchemas);
@@ -2577,7 +2662,7 @@ ${rows.join("\n")}
         }
         mergedEntity.created = mergedEntity.created || mergedEntity.updated || (/* @__PURE__ */ new Date()).toISOString();
         mergedEntity.updated = mergedEntity.updated || (/* @__PURE__ */ new Date()).toISOString();
-        const canonicalPath = path5.join(this.deps.entitiesDir, canonicalName);
+        const canonicalPath = path6.join(this.deps.entitiesDir, canonicalName);
         if (await canonicalDestinationOccupied(canonicalName, files)) {
           log.warn(`skipped entity merge into occupied ${canonicalName}`);
           continue;
@@ -2585,7 +2670,7 @@ ${rows.join("\n")}
         await this.deps.writeStorageSecureFile(canonicalPath, serializeEntityFile(mergedEntity, this.deps.entitySchemas, this.deps.okfConformanceEnabled()));
         this.deps.bumpEntityMutationVersion();
         for (const file of files) {
-          const filePath = path5.join(this.deps.entitiesDir, file);
+          const filePath = path6.join(this.deps.entitiesDir, file);
           if (filePath !== canonicalPath) {
             try {
               await unlink(filePath);
@@ -2605,7 +2690,7 @@ ${rows.join("\n")}
 
 // src/storage/identity-continuity-store.ts
 import { readdir as readdir3 } from "fs/promises";
-import path6 from "path";
+import path7 from "path";
 var IdentityContinuityStore = class {
   constructor(deps) {
     this.deps = deps;
@@ -2630,7 +2715,7 @@ var IdentityContinuityStore = class {
     const date = nowIso.slice(0, 10);
     const id = this.deps.generateId("incident");
     const incident = createContinuityIncidentRecord(id, input, nowIso);
-    const filePath = path6.join(this.deps.identityIncidentsDir, `${date}-${id}.md`);
+    const filePath = path7.join(this.deps.identityIncidentsDir, `${date}-${id}.md`);
     await this.deps.writeStorageSecureFile(filePath, serializeContinuityIncident(incident));
     return { ...incident, filePath };
   }
@@ -2643,7 +2728,7 @@ var IdentityContinuityStore = class {
       const incidents = [];
       for (const file of candidates) {
         if (incidents.length >= cappedLimit) break;
-        const filePath = path6.join(this.deps.identityIncidentsDir, file);
+        const filePath = path7.join(this.deps.identityIncidentsDir, file);
         try {
           const raw = await this.deps.readStorageSecureFile(filePath);
           const parsed = parseContinuityIncident(raw);
@@ -2674,7 +2759,7 @@ var IdentityContinuityStore = class {
     await this.deps.ensureDirectories();
     const safeKey = this.sanitizeIdentityAuditKey(key);
     const dir = period === "weekly" ? this.deps.identityAuditsWeeklyDir : this.deps.identityAuditsMonthlyDir;
-    const filePath = path6.join(dir, `${safeKey}.md`);
+    const filePath = path7.join(dir, `${safeKey}.md`);
     await this.deps.writeStorageSecureFile(filePath, content);
     return filePath;
   }
@@ -2682,7 +2767,7 @@ var IdentityContinuityStore = class {
     try {
       const safeKey = this.sanitizeIdentityAuditKey(key);
       const dir = period === "weekly" ? this.deps.identityAuditsWeeklyDir : this.deps.identityAuditsMonthlyDir;
-      return await this.deps.readStorageSecureFile(path6.join(dir, `${safeKey}.md`));
+      return await this.deps.readStorageSecureFile(path7.join(dir, `${safeKey}.md`));
     } catch (err) {
       if (err instanceof Error && err.message === "Invalid identity audit key") return null;
       if (!isErrnoCode(err, "ENOENT")) throw err;
@@ -2738,12 +2823,12 @@ var IdentityContinuityStore = class {
     const fileNames = await this.readContinuityIncidentFileNames();
     const directMatch = fileNames.find((name) => name.endsWith(`-${id}.md`));
     if (directMatch) {
-      const directPath = path6.join(this.deps.identityIncidentsDir, directMatch);
+      const directPath = path7.join(this.deps.identityIncidentsDir, directMatch);
       const parsed = await this.readContinuityIncidentFile(directPath);
       if (parsed?.id === id) return directPath;
     }
     for (const fileName of fileNames) {
-      const filePath = path6.join(this.deps.identityIncidentsDir, fileName);
+      const filePath = path7.join(this.deps.identityIncidentsDir, fileName);
       const parsed = await this.readContinuityIncidentFile(filePath);
       if (parsed?.id === id) return filePath;
     }
@@ -2865,6 +2950,7 @@ ${before.content}
 // src/storage/entity-canonical-id-migration-adapter.ts
 async function runLegacyEntityCanonicalIdMigration(host, parseEntityFile2, serializeEntityFile2, serializeMemoryWithEntityRef2) {
   const readMigrationFingerprint = () => getFingerprint(host.baseDir, host.entitiesDir, () => String(host.getEntityMutationVersion()));
+  let rewroteReferences = false;
   const completionFingerprint = await migrateLegacyEntityCanonicalIds({
     stateDir: host.stateDir,
     entitiesDir: host.entitiesDir,
@@ -2887,9 +2973,19 @@ async function runLegacyEntityCanonicalIdMigration(host, parseEntityFile2, seria
     invalidateKnowledgeIndexCache: host.invalidateKnowledgeIndexCache.bind(host),
     invalidateAllMemoriesCache: host.invalidateAllMemoriesCache.bind(host),
     invalidateColdMemoriesCache: host.invalidateColdMemoriesCache.bind(host),
-    bumpMemoryStatusVersion: host.bumpMemoryStatusVersion.bind(host),
+    bumpMemoryStatusVersion: () => {
+      rewroteReferences = true;
+      host.bumpMemoryStatusVersion();
+    },
     readMigrationFingerprint
   });
+  if (completionFingerprint !== void 0 && rewroteReferences) {
+    try {
+      host.onEntityMigrationComplete?.();
+    } catch {
+      log.warn("entity migration: search maintenance scheduling failed");
+    }
+  }
   return completionFingerprint;
 }
 
@@ -2917,7 +3013,7 @@ var EntityCanonicalIdMigrationRunner = class {
       await this.ensure();
       return;
     }
-    const { readSafeEntityEntries } = await import("./entity-canonical-id-migration-2YOLMOFC.js");
+    const { readSafeEntityEntries } = await import("./entity-canonical-id-migration-ZBNRGUNV.js");
     await readSafeEntityEntries(entitiesDir);
   }
   /**
@@ -3012,7 +3108,7 @@ import {
   readFileSync,
   realpathSync
 } from "fs";
-import path7 from "path";
+import path8 from "path";
 function resolveSafeAliasRoots(baseDir, configDir) {
   let baseStat;
   try {
@@ -3039,8 +3135,8 @@ function resolveSafeAliasRoots(baseDir, configDir) {
   return memoryRoot;
 }
 function readEntityAliasConfigSync(baseDir) {
-  const configDir = path7.join(baseDir, "config");
-  const aliasPath = path7.join(configDir, "aliases.json");
+  const configDir = path8.join(baseDir, "config");
+  const aliasPath = path8.join(configDir, "aliases.json");
   let memoryRoot = resolveSafeAliasRoots(baseDir, configDir);
   if (memoryRoot === void 0) return void 0;
   let aliasPreflight;
@@ -3102,7 +3198,7 @@ function decodeYamlScalar(value) {
 
 // src/orchestration/qmd-result-resolver.ts
 import { existsSync } from "fs";
-import path8 from "path";
+import path9 from "path";
 var INTERNAL_QMD_ROOTS = /* @__PURE__ */ new Set([
   ...ALL_CATEGORY_DIRS,
   "activity",
@@ -3124,7 +3220,7 @@ var INTERNAL_QMD_ROOTS = /* @__PURE__ */ new Set([
 ]);
 var PRIVATE_RESULT_RESOLUTION_CONCURRENCY = 16;
 function qmdCollectionPathParts(resultPath) {
-  if (!resultPath || path8.isAbsolute(resultPath)) return null;
+  if (!resultPath || path9.isAbsolute(resultPath)) return null;
   if (resultPath.trim().startsWith("qmd://")) {
     try {
       const parsed = new URL(resultPath.trim());
@@ -3149,9 +3245,9 @@ function qmdCollectionPathParts(resultPath) {
 }
 function qmdResultPathCandidates(storageDir, resultPath) {
   const candidates = /* @__PURE__ */ new Set();
-  const storageRoot = path8.resolve(storageDir);
+  const storageRoot = path9.resolve(storageDir);
   const addCandidate = (candidate) => {
-    const resolved = path8.resolve(candidate);
+    const resolved = path9.resolve(candidate);
     if (isPathInsideStorageRoot(storageRoot, resolved)) {
       candidates.add(resolved);
     }
@@ -3159,18 +3255,18 @@ function qmdResultPathCandidates(storageDir, resultPath) {
   const addRelativeCandidates = (relativePath) => {
     const normalized = relativePath.replace(/\\/g, "/").replace(/^\/+/, "");
     if (!normalized) return;
-    addCandidate(path8.join(storageRoot, normalized));
+    addCandidate(path9.join(storageRoot, normalized));
     if (/^\d{4}-\d{2}-\d{2}\//.test(normalized)) {
-      addCandidate(path8.join(storageRoot, "facts", normalized));
+      addCandidate(path9.join(storageRoot, "facts", normalized));
     }
   };
-  if (path8.isAbsolute(resultPath)) {
+  if (path9.isAbsolute(resultPath)) {
     addCandidate(resultPath);
-    const relative2 = path8.relative(storageRoot, path8.resolve(resultPath));
-    if (relative2 && !relative2.startsWith("..") && !path8.isAbsolute(relative2)) {
-      const normalized = relative2.split(path8.sep).join("/");
+    const relative2 = path9.relative(storageRoot, path9.resolve(resultPath));
+    if (relative2 && !relative2.startsWith("..") && !path9.isAbsolute(relative2)) {
+      const normalized = relative2.split(path9.sep).join("/");
       if (/^\d{4}-\d{2}-\d{2}\//.test(normalized)) {
-        addCandidate(path8.join(storageRoot, "facts", normalized));
+        addCandidate(path9.join(storageRoot, "facts", normalized));
       }
     }
   } else {
@@ -3186,9 +3282,9 @@ function normalizeFlatQmdResults(results, config, collection = config.qmdCollect
   }));
 }
 function withHotFactsPath(memoryDir, resolved) {
-  const relative2 = path8.relative(path8.resolve(memoryDir), resolved).split(path8.sep).join("/");
+  const relative2 = path9.relative(path9.resolve(memoryDir), resolved).split(path9.sep).join("/");
   if (!/^\d{4}-\d{2}-\d{2}\//.test(relative2) || existsSync(resolved)) return resolved;
-  const hot = path8.join(path8.resolve(memoryDir), "facts", relative2);
+  const hot = path9.join(path9.resolve(memoryDir), "facts", relative2);
   return existsSync(hot) ? hot : resolved;
 }
 function storageDirOrNull(storage) {
@@ -3219,7 +3315,7 @@ var QmdResultResolver = class {
       const seenStorageDirs = /* @__PURE__ */ new Set();
       const addStorage = (storage) => {
         const storageDir = storageDirOrNull(storage);
-        const storageKey = storageDir ? path8.resolve(storageDir) : `storage-without-dir-${storages.length}`;
+        const storageKey = storageDir ? path9.resolve(storageDir) : `storage-without-dir-${storages.length}`;
         if (seenStorageDirs.has(storageKey)) return;
         seenStorageDirs.add(storageKey);
         storages.push(storage);
@@ -3249,7 +3345,7 @@ var QmdResultResolver = class {
           continue;
         }
         try {
-          const coldRoot = path8.join(storageDir, "cold");
+          const coldRoot = path9.join(storageDir, "cold");
           for (const candidate of qmdResultPathCandidates(coldRoot, parts.relativePath)) {
             const memory = await storage.readMemoryByPath(candidate);
             if (memory) return memory;
@@ -3299,9 +3395,9 @@ var QmdResultResolver = class {
           error: err.message
         });
       }
-      if (!path8.isAbsolute(fallbackResultPath)) return null;
+      if (!path9.isAbsolute(fallbackResultPath)) return null;
     }
-    if (path8.isAbsolute(fallbackResultPath)) {
+    if (path9.isAbsolute(fallbackResultPath)) {
       if (!fallbackStorageDir) {
         return await fallbackStorage.readMemoryByPath(fallbackResultPath);
       }
@@ -3358,17 +3454,17 @@ var QmdResultResolver = class {
     if (!memory && parts && !collectionIsKnownInternal && !collectionIsConfigured) {
       memory = await this.readQmdResultMemory(parts.relativePath, fallbackStorage, namespaces, result.namespace);
     }
-    const absoluteInsideMemoryRoot = path8.isAbsolute(result.path) && isPathInsideStorageRoot(path8.resolve(config.memoryDir), path8.resolve(result.path));
+    const absoluteInsideMemoryRoot = path9.isAbsolute(result.path) && isPathInsideStorageRoot(path9.resolve(config.memoryDir), path9.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 || path8.isAbsolute(result.path) && !isPathInsideStorageRoot(path8.resolve(config.memoryDir), path8.resolve(result.path)));
+    const unresolvedExternalCollection = !memory && (parts !== null && !collectionIsKnownInternal && !collectionIsConfigured || path9.isAbsolute(result.path) && !isPathInsideStorageRoot(path9.resolve(config.memoryDir), path9.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 (path8.isAbsolute(memory.path)) {
+    if (path9.isAbsolute(memory.path)) {
       const ownerStorage = await this.storageForAbsoluteQmdResultPath(memory.path, fallbackStorage, recallNamespaces);
       ownerNamespace = ownerStorage?.namespace ?? null;
       if (!ownerNamespace && resolveNamespaceCapabilities(this.getConfig()).namespaces) return null;
@@ -3389,17 +3485,17 @@ var QmdResultResolver = class {
     };
   }
   async storageForAbsoluteQmdResultPath(resultPath, fallbackStorage, recallNamespaces = []) {
-    const resolvedPath = path8.resolve(resultPath);
+    const resolvedPath = path9.resolve(resultPath);
     const config = this.getConfig();
-    const memoryRoot = path8.resolve(config.memoryDir);
-    const namespacesRoot = path8.join(memoryRoot, "namespaces");
+    const memoryRoot = path9.resolve(config.memoryDir);
+    const namespacesRoot = path9.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 = path8.resolve(storageDir);
+      const candidateRoot = path9.resolve(storageDir);
       if (seenDirs.has(candidateRoot)) return;
       if (!isPathInsideStorageRoot(candidateRoot, resolvedPath)) return;
       if (candidateRoot === memoryRoot && isPathInsideStorageRoot(namespacesRoot, resolvedPath)) {
@@ -3417,7 +3513,7 @@ var QmdResultResolver = class {
       candidateNamespaces.add(ns);
     }
     if (isPathInsideStorageRoot(namespacesRoot, resolvedPath)) {
-      const relativeToNamespaces = path8.relative(namespacesRoot, resolvedPath);
+      const relativeToNamespaces = path9.relative(namespacesRoot, resolvedPath);
       const [namespaceSegment] = relativeToNamespaces.split(/[\\/]/);
       if (namespaceSegment) {
         candidateNamespaces.add(namespaceIdentityFromToken(namespaceSegment) ?? namespaceSegment);
@@ -4079,7 +4175,7 @@ function fuseDay(date, inputs, options = {}) {
 
 // src/wearables/fusion/store.ts
 import { createHash as createHash2 } from "crypto";
-import * as path9 from "path";
+import * as path10 from "path";
 var FUSION_KIND = "wearable-fusion";
 function hashFusionBody(conversations) {
   return createHash2("sha256").update(JSON.stringify(conversations), "utf-8").digest("hex");
@@ -4266,7 +4362,7 @@ var FusionArtifactStore = class {
         `invalid wearable fusion date '${String(date)}' \u2014 expected YYYY-MM-DD`
       );
     }
-    return path9.join(this.wearablesDir, FUSION_DIR_NAME, `${date}.md`);
+    return path10.join(this.wearablesDir, FUSION_DIR_NAME, `${date}.md`);
   }
   async writeFusedDay(date, serialized) {
     const filePath = this.fusedDayPath(date);
@@ -4303,7 +4399,7 @@ var FusionArtifactStore = class {
   }
   /** List dates with stored fused artifacts, newest first. */
   async listFusedDays() {
-    const fusionDir = path9.join(this.wearablesDir, FUSION_DIR_NAME);
+    const fusionDir = path10.join(this.wearablesDir, FUSION_DIR_NAME);
     await this.assertPathContained(fusionDir);
     let entries;
     try {
@@ -4347,10 +4443,10 @@ var FusionArtifactStore = class {
     try {
       rootReal = await this.io.realpath(this.memoryDir);
     } catch {
-      rootReal = path9.resolve(this.memoryDir);
+      rootReal = path10.resolve(this.memoryDir);
     }
     await this.assertNoEscape(rootReal, this.wearablesDir);
-    await this.assertNoEscape(rootReal, path9.dirname(targetPath));
+    await this.assertNoEscape(rootReal, path10.dirname(targetPath));
     await this.assertNoEscape(rootReal, targetPath);
     await this.assertFusionDirNotSymlinked();
   }
@@ -4364,7 +4460,7 @@ var FusionArtifactStore = class {
    * (a fresh write creates a real directory lexically under the root).
    */
   async assertFusionDirNotSymlinked() {
-    const fusionDir = path9.join(this.wearablesDir, FUSION_DIR_NAME);
+    const fusionDir = path10.join(this.wearablesDir, FUSION_DIR_NAME);
     let stat4;
     try {
       stat4 = await this.io.lstat(fusionDir);
@@ -4500,7 +4596,7 @@ function reconstructFusionInputs(date, dayTranscripts) {
 
 // src/meetings/store.ts
 import { createHash as createHash3 } from "crypto";
-import * as path10 from "path";
+import * as path11 from "path";
 var MEETINGS_DIR_NAME = "meetings";
 var MEETING_KIND = "meeting";
 var MEETING_FORMAT_VERSION = 1;
@@ -4669,7 +4765,7 @@ var MeetingRecordStore = class {
   constructor(memoryDir, io) {
     this.memoryDir = memoryDir;
     this.io = io;
-    this.meetingsDir = path10.join(memoryDir, MEETINGS_DIR_NAME);
+    this.meetingsDir = path11.join(memoryDir, MEETINGS_DIR_NAME);
   }
   memoryDir;
   io;
@@ -4685,7 +4781,7 @@ var MeetingRecordStore = class {
     if (idDate !== date) {
       throw new Error(`meeting id '${id}' does not belong to date '${date}'`);
     }
-    return path10.join(this.meetingsDir, date, `${id}.md`);
+    return path11.join(this.meetingsDir, date, `${id}.md`);
   }
   /** Idempotently persist a record: skip the write when contentHash is unchanged. */
   async saveMeetingRecord(record) {
@@ -4716,7 +4812,7 @@ var MeetingRecordStore = class {
     if (!isValidTranscriptDate(date)) {
       throw new Error(`invalid meeting date '${String(date)}' \u2014 expected YYYY-MM-DD`);
     }
-    const dayDir = path10.join(this.meetingsDir, date);
+    const dayDir = path11.join(this.meetingsDir, date);
     await this.assertPathContained(dayDir);
     let entries;
     try {
@@ -4784,10 +4880,10 @@ var MeetingRecordStore = class {
     try {
       rootReal = await this.io.realpath(this.memoryDir);
     } catch {
-      rootReal = path10.resolve(this.memoryDir);
+      rootReal = path11.resolve(this.memoryDir);
     }
     await this.assertNoEscape(rootReal, this.meetingsDir);
-    await this.assertNoEscape(rootReal, path10.dirname(targetPath));
+    await this.assertNoEscape(rootReal, path11.dirname(targetPath));
     await this.assertNoEscape(rootReal, targetPath);
     await this.assertNotSymlink(this.meetingsDir, "directory");
     const dayDir = this.dayDirWithin(targetPath);
@@ -4797,11 +4893,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 = path10.relative(this.meetingsDir, targetPath);
-    if (rel === "" || rel.startsWith("..") || path10.isAbsolute(rel)) return null;
-    const first = rel.split(path10.sep)[0];
+    const rel = path11.relative(this.meetingsDir, targetPath);
+    if (rel === "" || rel.startsWith("..") || path11.isAbsolute(rel)) return null;
+    const first = rel.split(path11.sep)[0];
     if (first === void 0 || first.length === 0) return null;
-    return path10.join(this.meetingsDir, first);
+    return path11.join(this.meetingsDir, first);
   }
   async assertNotSymlink(target, kind) {
     let stat4;
@@ -4812,7 +4908,7 @@ var MeetingRecordStore = class {
       throw err;
     }
     if (stat4.isSymbolicLink) {
-      const label = path10.relative(this.memoryDir, target) || MEETINGS_DIR_NAME;
+      const label = path11.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)`
       );
@@ -4836,8 +4932,8 @@ var SORT_STR = (a, b) => a < b ? -1 : a > b ? 1 : 0;
 
 // src/storage/buffer-session-files.ts
 import { createHash as createHash4 } from "crypto";
-import { lstat as lstat3, readdir as readdir4, unlink as unlink3 } from "fs/promises";
-import path11 from "path";
+import { lstat as lstat4, readdir as readdir4, unlink as unlink3 } from "fs/promises";
+import path12 from "path";
 function isMissing(err) {
   return err?.code === "ENOENT";
 }
@@ -4880,10 +4976,10 @@ var BufferSessionFiles = class {
   io;
   dirVerified = false;
   get dir() {
-    return path11.join(this.stateDir, "buffer");
+    return path12.join(this.stateDir, "buffer");
   }
   fileFor(key) {
-    return path11.join(this.dir, bufferSessionFileName(key));
+    return path12.join(this.dir, bufferSessionFileName(key));
   }
   /**
    * Refuse a symlinked buffer directory: following it would send buffered
@@ -4895,7 +4991,7 @@ var BufferSessionFiles = class {
     if (this.dirVerified) return;
     let stat4 = null;
     try {
-      stat4 = await lstat3(this.dir);
+      stat4 = await lstat4(this.dir);
     } catch (err) {
       if (!(err instanceof Error) || !isMissing(asFsError(err))) throw err;
     }
@@ -4936,7 +5032,7 @@ var BufferSessionFiles = class {
     const entries = /* @__PURE__ */ new Map();
     for (const name of names) {
       try {
-        const body = JSON.parse(await this.io.read(path11.join(this.dir, name)));
+        const body = JSON.parse(await this.io.read(path12.join(this.dir, name)));
         const parsed = entryFromBody(body);
         if (!parsed) throw new Error("invalid buffer session file shape");
         if (entries.has(parsed.key)) {
@@ -4960,7 +5056,7 @@ var BufferSessionFiles = class {
   async readLegacy(hasSessionFiles) {
     let raw;
     try {
-      raw = await this.io.read(path11.join(this.stateDir, "buffer.json"));
+      raw = await this.io.read(path12.join(this.stateDir, "buffer.json"));
     } catch (err) {
       if (err instanceof SecureStoreLockedError) throw err;
       if (err instanceof Error && isMissing(asFsError(err))) return null;
@@ -4993,7 +5089,7 @@ var BufferSessionFiles = class {
         await this.save(key, entry);
       }
       try {
-        await unlink3(path11.join(this.stateDir, "buffer.json"));
+        await unlink3(path12.join(this.stateDir, "buffer.json"));
       } catch (err) {
         if (!(err instanceof Error) || !isMissing(asFsError(err))) throw err;
       }
@@ -5022,7 +5118,7 @@ var BufferSessionFiles = class {
     for (const name of existing) {
       if (live.has(name)) continue;
       try {
-        await unlink3(path11.join(this.dir, name));
+        await unlink3(path12.join(this.dir, name));
       } catch (err) {
         if (!(err instanceof Error) || !isMissing(asFsError(err))) throw err;
       }
@@ -5032,7 +5128,7 @@ var BufferSessionFiles = class {
 
 // src/storage/supersession-audit.ts
 import { readdir as readdir5 } from "fs/promises";
-import path12 from "path";
+import path13 from "path";
 async function hasSupersessionAudit(lookup, oldMemoryId, newMemoryId, auditBody, structuredAttributes) {
   let entries;
   try {
@@ -5044,7 +5140,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(path13.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
     ))) {
@@ -5136,12 +5232,12 @@ Reason: ${reason}`;
 // src/storage/dropped-extraction-chunk.ts
 import { randomUUID } from "crypto";
 import { mkdir } from "fs/promises";
-import path13 from "path";
+import path14 from "path";
 async function saveDroppedExtractionChunk(stateDir, writeSecureFile, bufferKey, reason, turns) {
-  const droppedDir = path13.join(stateDir, "dropped");
+  const droppedDir = path14.join(stateDir, "dropped");
   await mkdir(droppedDir, { recursive: true });
   const safeKey = bufferKey.replace(/[^a-zA-Z0-9._-]/g, "-").slice(0, 80) || "default";
-  const filePath = path13.join(droppedDir, `${Date.now()}-${randomUUID().slice(0, 8)}-${safeKey}.json`);
+  const filePath = path14.join(droppedDir, `${Date.now()}-${randomUUID().slice(0, 8)}-${safeKey}.json`);
   const payload = { bufferKey, reason, droppedAt: (/* @__PURE__ */ new Date()).toISOString(), turns };
   await writeSecureFile(filePath, JSON.stringify(payload, null, 2));
   return filePath;
@@ -6147,17 +6243,17 @@ function inferEntityTypeFromContent(content) {
 }
 var KNOWN_ENTITY_FILENAME_PREFIXES = /* @__PURE__ */ new Set(["company", "other", "person", "place", "project", "tool", "topic"]);
 function inferEntityTypeFromFilename(pathRel) {
-  const basename = path14.basename(pathRel, ".md").toLowerCase();
+  const basename = path15.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(path14.sep).join("/");
+  const normalizedPath = pathRel.split(path15.sep).join("/");
   let normalizedFrontmatter = frontmatter;
   if (normalizedPath === "entities" || normalizedPath.startsWith("entities/") || normalizedPath.includes("/entities/")) {
-    const basename = path14.basename(pathRel, ".md");
+    const basename = path15.basename(pathRel, ".md");
     const inferredType = inferEntityTypeFromContent(content) || inferEntityTypeFromFilename(pathRel) || "entity";
     const existingTags = Array.isArray(frontmatter.tags) ? frontmatter.tags : [];
     normalizedFrontmatter = {
@@ -6630,9 +6726,9 @@ var StorageManager3 = class _StorageManager extends TombstoneBlockedCaptureIndex
     this.entitySchemas = entitySchemas;
     this.deletionRevisionStore = new DeletionRevisionStore({
       baseDir,
-      deletionRevisionMetadataPath: path14.join(baseDir, ".offline-sync", "deletion-revisions.v1.json"),
-      invalidationCommitMetadataPath: path14.join(baseDir, ".offline-sync", "invalidation-commits.v1.json"),
-      deletionRevisionLockPath: path14.join(baseDir, ".offline-sync", "deletion-revisions.v1.json.lock"),
+      deletionRevisionMetadataPath: path15.join(baseDir, ".offline-sync", "deletion-revisions.v1.json"),
+      invalidationCommitMetadataPath: path15.join(baseDir, ".offline-sync", "invalidation-commits.v1.json"),
+      deletionRevisionLockPath: path15.join(baseDir, ".offline-sync", "deletion-revisions.v1.json.lock"),
       assertManagedStoragePath: (filePath, method) => this.assertManagedStoragePath(filePath, method)
     });
     this.casRevisions = new CasRevisionHost(baseDir);
@@ -6786,6 +6882,8 @@ var StorageManager3 = class _StorageManager extends TombstoneBlockedCaptureIndex
   onCatalogWrite;
   /** Post-write embedding hook (#2019). Installed by the orchestrator; fire-and-forget. */
   onMemoryWrite;
+  /** Request search maintenance after a completed entity replay. */
+  onEntityMigrationComplete;
   notifyMemoryWrite(filePath) {
     try {
       this.onMemoryWrite?.(filePath);
@@ -6818,8 +6916,8 @@ var StorageManager3 = class _StorageManager extends TombstoneBlockedCaptureIndex
   }
   /** Whether `filePath` resolves to `stateDir` itself or a path contained in it. */
   isStateFilePath(filePath) {
-    const rel = path14.relative(this.stateDir, path14.resolve(filePath));
-    return rel === "" || !rel.startsWith("..") && !path14.isAbsolute(rel);
+    const rel = path15.relative(this.stateDir, path15.resolve(filePath));
+    return rel === "" || !rel.startsWith("..") && !path15.isAbsolute(rel);
   }
   // ── Tombstone store (issue #1579) ───────────────────────────────────────
   // Instance-scoped (rule 11) + namespace-scoped (rule 42) tombstone index.
@@ -6934,8 +7032,8 @@ var StorageManager3 = class _StorageManager extends TombstoneBlockedCaptureIndex
    * /srv/cold/remnic), skipping the patch and stranding a stale hot entry.
    */
   isColdOrArchiveTierPath(p) {
-    const rel = path14.relative(this.baseDir, p);
-    return rel === "cold" || rel === "archive" || rel.startsWith(`cold${path14.sep}`) || rel.startsWith(`archive${path14.sep}`);
+    const rel = path15.relative(this.baseDir, p);
+    return rel === "cold" || rel === "archive" || rel.startsWith(`cold${path15.sep}`) || rel.startsWith(`archive${path15.sep}`);
   }
   /**
    * Mark the secure-store as required for this storage instance.
@@ -7022,7 +7120,7 @@ var StorageManager3 = class _StorageManager extends TombstoneBlockedCaptureIndex
         void 0,
         this.baseDir
       );
-      const rel = path14.relative(this.baseDir, filePath).split(path14.sep).join("/");
+      const rel = path15.relative(this.baseDir, filePath).split(path15.sep).join("/");
       return `${rel}:${version.versionId}`;
     } catch (err) {
       log.warn(
@@ -7067,10 +7165,10 @@ var StorageManager3 = class _StorageManager extends TombstoneBlockedCaptureIndex
     _StorageManager.okfConformanceByDir.set(memoryDir, enabled !== false);
   }
   okfConformanceEnabled() {
-    for (let dir = this.baseDir; ; dir = path14.dirname(dir)) {
+    for (let dir = this.baseDir; ; dir = path15.dirname(dir)) {
       const registered = _StorageManager.okfConformanceByDir.get(dir);
       if (registered !== void 0) return registered;
-      if (dir === path14.dirname(dir)) return true;
+      if (dir === path15.dirname(dir)) return true;
     }
   }
   /**
@@ -7114,12 +7212,12 @@ var StorageManager3 = class _StorageManager extends TombstoneBlockedCaptureIndex
   }
   identityFilePath(workspaceDir, namespace) {
     const rawNamespace = typeof namespace === "string" ? namespace.trim() : "";
-    if (!rawNamespace) return path14.join(workspaceDir, "IDENTITY.md");
+    if (!rawNamespace) return path15.join(workspaceDir, "IDENTITY.md");
     const safeNamespace = rawNamespace.replace(/[^a-zA-Z0-9._-]/g, "-");
-    return path14.join(workspaceDir, `IDENTITY.${safeNamespace}.md`);
+    return path15.join(workspaceDir, `IDENTITY.${safeNamespace}.md`);
   }
   versionFilePath(kind) {
-    return path14.join(this.stateDir, `.${kind}-version.log`);
+    return path15.join(this.stateDir, `.${kind}-version.log`);
   }
   bumpSharedVersion(kind, fallbackMap) {
     const filePath = this.versionFilePath(kind);
@@ -7226,7 +7324,7 @@ var StorageManager3 = class _StorageManager extends TombstoneBlockedCaptureIndex
   // memories.
   // -------------------------------------------------------------------------
   get wearablesDir() {
-    return path14.join(this.baseDir, WEARABLES_DIR_NAME);
+    return path15.join(this.baseDir, WEARABLES_DIR_NAME);
   }
   /**
    * Resolve the on-disk path for a source/day transcript. Throws on
@@ -7242,7 +7340,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 path14.join(this.wearablesDir, sourceId, `${date}.md`);
+    return path15.join(this.wearablesDir, sourceId, `${date}.md`);
   }
   async writeWearableDayTranscript(sourceId, date, serialized) {
     const targetPath = this.wearableTranscriptPath(sourceId, date);
@@ -7271,7 +7369,7 @@ var StorageManager3 = class _StorageManager extends TombstoneBlockedCaptureIndex
       readDir: (d) => readdir6(d),
       deleteFile: (p) => unlink4(p),
       realpath: (p) => realpath3(p),
-      lstat: (p) => lstat4(p).then((st) => ({ isSymbolicLink: st.isSymbolicLink() }))
+      lstat: (p) => lstat5(p).then((st) => ({ isSymbolicLink: st.isSymbolicLink() }))
     });
   }
   _meetingRecordStore;
@@ -7289,7 +7387,7 @@ var StorageManager3 = class _StorageManager extends TombstoneBlockedCaptureIndex
       readDir: (d) => readdir6(d),
       deleteFile: (p) => unlink4(p),
       realpath: (p) => realpath3(p),
-      lstat: (p) => lstat4(p).then((st) => ({ isSymbolicLink: st.isSymbolicLink() }))
+      lstat: (p) => lstat5(p).then((st) => ({ isSymbolicLink: st.isSymbolicLink() }))
     });
   }
   /**
@@ -7356,25 +7454,25 @@ var StorageManager3 = class _StorageManager extends TombstoneBlockedCaptureIndex
     });
   }
   get factsDir() {
-    return path14.join(this.baseDir, "facts");
+    return path15.join(this.baseDir, "facts");
   }
   get correctionsDir() {
-    return path14.join(this.baseDir, "corrections");
+    return path15.join(this.baseDir, "corrections");
   }
   get proceduresDir() {
-    return path14.join(this.baseDir, "procedures");
+    return path15.join(this.baseDir, "procedures");
   }
   get reasoningTracesDir() {
-    return path14.join(this.baseDir, "reasoning-traces");
+    return path15.join(this.baseDir, "reasoning-traces");
   }
   get entitiesDir() {
-    return path14.join(this.baseDir, "entities");
+    return path15.join(this.baseDir, "entities");
   }
   resolveEntityFilePath(name) {
     if (typeof name !== "string") return null;
-    const filePath = path14.resolve(this.entitiesDir, `${name}.md`);
-    const relative2 = path14.relative(this.entitiesDir, filePath);
-    if (relative2 === "" || relative2.startsWith("..") || path14.isAbsolute(relative2)) {
+    const filePath = path15.resolve(this.entitiesDir, `${name}.md`);
+    const relative2 = path15.relative(this.entitiesDir, filePath);
+    if (relative2 === "" || relative2.startsWith("..") || path15.isAbsolute(relative2)) {
       return null;
     }
     return filePath;
@@ -7385,7 +7483,7 @@ var StorageManager3 = class _StorageManager extends TombstoneBlockedCaptureIndex
   async readDependencyPropagationQueueFile(filePath) {
     const target = await resolveSafeStoragePath(
       this.baseDir,
-      path14.relative(
+      path15.relative(
         this.baseDir,
         this.assertManagedStoragePath(filePath, "storage.readDependencyPropagationQueueFile")
       )
@@ -7395,7 +7493,7 @@ var StorageManager3 = class _StorageManager extends TombstoneBlockedCaptureIndex
   async writeDependencyPropagationQueueFile(filePath, content) {
     const target = await resolveSafeStoragePath(
       this.baseDir,
-      path14.relative(
+      path15.relative(
         this.baseDir,
         this.assertManagedStoragePath(filePath, "storage.writeDependencyPropagationQueueFile")
       )
@@ -7410,10 +7508,10 @@ var StorageManager3 = class _StorageManager extends TombstoneBlockedCaptureIndex
     });
   }
   assertManagedStoragePath(filePath, method) {
-    const resolved = path14.resolve(filePath);
-    const base = path14.resolve(this.baseDir);
-    const rel = path14.relative(base, resolved);
-    if (rel === "" || rel === ".." || rel.startsWith(`..${path14.sep}`) || path14.isAbsolute(rel)) {
+    const resolved = path15.resolve(filePath);
+    const base = path15.resolve(this.baseDir);
+    const rel = path15.relative(base, resolved);
+    if (rel === "" || rel === ".." || rel.startsWith(`..${path15.sep}`) || path15.isAbsolute(rel)) {
       throw new Error(`${method}: file path escapes memory dir`);
     }
     return resolved;
@@ -7450,7 +7548,7 @@ var StorageManager3 = class _StorageManager extends TombstoneBlockedCaptureIndex
   async digestOfflineSyncFile(filePath) {
     const target = this.assertManagedStoragePath(filePath, "storage.digestOfflineSyncFile");
     const st = await stat3(target);
-    const relPath = path14.relative(this.baseDir, target).split(path14.sep).join("/");
+    const relPath = path15.relative(this.baseDir, target).split(path15.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) {
@@ -7535,7 +7633,7 @@ var StorageManager3 = class _StorageManager extends TombstoneBlockedCaptureIndex
       const cache = this.offlineSyncDigestCache;
       if (!cache) return;
       const entries = [...cache.entries()].sort(([a], [b]) => a.localeCompare(b)).map(([entryPath, entry]) => ({ path: entryPath, ...entry }));
-      await mkdir2(path14.dirname(this.offlineSyncDigestCachePath), { recursive: true });
+      await mkdir2(path15.dirname(this.offlineSyncDigestCachePath), { recursive: true });
       await writeFile(this.offlineSyncDigestCachePath, `${JSON.stringify({ version: 1, entries })}
 `, "utf-8");
     }).catch((err) => {
@@ -7636,7 +7734,7 @@ var StorageManager3 = class _StorageManager extends TombstoneBlockedCaptureIndex
   }
   async appendStorageSecureFileUnlocked(filePath, content) {
     const writeKey = this.resolveWriteKey();
-    await mkdir2(path14.dirname(filePath), { recursive: true });
+    await mkdir2(path15.dirname(filePath), { recursive: true });
     if (writeKey === null) {
       try {
         if (await this.isEncryptedFileHeader(filePath)) {
@@ -7662,13 +7760,13 @@ var StorageManager3 = class _StorageManager extends TombstoneBlockedCaptureIndex
     this.notifyCatalogWriteForPath(filePath);
   }
   get stateDir() {
-    return path14.join(this.baseDir, "state");
+    return path15.join(this.baseDir, "state");
   }
   get offlineSyncDigestCachePath() {
-    return path14.join(this.baseDir, ".offline-sync", "digest-cache.v1.json");
+    return path15.join(this.baseDir, ".offline-sync", "digest-cache.v1.json");
   }
   get entitySynthesisQueuePath() {
-    return path14.join(this.stateDir, "entity-synthesis-queue.json");
+    return path15.join(this.stateDir, "entity-synthesis-queue.json");
   }
   // ── Tombstone store access (issue #1579) ─────────────────────────────────
   /**
@@ -7678,7 +7776,7 @@ var StorageManager3 = class _StorageManager extends TombstoneBlockedCaptureIndex
    * helpers are injected into the store).
    */
   get tombstonesPath() {
-    return path14.join(this.stateDir, "tombstones.jsonl");
+    return path15.join(this.stateDir, "tombstones.jsonl");
   }
   /**
    * Configure the tombstone invariant for this storage instance. Installed
@@ -7857,7 +7955,7 @@ var StorageManager3 = class _StorageManager extends TombstoneBlockedCaptureIndex
    * resolves to the legacy short bounds instead of the converge deadline.
    */
   captureLockLimitSource() {
-    const options = this.factHashIndexLockOptions;
+    const options = { ...this.factHashIndexLockOptions, ...scopedCaptureWriteLockLimits(this) };
     const keys = ["captureWriteLockInitialDelayMs", "captureWriteLockMaxDelayMs", "captureWriteLockDeadlineMs", "captureWriteLockSignal"];
     return keys.some((key) => options[key] !== void 0) ? options : void 0;
   }
@@ -7991,55 +8089,55 @@ var StorageManager3 = class _StorageManager extends TombstoneBlockedCaptureIndex
     return legacyMatches.length > 0 ? [...new Set(legacyMatches.map((content) => ContentHashIndex.computeHash(content)))] : [persistedHash];
   }
   get questionsDir() {
-    return path14.join(this.baseDir, "questions");
+    return path15.join(this.baseDir, "questions");
   }
   get artifactsDir() {
-    return path14.join(this.baseDir, "artifacts");
+    return path15.join(this.baseDir, "artifacts");
   }
   get identityDir() {
-    return path14.join(this.baseDir, "identity");
+    return path15.join(this.baseDir, "identity");
   }
   get identityAnchorPath() {
-    return path14.join(this.identityDir, "identity-anchor.md");
+    return path15.join(this.identityDir, "identity-anchor.md");
   }
   get identityIncidentsDir() {
-    return path14.join(this.identityDir, "incidents");
+    return path15.join(this.identityDir, "incidents");
   }
   get identityAuditsWeeklyDir() {
-    return path14.join(this.identityDir, "audits", "weekly");
+    return path15.join(this.identityDir, "audits", "weekly");
   }
   get identityAuditsMonthlyDir() {
-    return path14.join(this.identityDir, "audits", "monthly");
+    return path15.join(this.identityDir, "audits", "monthly");
   }
   get identityImprovementLoopsPath() {
-    return path14.join(this.identityDir, "improvement-loops.md");
+    return path15.join(this.identityDir, "improvement-loops.md");
   }
   get identityReflectionsPath() {
-    return path14.join(this.identityDir, "reflections.md");
+    return path15.join(this.identityDir, "reflections.md");
   }
   get profilePath() {
-    return path14.join(this.baseDir, "profile.md");
+    return path15.join(this.baseDir, "profile.md");
   }
   get memoryActionsPath() {
-    return path14.join(this.stateDir, "memory-actions.jsonl");
+    return path15.join(this.stateDir, "memory-actions.jsonl");
   }
   get memoryLifecycleLedgerPath() {
-    return path14.join(this.stateDir, "memory-lifecycle-ledger.jsonl");
+    return path15.join(this.stateDir, "memory-lifecycle-ledger.jsonl");
   }
   get compressionGuidelinesPath() {
-    return path14.join(this.stateDir, "compression-guidelines.md");
+    return path15.join(this.stateDir, "compression-guidelines.md");
   }
   get compressionGuidelineDraftPath() {
-    return path14.join(this.stateDir, "compression-guidelines.draft.md");
+    return path15.join(this.stateDir, "compression-guidelines.draft.md");
   }
   get compressionGuidelineStatePath() {
-    return path14.join(this.stateDir, "compression-guideline-state.json");
+    return path15.join(this.stateDir, "compression-guideline-state.json");
   }
   get compressionGuidelineDraftStatePath() {
-    return path14.join(this.stateDir, "compression-guideline-draft-state.json");
+    return path15.join(this.stateDir, "compression-guideline-draft-state.json");
   }
   get behaviorSignalsPath() {
-    return path14.join(this.stateDir, "behavior-signals.jsonl");
+    return path15.join(this.stateDir, "behavior-signals.jsonl");
   }
   /**
    * In-memory dedup key set for behavior-signals appends (issue #1909),
@@ -8071,7 +8169,7 @@ var StorageManager3 = class _StorageManager extends TombstoneBlockedCaptureIndex
    * governance sweeps can treat it uniformly.
    */
   get bufferSurpriseLedgerPath() {
-    return path14.join(this.stateDir, "buffer-surprise-ledger.jsonl");
+    return path15.join(this.stateDir, "buffer-surprise-ledger.jsonl");
   }
   /**
    * Entity alias table loaded from THIS store's config/aliases.json.
@@ -8134,7 +8232,7 @@ var StorageManager3 = class _StorageManager extends TombstoneBlockedCaptureIndex
     this.loadAliasesSync();
   }
   loadAliasesSync() {
-    const aliasPath = path14.join(this.baseDir, "config", "aliases.json");
+    const aliasPath = path15.join(this.baseDir, "config", "aliases.json");
     this.userAliases = {};
     const raw = readEntityAliasConfigSync(this.baseDir);
     if (raw === void 0) return;
@@ -8172,9 +8270,9 @@ var StorageManager3 = class _StorageManager extends TombstoneBlockedCaptureIndex
     await mkdir2(this.baseDir, { recursive: true });
     await validateRoots(this.baseDir, this.entitiesDir, this.stateDir, this.archiveDir);
     const today = (/* @__PURE__ */ new Date()).toISOString().slice(0, 10);
-    await mkdir2(path14.join(this.factsDir, today), { recursive: true });
-    await mkdir2(path14.join(this.proceduresDir, today), { recursive: true });
-    await mkdir2(path14.join(this.reasoningTracesDir, today), { recursive: true });
+    await mkdir2(path15.join(this.factsDir, today), { recursive: true });
+    await mkdir2(path15.join(this.proceduresDir, today), { recursive: true });
+    await mkdir2(path15.join(this.reasoningTracesDir, today), { recursive: true });
     await mkdir2(this.correctionsDir, { recursive: true });
     await mkdir2(this.entitiesDir, { recursive: true });
     await mkdir2(this.stateDir, { recursive: true });
@@ -8184,7 +8282,7 @@ var StorageManager3 = class _StorageManager extends TombstoneBlockedCaptureIndex
     await mkdir2(this.identityIncidentsDir, { recursive: true });
     await mkdir2(this.identityAuditsWeeklyDir, { recursive: true });
     await mkdir2(this.identityAuditsMonthlyDir, { recursive: true });
-    await mkdir2(path14.join(this.baseDir, "config"), { recursive: true });
+    await mkdir2(path15.join(this.baseDir, "config"), { recursive: true });
     await this.entityCanonicalIdMigration.begin(options.waitForEntityMigration !== false, this.entitiesDir);
     if (this.hotMemoriesCacheEnabled && this.getMemoryCorpusVersion() === 0) {
       this.bumpMemoryCorpusVersion();
@@ -8207,11 +8305,11 @@ var StorageManager3 = class _StorageManager extends TombstoneBlockedCaptureIndex
   async resolveCategoryWritePath(category, id, today) {
     if (category === "correction") {
       await mkdir2(this.correctionsDir, { recursive: true });
-      return path14.join(this.correctionsDir, `${id}.md`);
+      return path15.join(this.correctionsDir, `${id}.md`);
     }
-    const datedDir = path14.join(getCategoryDir(this.baseDir, category), today);
+    const datedDir = path15.join(getCategoryDir(this.baseDir, category), today);
     await mkdir2(datedDir, { recursive: true });
-    return path14.join(datedDir, `${id}.md`);
+    return path15.join(datedDir, `${id}.md`);
   }
   async findExistingTombstoneBlockedMemory(content, category, sourceConnector) {
     const identity = buildExplicitCaptureDedupKey(content, category, sourceConnector);
@@ -8590,7 +8688,7 @@ ${sanitized.text}
     await this.ensureDirectories();
     const now = /* @__PURE__ */ new Date();
     const day = now.toISOString().slice(0, 10);
-    const dir = path14.join(this.artifactsDir, day);
+    const dir = path15.join(this.artifactsDir, day);
     await mkdir2(dir, { recursive: true });
     const id = `artifact-${Date.now()}-${Math.random().toString(36).slice(2, 6)}`;
     const fm = {
@@ -8617,7 +8715,7 @@ ${sanitized.text}
       log.warn(`artifact content rejected for ${id}; violations=${sanitized.violations.join(", ")}`);
       return "";
     }
-    const filePath = path14.join(dir, `${id}.md`);
+    const filePath = path15.join(dir, `${id}.md`);
     await this.writeStorageSecureFile(filePath, `${serializeFrontmatter(this.withOkfType(fm))}
 
 ${sanitized.text}
@@ -8911,7 +9009,7 @@ ${sanitized.text}
    * per-process in-memory cache safe across process boundaries.
    */
   invalidateColdMemoriesCache() {
-    const coldRoot = path14.join(this.baseDir, "cold");
+    const coldRoot = path15.join(this.baseDir, "cold");
     _StorageManager.coldMemoriesCache.delete(coldRoot);
     this.bumpColdWriteVersion();
     invalidateAllForDir(this.baseDir);
@@ -9029,7 +9127,7 @@ ${sanitized.text}
     const correctionPaths = [];
     const factPaths = [];
     for (const filePath of filePaths) {
-      if (filePath === this.correctionsDir || filePath.startsWith(`${this.correctionsDir}${path14.sep}`)) {
+      if (filePath === this.correctionsDir || filePath.startsWith(`${this.correctionsDir}${path15.sep}`)) {
         correctionPaths.push(filePath);
       } else {
         factPaths.push(filePath);
@@ -9049,11 +9147,12 @@ ${sanitized.text}
     }
     return ordered;
   }
-  async readWindowBoundedBatch(candidateBatchPaths, remainingSlots, remainingInspectionBudget, readBatchSize) {
+  async readWindowBoundedBatch(candidateBatchPaths, remainingSlots, remainingInspectionBudget, readBatchSize, options) {
     const memories = [];
     const filePaths = [];
     const normalizedReadBatchSize = this.normalizeMemoryReadBatchSize(readBatchSize);
     for (let index = 0; index < candidateBatchPaths.length; ) {
+      checkCorpusReadAbort(options);
       if (memories.length >= remainingSlots || filePaths.length >= remainingInspectionBudget) break;
       const availableSlots = remainingSlots - memories.length;
       const availableInspectionBudget = remainingInspectionBudget - filePaths.length;
@@ -9065,7 +9164,7 @@ ${sanitized.text}
       index += candidatePaths.length;
       if (candidatePaths.length === 0) break;
       filePaths.push(...candidatePaths);
-      const parsedMemories = await this.readParsedMemoriesFromPaths(candidatePaths, candidatePaths.length);
+      const parsedMemories = await this.readParsedMemoriesFromPaths(candidatePaths, candidatePaths.length, options);
       if (parsedMemories.length === 0) continue;
       memories.push(...parsedMemories.slice(0, availableSlots));
     }
@@ -9095,7 +9194,7 @@ ${sanitized.text}
         const entries = (await readdir6(dir, { withFileTypes: true })).filter((e) => !isMacOsReplicationJunkBasename(e.name));
         for (const entry of entries) {
           checkCorpusReadAbort(options);
-          const fullPath = path14.join(dir, entry.name);
+          const fullPath = path15.join(dir, entry.name);
           if (entry.isDirectory()) {
             await readDir(fullPath);
           } else if (entry.name.endsWith(".md")) {
@@ -9135,7 +9234,7 @@ ${sanitized.text}
     return this.rememberMemorySnapshot(await this.memoryReadStore.readMemoryByPath(filePath));
   }
   resolveTierRootDir(tier) {
-    return tier === "cold" ? path14.join(this.baseDir, "cold") : this.baseDir;
+    return tier === "cold" ? path15.join(this.baseDir, "cold") : this.baseDir;
   }
   resolveMemoryDateDir(memory) {
     const preferred = memory.frontmatter.created || memory.frontmatter.updated;
@@ -9150,13 +9249,13 @@ ${sanitized.text}
   buildTierMemoryPath(memory, tier) {
     const root = this.resolveTierRootDir(tier);
     if (this.isArtifactMemory(memory)) {
-      return path14.join(root, "artifacts", this.resolveMemoryDateDir(memory), `${memory.frontmatter.id}.md`);
+      return path15.join(root, "artifacts", this.resolveMemoryDateDir(memory), `${memory.frontmatter.id}.md`);
     }
     if (memory.frontmatter.category === "correction") {
-      return path14.join(root, "corrections", `${memory.frontmatter.id}.md`);
+      return path15.join(root, "corrections", `${memory.frontmatter.id}.md`);
     }
     const dir = categoryDirName(memory.frontmatter.category);
-    return path14.join(root, dir, this.resolveMemoryDateDir(memory), `${memory.frontmatter.id}.md`);
+    return path15.join(root, dir, this.resolveMemoryDateDir(memory), `${memory.frontmatter.id}.md`);
   }
   async writeMemoryFileAtomic(targetPath, memory) {
     assertNotOkfReservedBasename(targetPath);
@@ -9235,8 +9334,8 @@ ${memory.content}
               memory.frontmatter.entityRef = current.frontmatter.entityRef;
             }
             durable = true;
-            const sourcePath = path14.resolve(current.path);
-            const destPath = path14.resolve(targetPath);
+            const sourcePath = path15.resolve(current.path);
+            const destPath = path15.resolve(targetPath);
             if (sourcePath !== destPath) {
               await recordArchiveDelete2(this.baseDir, current.path, () => this.deleteManagedStorageFile(current.path));
               this.invalidateAllMemoriesCache();
@@ -9260,8 +9359,8 @@ ${memory.content}
   }
   async migrateMemoryToTier(memory, targetTier) {
     const targetPath = this.buildTierMemoryPath(memory, targetTier);
-    const sourcePath = path14.resolve(memory.path);
-    const destPath = path14.resolve(targetPath);
+    const sourcePath = path15.resolve(memory.path);
+    const destPath = path15.resolve(targetPath);
     if (sourcePath === destPath) {
       return { changed: false, targetPath };
     }
@@ -9271,7 +9370,7 @@ ${memory.content}
     return { changed, targetPath };
   }
   get archiveDir() {
-    return path14.join(this.baseDir, "archive");
+    return path15.join(this.baseDir, "archive");
   }
   /**
    * Archive a memory by moving it from facts/ to archive/YYYY-MM-DD/.
@@ -9284,7 +9383,7 @@ ${memory.content}
       try {
         const now = lifecycle?.at ?? /* @__PURE__ */ new Date();
         const today = now.toISOString().slice(0, 10);
-        const destDir = path14.join(this.archiveDir, today);
+        const destDir = path15.join(this.archiveDir, today);
         await mkdir2(destDir, { recursive: true });
         const refIdsAtWrite = this.currentHistoricalIds();
         const updatedFm = canonicalizeEntityRefOption(
@@ -9300,7 +9399,7 @@ ${memory.content}
 
 ${current.content}
 `;
-        const destPath = path14.join(destDir, path14.basename(current.path));
+        const destPath = path15.join(destDir, path15.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") {
@@ -9534,7 +9633,7 @@ ${memory.content}
 `;
     await this.writeTombstoneBlockedFrontmatter(memory, fileContent, updated, async () => {
       this.invalidateAllMemoriesCache();
-      if (memory.path.includes(`${path14.sep}cold${path14.sep}`)) {
+      if (memory.path.includes(`${path15.sep}cold${path15.sep}`)) {
         this.invalidateColdMemoriesCache();
       }
     });
@@ -9546,7 +9645,7 @@ ${memory.content}
     }
     if (mentionReentry && !entityMentionEpoch.neutral(memory.frontmatter, updated)) entityMentionEpoch.bump(this.baseDir);
     await this.patchHotMemoriesCache({ addedPath: memory.path });
-    if (memory.path.includes(`${path14.sep}cold${path14.sep}`)) {
+    if (memory.path.includes(`${path15.sep}cold${path15.sep}`)) {
       this.invalidateColdMemoriesCache();
     }
     try {
@@ -9648,7 +9747,7 @@ ${memory.content}
     return saveDroppedExtractionChunk(this.stateDir, (file, content) => this.writeStorageSecureFile(file, content), bufferKey, reason, turns);
   }
   async loadMeta() {
-    const metaPath = path14.join(this.stateDir, "meta.json");
+    const metaPath = path15.join(this.stateDir, "meta.json");
     try {
       const raw = await this.readStorageSecureFile(metaPath);
       const parsed = JSON.parse(raw);
@@ -9681,7 +9780,7 @@ ${memory.content}
   }
   async saveMeta(state) {
     await this.ensureDirectories();
-    await this.writeStorageSecureFile(path14.join(this.stateDir, "meta.json"), JSON.stringify(state, null, 2));
+    await this.writeStorageSecureFile(path15.join(this.stateDir, "meta.json"), JSON.stringify(state, null, 2));
   }
   async appendMemoryActionEvents(events) {
     if (events.length === 0) return 0;
@@ -9750,7 +9849,7 @@ ${memory.content}
       },
       (payload) => this.appendStorageSecureFile(target, payload),
       async () => {
-        await mkdir2(path14.dirname(target), { recursive: true });
+        await mkdir2(path15.dirname(target), { recursive: true });
       }
     );
   }
@@ -9848,7 +9947,7 @@ ${memory.content}
   async appendReextractJobs(events) {
     if (events.length === 0) return 0;
     await this.ensureDirectories();
-    const filePath = path14.join(this.stateDir, "reextract-jobs.jsonl");
+    const filePath = path15.join(this.stateDir, "reextract-jobs.jsonl");
     const lines = events.map((event) => JSON.stringify(event)).join("\n") + "\n";
     try {
       await this.appendStorageSecureFile(filePath, lines);
@@ -9861,7 +9960,7 @@ ${memory.content}
   }
   async readReextractJobs(limit = 200) {
     const safeLimit = Number.isFinite(limit) ? Math.max(1, Math.min(1e3, Math.floor(limit))) : 200;
-    const filePath = path14.join(this.stateDir, "reextract-jobs.jsonl");
+    const filePath = path15.join(this.stateDir, "reextract-jobs.jsonl");
     try {
       const raw = await this.readStorageSecureFile(filePath);
       const lines = raw.split("\n").filter((line) => line.trim().length > 0);
@@ -10096,7 +10195,7 @@ ${question}
 
 **Context:** ${context}
 `;
-    const filePath = path14.join(this.questionsDir, `${id}.md`);
+    const filePath = path15.join(this.questionsDir, `${id}.md`);
     await this.writeStorageSecureFile(filePath, content);
     log.debug(`wrote question ${id} to ${filePath}`);
     this.invalidateQuestionsCache();
@@ -10155,11 +10254,11 @@ ${question}
     } catch {
     }
     const hygiene = opts?.hygiene;
-    const rotateEnabled = hygiene?.enabled === true && hygiene.rotateEnabled === true && Array.isArray(hygiene.rotatePaths) && hygiene.rotatePaths.includes(path14.basename(identityPath));
+    const rotateEnabled = hygiene?.enabled === true && hygiene.rotateEnabled === true && Array.isArray(hygiene.rotatePaths) && hygiene.rotatePaths.includes(path15.basename(identityPath));
     if (rotateEnabled) {
       const maxBytes = hygiene.rotateMaxBytes;
       if (existing.length > maxBytes) {
-        const archiveDir = path14.join(workspaceDir, hygiene.archiveDir);
+        const archiveDir = path15.join(workspaceDir, hygiene.archiveDir);
         const { newContent } = await rotateMarkdownFileToArchive({
           filePath: identityPath,
           archiveDir,
@@ -10419,7 +10518,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) => [path14.resolve(m.path), m]));
+    const memoryPathMap = new Map(memories.map((m) => [path15.resolve(m.path), m]));
     let updated = 0;
     const prevVersion = this.getMemoryCorpusVersion();
     let entityRefMoved = false;
@@ -10427,7 +10526,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(path14.resolve(entry.memoryPath)) : memoryMap.get(entry.memoryId);
+      const memory = entry.memoryPath ? memoryPathMap.get(path15.resolve(entry.memoryPath)) : memoryMap.get(entry.memoryId);
       if (!memory) continue;
       try {
         const applied = await this.withTombstoneBlockedMemoryPathLock(memory.path, async (current) => {
@@ -10459,7 +10558,7 @@ ${current.content}
         if (warm) {
           updateCacheOnWrite(this.baseDir, { ...applied.current, frontmatter: applied.newFm }, keyId);
         }
-        appliedPatches.set(path14.resolve(memory.path), {
+        appliedPatches.set(path15.resolve(memory.path), {
           accessCount: entry.newCount,
           lastAccessed: entry.lastAccessed
         });
@@ -10477,7 +10576,7 @@ ${current.content}
         const cur = getCachedMemories(this.baseDir, prevVersion, keyId);
         if (cur) {
           const reapplied = cur.map((m) => {
-            const patch = appliedPatches.get(path14.resolve(m.path));
+            const patch = appliedPatches.get(path15.resolve(m.path));
             return patch ? {
               ...m,
               frontmatter: { ...m.frontmatter, accessCount: patch.accessCount, lastAccessed: patch.lastAccessed }
@@ -10507,7 +10606,7 @@ ${current.content}
     const pathsById = /* @__PURE__ */ new Map();
     const filePathsById = /* @__PURE__ */ new Map();
     for (const filePath of filePaths) {
-      const memoryId = path14.basename(filePath, ".md");
+      const memoryId = path15.basename(filePath, ".md");
       if (!wantedIds.has(memoryId)) continue;
       const paths = filePathsById.get(memoryId) ?? [];
       paths.push(filePath);
@@ -10519,7 +10618,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(path14.resolve(filePath)));
+        const directMatch = existingPaths.find((filePath) => directCandidates.has(path15.resolve(filePath)));
         if (directMatch) {
           preferredMatches.push(directMatch);
           continue;
@@ -10531,7 +10630,7 @@ ${current.content}
             candidates.add(candidate);
           }
         }
-        const match = existingPaths.find((filePath) => candidates.has(path14.resolve(filePath)));
+        const match = existingPaths.find((filePath) => candidates.has(path15.resolve(filePath)));
         if (match) preferredMatches.push(match);
       }
       if (preferredMatches.length > 0) {
@@ -10853,11 +10952,11 @@ ${current.content}
     }
   }
   get summariesDir() {
-    return path14.join(this.baseDir, "summaries");
+    return path15.join(this.baseDir, "summaries");
   }
   async writeSummary(summary) {
     await mkdir2(this.summariesDir, { recursive: true });
-    const filePath = path14.join(this.summariesDir, `${summary.id}.json`);
+    const filePath = path15.join(this.summariesDir, `${summary.id}.json`);
     await this.writeStorageSecureFile(filePath, JSON.stringify(summary, null, 2));
     log.debug(`wrote summary ${summary.id}`);
   }
@@ -10867,7 +10966,7 @@ ${current.content}
       const summaries = [];
       for (const file of files) {
         if (isMacOsReplicationJunkBasename(file) || !file.endsWith(".json")) continue;
-        const filePath = path14.join(this.summariesDir, file);
+        const filePath = path15.join(this.summariesDir, file);
         const raw = await this.readStorageSecureFile(filePath);
         summaries.push(JSON.parse(raw));
       }
@@ -10937,13 +11036,13 @@ ${current.content}
     return archived;
   }
   async saveTopics(topics) {
-    const metaPath = path14.join(this.stateDir, "topics.json");
+    const metaPath = path15.join(this.stateDir, "topics.json");
     await mkdir2(this.stateDir, { recursive: true });
     await this.writeStorageSecureFile(metaPath, JSON.stringify({ topics, updatedAt: (/* @__PURE__ */ new Date()).toISOString() }, null, 2));
     log.debug(`saved ${topics.length} topic scores`);
   }
   async loadTopics() {
-    const metaPath = path14.join(this.stateDir, "topics.json");
+    const metaPath = path15.join(this.stateDir, "topics.json");
     try {
       const raw = await this.readStorageSecureFile(metaPath);
       return JSON.parse(raw);
@@ -11063,4 +11162,4 @@ export {
   isValidBufferSurpriseEvent,
   StorageManager3 as StorageManager
 };
-//# sourceMappingURL=chunk-L46MG2GE.js.map
+//# sourceMappingURL=chunk-GQIYL7OD.js.map