@remnic/core 9.3.741 → 9.3.742

package/dist/operator-toolkit.js

@@ -13,7 +13,7 @@ import {
   summarizeProvenanceCoverage,
   summarizeTierDistribution,
   summarizeTombstoneStatus
-} from "./chunk-QCO2QFLZ.js";
+} from "./chunk-AM7YKD7V.js";
 import "./chunk-UYYSOMS2.js";
 import "./chunk-7XH7VJN4.js";
 import "./chunk-YBPYIAA5.js";

package/dist/{orchestrator-BOAFN_Yr.d.ts → orchestrator-Dr-1v5EL.d.ts}

@@ -1080,6 +1080,63 @@ declare class RecallRerankCoordinator {
     applyMmrToQmdResults(sectionId: string, results: QmdSearchResult[], caps?: CapabilitySet): QmdSearchResult[];
 }
 
+/**
+ * QMD result resolver — extracted from the orchestrator (issue #1526 seam 11).
+ *
+ * Owns the subsystem that resolves a QMD search-result path back to the
+ * concrete `MemoryFile` (and its owning namespace/storage). Three concerns
+ * live here:
+ *
+ *   - `readQmdResultMemory` — resolve a result path to a `MemoryFile`,
+ *     handling cold-tier collections, namespace-prefixed collections, and
+ *     absolute vs relative paths.
+ *   - `resolveColdQmdResultForRecall` — wrap a result with its owner
+ *     namespace so the recall pipeline can scope-filter candidates.
+ *   - `storageForAbsoluteQmdResultPath` — find the `StorageManager` whose
+ *     directory tree contains an absolute result path.
+ *
+ * Behavior-preserving move from orchestrator.ts — no logic changes. The
+ * orchestrator constructs one instance and keeps thin delegating methods so
+ * existing call sites (recallInternal, applyColdFallbackPipeline,
+ * loadSearchResultMemoryMap, suggestLinksForMemory, and the
+ * RecallRerankCoordinator callback) continue to work.
+ *
+ * Config, the storage router, and the orchestrator's namespace-resolution
+ * helpers are accessed through getter callbacks (not captured at
+ * construction) so that post-construction reassignment of the
+ * orchestrator's live fields is honored. This mirrors the
+ * RecallRerankCoordinator / ConversationIndexCoordinator accessor pattern.
+ */
+
+/**
+ * Coordinator for resolving QMD search-result paths to concrete memory
+ * files and their owning namespace/storage.
+ */
+declare class QmdResultResolver {
+    private readonly getConfig;
+    private readonly storageFor;
+    private readonly storageDirNamespace;
+    private readonly qmdCollectionNamespaceFromPrefix;
+    private readonly namespaceFromPath;
+    constructor(options: {
+        getConfig: () => PluginConfig;
+        storageFor: (namespace: string) => Promise<StorageManager>;
+        storageDirNamespace: (storageDir: string) => string;
+        qmdCollectionNamespaceFromPrefix: (collectionPrefix: string) => string | null;
+        namespaceFromPath: (p: string) => string;
+    });
+    readQmdResultMemory(resultPath: string, fallbackStorage: StorageManager, recallNamespaces?: readonly string[]): Promise<MemoryFile | null>;
+    resolveColdQmdResultForRecall(result: QmdSearchResult, fallbackStorage: StorageManager, recallNamespaces?: readonly string[]): Promise<{
+        namespace: string;
+        result: QmdSearchResult;
+    } | null>;
+    storageForAbsoluteQmdResultPath(resultPath: string, fallbackStorage: StorageManager, recallNamespaces?: readonly string[]): Promise<{
+        storage: StorageManager;
+        dir: string;
+        namespace: string;
+    } | null>;
+}
+
 /**
  * Pattern-reinforcement maintenance job (issue #687 PR 2/4).
  *
@@ -1672,6 +1729,7 @@ declare class Orchestrator {
      */
     readonly conversationIndexCoordinator: ConversationIndexCoordinator;
     readonly recallRerankCoordinator: RecallRerankCoordinator;
+    readonly qmdResultResolver: QmdResultResolver;
     private heartbeatObserverChains;
     private recentExtractionFingerprints;
     private readonly consolidationObservers;

package/dist/orchestrator.d.ts

@@ -8,7 +8,7 @@ import './summarizer.js';
 import './local-llm.js';
 import './fallback-llm.js';
 import './orchestration/maintenance.js';
