@remnic/core 9.7.8 → 9.7.9

package/src/memory-cache.ts

@@ -5,49 +5,107 @@ interface CacheEntry {
   memories: Map<string, MemoryFile>; // keyed by file path
   version: number;
   loadedAt: number;
+  // Secure-store key identity that decrypted these memories (issue #1902, Codex
+  // P1). "" for plaintext/locked stores. A manager only reads an entry whose
+  // keyId matches its own, so a locked/unkeyed instance never sees content
+  // another instance decrypted under a key for the same baseDir.
+  keyId: string;
+  // Effective TTL (ms) this entry was stored under (issue #1902, Codex Medium),
+  // so the opportunistic sweep can evict abandoned corpora that are never
+  // revisited. 0 = no TTL (never swept by age).
+  ttlMs: number;
 }
 
 // Module-level singleton — shared across all StorageManager instances and sessions
 const hotCacheByDir = new Map<string, CacheEntry>();
 const archiveCacheByDir = new Map<string, CacheEntry>();
 
-export function getCachedMemories(baseDir: string, currentVersion: number): MemoryFile[] | null {
+/**
+ * Evict every hot entry whose own TTL has elapsed (issue #1902, Codex Medium).
+ * Called opportunistically on each set so a long-running process that reads many
+ * namespace/temporary roots and never revisits some of them still releases their
+ * (potentially hundreds-of-MB) corpora within the TTL, instead of holding them
+ * resident until an explicit global clear. O(entries) over a small map.
+ */
+function sweepExpiredHotEntries(now: number): void {
+  for (const [dir, entry] of hotCacheByDir) {
+    if (entry.ttlMs > 0 && now - entry.loadedAt > entry.ttlMs) hotCacheByDir.delete(dir);
+  }
+}
+
+export function getCachedMemories(
+  baseDir: string,
+  currentVersion: number,
+  keyId = "",
+  ttlMs = 0,
+): MemoryFile[] | null {
   // Don't serve from cache when version tracking is unavailable (version=0).
   // This ensures tests and fresh installs without a version file always read disk.
   if (currentVersion === 0) return null;
   const entry = hotCacheByDir.get(baseDir);
-  if (!entry || entry.version !== currentVersion) return null;
+  if (!entry || entry.version !== currentVersion || entry.keyId !== keyId) return null;
+  // TTL safety net (issue #1902): bound staleness from external filesystem edits
+  // that bypass the version sentinel. ttlMs <= 0 disables the check. On expiry
+  // evict the entry (not just return null) so a revisited-but-stale dir releases
+  // its resident corpus instead of lingering until an explicit clear.
+  if (ttlMs > 0 && Date.now() - entry.loadedAt > ttlMs) {
+    hotCacheByDir.delete(baseDir);
+    return null;
+  }
   return [...entry.memories.values()];
 }
 
-export function setCachedMemories(baseDir: string, memories: MemoryFile[], version: number): void {
+export function setCachedMemories(
+  baseDir: string,
+  memories: MemoryFile[],
+  version: number,
+  keyId = "",
+  ttlMs = 0,
+): void {
   const map = new Map<string, MemoryFile>();
   for (const m of memories) map.set(m.path, m);
-  hotCacheByDir.set(baseDir, { memories: map, version, loadedAt: Date.now() });
+  const now = Date.now();
+  hotCacheByDir.set(baseDir, { memories: map, version, loadedAt: now, keyId, ttlMs });
+  // Release abandoned corpora that expired but were never revisited (Codex Medium).
+  sweepExpiredHotEntries(now);
 }
 
-export function updateCacheOnWrite(baseDir: string, memory: MemoryFile): void {
+export function updateCacheOnWrite(baseDir: string, memory: MemoryFile, keyId = ""): void {
   const entry = hotCacheByDir.get(baseDir);
-  if (entry) entry.memories.set(memory.path, memory);
+  // Only mutate an entry that belongs to THIS key identity (issue #1902, Codex
+  // Medium). A concurrent differently-keyed manager may have replaced the
+  // single hotCacheByDir slot during an awaited parse; inserting our decrypted
+  // MemoryFile into its entry would leak plaintext across the key boundary.
+  if (entry && entry.keyId === keyId) entry.memories.set(memory.path, memory);
 }
 
-export function updateCacheOnDelete(baseDir: string, filePath: string): void {
+export function updateCacheOnDelete(baseDir: string, filePath: string, keyId = ""): void {
   const entry = hotCacheByDir.get(baseDir);
-  if (entry) entry.memories.delete(filePath);
+  if (entry && entry.keyId === keyId) entry.memories.delete(filePath);
 }
-
 // Archive cache — same pattern, separate store
-export function getCachedArchivedMemories(baseDir: string, currentVersion: number): MemoryFile[] | null {
+export function getCachedArchivedMemories(
+  baseDir: string,
+  currentVersion: number,
+  keyId = "",
+): MemoryFile[] | null {
   if (currentVersion === 0) return null;
   const entry = archiveCacheByDir.get(baseDir);
-  if (!entry || entry.version !== currentVersion) return null;
+  if (!entry || entry.version !== currentVersion || entry.keyId !== keyId) return null;
   return [...entry.memories.values()];
 }
 
-export function setCachedArchivedMemories(baseDir: string, memories: MemoryFile[], version: number): void {
+export function setCachedArchivedMemories(
+  baseDir: string,
+  memories: MemoryFile[],
+  version: number,
+  keyId = "",
+): void {
   const map = new Map<string, MemoryFile>();
   for (const m of memories) map.set(m.path, m);
-  archiveCacheByDir.set(baseDir, { memories: map, version, loadedAt: Date.now() });
+  // ttlMs: 0 — the archive cache has no age TTL; it is version-keyed and cleared
+  // via invalidation. The field satisfies the shared CacheEntry shape (#1902).
+  archiveCacheByDir.set(baseDir, { memories: map, version, loadedAt: Date.now(), keyId, ttlMs: 0 });
 }
 
 // Entity cache — same pattern as memory cache, but keyed by schema-aware parse inputs.
@@ -108,41 +166,77 @@ export function invalidateCachedEntities(baseDir: string): void {
 interface DerivedCacheEntry<T> {
   data: T;
   sourceVersion: number; // matches the hot cache version it was derived from
+  keyId: string; // secure-store key identity of the corpus it was derived from (#1902)
+  loadedAt: number; // build time — bounds staleness from external edits via ttlMs (#1902)
 }
 
 const episodeMapByDir = new Map<string, DerivedCacheEntry<Map<string, MemoryFile>>>();
 const ruleMemoriesByDir = new Map<string, DerivedCacheEntry<{ all: MemoryFile[]; byId: Map<string, MemoryFile> }>>();
 
-/** Get a pre-filtered Map of episode memories (keyed by ID). Derived from hot cache. */
-export function getCachedEpisodeMap(baseDir: string, currentVersion: number): Map<string, MemoryFile> | null {
+export function getCachedEpisodeMap(
+  baseDir: string,
+  currentVersion: number,
+  keyId = "",
+  ttlMs = 0,
+): Map<string, MemoryFile> | null {
   if (currentVersion === 0) return null;
   const entry = episodeMapByDir.get(baseDir);
-  if (!entry || entry.sourceVersion !== currentVersion) return null;
+  if (!entry || entry.sourceVersion !== currentVersion || entry.keyId !== keyId) return null;
+  // TTL safety net (issue #1902): the version sentinel doesn't move on a direct
+  // external edit, so bound how long a derived view is served before a rebuild
+  // (which re-reads via readAllMemories, itself TTL-bounded). ttlMs <= 0 disables.
+  if (ttlMs > 0 && Date.now() - entry.loadedAt > ttlMs) {
+    episodeMapByDir.delete(baseDir);
+    return null;
+  }
   return entry.data;
 }
 
 /** Build and cache the episode memory map from the full memory list. */
-export function setCachedEpisodeMap(baseDir: string, memories: MemoryFile[], version: number): Map<string, MemoryFile> {
+export function setCachedEpisodeMap(
+  baseDir: string,
+  memories: MemoryFile[],
+  version: number,
+  cache = true,
+  keyId = "",
+): Map<string, MemoryFile> {
   const map = new Map<string, MemoryFile>();
   for (const m of memories) {
     if (m.frontmatter.status === "archived" || m.frontmatter.status === "forgotten") continue;
     if (m.frontmatter.memoryKind !== "episode") continue;
     map.set(m.frontmatter.id, m);
   }
-  episodeMapByDir.set(baseDir, { data: map, sourceVersion: version });
+  if (cache) episodeMapByDir.set(baseDir, { data: map, sourceVersion: version, keyId, loadedAt: Date.now() });
   return map;
 }
 
 /** Get pre-filtered rule memories. Derived from hot cache. */
-export function getCachedRuleMemories(baseDir: string, currentVersion: number): { all: MemoryFile[]; byId: Map<string, MemoryFile> } | null {
+export function getCachedRuleMemories(
+  baseDir: string,
+  currentVersion: number,
+  keyId = "",
+  ttlMs = 0,
+): { all: MemoryFile[]; byId: Map<string, MemoryFile> } | null {
   if (currentVersion === 0) return null;
   const entry = ruleMemoriesByDir.get(baseDir);
-  if (!entry || entry.sourceVersion !== currentVersion) return null;
+  if (!entry || entry.sourceVersion !== currentVersion || entry.keyId !== keyId) return null;
+  // TTL safety net (issue #1902): bound staleness from direct external edits
+  // that don't move the version sentinel. ttlMs <= 0 disables.
+  if (ttlMs > 0 && Date.now() - entry.loadedAt > ttlMs) {
+    ruleMemoriesByDir.delete(baseDir);
+    return null;
+  }
   return entry.data;
 }
 
 /** Build and cache the rule memories from the full memory list. */
-export function setCachedRuleMemories(baseDir: string, memories: MemoryFile[], version: number): { all: MemoryFile[]; byId: Map<string, MemoryFile> } {
+export function setCachedRuleMemories(
+  baseDir: string,
+  memories: MemoryFile[],
+  version: number,
+  cache = true,
+  keyId = "",
+): { all: MemoryFile[]; byId: Map<string, MemoryFile> } {
   const byId = new Map<string, MemoryFile>();
   const all: MemoryFile[] = [];
   for (const m of memories) {
@@ -156,7 +250,7 @@ export function setCachedRuleMemories(baseDir: string, memories: MemoryFile[], v
     }
   }
   const result = { all, byId };
-  ruleMemoriesByDir.set(baseDir, { data: result, sourceVersion: version });
+  if (cache) ruleMemoriesByDir.set(baseDir, { data: result, sourceVersion: version, keyId, loadedAt: Date.now() });
   return result;
 }
 
@@ -295,6 +389,36 @@ export function invalidateAllForDir(baseDir: string): void {
   }
 }
 
+/**
+ * Invalidate every cache layer for `baseDir` EXCEPT the hot-memories layer
+ * (issue #1902). Single-file write paths use this instead of
+ * `invalidateAllForDir` because they patch the hot-memories entry in place
+ * (via `updateCacheOnWrite`/`updateCacheOnDelete`) and re-key it to the bumped
+ * version — so dropping it here would defeat the whole warm-cache fast path.
+ * The derived episode/rule views and the global QMD caches are cheap to
+ * rebuild and are not patched, so they are still evicted here. Every other
+ * layer remains reachable for the wholesale `invalidateAllForDir` /
+ * `clearMemoryCache` chokepoint used by bulk/ambiguous mutations.
+ */
+export function invalidateDerivedAndGlobalForDir(baseDir: string): void {
+  // Preserve the layers a single-file write intentionally keeps warm (issue
+  // #1902, Codex Medium): hot-memories is patched + re-keyed in place; the
+  // entities layer is keyed on memory-status, which plain create/content writes
+  // deliberately do NOT bump (so entity retrieval stays warm); and the
+  // archive-memories layer is version-keyed on the archive tier, untouched by a
+  // hot-tier write. Evict ONLY the derived (episode/rule) and global (QMD) views.
+  for (const layer of ALL_CACHE_LAYERS) {
+    if (
+      layer.name === "hot-memories" ||
+      layer.name === "entities" ||
+      layer.name === "archive-memories"
+    ) {
+      continue;
+    }
+    layer.invalidateForDir(baseDir);
+  }
+}
+
 export function clearMemoryCache(baseDir?: string): void {
   if (baseDir) {
     invalidateAllForDir(baseDir);

package/src/memory-corpus-version.ts

@@ -0,0 +1,45 @@
+import { appendFileSync, mkdirSync } from "node:fs";
+import path from "node:path";
+import { deleteInFlightReadsForDir } from "./in-flight-reads.js";
+import { invalidateDerivedAndGlobalForDir } from "./memory-cache.js";
+
+/**
+ * Filename of the memory-corpus version sentinel (issue #1902). MUST stay in
+ * sync with `StorageManager.versionFilePath("memory-corpus")` in storage.ts —
+ * the byte size of this append-only file IS the corpus version, and the
+ * version-keyed hot-memories result cache keys on it.
+ */
+export const MEMORY_CORPUS_VERSION_SENTINEL = ".memory-corpus-version.log";
+
+/**
+ * Out-of-band corpus-version bump (issue #1902) for code paths that write or
+ * modify memory files WITHOUT going through a StorageManager mutation method
+ * — review approval, governance restore, migration. Appends one byte to the
+ * on-disk sentinel so any process's version-keyed hot-memories cache rescans
+ * on its next read (StorageManager.readSharedVersion reads the file size, so
+ * the growth is observed immediately). Fail-open: a bump failure must never
+ * crash the caller — a stale-cache window self-heals on the next real write.
+ */
+export function bumpMemoryCorpusVersionForDir(memoryDir: string): void {
+  try {
+    const stateDir = path.join(memoryDir, "state");
+    mkdirSync(stateDir, { recursive: true });
+    appendFileSync(path.join(stateDir, MEMORY_CORPUS_VERSION_SENTINEL), "x");
+  } catch {
+    /* fail-open: never let a cache-coherence bump crash the primary operation */
+  }
+  // Drop any in-flight readAllMemories scan for this dir (Cursor Medium, #1902):
+  // after the sentinel advances, a concurrent read that missed the version-keyed
+  // hot entry must not attach to a scan that began BEFORE this out-of-band write
+  // and receive a pre-write corpus. Clearing forces a fresh scan of disk truth.
+  deleteInFlightReadsForDir(memoryDir);
+  // Also evict the TTL-keyed derived (episode/rule) and global (QMD search/recall)
+  // caches for this dir (issue #1902, Codex Medium). The sentinel bump self-heals
+  // the version-keyed hot cache, but the QMD caches are TTL-keyed, NOT
+  // corpus-version-keyed — without this, an out-of-band writer (capsule
+  // import/merge, review, spaces, governance restore, page revert, binary
+  // redirect) would leave a warm process serving pre-write recall/search results
+  // for the remainder of the QMD cache TTL. Route the bump through the same
+  // invalidation chokepoint the in-process mutation paths use.
+  invalidateDerivedAndGlobalForDir(memoryDir);
+}

package/src/namespaces/storage.ts

@@ -292,7 +292,26 @@ export class NamespaceStorageRouter {
       }
     }
 
-    const sm = new StorageManager(root, this.config.entitySchemas);
+    // Pass the hot-memories cache gate explicitly (issue #1902, Codex P2): a
+    // per-namespace child root is never registered in the per-dir default map,
+    // so without this it would fall back to the process-wide default and ignore
+    // THIS daemon's hotMemoriesCacheEnabled config. Threading it from config
+    // keeps every namespace storage aligned with its owning orchestrator.
+    const sm = new StorageManager(
+      root,
+      this.config.entitySchemas,
+      this.config.hotMemoriesCacheEnabled,
+    );
+    // Register this child root's gate AND TTL in the per-dir maps (issue #1902,
+    // Codex P2). The constructor override above fixes the child's own gate, but
+    // its TTL is resolved via the per-dir map (hotCacheTtlMs); an unregistered
+    // child root would fall back to the last process-wide TTL and could inherit
+    // another daemon's value. Registering keyed by root keeps both per-dir.
+    StorageManager.setHotMemoriesCacheDefault(
+      root,
+      this.config.hotMemoriesCacheEnabled,
+      this.config.hotMemoriesCacheTtlMs,
+    );
     // Propagate the inline-attribution template so that router-created storages
     // (used by extraction and shared-promotion paths) strip citations consistently,
     // matching the behaviour of the primary this.storage instance in the orchestrator.

package/src/operator-toolkit.ts

@@ -2297,7 +2297,13 @@ export async function runOperatorInventory(options: OperatorInventoryOptions): P
   let rejected = 0;
 
   for (const entry of uniqueRootEntries.values()) {
-    const storage = new StorageManager(entry.rootDir);
+    // Disable the hot-memories cache for these transient, one-shot inventory
+    // reads (issue #1902, Codex Medium). Each namespace root is read exactly once
+    // here; caching gives no benefit and would warm+RETAIN the full corpus under
+    // the process-wide gate/TTL (this path bypasses NamespaceStorageRouter, so
+    // the root is never registered in the per-dir maps). Disabling sidesteps both
+    // the cross-namespace gate/TTL inheritance and the retained-memory footprint.
+    const storage = new StorageManager(entry.rootDir, undefined, false);
     const memories = await storage.readAllMemories();
     const entities = await storage.readAllEntityFiles();
     namespaces.push({

package/src/orchestration/recall-internal.ts

@@ -2032,9 +2032,10 @@ export class RecallInternalCoordinator {
     // Verified recall and semantic rules both need readAllMemories().
     // Instead of a shared preload (which has namespace/dir mismatch issues),
     // each subsystem calls readAllMemories() on its correct storage instance.
-    // The process-level memory cache (keyed by baseDir + memoryStatusVersion)
-    // ensures only one actual disk scan happens — subsequent calls return
-    // from cache in <1ms.
+    // The version-keyed hot-memories cache (keyed by baseDir + the corpus
+    // version sentinel, issue #1902) serves repeat reads within a version epoch
+    // from memory, so these subsystems share one disk scan; a memory write
+    // between recalls bumps the corpus version and forces exactly one rescan.
 
     const verifiedRecallPromise = (async (): Promise<string | null> => {
       const t0 = Date.now();
@@ -2081,6 +2082,7 @@ export class RecallInternalCoordinator {
               query: retrievalQuery,
               maxResults,
               boxRecallDays: this.deps.config.boxRecallDays,
+              hotMemoriesCacheEnabled: this.deps.config.hotMemoriesCacheEnabled,
             }).catch((err) => {
               log.debug(`verified recall directory scan failed: ${err}`);
               return [] as VerifiedEpisodeResult[];
@@ -2169,6 +2171,7 @@ export class RecallInternalCoordinator {
               memoryDir,
               query: retrievalQuery,
               maxResults,
+              hotMemoriesCacheEnabled: this.deps.config.hotMemoriesCacheEnabled,
             }).catch((err) => {
               log.debug(`verified rules directory scan failed: ${err}`);
               return [] as VerifiedSemanticRuleResult[];

package/src/orchestrator.ts

@@ -1334,6 +1334,17 @@ export class Orchestrator {
 
   constructor(config: PluginConfig) {
     this.config = config;
+    // Thread the hot-memories cache escape hatch (issue #1902) to the storage
+    // layer BEFORE any StorageManager is constructed below, so every instance
+    // — including the ephemeral ones recall sub-stages build over the same dir
+    // — honors the operator's setting. Destructured (not `config.<flag>`) so
+    // this single access-layer read stays off the scattered-flag ratchet.
+    const { hotMemoriesCacheEnabled } = config;
+    StorageManager.setHotMemoriesCacheDefault(
+      config.memoryDir,
+      hotMemoriesCacheEnabled,
+      config.hotMemoriesCacheTtlMs,
+    );
     this.profiler = new ProfilingCollector({
       enabled: resolvePipelineProcessingCapabilities(this.config).profiling,
       storageDir: config.profilingStorageDir || path.join(config.memoryDir, "profiling"),
@@ -1490,7 +1501,20 @@ export class Orchestrator {
       tierMigrationStatus: this.tierMigrationStatus,
       getUtilityRuntimeValues: () => this.utilityRuntimeValues,
       getCompounding: () => this.compounding,
-      createColdStorage: (parentDir) => new StorageManager(parentDir),
+      createColdStorage: (parentDir) => {
+        // Register parentDir's gate AND TTL in the per-dir maps (issue #1902,
+        // Codex Medium) before constructing, mirroring the namespace-child fix.
+        // The constructor override only sets this manager's gate; its TTL is
+        // resolved via the per-dir map, so an unregistered cold root would fall
+        // back to the (first-writer) process-wide TTL and could inherit another
+        // orchestrator's value.
+        StorageManager.setHotMemoriesCacheDefault(
+          parentDir,
+          config.hotMemoriesCacheEnabled,
+          config.hotMemoriesCacheTtlMs,
+        );
+        return new StorageManager(parentDir, config.entitySchemas, config.hotMemoriesCacheEnabled);
+      },
     });
     this.compressionGuidelineCoordinator = new CompressionGuidelineCoordinator({
       config,

package/src/page-versioning.ts

@@ -25,7 +25,8 @@ import {
   writeFile,
   unlink,
 } from "node:fs/promises";
-import { ALL_CATEGORY_DIRS } from "./utils/category-dir.js";
+import { ALL_CATEGORY_DIRS, RECALL_FALLBACK_DIRS } from "./utils/category-dir.js";
+import { bumpMemoryCorpusVersionForDir } from "./memory-corpus-version.js";
 
 // ---------------------------------------------------------------------------
 // Public interfaces
@@ -332,6 +333,18 @@ export async function revertToVersion(
 
   // Write the reverted content to the actual page
   await writeFile(pagePath, targetContent, "utf-8");
+  // A revert overwrites a memory file out-of-band (not via a StorageManager
+  // mutation), so bump the corpus sentinel when the reverted page lives under a
+  // recall category dir — forcing a warm hot-memories cache to rescan on its
+  // next read (issue #1902, Codex P1). Non-recall pages (entities/artifacts/
+  // profiles) are not in the corpus scan, so they need no bump.
+  // The hot-memories corpus covers the RECALL corpus, which excludes the
+  // non-memory queue dirs (questions/). Use RECALL_FALLBACK_DIRS — a revert of a
+  // questions/ page must NOT bump the recall corpus sentinel and force a rescan.
+  const revertedTop = relPath(pagePath, resolvedMemoryDir).split(path.sep)[0];
+  if ((RECALL_FALLBACK_DIRS as readonly string[]).includes(revertedTop)) {
+    bumpMemoryCorpusVersionForDir(resolvedMemoryDir);
+  }
   log.debug(`page-versioning: reverted ${pagePath} to version ${versionId}`);
 
   return version;

package/src/provenance-frontmatter.test.ts

@@ -5,6 +5,7 @@ import path from "node:path";
 import { mkdtemp, mkdir, rm, writeFile, readFile } from "node:fs/promises";
 
 import { StorageManager } from "./storage.js";
+import { clearMemoryCache } from "./memory-cache.js";
 import type { ProvenanceSource } from "./types.js";
 
 /**
@@ -64,6 +65,11 @@ async function writeFactFile(
   const factsDir = path.join((storage as unknown as { baseDir: string }).baseDir, "facts", today);
   await mkdir(factsDir, { recursive: true });
   await writeFile(path.join(factsDir, `${id}.md`), `${lines.join("\n")}\n\n${body}\n`, "utf-8");
+  // This is an out-of-band write (bypasses StorageManager.writeMemory), so it
+  // must invalidate the version-keyed hot-memories cache (issue #1902) — drop
+  // every cache layer for this dir via the exported chokepoint so the next
+  // readAllMemories() rescans disk and sees this file (matches the harness seam).
+  clearMemoryCache(storage.dir);
   return id;
 }
 

package/src/review/index.ts

@@ -8,6 +8,7 @@
 import fs from "node:fs";
 import path from "node:path";
 import { getCategoryDir, ALL_CATEGORY_DIRS } from "../utils/category-dir.js";
+import { bumpMemoryCorpusVersionForDir } from "../memory-corpus-version.js";
 
 // ── Types ────────────────────────────────────────────────────────────────────
 
@@ -259,14 +260,21 @@ export function performReview(
   action: ReviewAction,
   options: ReviewActionOptions = {},
 ): ReviewResult {
-  switch (action) {
-    case "approve":
-      return approveItem(memoryDir, itemId, options);
-    case "dismiss":
-      return dismissItem(memoryDir, itemId, options);
-    case "flag":
-      return flagItem(memoryDir, itemId, options);
-  }
+  const result =
+    action === "approve"
+      ? approveItem(memoryDir, itemId, options)
+      : action === "dismiss"
+        ? dismissItem(memoryDir, itemId, options)
+        : flagItem(memoryDir, itemId, options);
+  // Review approval/dismissal/flagging edits, moves, or removes memory files
+  // directly (out-of-band — it does not go through a StorageManager mutation
+  // method), so bump the corpus sentinel to force the version-keyed hot cache
+  // to rescan on its next read (issue #1902). Only bump when a file was
+  // actually modified/moved (updatedPath set) — no-op early returns (item not
+  // found, unparsable frontmatter) must not advance the sentinel or needlessly
+  // clear caches (Cursor Medium).
+  if (result.updatedPath !== undefined) bumpMemoryCorpusVersionForDir(memoryDir);
+  return result;
 }
 
 // ── Actions ──────────────────────────────────────────────────────────────────

package/src/semantic-rule-promotion.ts

@@ -498,7 +498,15 @@ function normalizeRuleWhitespace(value: string): string {
 }
 
 function stripTrailingClausePunctuation(value: string): string {
-  return value.replace(/[,:;]+$/g, "").trim();
+  // Linear trailing-punctuation strip (no `/[,:;]+$/` — CodeQL flags that as a
+  // polynomial-backtracking ReDoS on long runs of ',;:'). Walk back once, O(n).
+  let end = value.length;
+  while (end > 0) {
+    const ch = value[end - 1];
+    if (ch === "," || ch === ":" || ch === ";") end--;
+    else break;
+  }
+  return value.slice(0, end).trim();
 }
 
 function canonicalizeRuleContent(value: string): string {

package/src/semantic-rule-verifier.ts

@@ -116,18 +116,31 @@ export async function searchVerifiedSemanticRules(options: {
   query: string;
   maxResults: number;
   minEffectiveConfidence?: number;
+  /** Hot-memories cache gate (issue #1902, Codex P2). Threaded from the caller
+   *  so a named-namespace root (never registered in the per-dir default map)
+   *  honors the owning daemon's config instead of the process-wide default. */
+  hotMemoriesCacheEnabled?: boolean;
 }): Promise<VerifiedSemanticRuleResult[]> {
   const queryTokens = new Set(normalizeRecallTokens(options.query, ["what", "which"]));
   if (queryTokens.size === 0 || options.maxResults <= 0) return [];
 
-  const storage = new StorageManager(options.memoryDir);
-  const version = storage.getMemoryStatusVersion();
-
-  // Use derived rule cache to avoid O(146K) iteration on every call.
-  let cachedRules = getCachedRuleMemories(storage.dir, version);
+  const storage = new StorageManager(options.memoryDir, undefined, options.hotMemoriesCacheEnabled);
+  // Key the derived rule cache on the CORPUS version, not memory-status (Codex
+  // P1, #1902): rule memories are derived from the full corpus, and plain
+  // creates/writeChunk bump only the corpus sentinel. Keying on memory-status
+  // would let a peer process serve a stale rule set that omits newly created
+  // rule memories.
+  const version = storage.getMemoryCorpusVersion();
+
+  // Use derived rule cache to avoid O(146K) iteration on every call — but honor
+  // the hotMemoriesCacheEnabled opt-out (Codex P2): when disabled, never read or
+  // retain the derived cache, always rebuild from a fresh scan.
+  const cacheEnabled = storage.isHotCacheEnabled();
+  const keyId = storage.hotCacheKeyId();
+  let cachedRules = cacheEnabled ? getCachedRuleMemories(storage.dir, version, keyId, storage.hotCacheTtlMs()) : null;
   if (!cachedRules) {
     const allMems = await storage.readAllMemories();
-    cachedRules = setCachedRuleMemories(storage.dir, allMems, version);
+    cachedRules = setCachedRuleMemories(storage.dir, allMems, version, cacheEnabled, keyId);
   }
   const { all: ruleMemories, byId: memoryById } = cachedRules;
   const minEffectiveConfidence = options.minEffectiveConfidence ?? DEFAULT_MIN_EFFECTIVE_CONFIDENCE;

package/src/spaces/index.ts

@@ -13,6 +13,7 @@ import crypto from "node:crypto";
 import fs from "node:fs";
 import path from "node:path";
 import { readEnvVar, resolveHomeDir } from "../runtime/env.js";
+import { bumpMemoryCorpusVersionForDir } from "../memory-corpus-version.js";
 
 // ── Types ────────────────────────────────────────────────────────────────────
 
@@ -935,6 +936,15 @@ function copyMemories(
     }
     fs.writeFileSync(targetPath, content);
     merged++;
+    // Bump the target's corpus sentinel per write (out-of-band — not through a
+    // StorageManager mutation), on the CANONICAL root (targetRoot), matching
+    // where files were written and where a StorageManager resolves its
+    // version/cache keys. Per-write (not once after the loop) so a warm
+    // hot-memories cache for the target rescans MID-batch and never serves the
+    // pre-copy corpus while copies are still landing (#1902; a symlinked target
+    // would otherwise diverge, and a once-after bump leaves in-batch reads
+    // stale).
+    bumpMemoryCorpusVersionForDir(targetRoot);
   }
 
   return { merged, conflicts, skipped };

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

@@ -60,6 +60,8 @@ export interface MemoryReadStoreDeps {
   readonly proceduresDir: string;
   readonly questionsDir: string;
   readColdWriteVersion(): number;
+  /** Secure-store key identity for keying decrypted-corpus caches (#1902). */
+  hotCacheKeyId(): string;
   readMemoryByPath(filePath: string): Promise<MemoryFile | null>;
   readParsedMemoriesFromPaths(
     filePaths: string[],
@@ -365,10 +367,15 @@ export class MemoryReadStore {
     // stale data for up to 30s when another process wrote a new cold memory.
     const currentColdVersion = this.deps.readColdWriteVersion();
 
-    // Return cached result if still valid by both TTL and sentinel version.
+    // Return cached result if still valid by TTL, sentinel version, AND the
+    // secure-store key identity (issue #1902). readParsedMemoriesFromPaths
+    // decrypts per this manager's key, so a differently-keyed manager must not
+    // read a cold corpus another instance decrypted for the same coldRoot.
+    const keyId = this.deps.hotCacheKeyId();
     const cached = this.deps.storageManagerClass.coldMemoriesCache.get(coldRoot);
     if (
       cached &&
+      cached.keyId === keyId &&
       Date.now() - cached.loadedAt < this.deps.storageManagerClass.COLD_SCAN_CACHE_TTL_MS &&
       cached.coldVersion === currentColdVersion
     ) {
@@ -407,7 +414,7 @@ export class MemoryReadStore {
 
     // Store in cache with the sentinel version captured above so that any
     // subsequent cold-version bump (by this or another process) invalidates it.
-    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;
   }