@remnic/core 9.45.4 → 9.46.0

package/src/orchestration/recall-search-pipeline.ts

@@ -34,7 +34,13 @@ import { RerankCache, rerankLocalOrNoop, reorderByRankedKeys } from "../rerank.j
 import type { SearchBackend, SearchDegradation, SearchExecutionOptions, SearchQueryOptions } from "../search/port.js";
 import { SecureStoreLockedError } from "../secure-store/index.js";
 import { isPathInsideStorageRoot } from "../storage-paths.js";
-import { extractTagsFromPrompt, isTemporalQuery, queryByDateRangeAsync, queryByTagsAsync, readIndexSnapshotAsync, recencyWindowFromPrompt, resolvePromptTagPrefilterAsync } from "../temporal-index.js";
+import { extractTagsFromPrompt, isTemporalQuery, queryByDateRangeAsync, queryByTagsAsync, readIndexSnapshotAsync, recencyWindowFromPrompt } from "../temporal-index.js";
+import {
+  buildQueryAwarePrefilter as buildQueryAwarePrefilterHelper,
+  fetchActiveArtifactsForNamespace as fetchActiveArtifactsForNamespaceHelper,
+  searchEmbeddingFallback as searchEmbeddingFallbackHelper,
+  searchQueryAwareFallback as searchQueryAwareFallbackHelper,
+} from "./recall-search-prefilter.js";
 import { shouldFilterSupersededFromRecall } from "../temporal-supersession.js";
 import { isValidAsOf, isValidityExpiredNow } from "../temporal-validity.js";
 import type { TrustStageResultItem } from "../trust-score-stage.js";
