@remnic/core 9.54.3 → 9.54.5

package/src/orchestration/qmd-result-resolver.test.ts

@@ -1,26 +1,27 @@
 import assert from "node:assert/strict";
-import test from "node:test";
 import { mkdir, mkdtemp, rm, writeFile } from "node:fs/promises";
 import os from "node:os";
 import path from "node:path";
+import test from "node:test";
 
 import { parseConfig } from "../config.js";
 import { StorageManager } from "../index.js";
-import {
-  QmdResultResolver,
-  qmdResultPathCandidates,
-} from "./qmd-result-resolver.js";
+import { QmdResultResolver, qmdCollectionPathParts, qmdResultPathCandidates } from "./qmd-result-resolver.js";
+
+test("qmdCollectionPathParts normalizes QMD URIs", () => {
+  assert.deepEqual(qmdCollectionPathParts("qmd://openclaw-engram/facts/private.md"), {
+    collection: "openclaw-engram",
+    relativePath: "facts/private.md",
+  });
+});
 
 test("qmdResultPathCandidates probes the facts/ fallback for relative date paths", () => {
   const root = path.join(os.tmpdir(), "remnic-resolver-rel");
   const candidates = qmdResultPathCandidates(root, "2026-07-21/fact-x.md");
   assert.deepEqual(
     candidates.sort(),
-    [
-      path.join(root, "2026-07-21", "fact-x.md"),
-      path.join(root, "facts", "2026-07-21", "fact-x.md"),
-    ].sort(),
-    "relative date paths probe both the literal and the facts/ location",
+    [path.join(root, "2026-07-21", "fact-x.md"), path.join(root, "facts", "2026-07-21", "fact-x.md")].sort(),
+    "relative date paths probe both the literal and the facts/ location"
   );
 });
 
@@ -31,7 +32,7 @@ test("qmdResultPathCandidates probes the facts/ fallback for absolute date paths
   assert.deepEqual(
     candidates.sort(),
     [absolute, path.join(root, "facts", "2026-07-21", "fact-x.md")].sort(),
-    "pre-absolutized date paths must probe the facts/ location too",
+    "pre-absolutized date paths must probe the facts/ location too"
   );
 });
 
@@ -41,7 +42,7 @@ test("qmdResultPathCandidates keeps non-date absolute paths literal", () => {
   assert.deepEqual(
     qmdResultPathCandidates(root, absolute),
     [absolute],
-    "non-date absolute paths must not grow a facts/ variant",
+    "non-date absolute paths must not grow a facts/ variant"
   );
 });
 
@@ -51,7 +52,7 @@ test("qmdResultPathCandidates rejects absolute paths outside the storage root",
   assert.deepEqual(
     qmdResultPathCandidates(root, outside),
     [],
-    "containment must drop escaping paths, including their facts/ variant",
+    "containment must drop escaping paths, including their facts/ variant"
   );
 });
 
@@ -77,7 +78,7 @@ test("readQmdResultMemory resolves an absolute date path whose file lives under
         "The storefront manages a uniqueId cookie with a 90-day expiration.",
         "",
       ].join("\n"),
-      "utf8",
+      "utf8"
     );
 
     const config = parseConfig({ memoryDir: dir });
@@ -101,3 +102,203 @@ test("readQmdResultMemory resolves an absolute date path whose file lives under
     await rm(dir, { recursive: true, force: true });
   }
 });