-export { L as BulkImportBatchIngestResult, M as BulkImportBatchPartialFailureError, N as GraphRecallRankedResult, Q as GraphRecallShadowComparison, G as GraphRecallSnapshot, I as IntentDebugSnapshot, O as Orchestrator, T as QmdRecallSnapshot, U as RecallInvocationOptions, V as RecallModeDecision, X as appendMemoryToGraphContext, Y as blendGraphExpandedRecallScore, Z as buildCompressionGuidelinesMarkdown, _ as buildMemoryPathById, $ as computeArtifactCandidateFetchLimit, a0 as computeArtifactRecallLimit, a1 as computeQmdHybridFetchLimit, q as defaultWorkspaceDir, a2 as deriveTopicsFromExtraction, a3 as filterRecallCandidates, a4 as graphPathRelativeToStorage, a5 as hasIdentityRecoveryIntent, a6 as isArtifactMemoryPath, a7 as lifecycleRecallScoreAdjustment, a8 as mergeArtifactRecallCandidates, a9 as mergeGraphExpandedResults, aa as resolveEffectiveIdentityInjectionMode, ab as resolveEffectiveRecallMode, ac as resolvePersistedMemoryRelativePath, ad as resolveRecallModeDecision, ae as resolveRecallModeDecisionAsync, af as resolveRecentThreadMemoryPaths, A as sanitizeSessionKeyForFilename, ag as shouldFilterLifecycleRecallCandidate, ah as summarizeGraphShadowComparison } from './orchestrator-BOAFN_Yr.js';
+export { L as BulkImportBatchIngestResult, M as BulkImportBatchPartialFailureError, N as GraphRecallRankedResult, Q as GraphRecallShadowComparison, G as GraphRecallSnapshot, I as IntentDebugSnapshot, O as Orchestrator, T as QmdRecallSnapshot, U as RecallInvocationOptions, V as RecallModeDecision, X as appendMemoryToGraphContext, Y as blendGraphExpandedRecallScore, Z as buildCompressionGuidelinesMarkdown, _ as buildMemoryPathById, $ as computeArtifactCandidateFetchLimit, a0 as computeArtifactRecallLimit, a1 as computeQmdHybridFetchLimit, q as defaultWorkspaceDir, a2 as deriveTopicsFromExtraction, a3 as filterRecallCandidates, a4 as graphPathRelativeToStorage, a5 as hasIdentityRecoveryIntent, a6 as isArtifactMemoryPath, a7 as lifecycleRecallScoreAdjustment, a8 as mergeArtifactRecallCandidates, a9 as mergeGraphExpandedResults, aa as resolveEffectiveIdentityInjectionMode, ab as resolveEffectiveRecallMode, ac as resolvePersistedMemoryRelativePath, ad as resolveRecallModeDecision, ae as resolveRecallModeDecisionAsync, af as resolveRecentThreadMemoryPaths, A as sanitizeSessionKeyForFilename, ag as shouldFilterLifecycleRecallCandidate, ah as summarizeGraphShadowComparison } from './orchestrator-Dr-1v5EL.js';
 export { formatCompressionGuidelinesForRecall } from './orchestration/compression-guideline-coordinator.js';
 import './live-connectors-runner.js';
 import './model-registry.js';

package/dist/orchestrator.js

@@ -26,8 +26,8 @@ import {
   sanitizeSessionKeyForFilename,
   shouldFilterLifecycleRecallCandidate,
   summarizeGraphShadowComparison
-} from "./chunk-VC7QELR6.js";
-import "./chunk-OZECYVGI.js";
+} from "./chunk-7HUGLMSW.js";
+import "./chunk-C7LDPZJJ.js";
 import {
   formatCompressionGuidelinesForRecall
 } from "./chunk-WIMKOTNY.js";
@@ -38,12 +38,12 @@ import "./chunk-7HYPN2GC.js";
 import "./chunk-666A3MOW.js";
 import "./chunk-HHLLAQGZ.js";
 import "./chunk-UWK5OXUJ.js";
-import "./chunk-773DPI6T.js";
+import "./chunk-V5RVMULT.js";
 import "./chunk-7N4KAIGN.js";
 import "./chunk-TPDBFYEG.js";
 import "./chunk-KCYE2MZM.js";
 import "./chunk-KYYL4U6X.js";
