@remnic/core 9.3.762 → 9.3.763

package/dist/semantic-consolidation.js

@@ -7,14 +7,14 @@ import {
   materializeAfterSemanticConsolidation,
   parseConsolidationResponse,
   parseOperatorAwareConsolidationResponse
-} from "./chunk-HDFS6RWQ.js";
-import "./chunk-OQ6F3WBX.js";
+} from "./chunk-CVINPTKG.js";
+import "./chunk-2RLECZ6J.js";
 import "./chunk-UUH4YQOF.js";
 import {
   resolveExtensionsRoot
 } from "./chunk-JLNBQWZ2.js";
 import "./chunk-3UXOZBHV.js";
-import "./chunk-P7W4CDX6.js";
+import "./chunk-DTTVX6EO.js";
 import "./chunk-M7XQSUBB.js";
 import "./chunk-L2B3EE7B.js";
 import "./chunk-5UZXUTVO.js";
@@ -30,7 +30,7 @@ import "./chunk-AWJ2FHCF.js";
 import "./chunk-42JKGUFJ.js";
 import "./chunk-RULE4VG5.js";
 import "./chunk-SCU65EZI.js";
-import "./chunk-MB5RSUW6.js";
+import "./chunk-SXN3LCUT.js";
 import "./chunk-6KYMPV2O.js";
 import "./chunk-DM2T26WE.js";
 import "./chunk-LDXUBPMO.js";

package/dist/semantic-rule-promotion.js

@@ -1,8 +1,8 @@
 import {
   promoteSemanticRuleFromMemory,
   setSemanticRulePromotionTestHooks
-} from "./chunk-KZWUJC7Y.js";
-import "./chunk-P7W4CDX6.js";
+} from "./chunk-X7HTU4HO.js";
+import "./chunk-DTTVX6EO.js";
 import "./chunk-M7XQSUBB.js";
 import "./chunk-L2B3EE7B.js";
 import "./chunk-5UZXUTVO.js";
@@ -18,7 +18,7 @@ import "./chunk-AWJ2FHCF.js";
 import "./chunk-42JKGUFJ.js";
 import "./chunk-RULE4VG5.js";
 import "./chunk-SCU65EZI.js";
-import "./chunk-MB5RSUW6.js";
+import "./chunk-SXN3LCUT.js";
 import "./chunk-6KYMPV2O.js";
 import "./chunk-DM2T26WE.js";
 import "./chunk-LDXUBPMO.js";

package/dist/semantic-rule-verifier.js

@@ -1,8 +1,8 @@
 import {
   compareVerifiedSemanticRuleResults,
   searchVerifiedSemanticRules
-} from "./chunk-ES3GAMSQ.js";
-import "./chunk-P7W4CDX6.js";
+} from "./chunk-VKHZFF5P.js";
+import "./chunk-DTTVX6EO.js";
 import "./chunk-M7XQSUBB.js";
 import "./chunk-L2B3EE7B.js";
 import "./chunk-5UZXUTVO.js";
@@ -18,7 +18,7 @@ import "./chunk-AWJ2FHCF.js";
 import "./chunk-42JKGUFJ.js";
 import "./chunk-RULE4VG5.js";
 import "./chunk-SCU65EZI.js";
-import "./chunk-MB5RSUW6.js";
+import "./chunk-SXN3LCUT.js";
 import "./chunk-6KYMPV2O.js";
 import "./chunk-DM2T26WE.js";
 import "./chunk-LDXUBPMO.js";

package/dist/storage.js

@@ -16,7 +16,7 @@ import {
   parseFrontmatter,
   parseFrontmatterStringValue,
   serializeEntityFile
-} from "./chunk-P7W4CDX6.js";
+} from "./chunk-DTTVX6EO.js";
 import "./chunk-M7XQSUBB.js";
 import "./chunk-L2B3EE7B.js";
 import "./chunk-5UZXUTVO.js";
@@ -34,7 +34,7 @@ import "./chunk-AWJ2FHCF.js";
 import "./chunk-42JKGUFJ.js";
 import "./chunk-RULE4VG5.js";
 import "./chunk-SCU65EZI.js";
