@remnic/core 1.1.31 → 9.3.516

package/src/surfaces/dreams.ts

@@ -1,6 +1,6 @@
 import { createHash } from "node:crypto";
 import { statSync, watch, type FSWatcher } from "node:fs";
-import { mkdir, readFile, writeFile } from "node:fs/promises";
+import { mkdir, readFile, rename, unlink, writeFile } from "node:fs/promises";
 import path from "node:path";
 
 export interface DreamEntry {
@@ -23,6 +23,7 @@ export interface DreamsSurface {
 
 const DIARY_START_MARKER = "<!-- openclaw:dreaming:diary:start -->";
 const DIARY_END_MARKER = "<!-- openclaw:dreaming:diary:end -->";
+const appendQueues = new Map<string, Promise<void>>();
 
 function stableDreamId(params: {
   timestamp: string;
@@ -140,7 +141,7 @@ function parseLegacyHeadingEntries(content: string): ParsedDreamEntry[] {
     const end = index + 1 < matches.length ? (matches[index + 1]?.index ?? content.length) : content.length;
     const heading = match[1]?.trim() ?? "";
     const body = content.slice(start + match[0].length, end).replace(/^\s+/, "");
-    const dividerTrimmed = body.replace(/\n---\s*$/m, "").trim();
+    const dividerTrimmed = body.replace(/\n---\s*$/, "").trim();
     const bodyLines = dividerTrimmed.split("\n");
     const tags = bodyLines.length > 0 ? parseTagsLine(bodyLines[bodyLines.length - 1] ?? "") : [];
     const contentLines =
@@ -221,6 +222,36 @@ function renderAppendBlock(entry: Omit<DreamEntry, "id" | "sourceOffset">): stri
   return `---\n\n*${entry.timestamp}${titlePart}*\n\n${entry.body.trim()}${tagsPart}\n`;
 }
 
+function serializeAppend<T>(filePath: string, operation: () => Promise<T>): Promise<T> {
+  const key = path.resolve(filePath);
+  const previous = appendQueues.get(key) ?? Promise.resolve();
+  const current = previous.catch(() => undefined).then(operation);
+  const next = current.then(
+    () => undefined,
+    () => undefined,
+  );
+  appendQueues.set(key, next);
+  next.finally(() => {
+    if (appendQueues.get(key) === next) appendQueues.delete(key);
+  });
+  return current;
+}
+
+async function atomicWriteUtf8(filePath: string, content: string): Promise<void> {
+  const tmpPath = `${filePath}.tmp-${process.pid}-${Date.now()}-${Math.random().toString(16).slice(2)}`;
+  try {
+    await writeFile(tmpPath, content, { encoding: "utf8", flag: "wx" });
+    await rename(tmpPath, filePath);
+  } catch (error) {
+    try {
+      await unlink(tmpPath);
+    } catch {
+      // Best-effort cleanup; the original file remains untouched if rename failed.
+    }
+    throw error;
+  }
+}
+
 export function createDreamsSurface(): DreamsSurface {
   return {
     async read(filePath: string): Promise<DreamEntry[]> {
@@ -239,23 +270,26 @@ export function createDreamsSurface(): DreamsSurface {
       filePath: string,
       entry: Omit<DreamEntry, "id" | "sourceOffset">,
     ): Promise<DreamEntry> {
-      await mkdir(path.dirname(filePath), { recursive: true });
-      let content = "";
-      try {
-        content = await readFile(filePath, "utf8");
-      } catch (error) {
-        if ((error as NodeJS.ErrnoException).code !== "ENOENT") throw error;
-      }
-      const ensured = ensureDiary(content);
-      const endIndex = ensured.indexOf(DIARY_END_MARKER);
-      const block = renderAppendBlock(entry);
-      const updated =
-        endIndex >= 0
-          ? `${ensured.slice(0, endIndex)}${block}\n${ensured.slice(endIndex)}`
-          : `${ensureDiary("")}${block}`;
-      await writeFile(filePath, updated.endsWith("\n") ? updated : `${updated}\n`, "utf8");
-      const entries = parseDreamEntries(updated);
-      return entries[entries.length - 1]!;
+      return serializeAppend(filePath, async () => {
+        await mkdir(path.dirname(filePath), { recursive: true });
+        let content = "";
+        try {
+          content = await readFile(filePath, "utf8");
+        } catch (error) {
+          if ((error as NodeJS.ErrnoException).code !== "ENOENT") throw error;
+        }
+        const ensured = ensureDiary(content);
+        const endIndex = ensured.indexOf(DIARY_END_MARKER);
+        const block = renderAppendBlock(entry);
+        const updated =
+          endIndex >= 0
+            ? `${ensured.slice(0, endIndex)}${block}\n${ensured.slice(endIndex)}`
+            : `${ensureDiary("")}${block}`;
+        const normalized = updated.endsWith("\n") ? updated : `${updated}\n`;
+        await atomicWriteUtf8(filePath, normalized);
+        const entries = parseDreamEntries(normalized);
+        return entries[entries.length - 1]!;
+      });
     },
 
     watch(filePath: string, onChange: (entries: DreamEntry[]) => void): () => void {

package/src/sync/index.ts

@@ -22,6 +22,8 @@ export interface SyncOptions {
   extensions?: string[];
   /** Directories to exclude */
   excludeDirs?: string[];
+  /** Poll interval for watchForChanges. Default: 5000ms */
+  pollIntervalMs?: number;
   /** Whether to actually write changes (default: true) */
   dryRun?: boolean;
 }
@@ -146,35 +148,53 @@ export function syncChanges(options: SyncOptions): SyncResult {
  */
 export function watchForChanges(
   options: SyncOptions,
-  onChange: (changes: FileChange[]) => void,
+  onChange: (changes: FileChange[]) => void | Promise<void>,
 ): { stop: () => void } {
   const { sourceDir, extensions, excludeDirs } = options;
   const extSet = new Set(extensions ?? DEFAULT_EXTENSIONS);
   const excludeSet = new Set([...DEFAULT_EXCLUDE, ...(excludeDirs ?? [])]);
+  const pollIntervalMs =
+    typeof options.pollIntervalMs === "number" &&
+    Number.isFinite(options.pollIntervalMs) &&
+    options.pollIntervalMs > 0
+      ? options.pollIntervalMs
+      : 5000;
 
   let lastHashes: Record<string, string> = {};
+  let pollInFlight = false;
 
   // Initial scan
   const currentFiles = scanFiles(sourceDir, extSet, excludeSet);
   lastHashes = { ...currentFiles };
 
   // Poll interval (FSWatcher doesn't reliably work for all platforms)
-  const interval = setInterval(() => {
-    const nowFiles = scanFiles(sourceDir, extSet, excludeSet);
-    const changes = computeDiff(nowFiles, lastHashes, sourceDir);
-
-    if (changes.length > 0) {
-      // Update hashes
-      for (const change of changes) {
-        if (change.type === "deleted") {
-          delete lastHashes[change.relativePath];
-        } else {
-          lastHashes[change.relativePath] = change.currentHash;
+  const poll = async (): Promise<void> => {
+    if (pollInFlight) return;
+    pollInFlight = true;
+    try {
+      const nowFiles = scanFiles(sourceDir, extSet, excludeSet);
+      const changes = computeDiff(nowFiles, lastHashes, sourceDir);
+
+      if (changes.length > 0) {
+        await onChange(changes);
+        // Update hashes
+        for (const change of changes) {
+          if (change.type === "deleted") {
+            delete lastHashes[change.relativePath];
+          } else {
+            lastHashes[change.relativePath] = change.currentHash;
+          }
         }
       }
-      onChange(changes);
+    } catch {
+      // Leave lastHashes unchanged so the next poll retries the same diff.
+    } finally {
+      pollInFlight = false;
     }
-  }, 5000);
+  };
+  const interval = setInterval(() => {
+    void poll();
+  }, pollIntervalMs);
 
   return {
     stop: () => clearInterval(interval),
@@ -190,11 +210,16 @@ function scanFiles(
 ): Record<string, string> {
   const result: Record<string, string> = {};
 
-  function walk(dir: string): void {
+  function walk(dir: string, isRoot = false): void {
     let entries: fs.Dirent[];
     try {
       entries = fs.readdirSync(dir, { withFileTypes: true });
-    } catch {
+    } catch (err) {
+      if (isRoot) {
+        throw new Error(
+          `sync scan failed for ${dir}: ${err instanceof Error ? err.message : String(err)}`,
+        );
+      }
       return;
     }
 
@@ -219,7 +244,7 @@ function scanFiles(
     }
   }
 
-  walk(root);
+  walk(root, true);
   return result;
 }
 

package/src/taxonomy/taxonomy-loader.ts

@@ -18,6 +18,21 @@ const MAX_SLUG_LENGTH = 32;
 
 /** Regex for valid slug: lowercase letters, digits, hyphens */
 const SLUG_RE = /^[a-z][a-z0-9-]*$/;
+const VALID_MEMORY_CATEGORIES = new Set([
+  "fact",
+  "preference",
+  "correction",
+  "entity",
+  "decision",
+  "relationship",
+  "principle",
+  "commitment",
+  "moment",
+  "skill",
+  "rule",
+  "procedure",
+  "reasoning_trace",
+]);
 
 /**
  * Validate a taxonomy category slug.
@@ -68,12 +83,31 @@ export function validateTaxonomy(taxonomy: Taxonomy): void {
     if (!Array.isArray(cat.filingRules)) {
       throw new Error(`Taxonomy category "${cat.id}" filingRules must be an array`);
     }
+    for (const [index, rule] of cat.filingRules.entries()) {
+      if (typeof rule !== "string" || rule.trim().length === 0) {
+        throw new Error(
+          `Taxonomy category "${cat.id}" filingRules[${index}] must be a non-empty string`,
+        );
+      }
+    }
     if (typeof cat.priority !== "number" || !Number.isFinite(cat.priority)) {
       throw new Error(`Taxonomy category "${cat.id}" must have a finite numeric priority`);
     }
     if (!Array.isArray(cat.memoryCategories)) {
       throw new Error(`Taxonomy category "${cat.id}" memoryCategories must be an array`);
     }
+    for (const [index, memoryCategory] of cat.memoryCategories.entries()) {
+      if (typeof memoryCategory !== "string" || memoryCategory.trim().length === 0) {
+        throw new Error(
+          `Taxonomy category "${cat.id}" memoryCategories[${index}] must be a non-empty string`,
+        );
+      }
+      if (!VALID_MEMORY_CATEGORIES.has(memoryCategory)) {
+        throw new Error(
+          `Taxonomy category "${cat.id}" memoryCategories[${index}] is unknown: "${memoryCategory}"`,
+        );
+      }
+    }
     if (cat.parentId !== undefined) {
       if (typeof cat.parentId !== "string") {
         throw new Error(`Taxonomy category "${cat.id}" parentId must be a string if set`);
@@ -117,10 +151,15 @@ export async function loadTaxonomy(memoryDir: string): Promise<Taxonomy> {
   }
 
   const obj = parsed as Record<string, unknown>;
-  const userVersion = typeof obj.version === "number" ? obj.version : DEFAULT_TAXONOMY.version;
-  const userCategories = Array.isArray(obj.categories)
-    ? (obj.categories as TaxonomyCategory[])
-    : [];
+  if (typeof obj.version !== "number") {
+    throw new Error("taxonomy.json version must be a number");
+  }
+  if (!Array.isArray(obj.categories)) {
+    throw new Error("taxonomy.json categories must be an array");
+  }
+
+  const userVersion = obj.version;
+  const userCategories = obj.categories as TaxonomyCategory[];
 
   // Validate: reject duplicate IDs in user categories before merging.
   // Without this check, duplicates are silently collapsed with last-write-wins

package/src/temporal-supersession.test.ts

@@ -1010,6 +1010,73 @@ test("applyTemporalSupersession: hot→cold migration race — cold copy is proc
   }
 });
 
+test("applyTemporalSupersession: stale superseded hot copy does not block active cold copy", async () => {
+  const { storage, cleanup } = await makeStorage("engram-temporal-stale-hot-cold-");
+  try {
+    const oldId = await writeFact(
+      storage,
+      "entity lives in Austin — cold copy",
+      TEST_ENTITY,
+      { city: "Austin" },
+    );
+    await new Promise((resolve) => setTimeout(resolve, 5));
+    const coldPath = await migrateFactToCold(storage, oldId);
+    await new Promise((resolve) => setTimeout(resolve, 5));
+    const newId = await writeFact(
+      storage,
+      "entity moved to NYC",
+      TEST_ENTITY,
+      { city: "NYC" },
+    );
+
+    storage.invalidateAllMemoriesCacheForDir();
+    const hotMemories = await storage.readAllMemories();
+    const coldMemories = await storage.readAllColdMemories();
+    const newEntry = hotMemories.find((m) => m.frontmatter.id === newId);
+    const coldEntry = coldMemories.find((m) => m.frontmatter.id === oldId);
+    assert.ok(newEntry, "new entry must exist in hot tier");
+    assert.ok(coldEntry, "cold entry must exist in cold tier");
+    assert.equal(coldEntry.frontmatter.status ?? "active", "active");
+
+    const staleHotEntry = {
+      path: coldPath.replace(/\.md$/, "-stale-hot.md"),
+      frontmatter: {
+        ...coldEntry.frontmatter,
+        status: "superseded",
+        supersededBy: "previous-newer-fact",
+      },
+      content: coldEntry.content,
+    };
+
+    const originalReadAll = storage.readAllMemories.bind(storage);
+    (storage as unknown as { readAllMemories: () => Promise<unknown> }).readAllMemories =
+      async () => [staleHotEntry, newEntry];
+
+    try {
+      const result = await applyTemporalSupersession({
+        storage,
+        newMemoryId: newId,
+        entityRef: TEST_ENTITY,
+        structuredAttributes: { city: "NYC" },
+        createdAt: new Date().toISOString(),
+        enabled: true,
+      });
+
+      assert.deepEqual(result.supersededIds, [oldId]);
+    } finally {
+      (storage as unknown as { readAllMemories: typeof originalReadAll }).readAllMemories =
+        originalReadAll;
+    }
+
+    const coldMem = await storage.readMemoryByPath(coldPath);
+    assert.ok(coldMem, "cold memory file must still exist");
+    assert.equal(coldMem!.frontmatter.status, "superseded");
+    assert.equal(coldMem!.frontmatter.supersededBy, newId);
+  } finally {
+    await cleanup();
+  }
+});
+
 // ─── Regression: round-6 Findings 2+3 — kill switch in recent-scan prefilter ─
 
 test("shouldFilterSupersededFromRecall: kill switch off (enabled=false) never filters superseded", () => {

package/src/temporal-supersession.ts

@@ -331,6 +331,14 @@ export async function applyTemporalSupersession(args: {
     if (memory.frontmatter.id === args.newMemoryId) continue;
     const dedupeKey = memory.frontmatter.id ?? memory.path;
     if (processedIds.has(dedupeKey)) continue;
+    const snapshotStatus = memory.frontmatter.status ?? "active";
+    if (snapshotStatus !== "active") {
+      // A stale non-active snapshot entry must not suppress an active copy of
+      // the same logical memory that appears later in another tier.  This can
+      // happen during hot/cold migration races where the hot snapshot is already
+      // superseded but the cold copy is still active and should be evaluated.
+      continue;
+    }
     // NOTE: do NOT call processedIds.add(dedupeKey) here.  We defer marking
     // the id as processed until AFTER the CAS re-read succeeds.  If we mark
     // it here and the re-read fails (e.g. the hot entry has already been

package/src/tmt.test.ts

@@ -0,0 +1,50 @@
+import assert from "node:assert/strict";
+import { mkdtemp, readFile, rm } from "node:fs/promises";
+import os from "node:os";
+import path from "node:path";
+import test from "node:test";
+
+import { TmtBuilder, hourNodePath, parseIsoDate, parseIsoHour } from "./tmt.js";
+
+test("TMT timestamp helpers derive UTC path tokens only from strict ISO instants", () => {
+  assert.equal(parseIsoDate("2026-05-22T01:30:00-05:00"), "2026-05-22");
+  assert.equal(parseIsoHour("2026-05-22T01:30:00-05:00"), "06");
+  assert.equal(parseIsoDate("../../evil"), "");
+  assert.equal(parseIsoHour("2026-05-22"), "");
+});
+
+test("TMT skips malformed timestamps instead of using raw slices as paths", async () => {
+  const dir = await mkdtemp(path.join(os.tmpdir(), "remnic-tmt-"));
+  try {
+    const builder = new TmtBuilder(dir, {
+      temporalMemoryTreeEnabled: true,
+      tmtHourlyMinMemories: 1,
+      tmtSummaryMaxTokens: 100,
+    });
+    await builder.maybeRebuildNodes(
+      [
+        {
+          path: "bad.md",
+          id: "bad",
+          created: "../../evilT99:99:99Z",
+          content: "bad",
+        },
+        {
+          path: "good.md",
+          id: "good",
+          created: "2026-05-22T01:30:00-05:00",
+          content: "good",
+        },
+      ],
+      async (items) => items.join("\n"),
+    );
+
+    assert.equal(
+      await readFile(hourNodePath(dir, "2026-05-22", "06"), "utf8").then((value) => value.includes("good")),
+      true,
+    );
+    await assert.rejects(() => readFile(path.join(dir, "tmt", "..", "..", "evil", "hour-99.md"), "utf8"));
+  } finally {
+    await rm(dir, { recursive: true, force: true });
+  }
+});

package/src/tmt.ts

@@ -109,11 +109,29 @@ export function serialiseTmtNode(fm: TmtNodeFrontmatter, summary: string): strin
 }
 
 export function parseIsoDate(iso: string): string {
-  return iso.slice(0, 10); // YYYY-MM-DD
+  return parseTmtInstant(iso)?.date ?? "";
 }
 
 export function parseIsoHour(iso: string): string {
-  return iso.slice(11, 13); // HH
+  return parseTmtInstant(iso)?.hour ?? "";
+}
+
+function parseTmtInstant(iso: string): { date: string; hour: string; dateValue: Date } | null {
+  if (typeof iso !== "string") return null;
+  const value = iso.trim();
+  if (
+    !/^\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}(?:\.\d{1,9})?(?:Z|[+-]\d{2}:\d{2})$/.test(value)
+  ) {
+    return null;
+  }
+  const dateValue = new Date(value);
+  if (!Number.isFinite(dateValue.getTime())) return null;
+  const utc = dateValue.toISOString();
+  return {
+    date: utc.slice(0, 10),
+    hour: utc.slice(11, 13),
+    dateValue,
+  };
 }
 
 // Returns ISO week key: YYYY-WW
@@ -162,8 +180,9 @@ export class TmtBuilder {
     // Group by date+hour
     const byHour = new Map<string, MemoryEntry[]>();
     for (const m of memories) {
-      const date = parseIsoDate(m.created);
-      const hour = parseIsoHour(m.created);
+      const instant = parseTmtInstant(m.created);
+      if (!instant) continue;
+      const { date, hour } = instant;
       const key = `${date}::${hour}`;
       if (!byHour.has(key)) byHour.set(key, []);
       byHour.get(key)!.push(m);
@@ -180,8 +199,8 @@ export class TmtBuilder {
         try {
           const existing = await readFile(nodePath, "utf8");
           const countMatch = existing.match(/memoryCount: (\d+)/);
-          if (!countMatch || parseInt(countMatch[1], 10) < entries.length) {
-            shouldBuild = true; // more memories now — rebuild
+          if (!countMatch || parseInt(countMatch[1], 10) !== entries.length) {
+            shouldBuild = true; // active memory set changed — rebuild
           }
         } catch { shouldBuild = true; }
       }
@@ -212,7 +231,9 @@ export class TmtBuilder {
     // Group by date
     const byDate = new Map<string, MemoryEntry[]>();
     for (const m of memories) {
-      const date = parseIsoDate(m.created);
+      const instant = parseTmtInstant(m.created);
+      if (!instant) continue;
+      const { date } = instant;
       if (!byDate.has(date)) byDate.set(date, []);
       byDate.get(date)!.push(m);
     }
@@ -225,8 +246,8 @@ export class TmtBuilder {
         try {
           const existing = await readFile(nodePath, "utf8");
           const countMatch = existing.match(/memoryCount: (\d+)/);
-          if (!countMatch || parseInt(countMatch[1], 10) < entries.length) {
-            shouldBuild = true; // more memories now — rebuild
+          if (!countMatch || parseInt(countMatch[1], 10) !== entries.length) {
+            shouldBuild = true; // active memory set changed — rebuild
           }
         } catch { shouldBuild = true; }
       }
@@ -237,6 +258,7 @@ export class TmtBuilder {
       const hourToEntries = new Map<string, MemoryEntry[]>();
       for (const e of entries) {
         const h = parseIsoHour(e.created);
+        if (!h) continue;
         if (!hourToEntries.has(h)) hourToEntries.set(h, []);
         hourToEntries.get(h)!.push(e);
       }
@@ -284,7 +306,9 @@ export class TmtBuilder {
     // Determine which ISO weeks appear in this memory batch
     const weekToEntries = new Map<string, MemoryEntry[]>();
     for (const m of memories) {
-      const week = isoWeekKey(new Date(m.created));
+      const instant = parseTmtInstant(m.created);
+      if (!instant) continue;
+      const week = isoWeekKey(instant.dateValue);
       if (!weekToEntries.has(week)) weekToEntries.set(week, []);
       weekToEntries.get(week)!.push(m);
     }
@@ -298,7 +322,7 @@ export class TmtBuilder {
         try {
           const existing = await readFile(nodePath, "utf8");
           const countMatch = existing.match(/memoryCount: (\d+)/);
-          if (!countMatch || parseInt(countMatch[1], 10) < entries.length) {
+          if (!countMatch || parseInt(countMatch[1], 10) !== entries.length) {
             shouldBuild = true;
           }
         } catch { shouldBuild = true; }

package/src/tokens.test.ts

@@ -8,6 +8,7 @@ import {
   buildTokenEntry,
   commitTokenEntry,
   generateToken,
+  getAllValidTokensCached,
   loadTokenStore,
   revokeToken,
   saveTokenStore,
@@ -176,3 +177,20 @@ test("legacy flat token stores reject empty connector keys before returning toke
     await rm(dir, { recursive: true, force: true });
   }
 });
+
+test("token writes invalidate the cached valid-token list", async () => {
+  const { dir, tokensPath } = await makeTempTokenPath();
+  try {
+    const entry = generateToken("codex", tokensPath);
+    assert.deepEqual(getAllValidTokensCached(tokensPath), [entry.token]);
+
+    assert.equal(revokeToken("codex", tokensPath), true);
+    assert.deepEqual(getAllValidTokensCached(tokensPath), []);
+
+    const replacement = buildTokenEntry("codex");
+    commitTokenEntry(replacement, tokensPath);
+    assert.deepEqual(getAllValidTokensCached(tokensPath), [replacement.token]);
+  } finally {
+    await rm(dir, { recursive: true, force: true });
+  }
+});

package/src/tokens.ts

@@ -183,6 +183,7 @@ export function saveTokenStore(store: TokenStore, tokensPath?: string): void {
     // Tighten permissions on pre-existing files after atomic replacement.
     try { fs.chmodSync(p, 0o600); } catch { /* ignore on platforms without chmod */ }
     fsyncDirectoryBestEffort(dir);
+    invalidateTokenCache();
   } catch (error) {
     if (fd !== null) {
       try { fs.closeSync(fd); } catch { /* ignore */ }
@@ -265,6 +266,12 @@ let _cachedTokens: string[] = [];
 let _cachedAt = 0;
 let _cachedPath: string | undefined;
 
+function invalidateTokenCache(): void {
+  _cachedTokens = [];
+  _cachedAt = 0;
+  _cachedPath = undefined;
+}
+
 export function getAllValidTokensCached(tokensPath?: string): string[] {
   const now = Date.now();
   if (now - _cachedAt < TOKEN_CACHE_TTL_MS && tokensPath === _cachedPath) return _cachedTokens;

package/src/training-export/converter.test.ts

@@ -1,10 +1,10 @@
 import assert from "node:assert/strict";
 import { describe, it } from "node:test";
-import { link, mkdtemp, mkdir, symlink, writeFile } from "node:fs/promises";
+import { link, mkdtemp, mkdir, realpath, rm, symlink, writeFile } from "node:fs/promises";
 import os from "node:os";
 import path from "node:path";
 
-import { convertMemoriesToRecords } from "./converter.js";
+import { convertMemoriesToRecords, readContainedMarkdownFile } from "./converter.js";
 
 // ---------------------------------------------------------------------------
 // Helper: create a synthetic memory file
@@ -206,6 +206,22 @@ describe("convertMemoriesToRecords", () => {
     assert.equal(noFilter.length, 2);
   });
 
+  it("excludes memories with overflowed calendar dates when date filters are active", async () => {
+    const dir = await makeTmpDir();
+    await writeSyntheticMemory(dir, "facts", "overflow.md", {
+      id: "overflow",
+      created: "2026-02-31T00:00:00Z",
+      content: "Memory with an overflowed date.",
+    });
+
+    const records = await convertMemoriesToRecords({
+      memoryDir: dir,
+      since: new Date("2026-03-01T00:00:00.000Z"),
+    });
+
+    assert.deepEqual(records, []);
+  });
+
   it("handles empty memory directory", async () => {
     const dir = await makeTmpDir();
     // Don't create any subdirectories
@@ -327,6 +343,43 @@ describe("convertMemoriesToRecords", () => {
     }
   });
 
+  it("refuses to open a symlink swapped into a previously validated markdown path", async () => {
+    const dir = await makeTmpDir();
+    await writeSyntheticMemory(dir, "facts", "race.md", {
+      id: "race",
+      content: "Original memory.",
+    });
+    const filePath = path.join(dir, "facts", "race.md");
+    const containmentRoot = await realpath(dir);
+
+    const outsideDir = await makeTmpDir();
+    const secretPath = path.join(outsideDir, "secret.md");
+    await writeFile(
+      secretPath,
+      [
+        "---",
+        "id: secret",
+        "category: fact",
+        "confidence: 0.99",
+        "tags: []",
+        "---",
+        "",
+        "EXFILTRATED SECRET CONTENT",
+      ].join("\n"),
+      "utf-8",
+    );
+
+    try {
+      await rm(filePath);
+      await symlink(secretPath, filePath);
+    } catch {
+      return; // symlinks unavailable
+    }
+
+    const raw = await readContainedMarkdownFile(filePath, containmentRoot);
+    assert.equal(raw, null);
+  });
+
   it("refuses to descend into directory symlinks that escape memoryDir", async () => {
     const dir = await makeTmpDir();
     const outsideDir = await makeTmpDir();