@remnic/core 9.3.663 → 9.3.665

package/dist/semantic-consolidation.js

@@ -7,14 +7,14 @@ import {
   materializeAfterSemanticConsolidation,
   parseConsolidationResponse,
   parseOperatorAwareConsolidationResponse
-} from "./chunk-D2EFNQMY.js";
-import "./chunk-ANJOULTP.js";
+} from "./chunk-XW3W4PV4.js";
+import "./chunk-C7AF236A.js";
 import "./chunk-LN4YGHTM.js";
 import {
   resolveExtensionsRoot
 } from "./chunk-JLNBQWZ2.js";
 import "./chunk-3UXOZBHV.js";
-import "./chunk-AX5O25EF.js";
+import "./chunk-VH6EIKVS.js";
 import "./chunk-M7XQSUBB.js";
 import "./chunk-5UZXUTVO.js";
 import "./chunk-J6A3CX5N.js";
@@ -34,16 +34,17 @@ import {
   isSemanticConsolidationLlmOperator,
   isValidDerivedFromEntry
 } from "./chunk-G7D6GZ5J.js";
-import "./chunk-ALEPI75L.js";
+import "./chunk-VF4XKTX3.js";
 import "./chunk-U3PN77QT.js";
 import "./chunk-4DJQYKMN.js";
 import "./chunk-EYIEWJNI.js";
 import "./chunk-JUC24CTX.js";
 import "./chunk-ZBJMUXZH.js";
 import "./chunk-2ODBA7MQ.js";
-import "./chunk-ILXTATKK.js";
+import "./chunk-J2HSAU72.js";
 import "./chunk-A6XUJE5D.js";
 import "./chunk-P7FMDTKL.js";
+import "./chunk-VS2IYZRU.js";
 import "./chunk-PZ5AY32C.js";
 export {
   CONSOLIDATION_OPERATORS,

package/dist/semantic-rule-promotion.js

@@ -1,8 +1,8 @@
 import {
   promoteSemanticRuleFromMemory,
   setSemanticRulePromotionTestHooks
-} from "./chunk-QXHBWFR3.js";
-import "./chunk-AX5O25EF.js";
+} from "./chunk-IHG6CC7T.js";
+import "./chunk-VH6EIKVS.js";
 import "./chunk-M7XQSUBB.js";
 import "./chunk-5UZXUTVO.js";
 import "./chunk-J6A3CX5N.js";
@@ -17,12 +17,13 @@ import "./chunk-DM2T26WE.js";
 import "./chunk-LDXUBPMO.js";
 import "./chunk-FVQJYWH7.js";
 import "./chunk-G7D6GZ5J.js";
-import "./chunk-ALEPI75L.js";
+import "./chunk-VF4XKTX3.js";
 import "./chunk-4DJQYKMN.js";
 import "./chunk-2ODBA7MQ.js";
-import "./chunk-ILXTATKK.js";
+import "./chunk-J2HSAU72.js";
 import "./chunk-A6XUJE5D.js";
 import "./chunk-P7FMDTKL.js";
+import "./chunk-VS2IYZRU.js";
 import "./chunk-PZ5AY32C.js";
 export {
   promoteSemanticRuleFromMemory,

package/dist/semantic-rule-verifier.js

@@ -1,8 +1,8 @@
 import {
   compareVerifiedSemanticRuleResults,
   searchVerifiedSemanticRules
-} from "./chunk-NMPEJV5M.js";
-import "./chunk-AX5O25EF.js";
+} from "./chunk-DSLUOQDY.js";
+import "./chunk-VH6EIKVS.js";
 import "./chunk-M7XQSUBB.js";
 import "./chunk-5UZXUTVO.js";
 import "./chunk-J6A3CX5N.js";
@@ -17,13 +17,14 @@ import "./chunk-DM2T26WE.js";
 import "./chunk-LDXUBPMO.js";
 import "./chunk-FVQJYWH7.js";
 import "./chunk-G7D6GZ5J.js";
-import "./chunk-ALEPI75L.js";
+import "./chunk-VF4XKTX3.js";
 import "./chunk-4DJQYKMN.js";
 import "./chunk-ZBJMUXZH.js";
 import "./chunk-2ODBA7MQ.js";
-import "./chunk-ILXTATKK.js";
+import "./chunk-J2HSAU72.js";
 import "./chunk-A6XUJE5D.js";
 import "./chunk-P7FMDTKL.js";