-import "./chunk-MB5RSUW6.js";
+import "./chunk-SXN3LCUT.js";
 import "./chunk-6KYMPV2O.js";
 import "./chunk-DM2T26WE.js";
 import "./chunk-LDXUBPMO.js";

package/dist/verified-recall.js

@@ -1,9 +1,9 @@
 import {
   compareVerifiedEpisodeResults,
   searchVerifiedEpisodes
-} from "./chunk-4HYJETVO.js";
+} from "./chunk-N4ZA2I7M.js";
 import "./chunk-7FL4CNPV.js";
-import "./chunk-P7W4CDX6.js";
+import "./chunk-DTTVX6EO.js";
 import "./chunk-M7XQSUBB.js";
 import "./chunk-L2B3EE7B.js";
 import "./chunk-5UZXUTVO.js";
@@ -19,7 +19,7 @@ import "./chunk-AWJ2FHCF.js";
 import "./chunk-42JKGUFJ.js";
 import "./chunk-RULE4VG5.js";
 import "./chunk-SCU65EZI.js";
-import "./chunk-MB5RSUW6.js";
+import "./chunk-SXN3LCUT.js";
 import "./chunk-6KYMPV2O.js";
 import "./chunk-DM2T26WE.js";
 import "./chunk-LDXUBPMO.js";

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@remnic/core",
-  "version": "9.3.762",
+  "version": "9.3.763",
   "description": "Framework-agnostic Remnic memory engine — orchestrator, storage, extraction, search, trust zones",
   "type": "module",
   "main": "dist/index.js",