+
+test("private-result filtering can preserve unresolved custom-collection hits", async () => {
+  const dir = await mkdtemp(path.join(os.tmpdir(), "remnic-resolver-custom-"));
+  try {
+    const storage = new StorageManager(dir);
+    await storage.ensureDirectories();
+    const config = parseConfig({ memoryDir: dir });
+    const resolver = new QmdResultResolver({
+      getConfig: () => config,
+      storageFor: async () => storage,
+      storageDirNamespace: () => config.defaultNamespace,
+      qmdCollectionNamespaceFromPrefix: () => null,
+      namespaceFromPath: () => config.defaultNamespace,
+    });
+    const result = { docid: "external", path: "custom-collection/page.md", snippet: "page", score: 1 };
+
+    const privateDir = path.join(dir, "preferences");
+    await mkdir(privateDir, { recursive: true });
+    await writeFile(
+      path.join(privateDir, "private.md"),
+      [
+        "---",
+        "id: private",
+        "category: preference",
+        "created: 2026-08-13T00:00:00.000Z",
+        "updated: 2026-08-13T00:00:00.000Z",
+        "status: active",
+        "tags:",
+        "  - support-passport-card",
+        "---",
+        "",
+        "Private support card.",
+        "",
+      ].join("\n"),
+      "utf8"
+    );
+
+    assert.deepEqual(await resolver.filterPrivateSearchResults([result], storage), [result]);
+    const qualifiedPrivate = {
+      ...result,
+      path: "custom-collection/preferences/private.md",
+      snippet: "Private support card.",
+    };
+    assert.deepEqual(await resolver.filterPrivateSearchResults([qualifiedPrivate], storage), []);
+    const configured = { ...result, path: `${config.qmdCollection}/page.md` };
+    assert.deepEqual(await resolver.filterPrivateSearchResults([configured], storage), []);
+    assert.deepEqual(await resolver.filterPrivateSearchResults([configured], storage, [], true), [configured]);
+    const externalAbsolute = { ...result, path: path.join(os.tmpdir(), "external-collection", "page.md") };
+    assert.deepEqual(await resolver.filterPrivateSearchResults([externalAbsolute], storage), [externalAbsolute]);
+  } finally {
+    await rm(dir, { recursive: true, force: true });
+  }
+});
+
+test("private-result filtering distinguishes custom category paths from explicit internal collections", async () => {
+  const dir = await mkdtemp(path.join(os.tmpdir(), "remnic-resolver-internal-"));
+  try {
+    const storage = new StorageManager(dir);
+    await storage.ensureDirectories();
+    const config = parseConfig({ memoryDir: dir });
+    const resolver = new QmdResultResolver({
+      getConfig: () => config,
+      storageFor: async () => storage,
+      storageDirNamespace: () => config.defaultNamespace,
+      qmdCollectionNamespaceFromPrefix: () => null,
+      namespaceFromPath: () => config.defaultNamespace,
+    });
+    for (const root of [
+      "activity",
+      "archive",
+      "artifacts",
+      "cold",
+      "entities",
+      "identity",
+      "state",
+      "summaries",
+      "transcripts",
+    ]) {
+      const result = { docid: root, path: `${root}/missing.md`, snippet: "private", score: 1 };
+      assert.deepEqual(await resolver.filterPrivateSearchResults([result], storage), []);
+      assert.deepEqual(await resolver.filterPrivateSearchResults([result], storage, [], true), [result]);
+    }
+    const explicitInternal = {
+      docid: "internal",
+      path: `qmd://${config.qmdCollection}/facts/missing.md`,
+      snippet: "private",
+      score: 1,
+    };
+    assert.deepEqual(await resolver.filterPrivateSearchResults([explicitInternal], storage, [], true), []);
+  } finally {
+    await rm(dir, { recursive: true, force: true });
+  }
+});
+
+test("private-result filtering resolves QMD URIs before checking passport privacy", async () => {
+  const dir = await mkdtemp(path.join(os.tmpdir(), "remnic-resolver-qmd-uri-"));
+  try {
+    const storage = new StorageManager(dir);
+    await storage.ensureDirectories();
+    const factDir = path.join(dir, "facts");
+    await mkdir(factDir, { recursive: true });
+    await writeFile(
+      path.join(factDir, "private.md"),
+      [
+        "---",
+        "id: private",
+        "category: preference",
+        "created: 2026-08-13T00:00:00.000Z",
+        "updated: 2026-08-13T00:00:00.000Z",
+        "status: active",
+        "tags:",
+        "  - support-passport-card",
+        "---",
+        "",
+        "Private support card.",
+        "",
+      ].join("\n"),
+      "utf8"
+    );
+    const config = parseConfig({ memoryDir: dir });
+    const resolver = new QmdResultResolver({
+      getConfig: () => config,
+      storageFor: async () => storage,
+      storageDirNamespace: () => config.defaultNamespace,
+      qmdCollectionNamespaceFromPrefix: () => null,
+      namespaceFromPath: () => config.defaultNamespace,
+    });
+    const result = {
+      docid: "private",
+      path: `qmd://${config.qmdCollection}/facts/private.md`,
+      snippet: "Private support card.",
+      score: 1,
+    };
+
+    assert.deepEqual(await resolver.filterPrivateSearchResults([result], storage), []);
+  } finally {
+    await rm(dir, { recursive: true, force: true });
+  }
+});
+
+test("private-result filtering resolves bounded batches and reuses prefix results", async () => {
+  const dir = await mkdtemp(path.join(os.tmpdir(), "remnic-resolver-batch-"));
+  try {
+    let activeReads = 0;
+    let maximumReads = 0;
+    const readCounts = new Map<string, number>();
+    const storage = {
+      dir,
+      async readMemoryByPath(filePath: string) {
+        const id = path.basename(filePath, ".md");
+        readCounts.set(id, (readCounts.get(id) ?? 0) + 1);
+        activeReads += 1;
+        maximumReads = Math.max(maximumReads, activeReads);
+        await new Promise((resolve) => setTimeout(resolve, 5));
+        activeReads -= 1;
+        return {
+          path: filePath,
+          content: `content for ${id}`,
+          frontmatter: {
+            id,
+            category: "fact",
+            created: "2026-08-13T00:00:00.000Z",
+            updated: "2026-08-13T00:00:00.000Z",
+            status: "active",
+            tags: id === "memory-0" ? ["support-passport-card"] : [],
+          },
+        };
+      },
+    } as unknown as StorageManager;
+    const config = parseConfig({ memoryDir: dir });
+    const resolver = new QmdResultResolver({
+      getConfig: () => config,
+      storageFor: async () => storage,
+      storageDirNamespace: () => config.defaultNamespace,
+      qmdCollectionNamespaceFromPrefix: () => null,
+      namespaceFromPath: () => config.defaultNamespace,
+    });
+    const results = Array.from({ length: 20 }, (_, index) => ({
+      docid: `memory-${index}`,
+      path: `facts/memory-${index}.md`,
+      snippet: "candidate",
+      score: 1,
+    }));
+    const visibilityCache = new Map<string, boolean>();
+
+    const first = await resolver.filterPrivateSearchResults(results.slice(0, 16), storage, [], false, visibilityCache);
+    const second = await resolver.filterPrivateSearchResults(results, storage, [], false, visibilityCache);
+
+    assert.equal(first.length, 15);
+    assert.equal(second.length, 19);
+    assert.equal(maximumReads, 16);
+    assert.equal(
+      [...readCounts.values()].reduce((total, count) => total + count, 0),
+      20
+    );
+    assert.equal(readCounts.get("memory-0"), 1);
+  } finally {
+    await rm(dir, { recursive: true, force: true });
+  }
+});

