@remnic/core 9.3.663 → 9.3.665

package/src/namespaces/catalog.test.ts

@@ -487,13 +487,13 @@ test("StorageRouter integration: catalog registers namespace on storageFor", asy
     const config = makeConfig(memoryDir);
     const catalog = new NamespaceCatalog(config);
     const router = new NamespaceStorageRouter(config, {
-      onResolve: (namespace, storageDir) => {
-        void catalog.registerResolved(namespace, storageDir);
-      },
+      // Return the registration promise so the router tracks it as in-flight and
+      // `whenResolveHooksSettled()` can await it deterministically (no timer race).
+      onResolve: (namespace, storageDir) => catalog.registerResolved(namespace, storageDir),
     });
     await router.storageFor("project-origin-abc123");
-    // allow the fire-and-forget registration to settle
-    await new Promise((r) => setTimeout(r, 10));
+    // Deterministically await the fire-and-forget registration instead of sleeping.
+    await router.whenResolveHooksSettled();
 
     const record = await catalog.getNamespaceRecord("project-origin-abc123");
     assert.ok(record, "storageFor should have registered the namespace");
@@ -2523,8 +2523,8 @@ test("an async onResolve hook rejection does not crash storage resolution", asyn
     // Must not throw or produce an unhandled rejection that fails the test.
     const sm = await router.storageFor("default");
     assert.ok(sm, "storage resolution succeeds despite a rejecting async hook");
-    // Give the swallowed rejection a tick to settle.
-    await new Promise((r) => setTimeout(r, 10));
+    // Deterministically await the swallowed rejection instead of sleeping.
+    await router.whenResolveHooksSettled();
     assert.ok(called >= 1, "the async hook was invoked");
   } finally {
     await rm(memoryDir, { recursive: true, force: true });
@@ -2564,7 +2564,7 @@ test("concurrent storageFor() for one namespace fires the resolve hook ONCE whil
     // Let the in-flight registration settle, then a steady-state cache hit must
     // still be a catalog no-op (now deduped via notifiedResolved).
     release();
-    await new Promise((r) => setTimeout(r, 10));
+    await router.whenResolveHooksSettled();
     await router.storageFor("project-origin-inflight");
     assert.equal(calls, 1, "a steady-state cache hit after settle must not re-fire the hook");
   } finally {
@@ -2589,20 +2589,20 @@ test("a dropped resolve registration (hook returns false) is retried on a later
     });
 
     await router.storageFor("project-origin-retry");
-    // Give the async hook a tick to settle and clear the in-flight marker.
-    await new Promise((r) => setTimeout(r, 10));
+    // Deterministically await the async hook so the in-flight marker is cleared.
+    await router.whenResolveHooksSettled();
     assert.equal(calls, 1, "the hook fired once for the dropped registration");
 
     // Now the registration will succeed; a later resolve must RETRY (not be
     // suppressed by a stale in-flight/notified marker from the dropped attempt).
     result = undefined; // success (legacy void)
     await router.storageFor("project-origin-retry");
-    await new Promise((r) => setTimeout(r, 10));
+    await router.whenResolveHooksSettled();
     assert.equal(calls, 2, "a dropped registration must be retried on the next storageFor()");
 
     // After a SUCCESSFUL registration, further cache hits are deduped (no retry).
     await router.storageFor("project-origin-retry");
-    await new Promise((r) => setTimeout(r, 10));
+    await router.whenResolveHooksSettled();
     assert.equal(calls, 2, "a successful registration is not re-fired on subsequent cache hits");
   } finally {
     await rm(memoryDir, { recursive: true, force: true });

package/src/namespaces/storage.ts

@@ -223,6 +223,11 @@ export class NamespaceStorageRouter {
   // entry is always removed when the promise settles, so the map cannot grow
   // unbounded (one transient entry per concurrently-resolving namespace).
   private readonly inFlightResolved = new Map<string, string>();
+  // Tracks every in-flight resolve-hook promise so callers can deterministically
+  // await the fire-and-forget registrations that `storageFor()` kicks off (see
+  // `whenResolveHooksSettled`). Entries are removed as each hook settles, so the
+  // set holds at most one promise per concurrently-resolving namespace.
+  private readonly pendingResolveHooks = new Set<Promise<unknown>>();
 
   // Normalized (trimmed) default namespace identity (NH-FH). `storageFor`
   // normalizes its input, so default-namespace branches must compare against the
@@ -325,7 +330,10 @@ export class NamespaceStorageRouter {
       // the map holds at most one transient entry per concurrently-resolving
       // namespace and cannot grow unbounded.
       this.inFlightResolved.set(namespace, storageDir);
-      Promise.resolve(hook(namespace, storageDir)).then(
+      const hookResult = Promise.resolve(hook(namespace, storageDir));
+      // Track the in-flight promise so `whenResolveHooksSettled()` can await it.
+      this.pendingResolveHooks.add(hookResult);
+      hookResult.then(
         (persisted) => {
           // Clear the in-flight marker ONLY if it is still ours (a newer resolve
           // for a different dir may have replaced it).
@@ -338,6 +346,7 @@ export class NamespaceStorageRouter {
           // On `false` (dropped touch) we intentionally do NOT mark notified, so
           // a later `storageFor()` retries the registration. Clearing the
           // in-flight marker above is what re-enables that retry.
+          this.pendingResolveHooks.delete(hookResult);
         },
         () => {
           // Registration failed — clear in-flight AND do NOT mark as notified, so
@@ -348,6 +357,7 @@ export class NamespaceStorageRouter {
           if (this.notifiedResolved.get(namespace) === storageDir) {
             this.notifiedResolved.delete(namespace);
           }
+          this.pendingResolveHooks.delete(hookResult);
         },
       );
     } catch {
@@ -358,4 +368,21 @@ export class NamespaceStorageRouter {
       }
     }
   }
+
+  /**
+   * Resolve once every in-flight `onResolve` registration has settled.
+   *
+   * `storageFor()` fires the resolve hook fire-and-forget, so its catalog side
+   * effect (e.g. `registerResolved(...)`) is not observable the moment
+   * `storageFor()` returns. Callers that must act on that side effect — notably
+   * tests asserting the catalog was updated — should await this instead of
+   * racing a timer. Resolves immediately when no hook is registered or nothing
+   * is in flight. The loop re-checks because a settling hook could, in
+   * principle, trigger a follow-on resolution.
+   */
+  async whenResolveHooksSettled(): Promise<void> {
+    while (this.pendingResolveHooks.size > 0) {
+      await Promise.allSettled([...this.pendingResolveHooks]);
+    }
+  }
 }

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 });
+  }
+});