@@ -3000,7 +3000,7 @@
     "core"
   ],
   "peerDependencies": {
-    "@remnic/coding-graph": "^9.3.762"
+    "@remnic/coding-graph": "^9.3.763"
   },
   "peerDependenciesMeta": {
     "@remnic/coding-graph": {

package/src/maintenance/purge.test.ts

@@ -5,6 +5,9 @@ import path from "node:path";
 import test from "node:test";
 
 import { purgeMemories } from "./purge.js";
+import { rebuildMemoryProjection } from "./rebuild-memory-projection.js";
+import { readProjectedMemoryBrowse } from "../memory-projection-store.js";
+import { StorageManager } from "../storage.js";
 import type { MemoryFile } from "../types.js";
 
 test("purgeMemories records audit errors without blocking hard delete", async () => {
@@ -54,6 +57,79 @@ test("purgeMemories records audit errors without blocking hard delete", async ()
   }
 });
 
+test("purgeMemories invalidates projection rows for hard-deleted memories", async () => {
+  const dir = await mkdtemp(path.join(os.tmpdir(), "remnic-purge-projection-"));
+  try {
+    const storage = new StorageManager(dir);
+    const { id } = await storage.writeMemory("fact", "purge projection target", {
+      source: "test",
+    });
+    const memory = await storage.getMemoryById(id);
+    assert.ok(memory);
+    await rebuildMemoryProjection({ memoryDir: dir, dryRun: false });
+    assert.equal(readProjectedMemoryBrowse(dir, { limit: 5, offset: 0 })?.total, 1);
+
+    const result = await purgeMemories({
+      storage,
+      olderThanMs: 1,
+      tier: "all",
+      dryRun: false,
+      now: () => new Date(Date.now() + 86_400_000),
+    });
+
+    assert.equal(result.purgedCount, 1);
+    assert.equal(readProjectedMemoryBrowse(dir, { limit: 5, offset: 0 })?.total, 0);
+  } finally {
+    await rm(dir, { recursive: true, force: true });
+  }
+});
+
+test("purgeMemories invalidates projection rows for already-absent files but not failed deletes, and dry-run never mutates", async () => {
+  const dir = await mkdtemp(path.join(os.tmpdir(), "remnic-purge-projection-branches-"));
+  try {
+    // Real projection with two rows; candidates come from a mock storage so the
+    // unlink outcomes are deterministic: one path is already absent (ENOENT),
+    // the other is a non-empty directory (unlink fails, not ENOENT).
+    const realStorage = new StorageManager(dir);
+    const first = await realStorage.writeMemory("fact", "purge branch enoent", { source: "test" });
+    const second = await realStorage.writeMemory("fact", "purge branch failure", { source: "test" });
+    await rebuildMemoryProjection({ memoryDir: dir, dryRun: false });
+    assert.equal(readProjectedMemoryBrowse(dir, { limit: 5, offset: 0 })?.total, 2);
+
+    const firstMemory = await realStorage.getMemoryById(first.id);
+    const secondMemory = await realStorage.getMemoryById(second.id);
+    assert.ok(firstMemory && secondMemory);
+    await rm(firstMemory.path);
+    await rm(secondMemory.path);
+    await mkdir(secondMemory.path);
+    await writeFile(path.join(secondMemory.path, "block.txt"), "x", "utf8");
+
+    const mockStorage = {
+      dir,
+      readAllMemories: async () => [firstMemory, secondMemory],
+      readAllColdMemories: async () => [],
+      readArchivedMemories: async () => [],
+    };
+    const future = () => new Date(Date.now() + 86_400_000);
+
+    // Dry-run: no projection mutation.
+    await purgeMemories({ storage: mockStorage as never, olderThanMs: 1, tier: "all", dryRun: true, now: future });
+    assert.equal(readProjectedMemoryBrowse(dir, { limit: 5, offset: 0 })?.total, 2);
+
+    const result = await purgeMemories({ storage: mockStorage as never, olderThanMs: 1, tier: "all", dryRun: false, now: future });
+
+    assert.equal(result.alreadyAbsentCount, 1);
+    assert.equal(result.purgedCount, 0);
+    assert.equal(result.errors.filter((e) => e.id === second.id).length, 1);
+    const page = readProjectedMemoryBrowse(dir, { limit: 5, offset: 0 });
+    assert.ok(page);
+    // ENOENT row invalidated; failed-delete row keeps its projection entry.
+    assert.equal(page.total, 1);
+  } finally {
+    await rm(dir, { recursive: true, force: true });
+  }
+});
+
 async function fileExists(filePath: string): Promise<boolean> {
   try {
     await access(filePath);

package/src/maintenance/purge.ts

@@ -23,6 +23,7 @@ import path from "node:path";
 import { appendFile, mkdir, unlink } from "node:fs/promises";
 import type { StorageManager } from "../storage.js";
 import type { MemoryFile } from "../types.js";
+import { markProjectedMemoryPathInvalid } from "../memory-projection-store.js";
 import type { SearchBackend } from "../search/port.js";
 
 export type PurgeTierFilter = "cold" | "all";
@@ -236,12 +237,14 @@ export async function purgeMemories(
       await unlink(candidate.path);
       actuallyPurged.push(candidate);
       addCollectionForCandidate(candidate);
+      markProjectedMemoryPathInvalid(storage.dir, candidate.id);
     } catch (err) {
       const message = err instanceof Error ? err.message : String(err);
       // ENOENT is fine — already gone
       if (hasErrorCode(err, "ENOENT")) {
         alreadyAbsent.push(candidate);
         addCollectionForCandidate(candidate);
+        markProjectedMemoryPathInvalid(storage.dir, candidate.id);
       } else {
         errors.push({ id: candidate.id, path: candidate.path, error: message });
       }

package/src/maintenance/rebuild-memory-projection.ts

@@ -24,6 +24,7 @@ import {
 import {
   getMemoryProjectionPath,
   initializeMemoryProjectionDb,
+  isProjectedMemoryPathValid,
   type ProjectedEntityMentionRow,
   type MemoryProjectionGovernanceAppliedActionRow,
   type MemoryProjectionGovernanceReviewQueueRow,
@@ -794,6 +795,7 @@ function writeProjectionDb(
   usedLifecycleLedger: boolean,
 ): void {
   const db = openBetterSqlite3(dbPath);
+  const memoryDir = path.dirname(path.dirname(dbPath));
   try {
     initializeMemoryProjectionDb(db);
 
@@ -810,6 +812,7 @@ function writeProjectionDb(
         status,
         lifecycle_state,
         path_rel,
+        path_valid,
         created_at,
         updated_at,
         archived_at,
@@ -823,7 +826,7 @@ function writeProjectionDb(
         last_accessed,
         tags_json,
         preview_text
-      ) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
+      ) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
     `);
 
     const insertTimeline = db.prepare(`
@@ -921,6 +924,7 @@ function writeProjectionDb(
           row.status,
           row.lifecycleState ?? null,
           row.pathRel,
+          isProjectedMemoryPathValid(memoryDir, row.pathRel) ? 1 : 0,
           row.created,
           row.updated,
           row.archivedAt ?? null,

package/src/memory-projection-store.ts

@@ -17,7 +17,7 @@ import {
   type BetterSqlite3Database,
 } from "./runtime/better-sqlite.js";
 
-export const MEMORY_PROJECTION_SCHEMA_VERSION = 2;
+export const MEMORY_PROJECTION_SCHEMA_VERSION = 3;
 
 export interface ProjectedMemoryBrowseOptions {
   query?: string;
@@ -153,11 +153,13 @@ function migrateProjectionSchemaIfNeeded(memoryDir: string): void {
 export function memoryCurrentSelectExpressions(db: BetterSqlite3Database): {
   tagsJson: string;
   previewText: string;
+  hasPathValid: boolean;
 } {
   const columns = listTableColumns(db, "memory_current");
   return {
     tagsJson: columns.has("tags_json") ? "tags_json" : `'[]' AS tags_json`,
     previewText: columns.has("preview_text") ? "preview_text" : `'' AS preview_text`,
+    hasPathValid: columns.has("path_valid"),
   };
 }
 
@@ -174,6 +176,7 @@ export function initializeMemoryProjectionDb(db: BetterSqlite3Database): void {
       status TEXT NOT NULL,
       lifecycle_state TEXT,
       path_rel TEXT NOT NULL,
+      path_valid INTEGER NOT NULL DEFAULT 0 CHECK (path_valid IN (0, 1)),
       created_at TEXT NOT NULL,
       updated_at TEXT NOT NULL,
       archived_at TEXT,
@@ -195,8 +198,6 @@ export function initializeMemoryProjectionDb(db: BetterSqlite3Database): void {
     CREATE INDEX IF NOT EXISTS idx_memory_current_category
       ON memory_current(category);
 
-    CREATE INDEX IF NOT EXISTS idx_memory_current_updated
-      ON memory_current(updated_at DESC);
 
     CREATE TABLE IF NOT EXISTS memory_timeline (
       event_id TEXT PRIMARY KEY,
@@ -297,6 +298,18 @@ export function initializeMemoryProjectionDb(db: BetterSqlite3Database): void {
   `);
 
   migrateMemoryCurrentTable(db);
+  if (listTableColumns(db, "memory_current").has("path_valid")) {
+    db.exec(`
+      CREATE INDEX IF NOT EXISTS idx_memory_current_browse_updated_desc
+        ON memory_current(path_valid, updated_at DESC, created_at DESC, memory_id ASC);
+      CREATE INDEX IF NOT EXISTS idx_memory_current_browse_updated_asc
+        ON memory_current(path_valid, updated_at ASC, created_at ASC, memory_id ASC);
+      CREATE INDEX IF NOT EXISTS idx_memory_current_browse_created_desc
+        ON memory_current(path_valid, created_at DESC, updated_at DESC, memory_id ASC);
+      CREATE INDEX IF NOT EXISTS idx_memory_current_browse_created_asc
+        ON memory_current(path_valid, created_at ASC, updated_at ASC, memory_id ASC);
+    `);
+  }
   db.prepare("INSERT OR REPLACE INTO meta(key, value) VALUES (?, ?)")
     .run("schemaVersion", String(MEMORY_PROJECTION_SCHEMA_VERSION));
 }
@@ -309,6 +322,42 @@ function openProjectionReadonly(memoryDir: string): BetterSqlite3Database | null
     return null;
   }
 }
+function updateProjectionBestEffort(
+  memoryDir: string,
+  sql: string,
+  params: unknown[],
+): void {
+  let db: BetterSqlite3Database | null = null;
+  try {
+    db = openBetterSqlite3(getMemoryProjectionPath(memoryDir), { fileMustExist: true });
+    db.prepare(sql).run(...params);
+  } catch {
+    // Projection updates must never block the canonical filesystem mutation.
+  } finally {
+    db?.close();
+  }
+}
+
+export function markProjectedMemoryPathInvalid(memoryDir: string, memoryId: string): void {
+  updateProjectionBestEffort(
+    memoryDir,
+    "UPDATE memory_current SET path_valid = 0 WHERE memory_id = ?",
+    [memoryId],
+  );
+}
+
+export function updateProjectedMemoryPath(
+  memoryDir: string,
+  memoryId: string,
+  pathRel: string,
+): void {
+  const pathValid = isProjectedMemoryPathValid(memoryDir, pathRel) ? 1 : 0;
+  updateProjectionBestEffort(
+    memoryDir,
+    "UPDATE memory_current SET path_rel = ?, path_valid = ? WHERE memory_id = ?",
+    [pathRel, pathValid, memoryId],
+  );
+}
 
 function withProjectionReadonly<T>(
   memoryDir: string,
@@ -363,7 +412,11 @@ function isPathInsideRoot(candidatePath: string, rootPath: string): boolean {
   return relative === "" || (!relative.startsWith("..") && !path.isAbsolute(relative));
 }
 
-function resolveProjectedMemoryPath(memoryDir: string, pathRel: string): string | null {
+function resolveProjectedMemoryPath(
+  memoryDir: string,
+  pathRel: string,
+  requireExisting = false,
+): string | null {
   if (path.isAbsolute(pathRel)) return null;
   const root = resolveMemoryDirRoot(memoryDir);
   const candidate = path.resolve(root, pathRel);
@@ -372,14 +425,21 @@ function resolveProjectedMemoryPath(memoryDir: string, pathRel: string): string
     const realCandidate = fs.realpathSync(candidate);
     if (!isPathInsideRoot(realCandidate, root)) return null;
   } catch {
+    if (requireExisting) return null;
     // Missing files are handled by callers. Still keep the lexical guard above.
   }
   return candidate;
 }
 
+export function isProjectedMemoryPathValid(memoryDir: string, pathRel: string): boolean {
+  return resolveProjectedMemoryPath(memoryDir, pathRel) !== null;
+}
+
 function projectedBrowseRowFromCurrentRow(
   memoryDir: string,
   row: Record<string, unknown>,
+  resolvedFilePath?: string,
+  requireExisting = false,
 ): ProjectedMemoryBrowseRow | null {
   if (
     typeof row.memory_id !== "string" ||
@@ -389,7 +449,7 @@ function projectedBrowseRowFromCurrentRow(
   ) {
     return null;
   }
-  const filePath = resolveProjectedMemoryPath(memoryDir, row.path_rel);
+  const filePath = resolvedFilePath ?? resolveProjectedMemoryPath(memoryDir, row.path_rel, requireExisting);
   if (!filePath) return null;
   return {
     id: row.memory_id,
@@ -613,8 +673,15 @@ export function readProjectedMemoryBrowse(
     const whereSql = whereClauses.length > 0 ? `WHERE ${whereClauses.join(" AND ")}` : "";
 
     if (normalizedQuery) {
-      // Query-based browse: fetch all matching rows, filter by full file content, then paginate in JS
-      const allRows = db
+      // Full-content search still examines every eligible row so totals and
+      // matches stay exact, but iteration keeps memory use proportional to the page.
+      const queryWhereClauses = currentSelect.hasPathValid
+        ? [...whereClauses, ...projectedBrowsePathSqlClauses(), "path_valid = 1"]
+        : whereClauses;
+      const queryWhereSql = queryWhereClauses.length > 0
+        ? `WHERE ${queryWhereClauses.join(" AND ")}`
+        : "";
+      const rows = db
         .prepare(`
           SELECT
             memory_id,
@@ -627,47 +694,88 @@ export function readProjectedMemoryBrowse(
             ${currentSelect.tagsJson},
             ${currentSelect.previewText}
           FROM memory_current
-          ${whereSql}
+          ${queryWhereSql}
           ORDER BY ${orderBySql}
         `)
-        .all(...params) as Array<Record<string, unknown>>;
+        .iterate(...params) as Iterable<Record<string, unknown>>;
+      const pageRows: ProjectedMemoryBrowseRow[] = [];
+      let total = 0;
 
-      const filtered = allRows.filter((row) => {
-        if (typeof row.memory_id !== "string" || typeof row.path_rel !== "string") return false;
-        const filePath = resolveProjectedMemoryPath(memoryDir, row.path_rel);
-        if (!filePath) return false;
-        // Check preview, category, entity_ref, tags first (fast)
+      for (const row of rows) {
+        if (typeof row.memory_id !== "string" || typeof row.path_rel !== "string") continue;
+        const filePath = resolveProjectedMemoryPath(
+          memoryDir,
+          row.path_rel,
+          currentSelect.hasPathValid,
+        );
+        if (!filePath) continue;
         const preview = typeof row.preview_text === "string" ? row.preview_text.toLowerCase() : "";
         const category = typeof row.category === "string" ? row.category.toLowerCase() : "";
         const entityRef = typeof row.entity_ref === "string" ? row.entity_ref.toLowerCase() : "";
         const tags = typeof row.tags_json === "string" ? row.tags_json.toLowerCase() : "";
-        if (preview.includes(normalizedQuery) || category.includes(normalizedQuery) ||
-            entityRef.includes(normalizedQuery) || tags.includes(normalizedQuery)) {
-          return true;
+        let matches = preview.includes(normalizedQuery) || category.includes(normalizedQuery) ||
+          entityRef.includes(normalizedQuery) || tags.includes(normalizedQuery);
+        if (!matches) {
+          try {
+            matches = fs.readFileSync(filePath, "utf-8").toLowerCase().includes(normalizedQuery);
+          } catch {
+            matches = false;
+          }
         }
-        // Fall back to reading full file content from disk
-        try {
-          const content = fs.readFileSync(filePath, "utf-8").toLowerCase();
-          return content.includes(normalizedQuery);
-        } catch {
-          return false;
+        if (!matches) continue;
+        if (total >= options.offset && pageRows.length < options.limit) {
+          const browseRow = projectedBrowseRowFromCurrentRow(memoryDir, row, filePath);
+          if (browseRow) pageRows.push(browseRow);
         }
-      });
-
-      const pageRows = filtered.slice(options.offset, options.offset + options.limit);
-      return {
-        total: filtered.length,
-        memories: pageRows
-          .map((row) => projectedBrowseRowFromCurrentRow(memoryDir, row))
-          .filter((row): row is ProjectedMemoryBrowseRow => row !== null),
-      };
+        total += 1;
+      }
+
+      return { total, memories: pageRows };
     }
 
-    // No query: push lexical path safety into SQL, then count through the same
-    // realpath-aware row parser used for returned rows so symlink escapes do not
-    // inflate totals.
     const browseWhereClauses = [...whereClauses, ...projectedBrowsePathSqlClauses()];
+    if (currentSelect.hasPathValid) {
+      browseWhereClauses.push("path_valid = 1");
+    }
     const browseWhereSql = `WHERE ${browseWhereClauses.join(" AND ")}`;
+
+    if (currentSelect.hasPathValid) {
+      const rows = db
+        .prepare(`
+          SELECT
+            memory_id,
+            path_rel,
+            category,
+            status,
+            created_at,
+            updated_at,
+            entity_ref,
+            ${currentSelect.tagsJson},
+            ${currentSelect.previewText}
+          FROM memory_current
+          ${browseWhereSql}
+          ORDER BY ${orderBySql}
+        `)
+        .iterate(...params) as Iterable<Record<string, unknown>>;
+      const pageRows: ProjectedMemoryBrowseRow[] = [];
+      let validRowsSeen = 0;
+      for (const row of rows) {
+        const browseRow = projectedBrowseRowFromCurrentRow(memoryDir, row, undefined, true);
+        if (!browseRow) continue;
+        if (validRowsSeen >= options.offset) {
+          pageRows.push(browseRow);
+          if (pageRows.length >= options.limit) break;
+        }
+        validRowsSeen += 1;
+      }
+      const totalRow = db
+        .prepare(`SELECT COUNT(*) AS total FROM memory_current ${browseWhereSql}`)
+        .get(...params) as { total: number };
+      return { total: totalRow.total, memories: pageRows };
+    }
+
+    // Legacy projections have no materialized path validity. Preserve the
+    // realpath-aware full scan rather than trusting rows from an older writer.
     const pageRows: ProjectedMemoryBrowseRow[] = [];
     const fetchSize = Math.max(options.limit * 2, 50);
     let validRowsSeen = 0;

package/src/storage.ts

@@ -103,11 +103,11 @@ import type {
 import { confidenceTier, SPECULATIVE_TTL_DAYS } from "./types.js";
 import {
   type ProjectedMemoryBrowseOptions,
-  type ProjectedMemoryBrowsePage,
+  type ProjectedMemoryBrowsePage, markProjectedMemoryPathInvalid,
   readProjectedMemoryState,
   readProjectedMemoryBrowse,
   readProjectedGovernanceRecord,
-  readProjectedMemoryTimeline,
+  readProjectedMemoryTimeline, updateProjectedMemoryPath,
 } from "./memory-projection-store.js";
 import {
   inferMemoryStatus,
@@ -4566,14 +4566,12 @@ export class StorageManager {
     const dir = categoryDirName(memory.frontmatter.category);
     return path.join(root, dir, this.resolveMemoryDateDir(memory), `${memory.frontmatter.id}.md`);
   }
-
   private async writeMemoryFileAtomic(targetPath: string, memory: MemoryFile): Promise<void> {
     const fileContent = `${serializeFrontmatter(memory.frontmatter)}\n\n${memory.content}\n`;
     await writeMaybeEncryptedFile(targetPath, fileContent, this.resolveWriteKey(), {}, this.baseDir);
     this.invalidateAllMemoriesCache();
     this.notifyCatalogWrite();
   }
-
   async moveMemoryToPath(memory: MemoryFile, targetPath: string): Promise<void> {
     await this.writeMemoryFileAtomic(targetPath, memory);
     const sourcePath = path.resolve(memory.path);
@@ -4591,6 +4589,7 @@ export class StorageManager {
       // invalidated, but a concurrent readAllMemories() may have re-populated
       // the cache between the write and the unlink.
       this.invalidateAllMemoriesCache();
+      updateProjectedMemoryPath(this.baseDir, memory.frontmatter.id, toMemoryPathRel(this.baseDir, targetPath));
     }
   }
 
@@ -4615,6 +4614,7 @@ export class StorageManager {
           throw err;
         }
       }
+      updateProjectedMemoryPath(this.baseDir, memory.frontmatter.id, toMemoryPathRel(this.baseDir, targetPath));
       this.bumpMemoryStatusVersion();
       return { changed: false, targetPath };
     }
@@ -4662,7 +4662,7 @@ export class StorageManager {
 
       // Write to archive location first (encrypted if applicable), then remove original.
       await this.writeStorageSecureFile(destPath, fileContent);
-      await unlink(memory.path);
+      await unlink(memory.path); markProjectedMemoryPathInvalid(this.baseDir, memory.frontmatter.id);
       this.invalidateAllMemoriesCache();
       await this.appendGeneratedMemoryLifecycleEventFailOpen(
         "storage.archiveMemory",
@@ -4767,7 +4767,7 @@ export class StorageManager {
     if (!memory) return false;
 
     try {
-      await unlink(memory.path);
+      await unlink(memory.path); markProjectedMemoryPathInvalid(this.baseDir, id);
       this.invalidateAllMemoriesCache();
       this.bumpMemoryStatusVersion();
       log.debug(`invalidated memory ${id}`);
@@ -4906,7 +4906,7 @@ export class StorageManager {
       const expiresAt = new Date(m.frontmatter.expiresAt).getTime();
       if (expiresAt < now) {
         try {
-          await unlink(m.path);
+          await unlink(m.path); markProjectedMemoryPathInvalid(this.baseDir, m.frontmatter.id);
           deleted.push(m);
           log.debug(`cleaned expired memory ${m.frontmatter.id} (TTL expired)`);
         } catch {
@@ -5981,7 +5981,7 @@ export class StorageManager {
       if (updatedAt < cutoff) {
         // Remove the file
         try {
-          await unlink(m.path);
+          await unlink(m.path); markProjectedMemoryPathInvalid(this.baseDir, m.frontmatter.id);
           deleted.push(m);
           log.debug(`cleaned expired commitment ${m.frontmatter.id}`);
         } catch {