package/src/orchestration/qmd-result-resolver.ts

@@ -27,13 +27,37 @@
  */
 
 import path from "node:path";
+import { resolveNamespaceCapabilities } from "../capabilities.js";
+import type { StorageManager } from "../index.js";
 import { log } from "../logger.js";
-import { isPathInsideStorageRoot } from "../storage-paths.js";
 import { namespaceIdentityFromToken } from "../namespaces/identity.js";
-import { resolveNamespaceCapabilities } from "../capabilities.js";
+import { normalizeQmdResultPath } from "../namespaces/search.js";
 import { SecureStoreLockedError } from "../secure-store/index.js";
-import type { PluginConfig, QmdSearchResult, MemoryFile } from "../types.js";
-import type { StorageManager } from "../index.js";
+import { isPathInsideStorageRoot } from "../storage-paths.js";
+import { isSupportPassportPrivateMemory } from "../support-passport/card-projection.js";
+import type { MemoryFile, PluginConfig, QmdSearchResult } from "../types.js";
+import { ALL_CATEGORY_DIRS } from "../utils/category-dir.js";
+
+const INTERNAL_QMD_ROOTS = new Set([
+  ...ALL_CATEGORY_DIRS,
+  "activity",
+  "archive",
+  "artifacts",
+  "cold",
+  "config",
+  "entities",
+  "identity",
+  "meetings",
+  "namespaces",
+  "state",
+  "summaries",
+  "transcripts",
+  "wearables",
+  "work",
+  "workspace",
+]);
+
+const PRIVATE_RESULT_RESOLUTION_CONCURRENCY = 16;
 
 /**
  * Split a relative QMD result path into its collection prefix and the
@@ -45,6 +69,18 @@ export function qmdCollectionPathParts(resultPath: string): {
   relativePath: string;
 } | null {
   if (!resultPath || path.isAbsolute(resultPath)) return null;
+  if (resultPath.trim().startsWith("qmd://")) {
+    try {
+      const parsed = new URL(resultPath.trim());
+      if (parsed.protocol !== "qmd:" || !parsed.hostname) return null;
+      const collection = parsed.hostname;
+      const relativePath = normalizeQmdResultPath(resultPath, collection).replace(/\\/g, "/").replace(/^\/+/, "");
+      if (!relativePath) return null;
+      return { collection, relativePath };
+    } catch {
+      return null;
+    }
+  }
   const normalized = resultPath.replace(/\\/g, "/").replace(/^\/+/, "");
   const slashIndex = normalized.indexOf("/");
   if (slashIndex <= 0 || slashIndex >= normalized.length - 1) return null;
@@ -61,10 +97,7 @@ export function qmdCollectionPathParts(resultPath: string): {
  * constrained to the storage root so a result path can never escape the
  * namespace directory.
  */