+import "./chunk-VS2IYZRU.js";
 import "./chunk-PZ5AY32C.js";
 export {
   compareVerifiedSemanticRuleResults,

package/dist/shared-context/manager.d.ts

@@ -22,9 +22,9 @@ declare const SharedFeedbackEntrySchema: z.ZodObject<{
     date: string;
     agent: string;
     reason: string;
+    confidence?: number | undefined;
     workflow?: string | undefined;
     tags?: string[] | undefined;
-    confidence?: number | undefined;
     severity?: "high" | "low" | "medium" | undefined;
     outcome?: string | undefined;
     refs?: string[] | undefined;
@@ -36,9 +36,9 @@ declare const SharedFeedbackEntrySchema: z.ZodObject<{
     date: string;
     agent: string;
     reason: string;
+    confidence?: number | undefined;
     workflow?: string | undefined;
     tags?: string[] | undefined;
-    confidence?: number | undefined;
     severity?: "high" | "low" | "medium" | undefined;
     outcome?: string | undefined;
     refs?: string[] | undefined;

package/dist/storage.d.ts

@@ -375,6 +375,19 @@ declare class StorageManager {
     loadAliases(): Promise<void>;
     private loadAliasesSync;
     ensureDirectories(): Promise<void>;
+    /**
+     * 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 resolveCategoryWritePath;
     writeMemory(category: MemoryCategory, content: string, options?: {
         actor?: string;
         confidence?: number;
@@ -521,9 +534,10 @@ declare 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.
      *

package/dist/storage.js

@@ -9,7 +9,7 @@ import {
   parseEntityFile,
   serializeEntityFile,
   stripAttributesSuffix
-} from "./chunk-AX5O25EF.js";
+} from "./chunk-VH6EIKVS.js";
 import "./chunk-M7XQSUBB.js";
 import "./chunk-5UZXUTVO.js";
 import "./chunk-J6A3CX5N.js";
@@ -24,12 +24,13 @@ import "./chunk-DM2T26WE.js";
 import "./chunk-LDXUBPMO.js";
 import "./chunk-FVQJYWH7.js";
 import "./chunk-G7D6GZ5J.js";
-import "./chunk-ALEPI75L.js";
+import "./chunk-VF4XKTX3.js";
 import "./chunk-4DJQYKMN.js";
 import "./chunk-2ODBA7MQ.js";
-import "./chunk-ILXTATKK.js";
+import "./chunk-J2HSAU72.js";
 import "./chunk-A6XUJE5D.js";
 import "./chunk-P7FMDTKL.js";
+import "./chunk-VS2IYZRU.js";
 import "./chunk-PZ5AY32C.js";
 export {
   ContentHashIndex,

package/dist/transfer/capsule-import.js

@@ -1,7 +1,7 @@
 import {
   importCapsule
-} from "../chunk-DHGSZ3UD.js";
-import "../chunk-ALEPI75L.js";
+} from "../chunk-ARV3AUOM.js";
+import "../chunk-VF4XKTX3.js";
 import "../chunk-WEHSQBFR.js";
 import "../chunk-X7Y7WX73.js";
 import "../chunk-BJMBJZ2Y.js";
@@ -9,6 +9,7 @@ import "../chunk-UKJAGEXH.js";
 import "../chunk-FP2373TW.js";
 import "../chunk-GCGJW34D.js";
 import "../chunk-A6XUJE5D.js";
+import "../chunk-VS2IYZRU.js";
 import "../chunk-PZ5AY32C.js";
 export {
   importCapsule

package/dist/transfer/types.d.ts

@@ -313,13 +313,13 @@ declare const CapsuleBlockSchema: z.ZodObject<{
         peerProfiles: boolean;
     }>;
 }, "strip", z.ZodTypeAny, {
-    schemaVersion: string;
     includes: {
         procedural: boolean;
         taxonomy: boolean;
         identityAnchors: boolean;
         peerProfiles: boolean;
     };
+    schemaVersion: string;
     id: string;
     description: string;
     version: string;
@@ -334,13 +334,13 @@ declare const CapsuleBlockSchema: z.ZodObject<{
         directAnswerEnabled: boolean;
     };
 }, {
-    schemaVersion: string;
     includes: {
         procedural: boolean;
         taxonomy: boolean;
         identityAnchors: boolean;
         peerProfiles: boolean;
     };
+    schemaVersion: string;
     id: string;
     description: string;
     version: string;
@@ -464,13 +464,13 @@ declare const ExportManifestV2Schema: z.ZodObject<{
             peerProfiles: boolean;
         }>;
     }, "strip", z.ZodTypeAny, {
-        schemaVersion: string;
         includes: {
             procedural: boolean;
             taxonomy: boolean;
             identityAnchors: boolean;
             peerProfiles: boolean;
         };
+        schemaVersion: string;
         id: string;
         description: string;
         version: string;
@@ -485,13 +485,13 @@ declare const ExportManifestV2Schema: z.ZodObject<{
             directAnswerEnabled: boolean;
         };
     }, {
-        schemaVersion: string;
         includes: {
             procedural: boolean;
             taxonomy: boolean;
             identityAnchors: boolean;
             peerProfiles: boolean;
         };
+        schemaVersion: string;
         id: string;
         description: string;
         version: string;
@@ -518,13 +518,13 @@ declare const ExportManifestV2Schema: z.ZodObject<{
     pluginVersion: string;
     includesTranscripts: boolean;
     capsule: {
-        schemaVersion: string;
         includes: {
             procedural: boolean;
             taxonomy: boolean;
             identityAnchors: boolean;
             peerProfiles: boolean;
         };
+        schemaVersion: string;
         id: string;
         description: string;
         version: string;
@@ -551,13 +551,13 @@ declare const ExportManifestV2Schema: z.ZodObject<{
     pluginVersion: string;
     includesTranscripts: boolean;
     capsule: {
-        schemaVersion: string;
         includes: {
             procedural: boolean;
             taxonomy: boolean;
             identityAnchors: boolean;
             peerProfiles: boolean;
         };
+        schemaVersion: string;
         id: string;
         description: string;
         version: string;
@@ -683,13 +683,13 @@ declare const ExportBundleV2Schema: z.ZodObject<{
                 peerProfiles: boolean;
             }>;
         }, "strip", z.ZodTypeAny, {
-            schemaVersion: string;
             includes: {
                 procedural: boolean;
                 taxonomy: boolean;
                 identityAnchors: boolean;
                 peerProfiles: boolean;
             };
+            schemaVersion: string;
             id: string;
             description: string;
             version: string;
@@ -704,13 +704,13 @@ declare const ExportBundleV2Schema: z.ZodObject<{
                 directAnswerEnabled: boolean;
             };
         }, {
-            schemaVersion: string;
             includes: {
                 procedural: boolean;
                 taxonomy: boolean;
                 identityAnchors: boolean;
                 peerProfiles: boolean;
             };
+            schemaVersion: string;
             id: string;
             description: string;
             version: string;
@@ -737,13 +737,13 @@ declare const ExportBundleV2Schema: z.ZodObject<{
         pluginVersion: string;
         includesTranscripts: boolean;
         capsule: {
-            schemaVersion: string;
             includes: {
                 procedural: boolean;
                 taxonomy: boolean;
                 identityAnchors: boolean;
                 peerProfiles: boolean;
             };
+            schemaVersion: string;
             id: string;
             description: string;
             version: string;
@@ -770,13 +770,13 @@ declare const ExportBundleV2Schema: z.ZodObject<{
         pluginVersion: string;
         includesTranscripts: boolean;
         capsule: {
-            schemaVersion: string;
             includes: {
                 procedural: boolean;
                 taxonomy: boolean;
                 identityAnchors: boolean;
                 peerProfiles: boolean;
             };
+            schemaVersion: string;
             id: string;
             description: string;
             version: string;
@@ -815,13 +815,13 @@ declare const ExportBundleV2Schema: z.ZodObject<{
         pluginVersion: string;
         includesTranscripts: boolean;
         capsule: {
-            schemaVersion: string;
             includes: {
                 procedural: boolean;
                 taxonomy: boolean;
                 identityAnchors: boolean;
                 peerProfiles: boolean;
             };
+            schemaVersion: string;
             id: string;
             description: string;
             version: string;
@@ -854,13 +854,13 @@ declare const ExportBundleV2Schema: z.ZodObject<{
         pluginVersion: string;
         includesTranscripts: boolean;
         capsule: {
-            schemaVersion: string;
             includes: {
                 procedural: boolean;
                 taxonomy: boolean;
                 identityAnchors: boolean;
                 peerProfiles: boolean;
             };
+            schemaVersion: string;
             id: string;
             description: string;
             version: string;

package/dist/verified-recall.js

@@ -1,9 +1,9 @@
 import {
   compareVerifiedEpisodeResults,
   searchVerifiedEpisodes
-} from "./chunk-TYIXG4VR.js";
+} from "./chunk-YW52BQSU.js";
 import "./chunk-HQ6NIBL6.js";
-import "./chunk-AX5O25EF.js";
+import "./chunk-VH6EIKVS.js";
 import "./chunk-M7XQSUBB.js";
 import "./chunk-5UZXUTVO.js";
 import "./chunk-J6A3CX5N.js";
@@ -18,13 +18,14 @@ import "./chunk-DM2T26WE.js";
 import "./chunk-LDXUBPMO.js";
 import "./chunk-FVQJYWH7.js";
 import "./chunk-G7D6GZ5J.js";
-import "./chunk-ALEPI75L.js";
+import "./chunk-VF4XKTX3.js";
 import "./chunk-4DJQYKMN.js";
 import "./chunk-ZBJMUXZH.js";
 import "./chunk-2ODBA7MQ.js";
-import "./chunk-ILXTATKK.js";
+import "./chunk-J2HSAU72.js";
 import "./chunk-A6XUJE5D.js";
 import "./chunk-P7FMDTKL.js";
+import "./chunk-VS2IYZRU.js";
 import "./chunk-PZ5AY32C.js";
 export {
   compareVerifiedEpisodeResults,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@remnic/core",
-  "version": "9.3.663",
+  "version": "9.3.665",
   "description": "Framework-agnostic Remnic memory engine — orchestrator, storage, extraction, search, trust zones",
   "type": "module",
   "main": "dist/index.js",

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) {