-import "./chunk-XPOOY35N.js";
+import "./chunk-W4H5A3TJ.js";
 import "./chunk-HW5EF6LV.js";
 import "./chunk-TECVW3JP.js";
 import "./chunk-O7GOFAM3.js";

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@remnic/core",
-  "version": "9.3.741",
+  "version": "9.3.742",
   "description": "Framework-agnostic Remnic memory engine — orchestrator, storage, extraction, search, trust zones",
   "type": "module",
   "main": "dist/index.js",
@@ -3000,7 +3000,7 @@
     "core"
   ],
   "peerDependencies": {
-    "@remnic/coding-graph": "^9.3.741"
+    "@remnic/coding-graph": "^9.3.742"
   },
   "peerDependenciesMeta": {
     "@remnic/coding-graph": {

package/src/cli.ts

@@ -2430,9 +2430,10 @@ export async function runPolicyStatusCliCommand(
   const defaultWindowMs = Math.max(0, orchestrator.config.behaviorLoopLearningWindowDays) * 24 * 60 * 60 * 1000;
   const cutoffIso = defaultWindowMs > 0 ? new Date(now.getTime() - defaultWindowMs).toISOString() : undefined;
 
+  const { behaviorLoopAutoTuneEnabled } = orchestrator.config;
   return {
     generatedAt: now.toISOString(),
-    autoTuneEnabled: orchestrator.config.behaviorLoopAutoTuneEnabled,
+    autoTuneEnabled: behaviorLoopAutoTuneEnabled,
     current: current
       ? {
         ...current,

package/src/graph-recall.ts

@@ -110,7 +110,8 @@ export function runGraphRecall(
   config: GraphRecallConfig,
   options: GraphRecallOptions,
 ): GraphRecallRun {
-  if (!config.recallGraphEnabled) {
+  const { recallGraphEnabled } = config;
+  if (!recallGraphEnabled) {
     return {
       ran: false,
       results: [],

package/src/lcm/engine.ts

@@ -117,6 +117,7 @@ export class LcmEngine {
     const db = openLcmDatabase(this.memoryDir);
     const archive = new LcmArchive(db);
     const dag = new LcmDag(db);
+    const { telemetryPrefilterEnabled } = this.config;
     const summarizer = new LcmSummarizer(
       archive,
       dag,
@@ -126,7 +127,7 @@ export class LcmEngine {
         rollupFanIn: this.config.rollupFanIn,
         maxDepth: this.config.maxDepth,
         deterministicMaxTokens: this.config.deterministicMaxTokens,
-        telemetryPrefilterEnabled: this.config.telemetryPrefilterEnabled,
+        telemetryPrefilterEnabled,
       },
     );
     const observeQueue = new LcmWorkQueue({
@@ -229,17 +230,18 @@ export class LcmEngine {
     if (messages.length === 0) return;
 
     const currentMax = this.archive.getMaxTurnIndex(sessionId);
+    const { messagePartsEnabled } = this.config;
     const newMessages = messages.map((m, i) => ({
       turnIndex: currentMax + 1 + i,
       role: m.role,
       content: m.content,
-      parts: this.config.messagePartsEnabled ? m.parts : undefined,
-      rawContent: this.config.messagePartsEnabled ? m.rawContent : undefined,
-      sourceFormat: this.config.messagePartsEnabled ? m.sourceFormat : undefined,
+      parts: messagePartsEnabled ? m.parts : undefined,
+      rawContent: messagePartsEnabled ? m.rawContent : undefined,
+      sourceFormat: messagePartsEnabled ? m.sourceFormat : undefined,
     }));
 
     this.archive.appendMessages(sessionId, newMessages, {
-      messagePartsEnabled: this.config.messagePartsEnabled,
+      messagePartsEnabled,
     });
 
     // Trigger incremental summarization inside the worker, after append.
@@ -346,7 +348,8 @@ export class LcmEngine {
     query: string,
     limit = this.config.messagePartsRecallMaxResults,
   ): Promise<LcmStructuredRecallMatch[]> {
-    if (!this.config.enabled || !this.config.messagePartsEnabled) return [];
+    const { messagePartsEnabled } = this.config;
+    if (!this.config.enabled || !messagePartsEnabled) return [];
     const normalizedSessionId = normalizeLcmSessionId(sessionId);
     if (!normalizedSessionId) return [];
     await this.ensureInitialized();

package/src/lcm/summarizer.ts

@@ -153,8 +153,9 @@ export class LcmSummarizer {
     text: string,
     targetTokens: number,
   ): Promise<{ text: string; escalation: number }> {
+    const { telemetryPrefilterEnabled } = this.config;
     if (
-      this.config.telemetryPrefilterEnabled &&
+      telemetryPrefilterEnabled &&
       looksLikeMechanicalTelemetryTranscript(text)
     ) {
       return {

package/src/operator-toolkit.ts

@@ -1617,7 +1617,8 @@ async function summarizeGraphEdgeDecayStatus(
 ): Promise<OperatorDoctorCheck> {
   // Lazy import to keep the doctor fast when the feature is disabled.
   const { readGraphEdgeDecayStatus } = await import("./maintenance/graph-edge-decay.js");
-  const enabled = config.graphEdgeDecayEnabled === true;
+  const { graphEdgeDecayEnabled } = config;
+  const enabled = graphEdgeDecayEnabled === true;
   if (!enabled) {
     return {
       key: "graph_edge_decay",

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

@@ -0,0 +1,377 @@
+/**
+ * QMD result resolver — extracted from the orchestrator (issue #1526 seam 11).
+ *
+ * Owns the subsystem that resolves a QMD search-result path back to the
+ * concrete `MemoryFile` (and its owning namespace/storage). Three concerns
+ * live here:
+ *
+ *   - `readQmdResultMemory` — resolve a result path to a `MemoryFile`,
+ *     handling cold-tier collections, namespace-prefixed collections, and
+ *     absolute vs relative paths.
+ *   - `resolveColdQmdResultForRecall` — wrap a result with its owner
+ *     namespace so the recall pipeline can scope-filter candidates.
+ *   - `storageForAbsoluteQmdResultPath` — find the `StorageManager` whose
+ *     directory tree contains an absolute result path.
+ *
+ * Behavior-preserving move from orchestrator.ts — no logic changes. The
+ * orchestrator constructs one instance and keeps thin delegating methods so
+ * existing call sites (recallInternal, applyColdFallbackPipeline,
+ * loadSearchResultMemoryMap, suggestLinksForMemory, and the
+ * RecallRerankCoordinator callback) continue to work.
+ *
+ * Config, the storage router, and the orchestrator's namespace-resolution
+ * helpers are accessed through getter callbacks (not captured at
+ * construction) so that post-construction reassignment of the
+ * orchestrator's live fields is honored. This mirrors the
+ * RecallRerankCoordinator / ConversationIndexCoordinator accessor pattern.
+ */
+
+import path from "node:path";
+import { log } from "../logger.js";
+import { isPathInsideStorageRoot } from "../storage-paths.js";
+import { namespaceIdentityFromToken } from "../namespaces/identity.js";
+import { resolveNamespaceCapabilities } from "../capabilities.js";
+import { SecureStoreLockedError } from "../secure-store/index.js";
+import type { PluginConfig, QmdSearchResult, MemoryFile } from "../types.js";
+import type { StorageManager } from "../index.js";
+
+/**
+ * Split a relative QMD result path into its collection prefix and the
+ * remainder. Returns `null` for absolute paths, date-only prefixes, or
+ * paths with no collection separator.
+ */
+export function qmdCollectionPathParts(resultPath: string): {
+  collection: string;
+  relativePath: string;
+} | null {
+  if (!resultPath || path.isAbsolute(resultPath)) return null;
+  const normalized = resultPath.replace(/\\/g, "/").replace(/^\/+/, "");
+  const slashIndex = normalized.indexOf("/");
+  if (slashIndex <= 0 || slashIndex >= normalized.length - 1) return null;
+  const collection = normalized.slice(0, slashIndex);
+  if (/^\d{4}-\d{2}-\d{2}$/.test(collection)) return null;
+  return {
+    collection,
+    relativePath: normalized.slice(slashIndex + 1),
+  };
+}
+
+/**
+ * Build the set of on-disk candidate paths to probe for a QMD result,
+ * constrained to the storage root so a result path can never escape the
+ * namespace directory.
+ */
+export function qmdResultPathCandidates(
+  storageDir: string,
+  resultPath: string,
+): string[] {
+  const candidates = new Set<string>();
+  const storageRoot = path.resolve(storageDir);
+  const addCandidate = (candidate: string) => {
+    const resolved = path.resolve(candidate);
+    if (isPathInsideStorageRoot(storageRoot, resolved)) {
+      candidates.add(resolved);
+    }
+  };
+  const addRelativeCandidates = (relativePath: string) => {
+    const normalized = relativePath.replace(/\\/g, "/").replace(/^\/+/, "");
+    if (!normalized) return;
+    addCandidate(path.join(storageRoot, normalized));
+    if (/^\d{4}-\d{2}-\d{2}\//.test(normalized)) {
+      addCandidate(path.join(storageRoot, "facts", normalized));
+    }
+  };
+
+  if (path.isAbsolute(resultPath)) {
+    addCandidate(resultPath);
+  } else {
+    addRelativeCandidates(resultPath);
+  }
+
+  return [...candidates];
+}
+
+/**
+ * Extract a non-empty `dir` from a storage, returning `null` when the
+ * property is absent or not a non-empty string at runtime. Proxy-backed
+ * fake storages used in recall paths may not provide a real `dir`, so
+ * every caller must handle the null case (skip or fall back to a direct
+ * `readMemoryByPath`).
+ */
+function storageDirOrNull(storage: StorageManager): string | null {
+  const dir = storage.dir;
+  return typeof dir === "string" && dir.length > 0 ? dir : null;
+}
+
+/**
+ * Coordinator for resolving QMD search-result paths to concrete memory
+ * files and their owning namespace/storage.
+ */
+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 namespaceFromPath: (p: string) => string;
+
+  constructor(options: {
+    getConfig: () => PluginConfig;
+    storageFor: (namespace: string) => Promise<StorageManager>;
+    storageDirNamespace: (storageDir: string) => string;
+    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.namespaceFromPath = options.namespaceFromPath;
+  }
+
+  async readQmdResultMemory(
+    resultPath: string,
+    fallbackStorage: StorageManager,
+    recallNamespaces: readonly string[] = [],
+  ): Promise<MemoryFile | null> {
+    const parts = qmdCollectionPathParts(resultPath);
+    const fallbackStorageDir = storageDirOrNull(fallbackStorage);
+    const config = this.getConfig();
+    const coldCollection = config.qmdColdCollection ?? "openclaw-engram-cold";
+    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}`;
+        if (seenStorageDirs.has(storageKey)) return;
+        seenStorageDirs.add(storageKey);
+        storages.push(storage);
+      };
+
+      const fallbackNamespace =
+        fallbackStorageDir !== null
+          ? this.storageDirNamespace(fallbackStorageDir)
+          : config.defaultNamespace;
+      if (
+        recallNamespaces.length === 0 ||
+        !resolveNamespaceCapabilities(config).namespaces ||
+        recallNamespaces.includes(fallbackNamespace)
+      ) {
+        addStorage(fallbackStorage);
+      }
+
+      if (recallNamespaces.length > 0) {
+        for (const namespace of recallNamespaces) {
+          try {
+            addStorage(await this.storageFor(namespace));
+          } catch (err) {
+            log.debug("qmd cold result namespace storage lookup skipped", {
+              path: resultPath,
+              namespace,
+              error: (err as Error).message,
+            });
+          }
+        }
+      }
+
+      for (const storage of storages) {
+        const storageDir = storageDirOrNull(storage);
+        if (!storageDir) {
+          const memory = await storage.readMemoryByPath(resultPath);
+          if (memory) return memory;
+          continue;
+        }
+        try {
+          const coldRoot = path.join(storageDir, "cold");
+          for (const candidate of qmdResultPathCandidates(
+            coldRoot,
+            parts.relativePath,
+          )) {
+            const memory = await storage.readMemoryByPath(candidate);
+            if (memory) return memory;
+          }
+        } catch (err) {
+          if (err instanceof SecureStoreLockedError) throw err;
+          log.debug("qmd cold result path lookup failed open", {
+            path: resultPath,
+            collection: coldCollection,
+            error: (err as Error).message,
+          });
+        }
+      }
+      return 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,
+        )) {
+          const memory = await collectionStorage.readMemoryByPath(candidate);
+          if (memory) return memory;
+        }
+        return null;
+      } catch (err) {
+        if (err instanceof SecureStoreLockedError) throw err;
+        log.debug("qmd result namespace path lookup failed open", {
+          path: resultPath,
+          namespace: collectionNamespace,
+          error: (err as Error).message,
+        });
+        return null;
+      }
+    }
+
+    if (path.isAbsolute(resultPath)) {
+      if (!fallbackStorageDir) {
+        return await fallbackStorage.readMemoryByPath(resultPath);
+      }
+      const ownerStorage = await this.storageForAbsoluteQmdResultPath(
+        resultPath,
+        fallbackStorage,
+        recallNamespaces,
+      );
+      if (!ownerStorage) return null;
+      for (const candidate of qmdResultPathCandidates(
+        ownerStorage.dir,
+        resultPath,
+      )) {
+        const memory = await ownerStorage.storage.readMemoryByPath(candidate);
+        if (memory) return memory;
+      }
+      return null;
+    }
+
+    if (!fallbackStorageDir) {
+      return await fallbackStorage.readMemoryByPath(resultPath);
+    }
+    for (const candidate of qmdResultPathCandidates(
+      fallbackStorageDir,
+      resultPath,
+    )) {
+      const memory = await fallbackStorage.readMemoryByPath(candidate);
+      if (memory) return memory;
+    }
+    return null;
+  }
+
+  async resolveColdQmdResultForRecall(
+    result: QmdSearchResult,
+    fallbackStorage: StorageManager,
+    recallNamespaces: readonly string[] = [],
+  ): Promise<{ namespace: string; result: QmdSearchResult } | null> {
+    const memory = await this.readQmdResultMemory(
+      result.path,
+      fallbackStorage,
+      recallNamespaces,
+    );
+    if (!memory) return null;
+
+    let ownerNamespace: string | null = null;
+    if (path.isAbsolute(memory.path)) {
+      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)
+    ) {
+      return null;
+    }
+
+    return {
+      namespace: ownerNamespace,
+      result: {
+        ...result,
+        docid: result.docid || memory.frontmatter.id,
+        path: memory.path,
+        snippet: result.snippet || memory.content.slice(0, 400),
+      },
+    };
+  }
+
+  async storageForAbsoluteQmdResultPath(
+    resultPath: string,
+    fallbackStorage: StorageManager,
+    recallNamespaces: readonly string[] = [],
+  ): Promise<{ storage: StorageManager; dir: string; namespace: string } | null> {
+    const resolvedPath = path.resolve(resultPath);
+    const config = this.getConfig();
+    const memoryRoot = path.resolve(config.memoryDir);
+    const namespacesRoot = path.join(memoryRoot, "namespaces");
+    const fallbackStorageDir = storageDirOrNull(fallbackStorage);
+    const matches: Array<{ storage: StorageManager; dir: string; namespace: string }> = [];
+    const seenDirs = new Set<string>();
+
+    const maybeAddStorage = (storage: StorageManager, namespace: string) => {
+      const storageDir = storageDirOrNull(storage);
+      if (!storageDir) return;
+      const candidateRoot = path.resolve(storageDir);
+      if (seenDirs.has(candidateRoot)) return;
+      if (!isPathInsideStorageRoot(candidateRoot, resolvedPath)) return;
+      if (
+        candidateRoot === memoryRoot &&
+        isPathInsideStorageRoot(namespacesRoot, resolvedPath)
+      ) {
+        return;
+      }
+      seenDirs.add(candidateRoot);
+      matches.push({ storage, dir: candidateRoot, namespace });
+    };
+
+    const fallbackNamespace =
+      fallbackStorageDir !== null
+        ? this.storageDirNamespace(fallbackStorageDir)
+        : config.defaultNamespace;
+    maybeAddStorage(fallbackStorage, fallbackNamespace);
+
+    const candidateNamespaces = new Set<string>();
+    candidateNamespaces.add(config.defaultNamespace);
+    candidateNamespaces.add(config.sharedNamespace);
+    for (const ns of recallNamespaces) {
+      candidateNamespaces.add(ns);
+    }
+    if (isPathInsideStorageRoot(namespacesRoot, resolvedPath)) {
+      const relativeToNamespaces = path.relative(namespacesRoot, resolvedPath);
+      const [namespaceSegment] = relativeToNamespaces.split(/[\\/]/);
+      if (namespaceSegment) {
+        candidateNamespaces.add(
+          namespaceIdentityFromToken(namespaceSegment) ?? namespaceSegment,
+        );
+      }
+    }
+    for (const policy of config.namespacePolicies ?? []) {
+      candidateNamespaces.add(policy.name);
+    }
+
+    for (const ns of candidateNamespaces) {
+      if (!ns) continue;
+      try {
+        maybeAddStorage(await this.storageFor(ns), ns);
+      } catch {
+        continue;
+      }
+    }
+
+    matches.sort((a, b) => b.dir.length - a.dir.length);
+    return matches[0] ?? null;
+  }
+}