@@ -49,7 +55,6 @@ import {
 } from "../recall-memory-map.js";
 import { type UtilityRuntimeValues, applyUtilityRankingRuntimeDelta } from "../utility-runtime.js";
 import {
-  computeArtifactCandidateFetchLimit,
   lifecycleRecallScoreAdjustment,
   shouldFilterLifecycleRecallCandidate,
   computeQmdHybridFetchLimit,
@@ -247,158 +252,17 @@ export class RecallSearchPipelineCoordinator {
     prompt: string,
     targetCount: number,
   ): Promise<MemoryFile[]> {
-    const storage = await this.deps.storageRouter.storageFor(namespace);
-    let fetchLimit = computeArtifactCandidateFetchLimit(targetCount);
-    const maxFetchLimit = Math.min(800, Math.max(fetchLimit, targetCount * 8));
-    const MAX_ATTEMPTS = 4;
-    let bestFiltered: MemoryFile[] = [];
-
-    for (let attempt = 0; attempt < MAX_ATTEMPTS; attempt += 1) {
-      const rawResults = await storage.searchArtifacts(prompt, fetchLimit);
-      const sourceIds = Array.from(
-        new Set(
-          rawResults
-            .map((a) => a.frontmatter.sourceMemoryId)
-            .filter(
-              (id): id is string => typeof id === "string" && id.length > 0,
-            ),
-        ),
-      );
-      const sourceStatus =
-        sourceIds.length > 0
-          ? await this.deps.resolveArtifactSourceStatuses(storage, sourceIds)
-          : new Map<string, "active" | "superseded" | "archived" | "missing">();
-
-      const filtered: MemoryFile[] = [];
-      for (const artifact of rawResults) {
-        const sourceId = artifact.frontmatter.sourceMemoryId;
-        if (!sourceId) {
-          filtered.push(artifact);
-          if (filtered.length >= targetCount) break;
-          continue;
-        }
-        const status = sourceStatus.get(sourceId) ?? "missing";
-        if (status !== "active") continue;
-        filtered.push(artifact);
-        if (filtered.length >= targetCount) break;
-      }
-
-      if (filtered.length >= targetCount) return filtered.slice(0, targetCount);
-      if (filtered.length > bestFiltered.length) {
-        bestFiltered = filtered;
-      }
-      if (rawResults.length === 0) return filtered;
-      if (rawResults.length < fetchLimit && filtered.length > 0)
-        return filtered;
-      if (fetchLimit >= maxFetchLimit) return filtered;
-
-      const growth = Math.max(targetCount * 2, 12);
-      fetchLimit = Math.min(maxFetchLimit, fetchLimit + growth);
-    }
-
-    return bestFiltered;
+    return fetchActiveArtifactsForNamespaceHelper(this.deps, namespace, prompt, targetCount);
   }
 
   async buildQueryAwarePrefilter(
     prompt: string,
     recallNamespaces: string[],
   ): Promise<QueryAwarePrefilter> {
-    if (!resolveIndexingCapabilities(this.deps.config).queryAwareIndexing || !prompt.trim()) {
-      return {
-        candidatePaths: null,
-        temporalFromDate: null,
-        matchedTags: [],
-        expandedTags: [],
-        combination: "none",
-        filteredToFullSearch: false,
-      };
-    }
-
-    const temporalFromDate = isTemporalQuery(prompt)
-      ? recencyWindowFromPrompt(prompt, Date.now())
-      : null;
-    // Read the temporal + tag prefilter indexes as ONE consistent snapshot
-    // (issue #1911, Codex Medium) so a concurrent async index mutation can't be
-    // observed half-applied (new temporal row, tag membership not yet written),
-    // which would drop the current memory from the tag prefilter.
-    const [rawTemporal, tagSignals] = await readIndexSnapshotAsync(
-      this.deps.config.memoryDir,
-      () =>
-        Promise.all([
-          temporalFromDate
-            ? queryByDateRangeAsync(this.deps.config.memoryDir, temporalFromDate)
-            : Promise.resolve<Set<string> | null>(null),
-          resolvePromptTagPrefilterAsync(this.deps.config.memoryDir, prompt).catch(
-            () => ({
-              matchedTags: extractTagsFromPrompt(prompt),
-              expandedTags: extractTagsFromPrompt(prompt),
-              paths: null,
-            }),
-          ),
-        ]),
-    );
-
-    const temporalCandidates = this.deps.scopeQueryAwarePaths(
-      rawTemporal,
-      recallNamespaces,
-    );
-    const tagCandidates = this.deps.scopeQueryAwarePaths(
-      tagSignals.paths,
-      recallNamespaces,
-    );
-    const maxCandidates = this.deps.config.queryAwareIndexingMaxCandidates;
-
-    let candidatePaths: Set<string> | null = null;
-    let combination: QueryAwarePrefilter["combination"] = "none";
-    let filteredToFullSearch = false;
-
-    if (
-      tagSignals.matchedTags.length > 0 &&
-      tagCandidates !== null &&
-      tagCandidates.size === 0
-    ) {
-      candidatePaths = tagCandidates;
-      combination = "tag";
-    } else if (temporalCandidates !== null && tagCandidates !== null) {
-      const intersection = new Set(
-        Array.from(temporalCandidates).filter((memoryPath) =>
-          tagCandidates.has(memoryPath),
-        ),
-      );
-      if (intersection.size > 0) {
-        candidatePaths = intersection;
-        combination = "intersection";
-      } else {
-        candidatePaths = new Set([...temporalCandidates, ...tagCandidates]);
-        combination = "union";
-      }
-    } else if (temporalCandidates !== null) {
-      candidatePaths = temporalCandidates;
-      combination = "temporal";
-    } else if (tagCandidates !== null) {
-      candidatePaths = tagCandidates;
-      combination = "tag";
-    }
-
-    if (
-      candidatePaths &&
-      maxCandidates > 0 &&
-      candidatePaths.size > maxCandidates
-    ) {
-      filteredToFullSearch = true;
-      candidatePaths = null;
-    }
-
-    return {
-      candidatePaths,
-      temporalFromDate,
-      matchedTags: tagSignals.matchedTags,
-      expandedTags: tagSignals.expandedTags,
-      combination,
-      filteredToFullSearch,
-    };
+    return buildQueryAwarePrefilterHelper(this.deps, prompt, recallNamespaces);
   }
 
+
   async fetchQmdMemoryResultsWithArtifactTopUp(
     prompt: string,
     qmdFetchLimit: number,
@@ -654,26 +518,7 @@ export class RecallSearchPipelineCoordinator {
     query: string,
     limit: number,
   ): Promise<QmdSearchResult[]> {
-    if (!resolveMemoryLifecycleCapabilities(this.deps.config).embeddingFallback) return [];
-    if (!(await this.deps.embeddingFallback.isAvailable())) return [];
-    const hits = await this.deps.embeddingFallback.search(query, limit);
-    if (hits.length === 0) return [];
-
-    const results: QmdSearchResult[] = [];
-    for (const hit of hits) {
-      const fullPath = path.isAbsolute(hit.path)
-        ? hit.path
-        : path.join(this.deps.config.memoryDir, hit.path);
-      const memory = await this.deps.storage.readMemoryByPath(fullPath);
-      if (!memory) continue;
-      results.push({
-        docid: hit.id,
-        path: fullPath,
-        score: hit.score,
-        snippet: memory.content.slice(0, 400).replace(/\n/g, " "),
-      });
-    }
-    return results;
+    return searchEmbeddingFallbackHelper(this.deps, query, limit);
   }
 
   /**
@@ -686,24 +531,10 @@ export class RecallSearchPipelineCoordinator {
     queryAwarePrefilter?: QueryAwarePrefilter,
     abortSignal?: AbortSignal,
   ): Promise<QmdSearchResult[]> {
-    throwIfRecallAborted(abortSignal);
-    const cappedLimit = Math.max(0, limit);
-    if (cappedLimit === 0 || queryAwarePrefilter?.candidatePaths?.size === 0) return [];
-
-    const candidatePaths = queryAwarePrefilter?.candidatePaths;
-    const scopedSeedResults = (
-      candidatePaths?.size
-        ? await this.deps.searchScopedMemoryCandidates(
-            candidatePaths,
-            prompt,
-            candidatePaths.size,
-            { allowArchived: true },
-          )
-        : []
-    ).filter((result) => !isGenericRecallExcludedPath(result.path, this.deps.config, "qmd"));
-    return scopedSeedResults.slice(0, cappedLimit);
+    return searchQueryAwareFallbackHelper(this.deps, prompt, limit, queryAwarePrefilter, abortSignal);
   }
 
+
   async applyColdFallbackPipeline(options: {
     prompt: string;
     recallNamespaces: string[];

package/src/orchestration/recall-search-prefilter.ts

@@ -0,0 +1,254 @@
+import path from "node:path";
+import { resolveIndexingCapabilities, resolveMemoryLifecycleCapabilities } from "../capabilities.js";
+import type { EmbeddingFallback } from "../embedding-fallback.js";
+import type { StorageManager } from "../index.js";
+import type { NamespaceStorageRouter } from "../namespaces/storage.js";
+import {
+  computeArtifactCandidateFetchLimit,
+  throwIfRecallAborted,
+  type QueryAwarePrefilter,
+} from "../orchestrator.js";
+import {
+  extractTagsFromPrompt,
+  isTemporalQuery,
+  queryByDateRangeAsync,
+  readIndexSnapshotAsync,
+  recencyWindowFromPrompt,
+  resolvePromptTagPrefilterAsync,
+} from "../temporal-index.js";
+import type { MemoryFile, PluginConfig, QmdSearchResult } from "../types.js";
+import { isGenericRecallExcludedPath } from "./generic-recall-paths.js";
+
+export interface PrefilterAndArtifactDeps {
+  readonly config: PluginConfig;
+  readonly storageRouter: NamespaceStorageRouter;
+  readonly storage: StorageManager;
+  readonly embeddingFallback: EmbeddingFallback;
+  resolveArtifactSourceStatuses(
+    storage: StorageManager,
+    sourceIds: string[],
+  ): Promise<Map<string, "active" | "superseded" | "archived" | "missing">>;
+  scopeQueryAwarePaths(
+    paths: Set<string> | null,
+    recallNamespaces: string[],
+  ): Set<string> | null;
+  searchScopedMemoryCandidates(
+    candidatePaths: Set<string>,
+    query: string,
+    limit: number,
+    options?: {
+      allowArchived?: boolean;
+    },
+  ): Promise<QmdSearchResult[]>;
+}
+
+export async function fetchActiveArtifactsForNamespace(
+  deps: Pick<PrefilterAndArtifactDeps, "storageRouter" | "resolveArtifactSourceStatuses">,
+  namespace: string,
+  prompt: string,
+  targetCount: number,
+): Promise<MemoryFile[]> {
+  const storage = await deps.storageRouter.storageFor(namespace);
+  let fetchLimit = computeArtifactCandidateFetchLimit(targetCount);
+  const maxFetchLimit = Math.min(800, Math.max(fetchLimit, targetCount * 8));
+  const MAX_ATTEMPTS = 4;
+  let bestFiltered: MemoryFile[] = [];
+
+  for (let attempt = 0; attempt < MAX_ATTEMPTS; attempt += 1) {
+    const rawResults = await storage.searchArtifacts(prompt, fetchLimit);
+    const sourceIds = Array.from(
+      new Set(
+        rawResults
+          .map((a) => a.frontmatter.sourceMemoryId)
+          .filter(
+            (id): id is string => typeof id === "string" && id.length > 0,
+          ),
+      ),
+    );
+    const sourceStatus =
+      sourceIds.length > 0
+        ? await deps.resolveArtifactSourceStatuses(storage, sourceIds)
+        : new Map<string, "active" | "superseded" | "archived" | "missing">();
+
+    const filtered: MemoryFile[] = [];
+    for (const artifact of rawResults) {
+      const sourceId = artifact.frontmatter.sourceMemoryId;
+      if (!sourceId) {
+        filtered.push(artifact);
+        if (filtered.length >= targetCount) break;
+        continue;
+      }
+      const status = sourceStatus.get(sourceId) ?? "missing";
+      if (status !== "active") continue;
+      filtered.push(artifact);
+      if (filtered.length >= targetCount) break;
+    }
+
+    if (filtered.length >= targetCount) return filtered.slice(0, targetCount);
+    if (filtered.length > bestFiltered.length) {
+      bestFiltered = filtered;
+    }
+    if (rawResults.length === 0) return filtered;
+    if (rawResults.length < fetchLimit && filtered.length > 0)
+      return filtered;
+    if (fetchLimit >= maxFetchLimit) return filtered;
+
+    const growth = Math.max(targetCount * 2, 12);
+    fetchLimit = Math.min(maxFetchLimit, fetchLimit + growth);
+  }
+
+  return bestFiltered;
+}
+
+export async function buildQueryAwarePrefilter(
+  deps: Pick<PrefilterAndArtifactDeps, "config" | "scopeQueryAwarePaths">,
+  prompt: string,
+  recallNamespaces: string[],
+): Promise<QueryAwarePrefilter> {
+  if (!resolveIndexingCapabilities(deps.config).queryAwareIndexing || !prompt.trim()) {
+    return {
+      candidatePaths: null,
+      temporalFromDate: null,
+      matchedTags: [],
+      expandedTags: [],
+      combination: "none",
+      filteredToFullSearch: false,
+    };
+  }
+
+  const temporalFromDate = isTemporalQuery(prompt)
+    ? recencyWindowFromPrompt(prompt, Date.now())
+    : null;
+  // Read the temporal + tag prefilter indexes as ONE consistent snapshot
+  // (issue #1911, Codex Medium) so a concurrent async index mutation can't be
+  // observed half-applied (new temporal row, tag membership not yet written),
+  // which would drop the current memory from the tag prefilter.
+  const [rawTemporal, tagSignals] = await readIndexSnapshotAsync(
+    deps.config.memoryDir,
+    () =>
+      Promise.all([
+        temporalFromDate
+          ? queryByDateRangeAsync(deps.config.memoryDir, temporalFromDate)
+          : Promise.resolve<Set<string> | null>(null),
+        resolvePromptTagPrefilterAsync(deps.config.memoryDir, prompt).catch(
+          () => ({
+            matchedTags: extractTagsFromPrompt(prompt),
+            expandedTags: extractTagsFromPrompt(prompt),
+            paths: null,
+          }),
+        ),
+      ]),
+  );
+
+  const temporalCandidates = deps.scopeQueryAwarePaths(
+    rawTemporal,
+    recallNamespaces,
+  );
+  const tagCandidates = deps.scopeQueryAwarePaths(
+    tagSignals.paths,
+    recallNamespaces,
+  );
+  const maxCandidates = deps.config.queryAwareIndexingMaxCandidates;
+
+  let candidatePaths: Set<string> | null = null;
+  let combination: QueryAwarePrefilter["combination"] = "none";
+  let filteredToFullSearch = false;
+
+  if (
+    tagSignals.matchedTags.length > 0 &&
+    tagCandidates !== null &&
+    tagCandidates.size === 0
+  ) {
+    candidatePaths = tagCandidates;
+    combination = "tag";
+  } else if (temporalCandidates !== null && tagCandidates !== null) {
+    const intersection = new Set(
+      Array.from(temporalCandidates).filter((memoryPath) =>
+        tagCandidates.has(memoryPath),
+      ),
+    );
+    if (intersection.size > 0) {
+      candidatePaths = intersection;
+      combination = "intersection";
+    } else {
+      candidatePaths = new Set([...temporalCandidates, ...tagCandidates]);
+      combination = "union";
+    }
+  } else if (temporalCandidates !== null) {
+    candidatePaths = temporalCandidates;
+    combination = "temporal";
+  } else if (tagCandidates !== null) {
+    candidatePaths = tagCandidates;
+    combination = "tag";
+  }
+
+  if (
+    candidatePaths &&
+    maxCandidates > 0 &&
+    candidatePaths.size > maxCandidates
+  ) {
+    filteredToFullSearch = true;
+    candidatePaths = null;
+  }
+
+  return {
+    candidatePaths,
+    temporalFromDate,
+    matchedTags: tagSignals.matchedTags,
+    expandedTags: tagSignals.expandedTags,
+    combination,
+    filteredToFullSearch,
+  };
+}
+
+export async function searchEmbeddingFallback(
+  deps: Pick<PrefilterAndArtifactDeps, "config" | "embeddingFallback" | "storage">,
+  query: string,
+  limit: number,
+): Promise<QmdSearchResult[]> {
+  if (!resolveMemoryLifecycleCapabilities(deps.config).embeddingFallback) return [];
+  if (!(await deps.embeddingFallback.isAvailable())) return [];
+  const hits = await deps.embeddingFallback.search(query, limit);
+  if (hits.length === 0) return [];
+
+  const results: QmdSearchResult[] = [];
+  for (const hit of hits) {
+    const fullPath = path.isAbsolute(hit.path)
+      ? hit.path
+      : path.join(deps.config.memoryDir, hit.path);
+    const memory = await deps.storage.readMemoryByPath(fullPath);
+    if (!memory) continue;
+    results.push({
+      docid: hit.id,
+      path: fullPath,
+      score: hit.score,
+      snippet: memory.content.slice(0, 400).replace(/\n/g, " "),
+    });
+  }
+  return results;
+}
+
+export async function searchQueryAwareFallback(
+  deps: Pick<PrefilterAndArtifactDeps, "config" | "searchScopedMemoryCandidates">,
+  prompt: string,
+  limit: number,
+  queryAwarePrefilter?: QueryAwarePrefilter,
+  abortSignal?: AbortSignal,
+): Promise<QmdSearchResult[]> {
+  throwIfRecallAborted(abortSignal);
+  const cappedLimit = Math.max(0, limit);
+  if (cappedLimit === 0 || queryAwarePrefilter?.candidatePaths?.size === 0) return [];
+
+  const candidatePaths = queryAwarePrefilter?.candidatePaths;
+  const scopedSeedResults = (
+    candidatePaths?.size
+      ? await deps.searchScopedMemoryCandidates(
+          candidatePaths,
+          prompt,
+          candidatePaths.size,
+          { allowArchived: true },
+        )
+      : []
+  ).filter((result) => !isGenericRecallExcludedPath(result.path, deps.config, "qmd"));
+  return scopedSeedResults.slice(0, cappedLimit);
+}

package/src/orchestration/session-context.ts

@@ -306,7 +306,7 @@ export class SessionContextCoordinator {
    * Register a peer ID for a session so recall can inject the peer's
    * profile into context (issue #679 PR 3/5). Pass `null` to clear.
    *
-   * Connectors and the `before_agent_start` hook call this when the
+   * Connectors and the `before_prompt_build` hook call this when the
    * session's counter-party is known. The ID is validated against
    * `PEER_ID_PATTERN` before storing.
    *

package/src/orchestrator.ts

@@ -656,7 +656,7 @@ export class Orchestrator {
 
   /**
    * Per-session workspace selections keyed by sessionKey.
-   * Set by the before_agent_start hook so recall() uses the correct
+   * Set by the before_prompt_build hook so recall() uses the correct
    * agent workspace for BOOT.md injection. Cleared after each recall.
    * Using a Map prevents concurrent sessions from overwriting each other.
    */

package/src/sdk-compat.ts

@@ -64,10 +64,8 @@ export function detectSdkCapabilities(api: Record<string, unknown>): SdkCapabili
   //   - registerMemoryCapability   (capability-based SDKs, ≥2026.4.5; the
   //     deprecated registerMemoryPromptSection may be absent)
   //   - registrationMode           (explicit registration lifecycle signal)
-  // Just having runtime.version is NOT sufficient — some legacy builds
-  // expose it. Omitting registerMemoryCapability here would cause the
-  // legacy before_agent_start hook to be registered on new SDKs that only
-  // expose registerMemoryCapability, silently breaking memory injection.
+  // Runtime version alone is not authoritative because some transitional
+  // builds expose it without the modern prompt-hook surfaces.
   const hasNewHookSystem =
     hasRegisterMemoryPromptSection || hasRegisterMemoryCapability || hasRegistrationMode;
 

package/src/source-agent-qualifier.ts

@@ -48,6 +48,9 @@ export interface ExtractionGroundingContext {
   roleAssertionSources?: ExtractionGroundingRoleSources;
   messageTimestamp: Date | undefined;
   sourceConnector?: string;
+  /** Input came from an always-on recorder (issue #2294); the proactive
+   *  second pass reads it so its prompts carry the same media warning. */
+  ambientCapture?: boolean;
   scopeClassificationEnabled?: boolean;
 }
 

package/src/storage-contract/cache-coherence.test.ts

@@ -435,3 +435,102 @@ test("citation path lookup resolves collection-prefixed QMD paths", async () =>
     await rm(dir, { recursive: true, force: true });
   }
 });
