@remnic/core 9.3.741 → 9.3.742

package/dist/{chunk-VC7QELR6.js → chunk-7HUGLMSW.js}

@@ -4,7 +4,7 @@ import {
   loadSyncState,
   syncWearableSource,
   wearableSourceLabel
-} from "./chunk-OZECYVGI.js";
+} from "./chunk-C7LDPZJJ.js";
 import {
   CompressionGuidelineCoordinator
 } from "./chunk-WIMKOTNY.js";
@@ -19,7 +19,7 @@ import {
 } from "./chunk-7HYPN2GC.js";
 import {
   LcmEngine
-} from "./chunk-773DPI6T.js";
+} from "./chunk-V5RVMULT.js";
 import {
   chunkTranscriptEntries
 } from "./chunk-TECVW3JP.js";
@@ -512,7 +512,7 @@ import {
 } from "./chunk-PVGDJXVK.js";
 
 // src/orchestrator.ts
-import path5 from "path";
+import path6 from "path";
 import os2 from "os";
 import { createHash as createHash2, randomBytes } from "crypto";
 import { existsSync, readFileSync } from "fs";
@@ -2196,7 +2196,7 @@ var RecallRerankCoordinator = class _RecallRerankCoordinator {
           nsMap = buildMemoryWorthCounterMap(memories);
           this.memoryWorthCounterCache.set(ns, { at: nowMs, counters: nsMap });
         }