package/src/storage.ts

@@ -4,7 +4,7 @@ import { createHash } from "node:crypto";
 import path from "node:path";
 import { log } from "./logger.js";
 import { isErrnoCode } from "./utils/errno.js";
-import { RECALL_FALLBACK_DIRS } from "./utils/category-dir.js";
+import { RECALL_FALLBACK_DIRS, getCategoryDir, categoryDirName } from "./utils/category-dir.js";
 import { getCachedEntities, invalidateAllForDir, setCachedEntities } from "./memory-cache.js";
 import { rotateMarkdownFileToArchive } from "./hygiene.js";
 import { sanitizeMemoryContent } from "./sanitize.js";
@@ -3297,6 +3297,32 @@ export class StorageManager {
     await mkdir(path.join(this.baseDir, "config"), { recursive: true });
   }
 
+  /**
+   * Resolve the on-disk write path for a memory of the given category, creating
+   * the target directory. Category routing goes through the shared
+   * `getCategoryDir()` chokepoint (utils/category-dir.ts → CATEGORY_DIR_MAP) so
+   * decision/preference/moment/etc. outputs land in their dedicated dirs
+   * (`decisions/`, `preferences/`, ...) instead of collapsing into `facts/`
+   * (issue #1546; CLAUDE.md rule 39). `correction` keeps its historical flat
+   * layout (no `<date>` subdir) as the corrections pipeline expects; every other
+   * category — including `fact`/`entity`, which fall back to `facts/` — is dated
+   * as `<dir>/<date>/`. Read/scan/reindex already iterate every category dir
+   * (RECALL_FALLBACK_DIRS; QMD scans baseDir recursively), so writes stay found.
+   */
+  private async resolveCategoryWritePath(
+    category: MemoryCategory,
+    id: string,
+    today: string,
+  ): Promise<string> {
+    if (category === "correction") {
+      await mkdir(this.correctionsDir, { recursive: true });
+      return path.join(this.correctionsDir, `${id}.md`);
+    }
+    const datedDir = path.join(getCategoryDir(this.baseDir, category), today);
+    await mkdir(datedDir, { recursive: true });
+    return path.join(datedDir, `${id}.md`);
+  }
+
   async writeMemory(
     category: MemoryCategory,
     content: string,
@@ -3435,20 +3461,7 @@ export class StorageManager {
 
     const fileContent = `${serializeFrontmatter(fm)}\n\n${sanitized.text}\n`;
 
-    let filePath: string;
-    if (category === "correction") {
-      filePath = path.join(this.correctionsDir, `${id}.md`);
-    } else if (category === "procedure") {
-      await mkdir(path.join(this.proceduresDir, today), { recursive: true });
-      filePath = path.join(this.proceduresDir, today, `${id}.md`);
-    } else if (category === "reasoning_trace") {
-      // Issue #564 PR 3: reasoning traces live in their own subtree so recall
-      // can filter on path cheaply without parsing frontmatter.
-      await mkdir(path.join(this.reasoningTracesDir, today), { recursive: true });
-      filePath = path.join(this.reasoningTracesDir, today, `${id}.md`);
-    } else {
-      filePath = path.join(this.factsDir, today, `${id}.md`);
-    }
+    const filePath = await this.resolveCategoryWritePath(category, id, today);
 
     await this.snapshotBeforeWrite(filePath, "write");
     await writeMaybeEncryptedFile(filePath, fileContent, this.resolveWriteKey(), {}, this.baseDir);
@@ -4325,9 +4338,10 @@ export class StorageManager {
    * Read all memories from the cold tier by scanning the entire cold/ root
    * tree.  Previously this only scanned cold/facts/ and cold/corrections/, but
    * structuredAttributes can appear on any MemoryCategory (preference, decision,
-   * entity, etc.).  Although buildTierMemoryPath currently routes all
-   * non-correction, non-artifact memories to cold/facts/, scanning the full
-   * coldRoot ensures correctness if that routing ever changes and guards against
+   * entity, etc.).  buildTierMemoryPath now routes each category to its own
+   * cold/<dir>/ subtree via the shared categoryDirName() chokepoint (issue
+   * #1546), so cold decisions/preferences/... live outside cold/facts/.
+   * Scanning the full coldRoot covers every category dir and guards against
    * files placed in unexpected subdirectories during manual operations or future
    * refactors.
    *
@@ -4535,19 +4549,17 @@ export class StorageManager {
       return path.join(root, "artifacts", this.resolveMemoryDateDir(memory), `${memory.frontmatter.id}.md`);
     }
     if (memory.frontmatter.category === "correction") {
+      // corrections/ is flat (no date subdir); preserved across tier moves.
       return path.join(root, "corrections", `${memory.frontmatter.id}.md`);
     }
-    if (memory.frontmatter.category === "procedure") {
-      return path.join(root, "procedures", this.resolveMemoryDateDir(memory), `${memory.frontmatter.id}.md`);
-    }
-    if (memory.frontmatter.category === "reasoning_trace") {
-      // Issue #564 PR 3: preserve the dedicated reasoning-traces/ subtree
-      // across tier moves. Without this branch, hot→cold migration would
-      // funnel the memory into facts/, breaking isReasoningTracePath() and
-      // silently disabling the recall boost for migrated traces.
-      return path.join(root, "reasoning-traces", this.resolveMemoryDateDir(memory), `${memory.frontmatter.id}.md`);
-    }
-    return path.join(root, "facts", this.resolveMemoryDateDir(memory), `${memory.frontmatter.id}.md`);
+    // Every other category — decisions/, preferences/, reasoning-traces/, ...
+    // plus the facts/ fallback for fact/entity/unknown — resolves through the
+    // shared categoryDirName() chokepoint so tier moves land in the SAME dir the
+    // writer used, instead of funneling non-{correction,procedure,reasoning_trace}
+    // categories into facts/ (issue #564 PR 3 preserved reasoning-traces/; #1546
+    // generalizes it to every category dir).
+    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> {
@@ -6984,20 +6996,7 @@ export class StorageManager {
     }
     const fileContent = `${serializeFrontmatter(fm)}\n\n${sanitized.text}\n`;
 
-    let filePath: string;
-    if (category === "correction") {
-      filePath = path.join(this.correctionsDir, `${id}.md`);
-    } else if (category === "procedure") {
-      await mkdir(path.join(this.proceduresDir, today), { recursive: true });
-      filePath = path.join(this.proceduresDir, today, `${id}.md`);
-    } else if (category === "reasoning_trace") {
-      // Issue #564 PR 3: chunks of a reasoning_trace memory live alongside the
-      // parent in reasoning-traces/<date>/.
-      await mkdir(path.join(this.reasoningTracesDir, today), { recursive: true });
-      filePath = path.join(this.reasoningTracesDir, today, `${id}.md`);
-    } else {
-      filePath = path.join(this.factsDir, today, `${id}.md`);
-    }
+    const filePath = await this.resolveCategoryWritePath(category, id, today);
 
     await this.writeStorageSecureFile(filePath, fileContent);
     log.debug(`wrote chunk ${id} (${chunkIndex + 1}/${chunkTotal}) to ${filePath}`);