+test("memory snapshots ignore object key order", async () => {
+  const { createMemorySnapshot } = await import("../memory-snapshot.js");
+  type SnapshotInput = Parameters<typeof createMemorySnapshot>[0];
+  const first = {
+    content: "payload",
+    frontmatter: { z: 1, nested: { y: 2, x: 3 } },
+  } as unknown as SnapshotInput;
+  const second = {
+    frontmatter: { nested: { x: 3, y: 2 }, z: 1 },
+    content: "payload",
+  } as unknown as SnapshotInput;
+  assert.equal(createMemorySnapshot(first), createMemorySnapshot(second));
+});
+
+test("tier move: caller-only mutation is not persisted by moveMemoryToPath", async () => {
+  const dir = await mkdtemp(path.join(os.tmpdir(), "remnic-caller-mut-"));
+  try {
+    resetStaticCaches();
+    const storage = new StorageManager(dir);
+    await storage.ensureDirectories();
+
+    const { id } = await storage.writeMemory("fact", "original disk content");
+    const memories = await storage.readAllMemories();
+    const memory = memories.find((m) => m.frontmatter.id === id);
+    assert.ok(memory, "memory must exist");
+
+    memory.content = "caller mutated unpersisted content";
+
+    const targetPath = storage.buildTierMemoryPath(memory, "cold");
+    await storage.moveMemoryToPath(memory, targetPath);
+
+    const onDisk = await readFile(targetPath, "utf8");
+    assert.ok(onDisk.includes("original disk content"), "Moved file on disk must retain original content");
+    assert.ok(!onDisk.includes("caller mutated unpersisted content"), "Moved file on disk must not carry caller's unpersisted content mutation");
+  } finally {
+    resetStaticCaches();
+    await rm(dir, { recursive: true, force: true });
+  }
+});
+
+test("tier move: stale on-disk mutation fails snapshot check during move", async () => {
+  const dir = await mkdtemp(path.join(os.tmpdir(), "remnic-stale-disk-"));
+  try {
+    resetStaticCaches();
+    const storage = new StorageManager(dir);
+    await storage.ensureDirectories();
+
+    const { id } = await storage.writeMemory("fact", "unmodified content");
+    const memories = await storage.readAllMemories();
+    const memory = memories.find((m) => m.frontmatter.id === id);
+    assert.ok(memory, "memory must exist");
+
+    const diskContent = await readFile(memory.path, "utf8");
+    await writeFile(memory.path, diskContent.replace("unmodified content", "external edit on disk"));
+
+    const targetPath = storage.buildTierMemoryPath(memory, "cold");
+    await assert.rejects(
+      async () => {
+        await storage.moveMemoryToPath(memory, targetPath);
+      },
+      (err: Error) => {
+        return err.message.includes("changed before its tier move");
+      }
+    );
+  } finally {
+    resetStaticCaches();
+    await rm(dir, { recursive: true, force: true });
+  }
+});
+
+test("tier move: cold-to-hot move invalidates cold cache and cannot remain in readAllColdMemories", async () => {
+  const dir = await mkdtemp(path.join(os.tmpdir(), "remnic-cold-to-hot-"));
+  try {
+    resetStaticCaches();
+    const storage = new StorageManager(dir);
+    await storage.ensureDirectories();
+
+    const { id } = await storage.writeMemory("fact", "demoted to cold then promoted");
+    const memories = await storage.readAllMemories();
+    const memory = memories.find((m) => m.frontmatter.id === id);
+    assert.ok(memory, "memory must exist");
+
+    const { targetPath: coldPath } = await storage.migrateMemoryToTier(memory, "cold");
+
+    const coldMemories = await storage.readAllColdMemories();
+    const coldMem = coldMemories.find((m) => m.frontmatter.id === id);
+    assert.ok(coldMem, "memory must be present in cold tier read");
+
+    const { changed } = await storage.migrateMemoryToTier(coldMem, "hot");
+    assert.equal(changed, true, "migration from cold to hot must succeed");
+
+    const coldMemoriesAfter = await storage.readAllColdMemories();
+    const foundInCold = coldMemoriesAfter.some((m) => m.frontmatter.id === id);
+    assert.equal(foundInCold, false, "promoted memory must not remain in readAllColdMemories cache");
+  } finally {
+    resetStaticCaches();
+    await rm(dir, { recursive: true, force: true });
+  }
+});