-export function qmdResultPathCandidates(
-  storageDir: string,
-  resultPath: string,
-): string[] {
+export function qmdResultPathCandidates(storageDir: string, resultPath: string): string[] {
   const candidates = new Set<string>();
   const storageRoot = path.resolve(storageDir);
   const addCandidate = (candidate: string) => {
@@ -122,25 +155,20 @@ export class QmdResultResolver {
   private readonly getConfig: () => PluginConfig;
   private readonly storageFor: (namespace: string) => Promise<StorageManager>;
   private readonly storageDirNamespace: (storageDir: string) => string;
-  private readonly qmdCollectionNamespaceFromPrefix: (
-    collectionPrefix: string,
-  ) => string | null;
+  private readonly qmdCollectionNamespaceFromPrefix: (collectionPrefix: string) => string | null;
   private readonly namespaceFromPath: (p: string) => string;
 
   constructor(options: {
     getConfig: () => PluginConfig;
     storageFor: (namespace: string) => Promise<StorageManager>;
     storageDirNamespace: (storageDir: string) => string;
-    qmdCollectionNamespaceFromPrefix: (
-      collectionPrefix: string,
-    ) => string | null;
+    qmdCollectionNamespaceFromPrefix: (collectionPrefix: string) => string | null;
     namespaceFromPath: (p: string) => string;
   }) {
     this.getConfig = options.getConfig;
     this.storageFor = options.storageFor;
     this.storageDirNamespace = options.storageDirNamespace;
-    this.qmdCollectionNamespaceFromPrefix =
-      options.qmdCollectionNamespaceFromPrefix;
+    this.qmdCollectionNamespaceFromPrefix = options.qmdCollectionNamespaceFromPrefix;
     this.namespaceFromPath = options.namespaceFromPath;
   }
 
@@ -148,29 +176,29 @@ export class QmdResultResolver {
     resultPath: string,
     fallbackStorage: StorageManager,
     recallNamespaces: readonly string[] = [],
-    preferredNamespace?: string,
+    preferredNamespace?: string
   ): Promise<MemoryFile | null> {
     const parts = qmdCollectionPathParts(resultPath);
     const fallbackStorageDir = storageDirOrNull(fallbackStorage);
     const config = this.getConfig();
     const coldCollection = config.qmdColdCollection ?? "openclaw-engram-cold";
+    const fallbackResultPath =
+      resultPath.trim().startsWith("qmd://") && parts?.collection === config.qmdCollection
+        ? parts.relativePath
+        : resultPath;
     if (parts && parts.collection === coldCollection) {
       const storages: StorageManager[] = [];
       const seenStorageDirs = new Set<string>();
       const addStorage = (storage: StorageManager): void => {
         const storageDir = storageDirOrNull(storage);
-        const storageKey = storageDir
-          ? path.resolve(storageDir)
-          : `storage-without-dir-${storages.length}`;
+        const storageKey = storageDir ? path.resolve(storageDir) : `storage-without-dir-${storages.length}`;
         if (seenStorageDirs.has(storageKey)) return;
         seenStorageDirs.add(storageKey);
         storages.push(storage);
       };
 
       const fallbackNamespace =
-        fallbackStorageDir !== null
-          ? this.storageDirNamespace(fallbackStorageDir)
-          : config.defaultNamespace;
+        fallbackStorageDir !== null ? this.storageDirNamespace(fallbackStorageDir) : config.defaultNamespace;
       if (
         recallNamespaces.length === 0 ||
         !resolveNamespaceCapabilities(config).namespaces ||
@@ -202,10 +230,7 @@ export class QmdResultResolver {
         }
         try {
           const coldRoot = path.join(storageDir, "cold");
-          for (const candidate of qmdResultPathCandidates(
-            coldRoot,
-            parts.relativePath,
-          )) {
+          for (const candidate of qmdResultPathCandidates(coldRoot, parts.relativePath)) {
             const memory = await storage.readMemoryByPath(candidate);
             if (memory) return memory;
           }
@@ -220,17 +245,12 @@ export class QmdResultResolver {
       }
       return null;
     }
-    const collectionNamespace = parts
-      ? this.qmdCollectionNamespaceFromPrefix(parts.collection)
-      : null;
+    const collectionNamespace = parts ? this.qmdCollectionNamespaceFromPrefix(parts.collection) : null;
 
     if (parts && collectionNamespace) {
       try {
         const collectionStorage = await this.storageFor(collectionNamespace);
-        for (const candidate of qmdResultPathCandidates(
-          collectionStorage.dir,
-          parts.relativePath,
-        )) {
+        for (const candidate of qmdResultPathCandidates(collectionStorage.dir, parts.relativePath)) {
           const memory = await collectionStorage.readMemoryByPath(candidate);
           if (memory) return memory;
         }
@@ -249,10 +269,7 @@ export class QmdResultResolver {
     if (preferredNamespace) {
       try {
         const preferredStorage = await this.storageFor(preferredNamespace);
-        for (const candidate of qmdResultPathCandidates(
-          preferredStorage.dir,
-          resultPath,
-        )) {
+        for (const candidate of qmdResultPathCandidates(preferredStorage.dir, fallbackResultPath)) {
           const memory = await preferredStorage.readMemoryByPath(candidate);
           if (memory) return memory;
         }
@@ -269,22 +286,19 @@ export class QmdResultResolver {
       // is stale/deleted — do NOT fall through to the default store and validate
       // a same-relative-path memory from the wrong namespace (#2020). Absolute
       // paths still fall through: the absolute branch resolves the true owner.
-      if (!path.isAbsolute(resultPath)) return null;
+      if (!path.isAbsolute(fallbackResultPath)) return null;
     }
-    if (path.isAbsolute(resultPath)) {
+    if (path.isAbsolute(fallbackResultPath)) {
       if (!fallbackStorageDir) {
-        return await fallbackStorage.readMemoryByPath(resultPath);
+        return await fallbackStorage.readMemoryByPath(fallbackResultPath);
       }
       const ownerStorage = await this.storageForAbsoluteQmdResultPath(
-        resultPath,
+        fallbackResultPath,
         fallbackStorage,
-        recallNamespaces,
+        recallNamespaces
       );
       if (!ownerStorage) return null;
-      for (const candidate of qmdResultPathCandidates(
-        ownerStorage.dir,
-        resultPath,
-      )) {
+      for (const candidate of qmdResultPathCandidates(ownerStorage.dir, fallbackResultPath)) {
         const memory = await ownerStorage.storage.readMemoryByPath(candidate);
         if (memory) return memory;
       }
@@ -292,46 +306,101 @@ export class QmdResultResolver {
     }
 
     if (!fallbackStorageDir) {
-      return await fallbackStorage.readMemoryByPath(resultPath);
+      return await fallbackStorage.readMemoryByPath(fallbackResultPath);
     }
-    for (const candidate of qmdResultPathCandidates(
-      fallbackStorageDir,
-      resultPath,
-    )) {
+    for (const candidate of qmdResultPathCandidates(fallbackStorageDir, fallbackResultPath)) {
       const memory = await fallbackStorage.readMemoryByPath(candidate);
       if (memory) return memory;
     }
     return null;
   }
 
+  async filterPrivateSearchResults(
+    results: QmdSearchResult[],
+    fallbackStorage: StorageManager,
+    namespaces: readonly string[] = [],
+    preserveUnresolved = false,
+    visibilityCache = new Map<string, boolean>()
+  ): Promise<QmdSearchResult[]> {
+    const namespaceKey = namespaces.join("\0");
+    const entries = results
+      .filter((result) => Boolean(result.path))
+      .map((result) => ({
+        result,
+        cacheKey: `${namespaceKey}\0${preserveUnresolved ? "1" : "0"}\0${result.namespace ?? ""}\0${result.path}`,
+      }));
+    const pending = new Map<string, QmdSearchResult>();
+    for (const { result, cacheKey } of entries) {
+      if (!visibilityCache.has(cacheKey)) pending.set(cacheKey, result);
+    }
+    const unresolved = [...pending];
+    for (let offset = 0; offset < unresolved.length; offset += PRIVATE_RESULT_RESOLUTION_CONCURRENCY) {
+      await Promise.all(
+        unresolved.slice(offset, offset + PRIVATE_RESULT_RESOLUTION_CONCURRENCY).map(async ([cacheKey, result]) => {
+          visibilityCache.set(
+            cacheKey,
+            await this.isVisibleSearchResult(result, fallbackStorage, namespaces, preserveUnresolved)
+          );
+        })
+      );
+    }
+    return entries.filter(({ cacheKey }) => visibilityCache.get(cacheKey) === true).map(({ result }) => result);
+  }
+
+  private async isVisibleSearchResult(
+    result: QmdSearchResult,
+    fallbackStorage: StorageManager,
+    namespaces: readonly string[],
+    preserveUnresolved: boolean
+  ): Promise<boolean> {
+    const parts = qmdCollectionPathParts(result.path);
+    const config = this.getConfig();
+    const collectionIsKnownInternal = parts !== null && INTERNAL_QMD_ROOTS.has(parts.collection);
+    const collectionIsConfigured =
+      parts !== null &&
+      (parts.collection === config.qmdCollection ||
+        parts.collection === (config.qmdColdCollection ?? "openclaw-engram-cold") ||
+        this.qmdCollectionNamespaceFromPrefix(parts.collection) !== null);
+    let memory = await this.readQmdResultMemory(result.path, fallbackStorage, namespaces, result.namespace);
+    if (!memory && parts && !collectionIsKnownInternal && !collectionIsConfigured) {
+      memory = await this.readQmdResultMemory(parts.relativePath, fallbackStorage, namespaces, result.namespace);
+    }
+    const absoluteInsideMemoryRoot =
+      path.isAbsolute(result.path) &&
+      isPathInsideStorageRoot(path.resolve(config.memoryDir), path.resolve(result.path));
+    const hasExplicitQmdCollection = result.path.trim().startsWith("qmd://");
+    const unresolvedInternalPath =
+      !memory &&
+      (absoluteInsideMemoryRoot ||
+        (collectionIsKnownInternal && (!preserveUnresolved || hasExplicitQmdCollection)) ||
+        (hasExplicitQmdCollection && collectionIsConfigured));
+    const unresolvedExternalCollection =
+      !memory &&
+      ((parts !== null && !collectionIsKnownInternal && !collectionIsConfigured) ||
+        (path.isAbsolute(result.path) &&
+          !isPathInsideStorageRoot(path.resolve(config.memoryDir), path.resolve(result.path))));
+    return (
+      (memory !== null && !isSupportPassportPrivateMemory(memory)) ||
+      (!memory && !unresolvedInternalPath && (preserveUnresolved || unresolvedExternalCollection))
+    );
+  }
+
   async resolveColdQmdResultForRecall(
     result: QmdSearchResult,
     fallbackStorage: StorageManager,
-    recallNamespaces: readonly string[] = [],
+    recallNamespaces: readonly string[] = []
   ): Promise<{ namespace: string; result: QmdSearchResult } | null> {
-    const memory = await this.readQmdResultMemory(
-      result.path,
-      fallbackStorage,
-      recallNamespaces,
-      result.namespace,
-    );
+    const memory = await this.readQmdResultMemory(result.path, fallbackStorage, recallNamespaces, result.namespace);
     if (!memory) return null;
 
     let ownerNamespace: string | null = null;
     if (path.isAbsolute(memory.path)) {
-      const ownerStorage = await this.storageForAbsoluteQmdResultPath(
-        memory.path,
-        fallbackStorage,
-        recallNamespaces,
-      );
+      const ownerStorage = await this.storageForAbsoluteQmdResultPath(memory.path, fallbackStorage, recallNamespaces);
       ownerNamespace = ownerStorage?.namespace ?? null;
       if (!ownerNamespace && resolveNamespaceCapabilities(this.getConfig()).namespaces) return null;
     }
     ownerNamespace ??= this.namespaceFromPath(memory.path);
-    if (
-      recallNamespaces.length > 0 &&
-      !recallNamespaces.includes(ownerNamespace)
-    ) {
+    if (recallNamespaces.length > 0 && !recallNamespaces.includes(ownerNamespace)) {
       return null;
     }
 
@@ -349,7 +418,7 @@ export class QmdResultResolver {
   async storageForAbsoluteQmdResultPath(
     resultPath: string,
     fallbackStorage: StorageManager,
-    recallNamespaces: readonly string[] = [],
+    recallNamespaces: readonly string[] = []
   ): Promise<{ storage: StorageManager; dir: string; namespace: string } | null> {
     const resolvedPath = path.resolve(resultPath);
     const config = this.getConfig();
@@ -365,10 +434,7 @@ export class QmdResultResolver {
       const candidateRoot = path.resolve(storageDir);
       if (seenDirs.has(candidateRoot)) return;
       if (!isPathInsideStorageRoot(candidateRoot, resolvedPath)) return;
-      if (
-        candidateRoot === memoryRoot &&
-        isPathInsideStorageRoot(namespacesRoot, resolvedPath)
-      ) {
+      if (candidateRoot === memoryRoot && isPathInsideStorageRoot(namespacesRoot, resolvedPath)) {
         return;
       }
       seenDirs.add(candidateRoot);
@@ -376,9 +442,7 @@ export class QmdResultResolver {
     };
 
     const fallbackNamespace =
-      fallbackStorageDir !== null
-        ? this.storageDirNamespace(fallbackStorageDir)
-        : config.defaultNamespace;
+      fallbackStorageDir !== null ? this.storageDirNamespace(fallbackStorageDir) : config.defaultNamespace;
     maybeAddStorage(fallbackStorage, fallbackNamespace);
 
     const candidateNamespaces = new Set<string>();
@@ -391,9 +455,7 @@ export class QmdResultResolver {
       const relativeToNamespaces = path.relative(namespacesRoot, resolvedPath);
       const [namespaceSegment] = relativeToNamespaces.split(/[\\/]/);
       if (namespaceSegment) {
-        candidateNamespaces.add(
-          namespaceIdentityFromToken(namespaceSegment) ?? namespaceSegment,
-        );
+        candidateNamespaces.add(namespaceIdentityFromToken(namespaceSegment) ?? namespaceSegment);
       }
     }
     for (const policy of config.namespacePolicies ?? []) {
@@ -404,9 +466,7 @@ export class QmdResultResolver {
       if (!ns) continue;
       try {
         maybeAddStorage(await this.storageFor(ns), ns);
-      } catch {
-        continue;
-      }
+      } catch {}
     }
 
     matches.sort((a, b) => b.dir.length - a.dir.length);