-        for (const [path6, c] of nsMap) counters.set(path6, c);
+        for (const [path7, c] of nsMap) counters.set(path7, c);
       } catch (err) {
         log.debug("memory-worth: failed to read namespace, skipping", {
           namespace: ns,
@@ -2281,7 +2281,7 @@ var RecallRerankCoordinator = class _RecallRerankCoordinator {
       namespaces,
       {
         readNamespaceMemories: async (ns) => (await this.getStorage(ns)).readAllMemories(),
-        readMemoryFrontmatter: async (path6) => {
+        readMemoryFrontmatter: async (path7) => {
           if (!fallbackReader) {
             for (const ns of namespaces) {
               try {
@@ -2292,7 +2292,7 @@ var RecallRerankCoordinator = class _RecallRerankCoordinator {
             }
           }
           if (!fallbackReader) return null;
-          const memory = await this.readQmdResultMemory(path6, fallbackReader, namespaces);
+          const memory = await this.readQmdResultMemory(path7, fallbackReader, namespaces);
           return memory ? memory.frontmatter : null;
         }
       },
@@ -2391,6 +2391,257 @@ var RecallRerankCoordinator = class _RecallRerankCoordinator {
   }
 };
 
+// src/orchestration/qmd-result-resolver.ts
+import path4 from "path";
+function qmdCollectionPathParts(resultPath) {
+  if (!resultPath || path4.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)
+  };
+}
+function qmdResultPathCandidates(storageDir, resultPath) {
+  const candidates = /* @__PURE__ */ new Set();
+  const storageRoot = path4.resolve(storageDir);
+  const addCandidate = (candidate) => {
+    const resolved = path4.resolve(candidate);
+    if (isPathInsideStorageRoot(storageRoot, resolved)) {
+      candidates.add(resolved);
+    }
+  };
+  const addRelativeCandidates = (relativePath) => {
+    const normalized = relativePath.replace(/\\/g, "/").replace(/^\/+/, "");
+    if (!normalized) return;
+    addCandidate(path4.join(storageRoot, normalized));
+    if (/^\d{4}-\d{2}-\d{2}\//.test(normalized)) {
+      addCandidate(path4.join(storageRoot, "facts", normalized));
+    }
+  };
+  if (path4.isAbsolute(resultPath)) {
+    addCandidate(resultPath);
+  } else {
+    addRelativeCandidates(resultPath);
+  }
+  return [...candidates];
+}
+function storageDirOrNull(storage) {
+  const dir = storage.dir;
+  return typeof dir === "string" && dir.length > 0 ? dir : null;
+}
+var QmdResultResolver = class {
+  getConfig;
+  storageFor;
+  storageDirNamespace;
+  qmdCollectionNamespaceFromPrefix;
+  namespaceFromPath;
+  constructor(options) {
+    this.getConfig = options.getConfig;
+    this.storageFor = options.storageFor;
+    this.storageDirNamespace = options.storageDirNamespace;
+    this.qmdCollectionNamespaceFromPrefix = options.qmdCollectionNamespaceFromPrefix;
+    this.namespaceFromPath = options.namespaceFromPath;
+  }
+  async readQmdResultMemory(resultPath, fallbackStorage, recallNamespaces = []) {
+    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 = [];
+      const seenStorageDirs = /* @__PURE__ */ new Set();
+      const addStorage = (storage) => {
+        const storageDir = storageDirOrNull(storage);
+        const storageKey = storageDir ? path4.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.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 = path4.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.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.message
+        });
+        return null;
+      }
+    }
+    if (path4.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, fallbackStorage, recallNamespaces = []) {
+    const memory = await this.readQmdResultMemory(
+      result.path,
+      fallbackStorage,
+      recallNamespaces
+    );
+    if (!memory) return null;
+    let ownerNamespace = null;
+    if (path4.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, fallbackStorage, recallNamespaces = []) {
+    const resolvedPath = path4.resolve(resultPath);
+    const config = this.getConfig();
+    const memoryRoot = path4.resolve(config.memoryDir);
+    const namespacesRoot = path4.join(memoryRoot, "namespaces");
+    const fallbackStorageDir = storageDirOrNull(fallbackStorage);
+    const matches = [];
+    const seenDirs = /* @__PURE__ */ new Set();
+    const maybeAddStorage = (storage, namespace) => {
+      const storageDir = storageDirOrNull(storage);
+      if (!storageDir) return;
+      const candidateRoot = path4.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 = /* @__PURE__ */ new Set();
+    candidateNamespaces.add(config.defaultNamespace);
+    candidateNamespaces.add(config.sharedNamespace);
+    for (const ns of recallNamespaces) {
+      candidateNamespaces.add(ns);
+    }
+    if (isPathInsideStorageRoot(namespacesRoot, resolvedPath)) {
+      const relativeToNamespaces = path4.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;
+  }
+};
+
 // src/maintenance/pattern-reinforcement.ts
 function patternReinforcementKey(content) {
   return content.trim().toLowerCase().replace(/\s+/g, " ").slice(0, 200);
@@ -2724,7 +2975,7 @@ function generateResolverDocument(taxonomy) {
 
 // src/taxonomy/taxonomy-loader.ts
 import { readFile, mkdir as mkdir2, writeFile as writeFile2 } from "fs/promises";
-import path4 from "path";
+import path5 from "path";
 var TAXONOMY_DIR = ".taxonomy";
 var TAXONOMY_FILE = "taxonomy.json";
 var MAX_SLUG_LENGTH = 32;
@@ -2822,7 +3073,7 @@ function validateTaxonomy(taxonomy) {
   }
 }
 async function loadTaxonomy(memoryDir) {
-  const taxonomyPath = path4.join(memoryDir, TAXONOMY_DIR, TAXONOMY_FILE);
+  const taxonomyPath = path5.join(memoryDir, TAXONOMY_DIR, TAXONOMY_FILE);
   let raw;
   try {
     raw = await readFile(taxonomyPath, "utf-8");
@@ -2872,16 +3123,16 @@ async function loadTaxonomy(memoryDir) {
 }
 async function saveTaxonomy(memoryDir, taxonomy) {
   validateTaxonomy(taxonomy);
-  const dir = path4.join(memoryDir, TAXONOMY_DIR);
+  const dir = path5.join(memoryDir, TAXONOMY_DIR);
   await mkdir2(dir, { recursive: true });
-  const filePath = path4.join(dir, TAXONOMY_FILE);
+  const filePath = path5.join(dir, TAXONOMY_FILE);
   await writeFile2(filePath, JSON.stringify(taxonomy, null, 2) + "\n", "utf-8");
 }
 function getTaxonomyDir(memoryDir) {
-  return path4.join(memoryDir, TAXONOMY_DIR);
+  return path5.join(memoryDir, TAXONOMY_DIR);
 }
 function getTaxonomyFilePath(memoryDir) {
-  return path4.join(memoryDir, TAXONOMY_DIR, TAXONOMY_FILE);
+  return path5.join(memoryDir, TAXONOMY_DIR, TAXONOMY_FILE);
 }
 
 // src/wearables/registry.ts
@@ -3781,42 +4032,6 @@ async function raceRecallAbort(promise, signal, message = "recall aborted") {
     }
   }
 }
-function qmdCollectionPathParts(resultPath) {
-  if (!resultPath || path5.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)
-  };
-}
-function qmdResultPathCandidates(storageDir, resultPath) {
-  const candidates = /* @__PURE__ */ new Set();
-  const storageRoot = path5.resolve(storageDir);
-  const addCandidate = (candidate) => {
-    const resolved = path5.resolve(candidate);
-    if (isPathInsideStorageRoot(storageRoot, resolved)) {
-      candidates.add(resolved);
-    }
-  };
-  const addRelativeCandidates = (relativePath) => {
-    const normalized = relativePath.replace(/\\/g, "/").replace(/^\/+/, "");
-    if (!normalized) return;
-    addCandidate(path5.join(storageRoot, normalized));
-    if (/^\d{4}-\d{2}-\d{2}\//.test(normalized)) {
-      addCandidate(path5.join(storageRoot, "facts", normalized));
-    }
-  };
-  if (path5.isAbsolute(resultPath)) {
-    addCandidate(resultPath);
-  } else {
-    addRelativeCandidates(resultPath);
-  }
-  return [...candidates];
-}
 var COMPACTION_SIGNAL_MAX_AGE_MS = 60 * 60 * 1e3;
 var DEFAULT_QMD_STARTUP_COLLECTION_CHECK_TIMEOUT_MS = 1e4;
 function normalizeIanaTimeZone(value) {
@@ -3927,7 +4142,7 @@ async function qmdStartupCollectionCheckWithTimeout(promise, controller, label)
   return await Promise.race([checkedPromise, timeoutPromise]);
 }
 function defaultWorkspaceDir() {
-  return path5.join(os2.homedir(), ".openclaw", "workspace");
+  return path6.join(os2.homedir(), ".openclaw", "workspace");
 }
 function sanitizeSessionKeyForFilename(sessionKey) {
   const readable = sessionKey.replace(/[^a-zA-Z0-9._-]/g, "_");
@@ -4204,11 +4419,11 @@ function mergeGraphExpandedResults(primary, expanded) {
   return Array.from(mergedByPath.values());
 }
 function graphPathRelativeToStorage(storageDir, candidatePath) {
-  const absolutePath = path5.isAbsolute(candidatePath) ? candidatePath : path5.resolve(storageDir, candidatePath);
-  const rel = path5.relative(storageDir, absolutePath);
+  const absolutePath = path6.isAbsolute(candidatePath) ? candidatePath : path6.resolve(storageDir, candidatePath);
+  const rel = path6.relative(storageDir, absolutePath);
   if (!rel || rel === ".") return null;
   if (rel.startsWith("..")) return null;
-  return rel.split(path5.sep).join("/");
+  return rel.split(path6.sep).join("/");
 }
 function normalizeGraphActivationScore(score) {
   const bounded = Number.isFinite(score) && score > 0 ? score : 0;
@@ -4353,7 +4568,7 @@ function buildMemoryPathById(allMemsForGraph, storageDir) {
   for (const mem of allMemsForGraph ?? []) {
     const id = mem.frontmatter.id;
     if (!id) continue;
-    pathById.set(id, path5.relative(storageDir, mem.path));
+    pathById.set(id, path6.relative(storageDir, mem.path));
   }
   return pathById;
 }
@@ -4361,7 +4576,7 @@ function appendMemoryToGraphContext(options) {
   if (!Array.isArray(options.allMemsForGraph)) return;
   const nowIso = (/* @__PURE__ */ new Date()).toISOString();
   options.allMemsForGraph.push({
-    path: path5.join(options.storageDir, options.memoryRelPath),
+    path: path6.join(options.storageDir, options.memoryRelPath),
     content: options.content,
     frontmatter: {
       id: options.memoryId,
@@ -4381,16 +4596,16 @@ function resolvePersistedMemoryRelativePath(options) {
   const persisted = options.pathById.get(options.memoryId);
   if (persisted) return persisted;
   if (options.category === "correction") {
-    return path5.join("corrections", `${options.memoryId}.md`);
+    return path6.join("corrections", `${options.memoryId}.md`);
   }
   const subtree = categoryDirName(options.category);
   const idParts = options.memoryId.split("-");
   const maybeTimestamp = Number(idParts[1]);
   if (Number.isFinite(maybeTimestamp) && maybeTimestamp > 0) {
     const day = new Date(maybeTimestamp).toISOString().slice(0, 10);
-    return path5.join(subtree, day, `${options.memoryId}.md`);
+    return path6.join(subtree, day, `${options.memoryId}.md`);
   }
-  return path5.join(subtree, `${options.memoryId}.md`);
+  return path6.join(subtree, `${options.memoryId}.md`);
 }
 var Orchestrator = class _Orchestrator {
   storage;
@@ -4552,6 +4767,7 @@ var Orchestrator = class _Orchestrator {
    */
   conversationIndexCoordinator;
   recallRerankCoordinator;
+  qmdResultResolver;
   heartbeatObserverChains = /* @__PURE__ */ new Map();
   recentExtractionFingerprints = /* @__PURE__ */ new Map();
   consolidationObservers = /* @__PURE__ */ new Set();
@@ -4844,7 +5060,7 @@ var Orchestrator = class _Orchestrator {
     const defaultNs = normalizeNamespaceIdentity(this.config.defaultNamespace);
     if (ns !== defaultNs && !isSafeRouteNamespace(ns)) return;
     if (!this.storageDirMatchesNamespaceHint(ns, storageDir)) return;
-    const resolvedStorageDir = path5.resolve(storageDir);
+    const resolvedStorageDir = path6.resolve(storageDir);
     let hints = this.namespaceStorageDirHints.get(resolvedStorageDir);
     if (!hints) {
       hints = /* @__PURE__ */ new Set();
@@ -4855,21 +5071,21 @@ var Orchestrator = class _Orchestrator {
   storageDirMatchesNamespaceHint(namespace, storageDir) {
     const ns = normalizeNamespaceIdentity(namespace);
     if (!ns) return false;
-    const resolvedStorageDir = path5.resolve(storageDir);
-    const resolvedMemoryDir = path5.resolve(this.config.memoryDir);
+    const resolvedStorageDir = path6.resolve(storageDir);
+    const resolvedMemoryDir = path6.resolve(this.config.memoryDir);
     const defaultNs = normalizeNamespaceIdentity(this.config.defaultNamespace);
     if (resolvedStorageDir === resolvedMemoryDir) return ns === defaultNs;
-    const resolvedNamespacesDir = path5.join(resolvedMemoryDir, "namespaces");
+    const resolvedNamespacesDir = path6.join(resolvedMemoryDir, "namespaces");
     if (!isPathInsideStorageRoot(resolvedNamespacesDir, resolvedStorageDir)) return false;
-    const rawRoot = path5.resolve(resolvedNamespacesDir, ns);
-    const tokenRoot = path5.resolve(resolvedNamespacesDir, namespaceIdentityToken(ns));
+    const rawRoot = path6.resolve(resolvedNamespacesDir, ns);
+    const tokenRoot = path6.resolve(resolvedNamespacesDir, namespaceIdentityToken(ns));
     return resolvedStorageDir === rawRoot || resolvedStorageDir === tokenRoot;
   }
   namespaceStorageDirHintOwnershipRank(record, resolvedStorageDir, configured) {
-    if (resolvedStorageDir === path5.resolve(this.config.memoryDir)) {
+    if (resolvedStorageDir === path6.resolve(this.config.memoryDir)) {
       return record.namespace === normalizeNamespaceIdentity(this.config.defaultNamespace) ? 0 : 3;
     }
-    const leaf = path5.basename(resolvedStorageDir);
+    const leaf = path6.basename(resolvedStorageDir);
     const tokenOwnsRoot = namespaceIdentityToken(record.namespace) === leaf;
     if (tokenOwnsRoot && configured.has(record.namespace)) return 0;
     if (record.namespace === leaf) return 1;
@@ -4897,7 +5113,7 @@ var Orchestrator = class _Orchestrator {
   loadNamespaceStorageDirHintsFromCatalog() {
     if (this.namespaceStorageDirHintsLoaded || !this.namespaceCatalog.enabled) return;
     this.namespaceStorageDirHintsLoaded = true;
-    const catalogPath = path5.join(this.config.memoryDir, "state", "namespaces.jsonl");
+    const catalogPath = path6.join(this.config.memoryDir, "state", "namespaces.jsonl");
     if (!existsSync(catalogPath)) return;
     let body;
     try {
@@ -4934,7 +5150,7 @@ var Orchestrator = class _Orchestrator {
       if (!this.storageDirMatchesNamespaceHint(record.namespace, record.storageDir)) {
         continue;
       }
-      const resolvedStorageDir = path5.resolve(record.storageDir);
+      const resolvedStorageDir = path6.resolve(record.storageDir);
       const current = preferredByStorageDir.get(resolvedStorageDir);
       preferredByStorageDir.set(
         resolvedStorageDir,
@@ -5198,7 +5414,7 @@ var Orchestrator = class _Orchestrator {
     this.config = config;
     this.profiler = new ProfilingCollector({
       enabled: resolvePipelineProcessingCapabilities(this.config).profiling,
-      storageDir: config.profilingStorageDir || path5.join(config.memoryDir, "profiling"),
+      storageDir: config.profilingStorageDir || path6.join(config.memoryDir, "profiling"),
       maxTraces: config.profilingMaxTraces
     });
     this.namespaceCatalog = new NamespaceCatalog(config);
@@ -5268,7 +5484,7 @@ var Orchestrator = class _Orchestrator {
     this.compounding = resolveConsolidationCapabilities(config).compounding ? new CompoundingEngine(config, this.storage) : void 0;
     this.buffer = new SmartBuffer(config, this.storage);
     this.transcript = new TranscriptManager(config);
-    this.conversationIndexDir = path5.join(
+    this.conversationIndexDir = path6.join(
       config.memoryDir,
       "conversation-index",
       "chunks"
@@ -5310,6 +5526,13 @@ var Orchestrator = class _Orchestrator {
       getStorage: (namespace) => this.getStorage(namespace),
       fastChatCompletion: (messages, options) => this.fastChatCompletion(messages, options)
     });
+    this.qmdResultResolver = new QmdResultResolver({
+      getConfig: () => this.config,
+      storageFor: (namespace) => this.storageRouter.storageFor(namespace),
+      storageDirNamespace: (storageDir) => this.storageDirNamespace(storageDir),
+      qmdCollectionNamespaceFromPrefix: (prefix) => this.qmdCollectionNamespaceFromPrefix(prefix),
+      namespaceFromPath: (p) => this.namespaceFromPath(p)
+    });
     this.sessionObserver = new SessionObserverState({
       memoryDir: config.memoryDir,
       debounceMs: config.sessionObserverDebounceMs ?? 12e4,
@@ -5374,7 +5597,7 @@ var Orchestrator = class _Orchestrator {
       saveContentHashIndexes: () => this.saveContentHashIndexes()
     });
     this.threading = new ThreadingManager(
-      path5.join(config.memoryDir, "threads"),
+      path6.join(config.memoryDir, "threads"),
       config.threadingGapMinutes
     );
     const lifecycleCaps = resolveMemoryLifecycleCapabilities(config);
@@ -5697,7 +5920,7 @@ var Orchestrator = class _Orchestrator {
           const files = await readdir2(wsDir).catch(() => []);
           for (const f of files) {
             if (!f.startsWith(".compaction-reset-signal-")) continue;
-            const fp = path5.join(wsDir, f);
+            const fp = path6.join(wsDir, f);
             const s = await stat(fp).catch(() => null);
             if (s && Date.now() - s.mtimeMs >= COMPACTION_SIGNAL_MAX_AGE_MS) {
               await unlink(fp).catch(() => {
@@ -5915,7 +6138,7 @@ var Orchestrator = class _Orchestrator {
     if (signal.aborted) return;
     if (!this.wearablesAutoSyncHandle && this.config.wearables.enabled && this.config.wearables.autoSyncEnabled && Object.values(this.config.wearables.sources).some((source) => source.enabled)) {
       try {
-        const { startWearablesAutoSync } = await import("./auto-sync-G3V5AN4C.js");
+        const { startWearablesAutoSync } = await import("./auto-sync-XHSKKQAH.js");
         if (signal.aborted) return;
         this.wearablesAutoSyncHandle = startWearablesAutoSync(
           {
@@ -6206,15 +6429,15 @@ ${doc.content}` : doc.content,
     this.lastFileHygieneRunAtMs = now;
     if (hygiene.rotateEnabled) {
       for (const rel of hygiene.rotatePaths) {
-        const abs = path5.isAbsolute(rel) ? rel : path5.join(this.config.workspaceDir, rel);
+        const abs = path6.isAbsolute(rel) ? rel : path6.join(this.config.workspaceDir, rel);
         try {
           const raw = await readFile2(abs, "utf-8");
           if (raw.length > hygiene.rotateMaxBytes) {
-            const archiveDir = path5.join(
+            const archiveDir = path6.join(
               this.config.workspaceDir,
               hygiene.archiveDir
             );
-            const base = path5.basename(abs);
+            const base = path6.basename(abs);
             const prefix = base.toUpperCase().replace(/\.MD$/i, "").replace(/[^A-Z0-9]+/g, "-") || "FILE";
             const { newContent } = await rotateMarkdownFileToArchive({
               filePath: abs,
@@ -6239,8 +6462,8 @@ ${doc.content}` : doc.content,
         log.warn(w.message);
       }
       if (hygiene.warningsLogEnabled && warnings.length > 0) {
-        const fp = path5.join(this.config.memoryDir, hygiene.warningsLogPath);
-        await mkdir3(path5.dirname(fp), { recursive: true });
+        const fp = path6.join(this.config.memoryDir, hygiene.warningsLogPath);
+        await mkdir3(path6.dirname(fp), { recursive: true });
         const stamp = (/* @__PURE__ */ new Date()).toISOString();
         const block = `
 
@@ -6379,7 +6602,7 @@ ${doc.content}` : doc.content,
     for (const categoryDir of RECALL_FALLBACK_DIRS) {
       if (memoryRootReal === null) break;
       for (const date of datesToScan) {
-        const dateDir = path5.join(storage.dir, categoryDir, date);
+        const dateDir = path6.join(storage.dir, categoryDir, date);
         try {
           const dirStat = await lstat(dateDir);
           if (dirStat.isSymbolicLink() || !dirStat.isDirectory()) continue;
@@ -6388,7 +6611,7 @@ ${doc.content}` : doc.content,
           for (const entry of entries) {
             if (entry.isSymbolicLink()) continue;
             if (!entry.name.endsWith(".md")) continue;
-            const fullPath = path5.join(dateDir, entry.name);
+            const fullPath = path6.join(dateDir, entry.name);
             try {
               assertPathInsideRoot(memoryRootReal, await realpath(fullPath), fullPath);
               const raw = await readFile2(fullPath, "utf-8");
@@ -6410,7 +6633,7 @@ ${doc.content}` : doc.content,
               facts.push({
                 path: fullPath,
                 frontmatter: {
-                  id: fm.id || path5.basename(entry.name, ".md"),
+                  id: fm.id || path6.basename(entry.name, ".md"),
                   category: fm.category || "fact",
                   created,
                   updated: fm.updated || created,
@@ -6433,13 +6656,13 @@ ${doc.content}` : doc.content,
       return a.frontmatter.created < b.frontmatter.created ? -1 : 1;
     });
     const hourlySummaries = [];
-    const hourlyBaseDir = path5.join(storage.dir, "summaries", "hourly");
+    const hourlyBaseDir = path6.join(storage.dir, "summaries", "hourly");
     try {
       const sessionKeys = await readdir2(hourlyBaseDir, { withFileTypes: true });
       for (const sk of sessionKeys) {
         if (!sk.isDirectory()) continue;
         for (const date of datesToScan) {
-          const summaryFile = path5.join(hourlyBaseDir, sk.name, `${date}.md`);
+          const summaryFile = path6.join(hourlyBaseDir, sk.name, `${date}.md`);
           try {
             const raw = await readFile2(summaryFile, "utf-8");
             const filtered = filterHourlySummaryMarkdownForLocalDay(
@@ -6543,7 +6766,7 @@ ${doc.content}` : doc.content,
   }
   async getLastGraphRecallSnapshot(namespace) {
     const storage = await this.getStorage(namespace);
-    const snapshotPath = path5.join(
+    const snapshotPath = path6.join(
       storage.dir,
       "state",
       "last_graph_recall.json"
@@ -6582,7 +6805,7 @@ ${doc.content}` : doc.content,
   }
   async getLastIntentSnapshot(namespace) {
     const storage = await this.getStorage(namespace);
-    const snapshotPath = path5.join(storage.dir, "state", "last_intent.json");
+    const snapshotPath = path6.join(storage.dir, "state", "last_intent.json");
     try {
       const raw = await readFile2(snapshotPath, "utf-8");
       const parsed = JSON.parse(raw);
@@ -6615,7 +6838,7 @@ ${doc.content}` : doc.content,
   }
   async getLastQmdRecallSnapshot(namespace) {
     const storage = await this.getStorage(namespace);
-    const snapshotPath = path5.join(
+    const snapshotPath = path6.join(
       storage.dir,
       "state",
       "last_qmd_recall.json"
@@ -7499,7 +7722,7 @@ ${doc.content}` : doc.content,
         resolvedPath = resolvedCold.result.path;
         resolvedResult = resolvedCold.result;
       }
-      if (!path5.isAbsolute(resolvedPath)) {
+      if (!path6.isAbsolute(resolvedPath)) {
         resolvedAmbiguousSeeds.set(result.path, null);
         return null;
       }
@@ -7524,7 +7747,7 @@ ${doc.content}` : doc.content,
         }
         continue;
       }
-      if (path5.isAbsolute(result.path)) {
+      if (path6.isAbsolute(result.path)) {
         const resolved = await resolveAmbiguousSeedOwner(result, null);
         if (resolved) {
           addResultForNamespace(resolved.namespace, resolved.result);
@@ -7567,7 +7790,7 @@ ${doc.content}` : doc.content,
         0
       );
       seedPaths.push(
-        ...seedRelativePaths.map((rel) => path5.join(storage.dir, rel))
+        ...seedRelativePaths.map((rel) => path6.join(storage.dir, rel))
       );
       const seedSet = new Set(seedRelativePaths);
       const expanded = await this.graphIndexFor(storage).spreadingActivation(
@@ -7583,7 +7806,7 @@ ${doc.content}` : doc.content,
       for (const candidate of expanded.slice(0, perNamespaceExpandedCap)) {
         if (deadlineExpired()) break;
         if (seedSet.has(candidate.path)) continue;
-        const memoryPath = path5.resolve(storage.dir, candidate.path);
+        const memoryPath = path6.resolve(storage.dir, candidate.path);
         const memory = await storage.readMemoryByPath(memoryPath);
         if (deadlineExpired()) break;
         if (!memory) continue;
@@ -7608,7 +7831,7 @@ ${doc.content}` : doc.content,
           path: memory.path,
           score,
           namespace,
-          seed: path5.resolve(storage.dir, candidate.seed),
+          seed: path6.resolve(storage.dir, candidate.seed),
           hopDepth: candidate.hopDepth,
           decayedWeight: candidate.decayedWeight,
           graphType: candidate.graphType,
@@ -7629,12 +7852,12 @@ ${doc.content}` : doc.content,
   }
   async recordLastGraphRecallSnapshot(options) {
     try {
-      const snapshotPath = path5.join(
+      const snapshotPath = path6.join(
         options.storage.dir,
         "state",
         "last_graph_recall.json"
       );
-      await mkdir3(path5.dirname(snapshotPath), { recursive: true });
+      await mkdir3(path6.dirname(snapshotPath), { recursive: true });
       const now = (/* @__PURE__ */ new Date()).toISOString();
       const totalSeedCount = options.seedPaths.length;
       const totalExpandedCount = options.expandedPaths.length;
@@ -7668,12 +7891,12 @@ ${doc.content}` : doc.content,
   }
   async recordLastIntentSnapshot(options) {
     try {
-      const snapshotPath = path5.join(
+      const snapshotPath = path6.join(
         options.storage.dir,
         "state",
         "last_intent.json"
       );
-      await mkdir3(path5.dirname(snapshotPath), { recursive: true });
+      await mkdir3(path6.dirname(snapshotPath), { recursive: true });
       await writeFile3(
         snapshotPath,
         JSON.stringify(options.snapshot, null, 2),
@@ -7685,12 +7908,12 @@ ${doc.content}` : doc.content,
   }
   async recordLastQmdRecallSnapshot(options) {
     try {
-      const snapshotPath = path5.join(
+      const snapshotPath = path6.join(
         options.storage.dir,
         "state",
         "last_qmd_recall.json"
       );
-      await mkdir3(path5.dirname(snapshotPath), { recursive: true });
+      await mkdir3(path6.dirname(snapshotPath), { recursive: true });
       await writeFile3(
         snapshotPath,
         JSON.stringify(options.snapshot, null, 2),
@@ -7705,8 +7928,8 @@ ${doc.content}` : doc.content,
       const stateDir = await this.resolveStateDirForNamespace(
         options.namespace
       );
-      const snapshotPath = path5.join(stateDir, "last_intent.json");
-      await mkdir3(path5.dirname(snapshotPath), { recursive: true });
+      const snapshotPath = path6.join(stateDir, "last_intent.json");
+      await mkdir3(path6.dirname(snapshotPath), { recursive: true });
       await writeFile3(
         snapshotPath,
         JSON.stringify(options.snapshot, null, 2),
@@ -7718,12 +7941,12 @@ ${doc.content}` : doc.content,
   }
   async resolveStateDirForNamespace(namespace) {
     if (!resolveNamespaceCapabilities(this.config).namespaces) {
-      return path5.join(this.config.memoryDir, "state");
+      return path6.join(this.config.memoryDir, "state");
     }
     if (namespace !== this.config.defaultNamespace) {
-      return path5.join(this.config.memoryDir, "namespaces", namespace, "state");
+      return path6.join(this.config.memoryDir, "namespaces", namespace, "state");
     }
-    const candidate = path5.join(
+    const candidate = path6.join(
       this.config.memoryDir,
       "namespaces",
       this.config.defaultNamespace
@@ -7731,11 +7954,11 @@ ${doc.content}` : doc.content,
     try {
       const candidateStat = await stat(candidate);
       if (candidateStat.isDirectory()) {
-        return path5.join(candidate, "state");
+        return path6.join(candidate, "state");
       }
     } catch {
     }
-    return path5.join(this.config.memoryDir, "state");
+    return path6.join(this.config.memoryDir, "state");
   }
   buildGraphRecallRankedResults(results, sourceLabelResolver, limit = 64) {
     return results.slice(0, limit).map((result) => ({
@@ -8137,7 +8360,7 @@ ${doc.content}` : doc.content,
       const graphExpandedResultPaths = /* @__PURE__ */ new Set();
       const graphSourceLabelsForPath = (resultPath) => {
         const labels = [];
-        const normalizedPath = resultPath.split(path5.sep).join("/");
+        const normalizedPath = resultPath.split(path6.sep).join("/");
         const isEntityPath = normalizedPath.startsWith("entities/") || normalizedPath.includes("/entities/");
         if (graphBaselinePaths.has(resultPath)) labels.push("baseline");
         if (graphExpandedResultPaths.has(resultPath))
@@ -8287,7 +8510,7 @@ ${doc.content}` : doc.content,
         profileStorageNamespaces.map((namespace) => this.storageRouter.storageFor(namespace))
       );
       const emptyProfileStorage = new Proxy(
-        { dir: path5.join(this.config.memoryDir, ".empty-scope-profile") },
+        { dir: path6.join(this.config.memoryDir, ".empty-scope-profile") },
         {
           get(target, prop) {
             if (prop in target) return target[prop];
@@ -9763,11 +9986,11 @@ ${formatted}`;
         if (!resolveRecallAuxiliaryCapabilities(this.config).compactionReset) return null;
         const workspaceDir = compactionWorkspaceDir || this.config.workspaceDir || defaultWorkspaceDir();
         const safeSessionKey = sanitizeSessionKeyForFilename(effectiveSessionKey);
-        const signalPath = path5.join(
+        const signalPath = path6.join(
           workspaceDir,
           `.compaction-reset-signal-${safeSessionKey}`
         );
-        const bootPath = path5.join(workspaceDir, "BOOT.md");
+        const bootPath = path6.join(workspaceDir, "BOOT.md");
         try {
           const signalStat = await stat(signalPath).catch(() => null);
           if (!signalStat) return null;
@@ -14369,7 +14592,7 @@ ${normalized}`).digest("hex");
         const allMems = allMemsForGraph ?? [];
         for (const m of allMems) {
           if (m.frontmatter.entityRef === entityRef) {
-            const rel = path5.relative(storage.dir, m.path);
+            const rel = path6.relative(storage.dir, m.path);
             if (rel !== memoryRelPath) entitySiblings.push(rel);
           }
         }
@@ -14693,7 +14916,7 @@ ${normalized}`).digest("hex");
     }
     if (resolveConsolidationCapabilities(this.config).semanticConsolidation) {
       try {
-        const stateFilePath = path5.join(
+        const stateFilePath = path6.join(
           this.config.memoryDir,
           "state",
           "semantic-consolidation-last-run.json"
@@ -14741,7 +14964,7 @@ ${normalized}`).digest("hex");
             );
           }
           if (semResult.errors === 0 || semResult.memoriesArchived > 0) {
-            const stateDir = path5.join(this.config.memoryDir, "state");
+            const stateDir = path6.join(this.config.memoryDir, "state");
             await mkdir3(stateDir, { recursive: true });
             await writeFile3(
               stateFilePath,
@@ -15052,198 +15275,16 @@ ${reflectionsContent.trim()}
     }
     return null;
   }
+  // Issue #1526 seam 11: QMD result-resolution methods moved to QmdResultResolver.
+  // Thin delegation keeps the private API stable for callers + tests.
   async readQmdResultMemory(resultPath, fallbackStorage, recallNamespaces = []) {
-    const parts = qmdCollectionPathParts(resultPath);
-    const storageDirFor = (storage) => typeof storage.dir === "string" && storage.dir ? storage.dir : null;
-    const fallbackStorageDir = storageDirFor(fallbackStorage);
-    const coldCollection = this.config.qmdColdCollection ?? "openclaw-engram-cold";
-    if (parts && parts.collection === coldCollection) {
-      const storages = [];
-      const seenStorageDirs = /* @__PURE__ */ new Set();
-      const addStorage = (storage) => {
-        const storageDir = storageDirFor(storage);
-        const storageKey = storageDir ? path5.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) : this.config.defaultNamespace;
-      if (recallNamespaces.length === 0 || !resolveNamespaceCapabilities(this.config).namespaces || recallNamespaces.includes(fallbackNamespace)) {
-        addStorage(fallbackStorage);
-      }
-      if (recallNamespaces.length > 0) {
-        for (const namespace of recallNamespaces) {
-          try {
-            addStorage(await this.storageRouter.storageFor(namespace));
-          } catch (err) {
-            log.debug("qmd cold result namespace storage lookup skipped", {
-              path: resultPath,
-              namespace,
-              error: err.message
-            });
-          }
-        }
-      }
-      for (const storage of storages) {
-        const storageDir = storageDirFor(storage);
-        if (!storageDir) {
-          const memory = await storage.readMemoryByPath(resultPath);
-          if (memory) return memory;
-          continue;
-        }
-        try {
-          const coldRoot = path5.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.message
-          });
-        }
-      }
-      return null;
-    }
-    const collectionNamespace = parts ? this.qmdCollectionNamespaceFromPrefix(parts.collection) : null;
-    if (parts && collectionNamespace) {
-      try {
-        const collectionStorage = await this.storageRouter.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.message
-        });
-        return null;
-      }
-    }
-    if (path5.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;
+    return this.qmdResultResolver.readQmdResultMemory(resultPath, fallbackStorage, recallNamespaces);
   }
   async resolveColdQmdResultForRecall(result, fallbackStorage, recallNamespaces = []) {
-    const memory = await this.readQmdResultMemory(
-      result.path,
-      fallbackStorage,
-      recallNamespaces
-    );
-    if (!memory) return null;
-    let ownerNamespace = null;
-    if (path5.isAbsolute(memory.path)) {
-      const ownerStorage = await this.storageForAbsoluteQmdResultPath(
-        memory.path,
-        fallbackStorage,
-        recallNamespaces
-      );
-      ownerNamespace = ownerStorage?.namespace ?? null;
-      if (!ownerNamespace && resolveNamespaceCapabilities(this.config).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)
-      }
-    };
+    return this.qmdResultResolver.resolveColdQmdResultForRecall(result, fallbackStorage, recallNamespaces);
   }
   async storageForAbsoluteQmdResultPath(resultPath, fallbackStorage, recallNamespaces = []) {
-    const resolvedPath = path5.resolve(resultPath);
-    const memoryRoot = path5.resolve(this.config.memoryDir);
-    const namespacesRoot = path5.join(memoryRoot, "namespaces");
-    const fallbackStorageDir = typeof fallbackStorage.dir === "string" && fallbackStorage.dir ? fallbackStorage.dir : null;
-    const matches = [];
-    const seenDirs = /* @__PURE__ */ new Set();
-    const maybeAddStorage = (storage, namespace) => {
-      const storageDir = typeof storage.dir === "string" && storage.dir ? storage.dir : null;
-      if (!storageDir) return;
-      const candidateRoot = path5.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) : this.config.defaultNamespace;
-    maybeAddStorage(fallbackStorage, fallbackNamespace);
-    const candidateNamespaces = /* @__PURE__ */ new Set();
-    candidateNamespaces.add(this.config.defaultNamespace);
-    candidateNamespaces.add(this.config.sharedNamespace);
-    for (const ns of recallNamespaces) {
-      candidateNamespaces.add(ns);
-    }
-    if (isPathInsideStorageRoot(namespacesRoot, resolvedPath)) {
-      const relativeToNamespaces = path5.relative(namespacesRoot, resolvedPath);
-      const [namespaceSegment] = relativeToNamespaces.split(/[\\/]/);
-      if (namespaceSegment) {
-        candidateNamespaces.add(
-          namespaceIdentityFromToken(namespaceSegment) ?? namespaceSegment
-        );
-      }
-    }
-    for (const policy of this.config.namespacePolicies ?? []) {
-      candidateNamespaces.add(policy.name);
-    }
-    for (const ns of candidateNamespaces) {
-      if (!ns) continue;
-      try {
-        maybeAddStorage(await this.storageRouter.storageFor(ns), ns);
-      } catch {
-        continue;
-      }
-    }
-    matches.sort((a, b) => b.dir.length - a.dir.length);
-    return matches[0] ?? null;
+    return this.qmdResultResolver.storageForAbsoluteQmdResultPath(resultPath, fallbackStorage, recallNamespaces);
   }
   // Issue #1526: recall-rerank methods moved to RecallRerankCoordinator.
   // Thin delegation keeps the private API stable for callers + tests.
@@ -15336,12 +15377,12 @@ ${reflectionsContent.trim()}
    */
   semanticDedupScopeFor(targetStorage) {
     if (!resolveNamespaceCapabilities(this.config).namespaces) return {};
-    const memoryDir = path5.resolve(this.config.memoryDir);
-    const storageDir = path5.resolve(targetStorage.dir);
+    const memoryDir = path6.resolve(this.config.memoryDir);
+    const storageDir = path6.resolve(targetStorage.dir);
     if (storageDir === memoryDir) {
       return { pathExcludePrefixes: ["namespaces/"] };
     }
-    let rel = path5.relative(memoryDir, storageDir);
+    let rel = path6.relative(memoryDir, storageDir);
     if (!rel || rel.startsWith("..")) {
       log.debug(
         `semantic dedup: target storage dir ${storageDir} is outside memoryDir ${memoryDir}; scoping lookup to absolute path prefix`
@@ -15360,7 +15401,7 @@ ${reflectionsContent.trim()}
     if (hits.length === 0) return [];
     const results = [];
     for (const hit of hits) {
-      const fullPath = path5.isAbsolute(hit.path) ? hit.path : path5.join(this.config.memoryDir, hit.path);
+      const fullPath = path6.isAbsolute(hit.path) ? hit.path : path6.join(this.config.memoryDir, hit.path);
       const memory = await this.storage.readMemoryByPath(fullPath);
       if (!memory) continue;
       results.push({
@@ -15557,7 +15598,7 @@ ${reflectionsContent.trim()}
           const storage = await this.storageRouter.storageFor(namespace);
           const storageDir = typeof storage.dir === "string" && storage.dir ? storage.dir : null;
           if (!storageDir) continue;
-          const recallRoot = path5.resolve(storageDir);
+          const recallRoot = path6.resolve(storageDir);
           if (seenRecallRoots.has(recallRoot)) continue;
           seenRecallRoots.add(recallRoot);
           recallRoots.push(recallRoot);
@@ -15581,8 +15622,8 @@ ${reflectionsContent.trim()}
           if (resolvedCold) scopedResults.push(resolvedCold.result);
           continue;
         }
-        if (path5.isAbsolute(result.path)) {
-          const resolvedPath = path5.resolve(result.path);
+        if (path6.isAbsolute(result.path)) {
+          const resolvedPath = path6.resolve(result.path);
           if (recallRoots.some(
             (recallRoot) => isPathInsideStorageRoot(recallRoot, resolvedPath)
           )) {
@@ -16516,4 +16557,4 @@ export {
   resolvePersistedMemoryRelativePath,
   Orchestrator
 };
-//# sourceMappingURL=chunk-VC7QELR6.js.map
+//# sourceMappingURL=chunk-7HUGLMSW.js.map