@remnic/core 9.3.662 → 9.3.664

package/src/cli.ts

@@ -1,6 +1,6 @@
 import os from "node:os";
 import path from "node:path";
-import { access, readFile, readdir, unlink } from "node:fs/promises";
+import { access, lstat, readFile, readdir, realpath, unlink } from "node:fs/promises";
 import { createHash } from "node:crypto";
 import type { Readable, Writable } from "node:stream";
 import type { Orchestrator } from "./orchestrator.js";
@@ -215,6 +215,8 @@ import {
 } from "./policy-runtime.js";
 import { resolveHomeDir } from "./runtime/env.js";
 import { expandTildePath } from "./utils/path.js";
+import { RECALL_FALLBACK_DIRS } from "./utils/category-dir.js";
+import { assertPathInsideRoot } from "./utils/path-containment.js";
 import { convertMemoriesToRecords } from "./training-export/converter.js";
 import { parseStrictCliDate as parseStrictCliDateShared } from "./training-export/date-parse.js";
 import { getTrainingExportAdapter, listTrainingExportAdapters } from "./training-export/registry.js";
@@ -3320,32 +3322,69 @@ export async function resolveMemoryDirForNamespace(
 }
 
 /**
- * Walk `memoryDir/{facts,corrections}` recursively and invoke `visit` for
- * every `*.md` file. Intentionally swallows per-directory errors so a missing
- * subdir reads as empty. Shared primitive for `listMemoryMarkdownFilePaths`,
- * `readAllMemoryFiles`, and any future walker that needs the same roots +
- * `.md` filter.
+ * Walk every recall category directory under `memoryDir` recursively and invoke
+ * `visit` for every `*.md` file. The directory set is `RECALL_FALLBACK_DIRS`
+ * (single source of truth), so newly-routed categories (decisions/, ...) are
+ * covered without touching this walker again (#1546). Swallows per-directory
+ * errors so a missing subdir reads as empty. Shared primitive for
+ * `listMemoryMarkdownFilePaths`, `readAllMemoryFiles`, and future walkers.
+ *
+ * Symlink/containment hardening (mirrors `scanDir` in
+ * search/document-scanner.ts): downstream consumers include `readAllMemoryFiles`
+ * → the `dedupe-exact` / `dedupe-aggressive` commands, which `unlink()` files.
+ * Because this walker scans EVERY category root, a symlinked category dir
+ * (e.g. `decisions/` → outside `memoryDir`) could otherwise redirect the walk —
+ * and a destructive dedupe delete — outside the memory store. We resolve the
+ * memory root once, skip symlinked dirs/entries, and assert every realpath stays
+ * inside the root before descending or visiting. A single poisoned entry is
+ * skipped (logged), never aborting a legitimate dedupe run.
  */
 async function walkMemoryMarkdownFiles(
   memoryDir: string,
   visit: (fullPath: string) => void | Promise<void>,
 ): Promise<void> {
-  const roots = [path.join(memoryDir, "facts"), path.join(memoryDir, "corrections")];
+  let memoryRootReal: string;
+  try {
+    memoryRootReal = await realpath(memoryDir);
+  } catch {
+    return; // memoryDir itself does not exist — nothing to walk.
+  }
+
+  const skip = (target: string, err: unknown): void => {
+    // ENOENT (optional dir absent) is silent; containment/other errors log.
+    if (!(err instanceof Error && /ENOENT/.test(err.message))) {
+      console.debug(`walkMemoryMarkdownFiles: skipping ${target}: ${err instanceof Error ? err.message : String(err)}`);
+    }
+  };
 
   const walk = async (dir: string): Promise<void> => {
-    let entries: Array<{ isDirectory(): boolean; isFile(): boolean; name: string | Buffer }>;
+    // Reject symlinked / non-directory roots and anything resolving outside the
+    // memory store before reading it.
     try {
-      entries = (await readdir(dir, { withFileTypes: true })) as Array<{
-        isDirectory(): boolean;
-        isFile(): boolean;
-        name: string | Buffer;
-      }>;
+      const dirStat = await lstat(dir);
+      if (dirStat.isSymbolicLink() || !dirStat.isDirectory()) return;
+      assertPathInsideRoot(memoryRootReal, await realpath(dir), dir);
+    } catch (err) {
+      skip(dir, err);
+      return;
+    }
+
+    let entries: Array<{ isDirectory(): boolean; isFile(): boolean; isSymbolicLink(): boolean; name: string | Buffer }>;
+    try {
+      entries = (await readdir(dir, { withFileTypes: true })) as typeof entries;
     } catch {
       return;
     }
     for (const entry of entries) {
+      if (entry.isSymbolicLink()) continue; // never follow symlinked entries
       const entryName = typeof entry.name === "string" ? entry.name : entry.name.toString("utf-8");
       const fullPath = path.join(dir, entryName);
+      try {
+        assertPathInsideRoot(memoryRootReal, await realpath(fullPath), fullPath);
+      } catch (err) {
+        skip(fullPath, err); // poisoned entry — skip, keep walking the rest.
+        continue;
+      }
       if (entry.isDirectory()) {
         await walk(fullPath);
         continue;
@@ -3355,22 +3394,22 @@ async function walkMemoryMarkdownFiles(
     }
   };
 
-  for (const root of roots) {
+  for (const root of RECALL_FALLBACK_DIRS.map((dir) => path.join(memoryDir, dir))) {
     await walk(root);
   }
 }
 
 /**
- * List absolute paths of every `*.md` file under `memoryDir/{facts,corrections}`.
- * Used by the bulk-import CLI to derive a per-batch `memoriesCreated` count
- * via set-subtraction of "paths after extraction" against "paths before
- * extraction". Caveat: the extraction queue is shared across sessions, so
- * concurrent organic extractions that write memories between the two
- * snapshots will still inflate the reported count. Filename-set diff at
- * least correctly ignores pre-existing files and files that were deleted
- * while the batch ran.
+ * List absolute paths of every `*.md` file under each recall category directory
+ * of `memoryDir` (facts/, corrections/, decisions/, ...; see
+ * `walkMemoryMarkdownFiles`). Used by the bulk-import CLI to derive a per-batch
+ * `memoriesCreated` count via set-subtraction of "paths after extraction"
+ * against "paths before extraction". Caveat: the extraction queue is shared
+ * across sessions, so concurrent organic extractions between the two snapshots
+ * can still inflate the count; the set diff at least ignores pre-existing and
+ * deleted files. Exported for category-dir coverage tests (#1546).
  */
-async function listMemoryMarkdownFilePaths(memoryDir: string): Promise<string[]> {
+export async function listMemoryMarkdownFilePaths(memoryDir: string): Promise<string[]> {
   const paths: string[] = [];
   await walkMemoryMarkdownFiles(memoryDir, (fullPath) => {
     paths.push(fullPath);

package/src/consolidation-provenance-check.ts

@@ -29,6 +29,7 @@ import {
 // review, cursor Medium) so a future key-format change stays in
 // lock-step with the doctor scan.
 import { sidecarKey } from "./page-versioning.js";
+import { RECALL_FALLBACK_DIRS } from "./utils/category-dir.js";
 
 /**
  * Regex to spot a `derived_via: <value>` line in the raw YAML frontmatter
@@ -490,14 +491,14 @@ export async function runConsolidationProvenanceCheck(options: {
 
   // Parse-failure detection (PR #634 round-4 review, codex P2):
   // `readAllMemories()` silently drops files whose frontmatter
-  // doesn't parse.  Walk the facts/ and corrections/ directories for
-  // `.md` files that DO reference provenance frontmatter but didn't
-  // come back from the reader — those are the corruption cases the
-  // doctor is meant to surface.
+  // doesn't parse.  Walk every recall category directory for `.md` files
+  // that DO reference provenance frontmatter but didn't come back from the
+  // reader — those are the corruption cases the doctor is meant to surface.
+  // Uses RECALL_FALLBACK_DIRS (the single source of truth) so newly-routed
+  // categories (decisions/, preferences/, ...) are scanned too (#1546).
   try {
     const seenPaths = new Set(memories.map((m) => m.path));
-    const scanRoots = ["facts", "corrections", "procedures", "reasoning-traces"];
-    for (const rootName of scanRoots) {
+    for (const rootName of RECALL_FALLBACK_DIRS) {
       const rootPath = path.join(memoryDir, rootName);
       for await (const file of walkMarkdownFiles(rootPath, memoryDir)) {
         if (seenPaths.has(file)) continue;

package/src/maintenance/memory-governance.ts

@@ -1,8 +1,10 @@
 import path from "node:path";
-import { mkdir, readFile, readdir, rm, writeFile } from "node:fs/promises";
+import { lstat, mkdir, readFile, readdir, realpath, rm, writeFile } from "node:fs/promises";
 import { StorageManager } from "../storage.js";
 import { decideLifecycleTransition } from "../lifecycle.js";
 import type { MemoryFile, MemoryStatus } from "../types.js";
+import { RECALL_FALLBACK_DIRS } from "../utils/category-dir.js";
+import { assertPathInsideRoot } from "../utils/path-containment.js";
 
 export type MemoryGovernanceMode = "shadow" | "apply";
 export type MemoryGovernanceReasonCode =
@@ -337,23 +339,42 @@ function buildExplicitCaptureReviewEntries(
     }));
 }
 
-async function listMarkdownFiles(root: string): Promise<string[]> {
+/**
+ * List every `*.md` under `root`, refusing to follow symlinked directories or
+ * entries that resolve outside `containmentRoot` (a realpath-resolved memory
+ * store root). Mirrors the containment guard in consolidation-provenance's
+ * walkMarkdownFiles / the CLI walker, reusing the shared assertPathInsideRoot
+ * (rule 22). Without this, a symlinked category dir (e.g. decisions/ → outside
+ * memoryDir) would be walked and its files surfaced by the malformed-import
+ * governance sweep — an out-of-store info leak.
+ */
+async function listMarkdownFiles(root: string, containmentRoot: string): Promise<string[]> {
   const files: string[] = [];
   const walk = async (dir: string) => {
     try {
+      const dirStat = await lstat(dir);
+      if (dirStat.isSymbolicLink() || !dirStat.isDirectory()) return;
+      assertPathInsideRoot(containmentRoot, await realpath(dir), dir);
       const entries = await readdir(dir, { withFileTypes: true });
       for (const entry of entries) {
+        if (entry.isSymbolicLink()) continue; // never follow symlinked entries
         const fullPath = path.join(dir, entry.name);
         if (entry.isDirectory()) {
           await walk(fullPath);
           continue;
         }
         if (entry.isFile() && entry.name.endsWith(".md")) {
+          try {
+            assertPathInsideRoot(containmentRoot, await realpath(fullPath), fullPath);
+          } catch {
+            continue; // poisoned entry escaping the root — skip it.
+          }
           files.push(fullPath);
         }
       }
     } catch {
-      // Directory may not exist yet.
+      // Absent dir (ENOENT), symlinked/out-of-root dir, or containment
+      // violation — skip this subtree without aborting the sweep.
     }
   };
 
@@ -372,10 +393,29 @@ async function buildMalformedImportEntries(
   candidateFiles?: string[],
 ): Promise<MemoryGovernanceReviewQueueEntry[]> {
   const parsedPaths = new Set(parsedMemories.map((memory) => memory.path));
-  const filesToInspect = candidateFiles ?? [
-    ...await listMarkdownFiles(path.join(memoryDir, "facts")),
-    ...await listMarkdownFiles(path.join(memoryDir, "corrections")),
-  ];
+  // Inspect every recall category directory (RECALL_FALLBACK_DIRS — the single
+  // source of truth) so malformed files under newly-routed categories
+  // (decisions/, preferences/, ...) are surfaced too, not just facts/ (#1546).
+  // Resolve the containment root (realpath) once and thread it into the walker
+  // so a symlinked category dir can't escape memoryDir. If memoryDir itself
+  // can't be resolved, there is nothing valid to inspect.
+  let containmentRoot: string | null = null;
+  try {
+    containmentRoot = await realpath(memoryDir);
+  } catch {
+    containmentRoot = null;
+  }
+  const filesToInspect =
+    candidateFiles ??
+    (containmentRoot === null
+      ? []
+      : (
+          await Promise.all(
+            RECALL_FALLBACK_DIRS.map((dir) =>
+              listMarkdownFiles(path.join(memoryDir, dir), containmentRoot as string),
+            ),
+          )
+        ).flat());
   const entries: MemoryGovernanceReviewQueueEntry[] = [];
 
   for (const filePath of filesToInspect) {

package/src/orchestrator.ts

@@ -8,9 +8,11 @@ import os from "node:os";
 import { createHash, randomBytes } from "node:crypto";
 import { existsSync, readFileSync } from "node:fs";
 import {
+  lstat,
   mkdir,
   readdir,
   readFile,
+  realpath,
   stat,
   unlink,
   writeFile,
@@ -343,6 +345,8 @@ import {
   defaultTierMigrationCycleBudget,
 } from "./compounding/engine.js";
 import { parseFlexibleIsoTimestamp } from "./utils/iso-timestamp.js";
+import { categoryDirName, RECALL_FALLBACK_DIRS } from "./utils/category-dir.js";
+import { assertPathInsideRoot } from "./utils/path-containment.js";
 // IRC preference consolidation — used by eval adapter directly;
 // orchestrator integration planned for future PR.
 // import { consolidatePreferences, buildQueryAwarePreferenceSection, synthesizePreferencesFromLcm } from "./compounding/preference-consolidator.js";
@@ -1758,16 +1762,13 @@ export function resolvePersistedMemoryRelativePath(options: {
   }
   // Pick the subtree that matches the StorageManager.writeMemory routing
   // so fallback paths (used before memoryPathById has seen the fresh
-  // write) agree with where the file actually lives. Without this branch,
-  // reasoning_trace graph edges point at facts/<date>/, and subsequent
-  // graph expansion silently drops those nodes when readMemoryByPath
-  // cannot resolve them (issue #564 PR 3 review).
-  const subtree =
-    options.category === "procedure"
-      ? "procedures"
-      : options.category === "reasoning_trace"
-        ? "reasoning-traces"
-        : "facts";
+  // write) agree with where the file actually lives. Routing goes through
+  // the shared categoryDirName() chokepoint (utils/category-dir.ts) so
+  // every category — decisions/, preferences/, reasoning-traces/, ... —
+  // resolves to the same dir the writer used; otherwise graph edges point
+  // at the wrong subtree and graph expansion silently drops those nodes
+  // when readMemoryByPath cannot resolve them (issue #564 PR 3 / #1546).
+  const subtree = categoryDirName(options.category);
   const idParts = options.memoryId.split("-");
   const maybeTimestamp = Number(idParts[1]);
   if (Number.isFinite(maybeTimestamp) && maybeTimestamp > 0) {
@@ -4787,60 +4788,85 @@ export class Orchestrator {
     // a local calendar day. Scan the UTC-date envelope that overlaps the local
     // day, then filter parseable fact timestamps to that configured local day.
     const datesToScan = utcDateKeysForLocalDay(now, timeZone);
-    const factsBaseDir = path.join(storage.dir, "facts");
     const MAX_CHARS = 100_000;
 
-    // --- Read fact files from each date directory ---
+    // --- Read memory files from each category dir × date directory ---
+    // Iterate every recall category dir (RECALL_FALLBACK_DIRS — single source
+    // of truth) so the day summary includes decisions/, moments/, ... not just
+    // facts/ (#1546). corrections/ is flat, so corrections/<date>/ never exists
+    // and is skipped by the ENOENT guard — preserving the prior exclusion. The
+    // per-file created→local-day filter below is unchanged.
+    //
+    // Symlink/containment hardening (mirrors scanDir / the CLI walker): the
+    // gathered contents feed the day-summary LLM input, so a symlinked category
+    // dir (decisions/ → outside memoryDir) must not be followed and leak files.
+    // Resolve the store root once; skip symlinked / out-of-root dirs and
+    // entries; skip the scan gracefully if the root can't be resolved.
     const facts: MemoryFile[] = [];
-    for (const date of datesToScan) {
-      const factsDir = path.join(factsBaseDir, date);
-      try {
-        const entries = await readdir(factsDir, { withFileTypes: true });
-        for (const entry of entries) {
-          if (!entry.name.endsWith(".md")) continue;
-          const fullPath = path.join(factsDir, entry.name);
-          try {
-            const raw = await readFile(fullPath, "utf-8");
-            const fmMatch = raw.match(/^---\n([\s\S]*?)\n---\n?([\s\S]*)$/);
-            if (!fmMatch) continue;
-            const fmBlock = fmMatch[1];
-            const content = fmMatch[2].trim();
-            const fm: Record<string, string> = {};
-            for (const line of fmBlock.split("\n")) {
-              const colonIdx = line.indexOf(":");
-              if (colonIdx === -1) continue;
-              fm[line.slice(0, colonIdx).trim()] = line
-                .slice(colonIdx + 1)
-                .trim();
-            }
-            const created = fm.created || "unknown";
-            const createdAt = parseFiniteDate(created);
-            if (
-              createdAt &&
-              formatDateInTimeZone(createdAt, timeZone) !== targetLocalDate
-            ) {
-              continue;
+    let memoryRootReal: string | null = null;
+    try {
+      memoryRootReal = await realpath(storage.dir);
+    } catch {
+      memoryRootReal = null;
+    }
+    for (const categoryDir of RECALL_FALLBACK_DIRS) {
+      if (memoryRootReal === null) break;
+      for (const date of datesToScan) {
+        const dateDir = path.join(storage.dir, categoryDir, date);
+        try {
+          const dirStat = await lstat(dateDir);
+          if (dirStat.isSymbolicLink() || !dirStat.isDirectory()) continue;
+          assertPathInsideRoot(memoryRootReal, await realpath(dateDir), dateDir);
+          const entries = await readdir(dateDir, { withFileTypes: true });
+          for (const entry of entries) {
+            if (entry.isSymbolicLink()) continue;
+            if (!entry.name.endsWith(".md")) continue;
+            const fullPath = path.join(dateDir, entry.name);
+            try {
+              assertPathInsideRoot(memoryRootReal, await realpath(fullPath), fullPath);
+              const raw = await readFile(fullPath, "utf-8");
+              const fmMatch = raw.match(/^---\n([\s\S]*?)\n---\n?([\s\S]*)$/);
+              if (!fmMatch) continue;
+              const fmBlock = fmMatch[1];
+              const content = fmMatch[2].trim();
+              const fm: Record<string, string> = {};
+              for (const line of fmBlock.split("\n")) {
+                const colonIdx = line.indexOf(":");
+                if (colonIdx === -1) continue;
+                fm[line.slice(0, colonIdx).trim()] = line
+                  .slice(colonIdx + 1)
+                  .trim();
+              }
+              const created = fm.created || "unknown";
+              const createdAt = parseFiniteDate(created);
+              if (
+                createdAt &&
+                formatDateInTimeZone(createdAt, timeZone) !== targetLocalDate
+              ) {
+                continue;
+              }
+              facts.push({
+                path: fullPath,
+                frontmatter: {
+                  id: fm.id || path.basename(entry.name, ".md"),
+                  category: (fm.category as any) || "fact",
+                  created,
+                  updated: fm.updated || created,
+                  source: fm.source || "unknown",
+                  confidence: parseFloat(fm.confidence || "0.8"),
+                  confidenceTier: (fm.confidenceTier as any) || "implied",
+                  tags: [],
+                },
+                content,
+              });
+            } catch {
+              // Skip unreadable files
             }
-            facts.push({
-              path: fullPath,
-              frontmatter: {
-                id: fm.id || path.basename(entry.name, ".md"),
-                category: (fm.category as any) || "fact",
-                created,
-                updated: fm.updated || created,
-                source: fm.source || "unknown",
-                confidence: parseFloat(fm.confidence || "0.8"),
-                confidenceTier: (fm.confidenceTier as any) || "implied",
-                tags: [],
-              },
-              content,
-            });
-          } catch {
-            // Skip unreadable files
           }
+        } catch {
+          // Absent dir (ENOENT), symlinked/out-of-root dir, or containment
+          // violation — skip this category/date without aborting the summary.
         }
-      } catch {
-        // Directory doesn't exist — no facts for this date
       }
     }
 

package/src/page-versioning.ts

@@ -25,6 +25,7 @@ import {
   writeFile,
   unlink,
 } from "node:fs/promises";
+import { ALL_CATEGORY_DIRS } from "./utils/category-dir.js";
 
 // ---------------------------------------------------------------------------
 // Public interfaces
@@ -445,13 +446,15 @@ function computeLCS(a: string[], b: string[]): string[] {
  * optional `memoryDir` parameter is omitted.
  */
 function resolveMemoryDir(pagePath: string): string {
-  const knownSubdirs = new Set([
-    "facts",
-    "corrections",
+  // Derive the recall category dirs from ALL_CATEGORY_DIRS (single source of
+  // truth) so newly-routed categories (decisions/, preferences/, ...) are
+  // recognized when walking up to the memory root (#1546); the non-category
+  // subdirs are listed explicitly.
+  const knownSubdirs = new Set<string>([
+    ...ALL_CATEGORY_DIRS,
     "entities",
     "state",
     "artifacts",
-    "questions",
     "profiles",
   ]);
 

package/src/search/document-scanner.test.ts

@@ -78,3 +78,32 @@ test("scanMemoryDir skips nested symlink entries", async (t) => {
     await rm(outsideDir, { recursive: true, force: true });
   }
 });
+
+test("scanMemoryDir indexes memories under category dirs beyond facts/ (issue #1546)", async () => {
+  const memoryDir = await mkdtemp(path.join(os.tmpdir(), "remnic-scan-category-"));
+  try {
+    // A decision routed into decisions/<date>/ must be picked up by the
+    // non-QMD index scanner (Orama/Meilisearch/LanceDB), not just facts/.
+    const decisionDir = path.join(memoryDir, "decisions", "2026-02-22");
+    await mkdir(decisionDir, { recursive: true });
+    await writeFile(
+      path.join(decisionDir, "decision-1.md"),
+      ["---", "id: decision-1", "category: decision", "---", "We chose blue-green deploys."].join("\n"),
+      "utf8",
+    );
+    const factsDir = path.join(memoryDir, "facts", "2026-02-22");
+    await mkdir(factsDir, { recursive: true });
+    await writeFile(
+      path.join(factsDir, "fact-1.md"),
+      ["---", "id: fact-1", "category: fact", "---", "The worker retries three times."].join("\n"),
+      "utf8",
+    );
+
+    const docs = await scanMemoryDir(memoryDir);
+    const ids = docs.map((doc) => doc.docid).sort();
+
+    assert.deepEqual(ids, ["decision-1", "fact-1"]);
+  } finally {
+    await rm(memoryDir, { recursive: true, force: true });
+  }
+});

package/src/search/document-scanner.ts

@@ -1,5 +1,7 @@
 import path from "node:path";
 import { lstat, readdir, readFile, realpath } from "node:fs/promises";
+import { RECALL_FALLBACK_DIRS } from "../utils/category-dir.js";
+import { assertPathInsideRoot } from "../utils/path-containment.js";
 
 export interface IndexableDocument {
   /** Memory ID from frontmatter or filename stem */
@@ -94,25 +96,18 @@ function isNodeError(err: unknown): err is NodeJS.ErrnoException {
   return typeof err === "object" && err !== null && "code" in err;
 }
 
-function pathIsInside(parent: string, child: string): boolean {
-  const relative = path.relative(parent, child);
-  return relative === "" || (!relative.startsWith("..") && !path.isAbsolute(relative));
-}
-
-function assertPathInsideRoot(rootReal: string, candidateReal: string, originalPath: string): void {
-  if (!pathIsInside(rootReal, candidateReal)) {
-    throw new Error(`Refusing to scan memory path outside memoryDir: ${originalPath}`);
-  }
-}
-
 /**
- * Scan `facts/`, `corrections/`, `procedures/`, and `reasoning-traces/`
- * subdirs of memoryDir for indexable markdown documents.
- *
- * Note: reasoning-traces live under their own subtree (issue #564 PR 3).
- * Non-QMD backends (Orama / Meilisearch / LanceDB) build their index
- * through this helper, so any new category subtree must be listed here
- * or those backends silently stop seeing the new memories.
+ * Scan every recall category subdir of memoryDir for indexable markdown
+ * documents. The directory set is derived from `RECALL_FALLBACK_DIRS`
+ * (utils/category-dir.ts → ALL_CATEGORY_DIRS minus non-recall queue dirs) —
+ * the single source of truth — so adding a new category never requires
+ * touching this scanner. Non-QMD backends (Orama / Meilisearch / LanceDB)
+ * build their index through this helper; deriving from RECALL_FALLBACK_DIRS
+ * keeps them in parity with writeMemory's category-dir routing (issue #1546)
+ * and the QMD filesystem-fallback corpus. reasoning-traces/ and the other
+ * category dirs are covered automatically (issue #564 PR 3 no longer needs a
+ * hand-maintained list). scanDir tolerates missing dirs (ENOENT), so category
+ * dirs that do not exist yet are skipped.
  */
 export async function scanMemoryDir(memoryDir: string): Promise<IndexableDocument[]> {
   let memoryRootReal: string;
@@ -124,15 +119,8 @@ export async function scanMemoryDir(memoryDir: string): Promise<IndexableDocumen
     }
     throw err;
   }
-  const factsDir = path.join(memoryDir, "facts");
-  const correctionsDir = path.join(memoryDir, "corrections");
-  const proceduresDir = path.join(memoryDir, "procedures");
-  const reasoningTracesDir = path.join(memoryDir, "reasoning-traces");
-  const [facts, corrections, procedures, reasoningTraces] = await Promise.all([
-    scanDir(factsDir, memoryRootReal),
-    scanDir(correctionsDir, memoryRootReal),
-    scanDir(proceduresDir, memoryRootReal),
-    scanDir(reasoningTracesDir, memoryRootReal),
-  ]);
-  return [...facts, ...corrections, ...procedures, ...reasoningTraces];
+  const perDir = await Promise.all(
+    RECALL_FALLBACK_DIRS.map((dir) => scanDir(path.join(memoryDir, dir), memoryRootReal)),
+  );
+  return perDir.flat();
 }

package/src/secure-store/secure-fs.ts

@@ -59,6 +59,7 @@ import {
   parseEnvelope,
   seal,
 } from "./cipher.js";
+import { RECALL_FALLBACK_DIRS } from "../utils/category-dir.js";
 
 // ---------------------------------------------------------------------------
 // Error classes
@@ -704,11 +705,24 @@ function normalizeStorageRelativePath(rel: string): string {
   return normalized;
 }
 
-const ENCRYPTABLE_MARKDOWN_STORAGE_ROOTS = new Set([
-  "facts",
-  "corrections",
-  "procedures",
-  "reasoning-traces",
+// Every recall MEMORY category directory (facts/ + the CATEGORY_DIR_MAP memory
+// dirs) must be encryptable at rest — #1546 routes decision/preference/moment/...
+// memories into their own dirs, so hardcoding only facts/corrections/procedures/
+// reasoning-traces would silently write those categories in plaintext on
+// encrypted stores. RECALL_FALLBACK_DIRS is the single source of truth for that
+// set; the extra non-category markdown roots (artifacts/archive/entities/
+// identity) are appended.
+//
+// questions/ is deliberately EXCLUDED (RECALL_FALLBACK_DIRS omits the non-memory
+// queue dirs): the question queue is written/resolved through plain readFile/
+// writeFile (StorageManager.writeQuestion/resolveQuestion), NOT the secure-file
+// helpers. Encrypting questions/ here would make migration seal those files,
+// after which resolveQuestion() would read ciphertext as UTF-8, fail to update
+// the frontmatter, and overwrite/corrupt the file while returning success
+// (codex #1563 review). Keeping questions/ plaintext preserves the queue's
+// existing behavior; #1546 does not change question encryption.
+const ENCRYPTABLE_MARKDOWN_STORAGE_ROOTS = new Set<string>([
+  ...RECALL_FALLBACK_DIRS,
   "artifacts",
   "archive",
   "entities",

package/src/secure-store/secure-store.test.ts

@@ -935,3 +935,31 @@ test("backspace on BMP character removes exactly one character (thread 7 — reg
 
   assert.equal(result, "a");
 });
+
+test("secure-store migration encrypts memory category dirs but leaves the questions queue plaintext", async () => {
+  // #1546 routes decision/preference/... memories into their own dirs, which
+  // must be encryptable at rest. But questions/ is written/resolved via plain
+  // readFile/writeFile (writeQuestion/resolveQuestion), so encrypting it would
+  // make resolveQuestion() read ciphertext as UTF-8 and corrupt the file
+  // (codex #1563 review). Migration must seal decisions/ but skip questions/.
+  const tempRoot = await mkdtemp(path.join(tmpdir(), "remnic-secure-store-questions-"));
+  try {
+    const memoryDir = path.join(tempRoot, "memory");
+    const decisionPath = path.join(memoryDir, "decisions", "2026-02-22", "decision-1.md");
+    const questionPath = path.join(memoryDir, "questions", "q-1.md");
+    await mkdir(path.dirname(decisionPath), { recursive: true });
+    await mkdir(path.dirname(questionPath), { recursive: true });
+    await writeFile(decisionPath, "---\ncategory: decision\n---\n\nChose Postgres.\n", "utf8");
+    await writeFile(questionPath, "---\nid: q-1\nresolved: false\n---\n\nWhat DB?\n", "utf8");
+
+    const key = deriveKeyScrypt("questions-plaintext", Buffer.alloc(KDF_SALT_LENGTH, 0x5a), FAST_SCRYPT);
+    const migrated = await migrateMemoryDirToEncrypted(memoryDir, key);
+
+    assert.equal(migrated.encrypted, 1, "only the decision memory should be encrypted");
+    assert.equal(isEncryptedFile(await readFile(decisionPath)), true, "decisions/ is encrypted at rest");
+    assert.equal(isEncryptedFile(await readFile(questionPath)), false, "questions/ stays plaintext");
+    assert.match(await readFile(questionPath, "utf8"), /What DB\?/, "question body remains readable UTF-8");
+  } finally {
+    await rm(tempRoot, { recursive: true, force: true });
+  }
+});