@remnic/core 9.7.7 → 9.7.9

package/dist/{chunk-KTOH7EJE.js → chunk-PV7E2FGY.js}

@@ -37,20 +37,7 @@ import {
 import {
   SPECULATIVE_TTL_DAYS,
   confidenceTier
-} from "./chunk-JO5AT6QT.js";
-import {
-  markProjectedMemoryPathInvalid,
-  readProjectedGovernanceRecord,
-  readProjectedMemoryBrowse,
-  readProjectedMemoryState,
-  readProjectedMemoryTimeline,
-  updateProjectedMemoryPath
-} from "./chunk-RHOZ5LLO.js";
-import {
-  getCachedEntities,
-  invalidateAllForDir,
-  setCachedEntities
-} from "./chunk-AWJ2FHCF.js";
+} from "./chunk-3ZVFLMFQ.js";
 import {
   inferMemoryStatus,
   isArchivedMemoryPath,
@@ -61,6 +48,14 @@ import {
   normalizeProjectionPreview,
   normalizeProjectionTags
 } from "./chunk-SCU65EZI.js";
+import {
+  markProjectedMemoryPathInvalid,
+  readProjectedGovernanceRecord,
+  readProjectedMemoryBrowse,
+  readProjectedMemoryState,
+  readProjectedMemoryTimeline,
+  updateProjectedMemoryPath
+} from "./chunk-RHOZ5LLO.js";
 import {
   rotateMarkdownFileToArchive
 } from "./chunk-DM2T26WE.js";
@@ -76,14 +71,32 @@ import {
 import {
   parseFaithfulnessField,
   serializeFaithfulnessFields
-} from "./chunk-LKT755LP.js";
+} from "./chunk-VA4WSW54.js";
 import {
   isConsolidationOperator,
   isValidDerivedFromEntry
 } from "./chunk-G7D6GZ5J.js";
 import {
   createVersion
-} from "./chunk-VF4XKTX3.js";
+} from "./chunk-VZ5OJE4X.js";
+import {
+  clearMemoryCache,
+  getCachedEntities,
+  getCachedMemories,
+  invalidateAllForDir,
+  invalidateDerivedAndGlobalForDir,
+  setCachedEntities,
+  setCachedMemories,
+  updateCacheOnDelete,
+  updateCacheOnWrite
+} from "./chunk-X47LWMKA.js";
+import {
+  clearInFlightReads,
+  deleteInFlightRead,
+  deleteInFlightReadsForDir,
+  getInFlightRead,
+  setInFlightRead
+} from "./chunk-PDJTHRAW.js";
 import {
   computeContentHash,
   normalizeContent
@@ -339,8 +352,9 @@ var MemoryReadStore = class {
   async readAllColdMemories() {
     const coldRoot = this.deps.resolveTierRootDir("cold");
     const currentColdVersion = this.deps.readColdWriteVersion();
+    const keyId = this.deps.hotCacheKeyId();
     const cached = this.deps.storageManagerClass.coldMemoriesCache.get(coldRoot);
-    if (cached && Date.now() - cached.loadedAt < this.deps.storageManagerClass.COLD_SCAN_CACHE_TTL_MS && cached.coldVersion === currentColdVersion) {
+    if (cached && cached.keyId === keyId && Date.now() - cached.loadedAt < this.deps.storageManagerClass.COLD_SCAN_CACHE_TTL_MS && cached.coldVersion === currentColdVersion) {
       return cached.memories;
     }
     const filePaths = [];
@@ -364,7 +378,7 @@ var MemoryReadStore = class {
     };
     await collectPaths(coldRoot);
     const memories = await this.deps.readParsedMemoriesFromPaths(filePaths, 50);
-    this.deps.storageManagerClass.coldMemoriesCache.set(coldRoot, { memories, loadedAt: Date.now(), coldVersion: currentColdVersion });
+    this.deps.storageManagerClass.coldMemoriesCache.set(coldRoot, { memories, loadedAt: Date.now(), coldVersion: currentColdVersion, keyId });
     return memories;
   }
   /** Read a single memory file by its absolute path. Returns null if unreadable. */
@@ -3952,9 +3966,10 @@ function parseExtractionRetryStateEntries(raw) {
   return valid;
 }
 var StorageManager3 = class _StorageManager {
-  constructor(baseDir, entitySchemas) {
+  constructor(baseDir, entitySchemas, hotMemoriesCacheEnabledOverride) {
     this.baseDir = baseDir;
     this.entitySchemas = entitySchemas;
+    this.hotMemoriesCacheEnabled = hotMemoriesCacheEnabledOverride ?? _StorageManager.hotMemoriesCacheDefaultByDir.get(baseDir) ?? _StorageManager.hotMemoriesCacheDefault;
     this.loadAliasesSync();
   }
   baseDir;
@@ -3969,22 +3984,66 @@ var StorageManager3 = class _StorageManager {
   // 1 minute
   static artifactWriteVersionByDir = /* @__PURE__ */ new Map();
   static memoryStatusVersionByDir = /* @__PURE__ */ new Map();
+  // Corpus version sentinel (issue #1902): bumped on every memory-FILE mutation
+  // so the version-keyed hot-memories cache stays coherent across processes,
+  // without touching memory-status (which would invalidate the entity cache on
+  // every plain create). In-process fallback when the on-disk sentinel is
+  // unavailable; canonical source is state/.memory-corpus-version.log.
+  static memoryCorpusVersionByDir = /* @__PURE__ */ new Map();
   static secureStoreEntityCacheKeyIds = /* @__PURE__ */ new WeakMap();
   static nextSecureStoreEntityCacheKeyId = 1;
   // In-process fallback for the cold-write sentinel (used when the disk file
   // is not accessible).  The canonical source of truth is state/cold-write.log.
   static coldWriteVersionByDir = /* @__PURE__ */ new Map();
-  // Module-level cache for readAllMemories() keyed by base directory.
-  // Shared across all StorageManager instances to avoid duplicate I/O when
-  // multiple concurrent callers (e.g. verifiedRecall + verifiedRules) read the
-  // same directory simultaneously.  In-flight deduplication prevents multiple
-  // concurrent reads of the same directory.
-  //
-  // Stale-while-revalidate: once the cache has a value, subsequent reads after
-  // TTL expiry return the stale cached data immediately and kick off a background
-  // refresh.  This eliminates the 13-60 s cold-scan penalty that would otherwise
-  // block recall requests every 5 minutes on large memory collections (80k+ files).
-  static allMemoriesInFlight = /* @__PURE__ */ new Map();
+  /**
+   * Process-wide default for the hot-memories result cache gate (issue #1902).
+   * Set once from config by the orchestrator/access layer via
+   * setHotMemoriesCacheDefault() so that EVERY StorageManager — including the
+   * ephemeral instances recall sub-stages (verified-recall, semantic-rule
+   * verification, ...) construct over the same dir — honors the operator's
+   * hotMemoriesCacheEnabled setting. The constructor option overrides this
+   * per-instance (tests). Defaults true (cache on).
+   */
+  static hotMemoriesCacheDefault = true;
+  /**
+   * Per-memory-directory override of the hot-cache gate (issue #1902, Codex
+   * P2). setHotMemoriesCacheDefault(memoryDir, enabled) registers the
+   * operator's setting keyed by dir, so a StorageManager constructed over that
+   * dir honors ITS owning orchestrator's config — not merely the last
+   * orchestrator constructed in the process. Unregistered dirs fall back to
+   * the process-wide default above.
+   */
+  static hotMemoriesCacheDefaultByDir = /* @__PURE__ */ new Map();
+  /**
+   * Process-wide TTL (ms) safety net for the hot cache (issue #1902). Bounds
+   * how long a version-keyed entry is served before a fresh disk scan, so
+   * external filesystem edits (manual/git/editor) that don't bump the sentinel
+   * self-heal. Set from config by the orchestrator via setHotMemoriesCacheDefault.
+   * 0 disables the TTL (version invalidation only). Default 60s.
+   */
+  static hotMemoriesCacheTtlMs = 6e4;
+  /**
+   * Per-memory-directory override of the hot-cache TTL (issue #1902, Codex P2),
+   * mirroring hotMemoriesCacheDefaultByDir. Registered by
+   * setHotMemoriesCacheDefault so two orchestrators in one process with
+   * different TTLs don't clobber each other's setting. Unregistered dirs fall
+   * back to the process-wide default above.
+   */
+  static hotMemoriesCacheTtlByDir = /* @__PURE__ */ new Map();
+  /**
+   * Whether the process-wide hot-cache fallbacks (hotMemoriesCacheDefault /
+   * hotMemoriesCacheTtlMs) have been seeded by the first
+   * setHotMemoriesCacheDefault call (issue #1902, Cursor Low). Only the first
+   * registration seeds them; later registrations touch ONLY their per-dir map
+   * entry. This makes the process-wide fallback deterministic (first-writer,
+   * by init order) instead of last-writer-wins, so a second orchestrator with
+   * a divergent config cannot silently flip the fallback that unregistered
+   * dirs resolve to. All REGISTERED dirs are isolated by the per-dir maps.
+   */
+  static hotMemoriesCacheProcessDefaultSeeded = false;
+  // Module-level maps for readAllMemories() keyed by base directory, shared
+  // across all StorageManager instances (static) so concurrent callers over
+  // the same dir cooperate.
   // Cache for readAllColdMemories() — keyed by cold root directory path.
   // Prevents an uncached full-tree directory scan on every structured-attribute
   // write (Finding UOGi, PR #402 round-6). Invalidated when cold-tier content
@@ -4085,6 +4144,45 @@ var StorageManager3 = class _StorageManager {
     }
     return `secure-store:key:${id}`;
   }
+  /**
+   * Secure-store key identity for the version-keyed hot/archive memory caches
+   * (issue #1902, Codex P1). Scopes cached DECRYPTED corpora by the key that
+   * decrypted them, so a locked/unkeyed StorageManager for the same baseDir
+   * never reads content another instance decrypted under a key (which would
+   * bypass the locked-store error). Plaintext and locked stores share the ""
+   * namespace; an unlocked encrypted store uses its per-key id.
+   */
+  hotCacheKeyId() {
+    return this._secureStoreKey === null ? "" : this.getEntityCacheSecureStoreKey();
+  }
+  /**
+   * Resolved hot-cache gate for THIS store (issue #1902, Cursor Medium): the
+   * per-instance override if one was passed, else the per-dir/process default.
+   * Recall sub-stages (verified-recall, semantic-rule) read this to honor the
+   * operator's opt-out for their derived caches even when the caller omits the
+   * flag in options.
+   */
+  isHotCacheEnabled() {
+    return this.hotMemoriesCacheEnabled;
+  }
+  /**
+   * Effective hot-cache TTL (ms) for this store's dir (issue #1902): the per-dir
+   * registration if present, else the process-wide default. 0 disables the TTL.
+   */
+  hotCacheTtlMs() {
+    return _StorageManager.hotMemoriesCacheTtlByDir.get(this.baseDir) ?? _StorageManager.hotMemoriesCacheTtlMs;
+  }
+  /**
+   * True if `p` lives in this store's cold/ or archive/ tier (issue #1902,
+   * Codex P2). Determined RELATIVE to baseDir — a substring scan of the
+   * absolute path would misclassify every active path when memoryDir itself is
+   * nested under a dir literally named "cold" or "archive" (e.g.
+   * /srv/cold/remnic), skipping the patch and stranding a stale hot entry.
+   */
+  isColdOrArchiveTierPath(p) {
+    const rel = path5.relative(this.baseDir, p);
+    return rel === "cold" || rel === "archive" || rel.startsWith(`cold${path5.sep}`) || rel.startsWith(`archive${path5.sep}`);
+  }
   /**
    * Mark the secure-store as required for this storage instance.
    * When required and locked, writes throw SecureStoreLockedError
@@ -4172,6 +4270,25 @@ var StorageManager3 = class _StorageManager {
       return null;
     }
   }
+  hotMemoriesCacheEnabled;
+  /** Set the process-wide hot-memories cache default (issue #1902). The
+   *  orchestrator/access layer calls this with the operator's
+   *  hotMemoriesCacheEnabled config so the escape hatch reaches every
+   *  StorageManager, including ephemeral recall-sub-stage instances. Only an
+   *  explicit `false` disables; `undefined` (e.g. a cast test config missing
+   *  the field) leaves the cache on. */
+  static setHotMemoriesCacheDefault(memoryDir, enabled, ttlMs) {
+    _StorageManager.hotMemoriesCacheDefaultByDir.set(memoryDir, enabled !== false);
+    const ttlValid = typeof ttlMs === "number" && Number.isFinite(ttlMs) && ttlMs >= 0;
+    if (ttlValid) {
+      _StorageManager.hotMemoriesCacheTtlByDir.set(memoryDir, ttlMs);
+    }
+    if (!_StorageManager.hotMemoriesCacheProcessDefaultSeeded) {
+      _StorageManager.hotMemoriesCacheDefault = enabled !== false;
+      if (ttlValid) _StorageManager.hotMemoriesCacheTtlMs = ttlMs;
+      _StorageManager.hotMemoriesCacheProcessDefaultSeeded = true;
+    }
+  }
   /**
    * The LIVE class object of this instance (issue #1809 review of the
    * storage decomposition): extracted store modules must read/write the
@@ -4221,7 +4338,7 @@ var StorageManager3 = class _StorageManager {
     return path5.join(workspaceDir, `IDENTITY.${safeNamespace}.md`);
   }
   versionFilePath(kind) {
-    const fileName = kind === "memory-status" ? ".memory-status-version.log" : kind === "artifact-write" ? ".artifact-write-version.log" : ".cold-write-version.log";
+    const fileName = kind === "memory-status" ? ".memory-status-version.log" : kind === "artifact-write" ? ".artifact-write-version.log" : kind === "cold-write" ? ".cold-write-version.log" : ".memory-corpus-version.log";
     return path5.join(this.stateDir, fileName);
   }
   bumpSharedVersion(kind, fallbackMap) {
@@ -4248,11 +4365,56 @@ var StorageManager3 = class _StorageManager {
   }
   bumpMemoryStatusVersion() {
     this.bumpSharedVersion("memory-status", _StorageManager.memoryStatusVersionByDir);
+    this.bumpSharedVersion("memory-corpus", _StorageManager.memoryCorpusVersionByDir);
     invalidateAllForDir(this.baseDir);
   }
   getMemoryStatusVersion() {
     return this.readSharedVersion("memory-status", _StorageManager.memoryStatusVersionByDir);
   }
+  /**
+   * Corpus version sentinel for the hot-memories result cache (issue #1902).
+   * Distinct from memory-status: it bumps on EVERY memory-file mutation
+   * (create/update/delete/bulk) so the version-keyed hot cache stays coherent
+   * across processes, WITHOUT bumping memory-status — which would needlessly
+   * invalidate the version-keyed entity cache on every plain fact create (the
+   * ki-spike regression the sibling perf work removes). memory-status keeps its
+   * lifecycle/status/entity semantics unchanged.
+   */
+  getMemoryCorpusVersion() {
+    return this.readSharedVersion("memory-corpus", _StorageManager.memoryCorpusVersionByDir);
+  }
+  bumpMemoryCorpusVersion() {
+    this.bumpSharedVersion("memory-corpus", _StorageManager.memoryCorpusVersionByDir);
+    deleteInFlightReadsForDir(this.baseDir);
+  }
+  /**
+   * Corpus bump that reports whether THIS process's append was the only one
+   * since the pre-bump size (issue #1902, Codex P1). appendFileSync is atomic
+   * per write, but a peer process can append concurrently; the `exclusive`
+   * flag lets patchHotMemoriesCache refuse to re-key its locally patched
+   * (peer-incomplete) corpus at a version that already reflects a peer's
+   * still-unread write.
+   */
+  bumpMemoryCorpusVersionExclusive() {
+    const filePath = this.versionFilePath("memory-corpus");
+    try {
+      mkdirSync(this.stateDir, { recursive: true });
+      let before = 0;
+      try {
+        before = statSync(filePath).size;
+      } catch {
+        before = 0;
+      }
+      appendFileSync(filePath, "x");
+      const produced = statSync(filePath).size;
+      _StorageManager.memoryCorpusVersionByDir.set(this.baseDir, produced);
+      return { produced, exclusive: produced === before + 1 };
+    } catch {
+      const next = (_StorageManager.memoryCorpusVersionByDir.get(this.baseDir) ?? 0) + 1;
+      _StorageManager.memoryCorpusVersionByDir.set(this.baseDir, next);
+      return { produced: next, exclusive: true };
+    }
+  }
   bumpArtifactWriteVersion() {
     return this.bumpSharedVersion("artifact-write", _StorageManager.artifactWriteVersionByDir);
   }
@@ -4990,6 +5152,9 @@ var StorageManager3 = class _StorageManager {
     await mkdir(this.identityAuditsWeeklyDir, { recursive: true });
     await mkdir(this.identityAuditsMonthlyDir, { recursive: true });
     await mkdir(path5.join(this.baseDir, "config"), { recursive: true });
+    if (this.hotMemoriesCacheEnabled && this.getMemoryCorpusVersion() === 0) {
+      this.bumpMemoryCorpusVersion();
+    }
   }
   /**
    * Resolve the on-disk write path for a memory of the given category, creating
@@ -5133,7 +5298,7 @@ ${sanitized.text}
     const filePath = await this.resolveCategoryWritePath(category, id, today);
     await this.snapshotBeforeWrite(filePath, "write");
     await this.writeStorageSecureFile(filePath, fileContent);
-    this.invalidateAllMemoriesCache();
+    await this.patchHotMemoriesCache({ addedPath: filePath });
     await this.appendGeneratedMemoryLifecycleEventFailOpen("storage.writeMemory", {
       memoryId: id,
       eventType: "created",
@@ -5399,16 +5564,31 @@ ${sanitized.text}
     return lineCount > threshold;
   }
   async readAllMemories() {
-    const inFlight = _StorageManager.allMemoriesInFlight.get(this.baseDir);
+    if (this.hotMemoriesCacheEnabled) {
+      const cached = getCachedMemories(
+        this.baseDir,
+        this.getMemoryCorpusVersion(),
+        this.hotCacheKeyId(),
+        this.hotCacheTtlMs()
+      );
+      if (cached !== null) return cached;
+    }
+    const keyId = this.hotCacheKeyId();
+    const inFlight = getInFlightRead(this.baseDir, keyId);
     if (inFlight) return inFlight;
-    const readPromise = this._readAllMemoriesFromDisk();
-    _StorageManager.allMemoriesInFlight.set(this.baseDir, readPromise);
+    const readPromise = (async () => {
+      const version = this.getMemoryCorpusVersion();
+      const memories = await this._readAllMemoriesFromDisk();
+      if (this.hotMemoriesCacheEnabled && this.getMemoryCorpusVersion() === version && this.hotCacheKeyId() === keyId) {
+        setCachedMemories(this.baseDir, memories, version, keyId, this.hotCacheTtlMs());
+      }
+      return memories;
+    })();
+    setInFlightRead(this.baseDir, keyId, readPromise);
     try {
       return await readPromise;
     } finally {
-      if (_StorageManager.allMemoriesInFlight.get(this.baseDir) === readPromise) {
-        _StorageManager.allMemoriesInFlight.delete(this.baseDir);
-      }
+      deleteInFlightRead(this.baseDir, keyId, readPromise);
     }
   }
   /** Invalidate the readAllMemories() cache after writes that add/remove memories. */
@@ -5438,9 +5618,15 @@ ${sanitized.text}
   /** Clear ALL static caches. Use in tests that write files directly
    *  (bypassing StorageManager.writeMemory) to avoid stale reads. */
   static clearAllStaticCaches() {
-    _StorageManager.allMemoriesInFlight.clear();
+    clearInFlightReads();
     _StorageManager.questionsCache.clear();
     _StorageManager.coldMemoriesCache.clear();
+    clearMemoryCache();
+    _StorageManager.hotMemoriesCacheDefaultByDir.clear();
+    _StorageManager.hotMemoriesCacheTtlByDir.clear();
+    _StorageManager.hotMemoriesCacheDefault = true;
+    _StorageManager.hotMemoriesCacheTtlMs = 6e4;
+    _StorageManager.hotMemoriesCacheProcessDefaultSeeded = false;
   }
   /** Cancel any in-flight concurrent read so the next readAllMemories()
    *  starts a fresh disk scan and sees the just-written data.
@@ -5455,7 +5641,8 @@ ${sanitized.text}
    *  cold content actually changes (hot→cold demotions, writeMemoryFileAtomic
    *  inside cold/, archiveMemory, etc.). */
   invalidateAllMemoriesCache() {
-    _StorageManager.allMemoriesInFlight.delete(this.baseDir);
+    deleteInFlightReadsForDir(this.baseDir);
+    this.bumpMemoryCorpusVersion();
     invalidateAllForDir(this.baseDir);
     if (this.tombstoneStore) {
       this.tombstoneStore.invalidate();
@@ -5463,6 +5650,57 @@ ${sanitized.text}
       this.tombstoneStoreLoadPromise = null;
     }
   }
+  /**
+   * Single-file write/delete fast path for the hot-memories cache (issue
+   * #1902). Keeps THIS process's version-keyed corpus entry warm by patching
+   * the changed memory in place, bumps the dedicated `.memory-corpus-version.log`
+   * sentinel so PEER processes rescan (memory-status is deliberately NOT bumped
+   * here so plain creates/content edits don't invalidate the entity cache), and
+   * evicts only the derived/global layers (which
+   * are cheap to rebuild and are never patched). Mirrors the in-flight-dedup
+   * and tombstone-store invalidation that invalidateAllMemoriesCache() does.
+   *
+   * `added` is the written MemoryFile (writes/overwrites); `removedPath` is a
+   * deleted path. A path outside the active scan roots (under cold/ or
+   * archive/) is NOT applied to the hot map — that cache holds active memories
+   * only — but the version bump and derived/global eviction still run so
+   * coherence is preserved. Bulk/ambiguous mutations keep the wholesale
+   * invalidateAllMemoriesCache() drop instead (issue #1902 Step 5).
+   */
+  async patchHotMemoriesCache(opts) {
+    const prevVersion = this.getMemoryCorpusVersion();
+    const keyId = this.hotCacheKeyId();
+    const warm = this.hotMemoriesCacheEnabled && getCachedMemories(this.baseDir, prevVersion, keyId, this.hotCacheTtlMs()) !== null;
+    if (warm && opts.removedPath !== void 0 && !this.isColdOrArchiveTierPath(opts.removedPath)) {
+      updateCacheOnDelete(this.baseDir, opts.removedPath, keyId);
+    }
+    const { produced, exclusive } = this.bumpMemoryCorpusVersionExclusive();
+    deleteInFlightReadsForDir(this.baseDir);
+    let patchedOk = warm;
+    if (warm && opts.addedPath !== void 0 && !this.isColdOrArchiveTierPath(opts.addedPath)) {
+      let parsed;
+      try {
+        [parsed] = await this.readParsedMemoriesFromPaths([opts.addedPath], 1);
+      } catch {
+        parsed = void 0;
+      }
+      if (parsed) {
+        updateCacheOnWrite(this.baseDir, parsed, keyId);
+      } else {
+        patchedOk = false;
+      }
+    }
+    if (patchedOk && exclusive && produced === prevVersion + 1 && this.getMemoryCorpusVersion() === produced && this.hotCacheKeyId() === keyId) {
+      const patched = getCachedMemories(this.baseDir, prevVersion, keyId);
+      if (patched) setCachedMemories(this.baseDir, patched, produced, keyId, this.hotCacheTtlMs());
+    }
+    invalidateDerivedAndGlobalForDir(this.baseDir);
+    if (this.tombstoneStore) {
+      this.tombstoneStore.invalidate();
+      this.tombstoneStore = null;
+      this.tombstoneStoreLoadPromise = null;
+    }
+  }
   /**
    * Invalidate the cold-scan cache for this storage root and bump the
    * on-disk cold-version sentinel so that other processes (gateway, CLI) see
@@ -5881,7 +6119,7 @@ ${memory.content}
 ${sanitized.text}
 `;
     await this.writeStorageSecureFile(memory.path, fileContent);
-    this.invalidateAllMemoriesCache();
+    await this.patchHotMemoriesCache({ addedPath: memory.path });
     await this.appendGeneratedMemoryLifecycleEventFailOpen("storage.updateMemory", {
       memoryId: id,
       eventType: "updated",
@@ -5913,7 +6151,7 @@ ${sanitized.text}
 ${memory.content}
 `;
     await this.writeStorageSecureFile(memory.path, fileContent);
-    this.invalidateAllMemoriesCache();
+    await this.patchHotMemoriesCache({ addedPath: memory.path });
     if (memory.path.includes(`${path5.sep}cold${path5.sep}`)) {
       this.invalidateColdMemoriesCache();
     }
@@ -5971,6 +6209,7 @@ ${memory.content}
         try {
           await unlink2(m.path);
           markProjectedMemoryPathInvalid(this.baseDir, m.frontmatter.id);
+          this.bumpMemoryCorpusVersion();
           deleted.push(m);
           log.debug(`cleaned expired memory ${m.frontmatter.id} (TTL expired)`);
         } catch {
@@ -6761,6 +7000,7 @@ ${reflection}
         try {
           await unlink2(m.path);
           markProjectedMemoryPathInvalid(this.baseDir, m.frontmatter.id);
+          this.bumpMemoryCorpusVersion();
           deleted.push(m);
           log.debug(`cleaned expired commitment ${m.frontmatter.id}`);
         } catch {
@@ -6784,6 +7024,10 @@ ${reflection}
     const memories = await this.readAllMemories();
     const memoryMap = new Map(memories.map((m) => [m.frontmatter.id, m]));
     let updated = 0;
+    const prevVersion = this.getMemoryCorpusVersion();
+    const keyId = this.hotCacheKeyId();
+    const warm = this.hotMemoriesCacheEnabled && getCachedMemories(this.baseDir, prevVersion, keyId, this.hotCacheTtlMs()) !== null;
+    const appliedPatches = /* @__PURE__ */ new Map();
     for (const entry of entries) {
       const memory = memoryMap.get(entry.memoryId);
       if (!memory) continue;
@@ -6798,12 +7042,29 @@ ${reflection}
 ${memory.content}
 `;
         await this.writeStorageSecureFile(memory.path, fileContent);
+        if (warm) {
+          updateCacheOnWrite(this.baseDir, { ...memory, frontmatter: newFm }, keyId);
+        }
+        appliedPatches.set(entry.memoryId, { accessCount: entry.newCount, lastAccessed: entry.lastAccessed });
         updated++;
       } catch (err) {
         log.debug(`failed to update access tracking for ${entry.memoryId}: ${err}`);
       }
     }
     if (updated > 0) {
+      const { produced, exclusive } = this.bumpMemoryCorpusVersionExclusive();
+      deleteInFlightReadsForDir(this.baseDir);
+      if (warm && exclusive && produced === prevVersion + 1 && this.getMemoryCorpusVersion() === produced && this.hotCacheKeyId() === keyId) {
+        const cur = getCachedMemories(this.baseDir, prevVersion, keyId);
+        if (cur) {
+          const reapplied = cur.map((m) => {
+            const patch = appliedPatches.get(m.frontmatter.id);
+            return patch ? { ...m, frontmatter: { ...m.frontmatter, accessCount: patch.accessCount, lastAccessed: patch.lastAccessed } } : m;
+          });
+          setCachedMemories(this.baseDir, reapplied, produced, keyId, this.hotCacheTtlMs());
+        }
+      }
+      invalidateDerivedAndGlobalForDir(this.baseDir);
       log.debug(`flushed access tracking for ${updated} memories`);
     }
     return updated;
@@ -6943,6 +7204,7 @@ ${sanitized.text}
 `;
     const filePath = await this.resolveCategoryWritePath(category, id, today);
     await this.writeStorageSecureFile(filePath, fileContent);
+    await this.patchHotMemoriesCache({ addedPath: filePath });
     log.debug(`wrote chunk ${id} (${chunkIndex + 1}/${chunkTotal}) to ${filePath}`);
     return id;
   }
@@ -6979,6 +7241,7 @@ ${oldMemory.content}
 `;
     try {
       await this.writeStorageSecureFile(oldMemory.path, fileContent);
+      this.bumpMemoryCorpusVersion();
       await this.appendGeneratedMemoryLifecycleEventFailOpen("storage.supersedeMemory", {
         memoryId: oldMemoryId,
         eventType: "superseded",
@@ -7082,6 +7345,7 @@ Reason: ${reason}`, {
 ${memory.content}
 `;
         await this.writeStorageSecureFile(memory.path, fileContent);
+        this.bumpMemoryCorpusVersion();
         await this.appendGeneratedMemoryLifecycleEventFailOpen("storage.archiveMemories", {
           memoryId: id,
           eventType: "archived",
@@ -7231,4 +7495,4 @@ export {
   isValidBufferSurpriseEvent,
   StorageManager3 as StorageManager
 };
-//# sourceMappingURL=chunk-KTOH7EJE.js.map
+//# sourceMappingURL=chunk-PV7E2FGY.js.map