@remnic/core 9.3.637 → 9.3.639

package/dist/{chunk-XM6M6DHG.js → chunk-52XI77OQ.js}

@@ -11,7 +11,7 @@ import {
 } from "./chunk-DGNQRNLL.js";
 import {
   toRecallExplainJson
-} from "./chunk-PW6GURU3.js";
+} from "./chunk-EKIQBGAY.js";
 import {
   applyTagFilter,
   normalizeTags,
@@ -27,7 +27,7 @@ import {
   listMemoryGovernanceRuns,
   readMemoryGovernanceRunArtifact,
   runMemoryGovernance
-} from "./chunk-C4KKM62E.js";
+} from "./chunk-UU5LHD6J.js";
 import {
   clusterByKey,
   combineNamespaces,
@@ -44,12 +44,18 @@ import {
   seedTrustZoneDemoDataset,
   summarizeTrustZonePromotionReadiness
 } from "./chunk-JGSKJHF7.js";
+import {
+  isPathInsideStorageRoot
+} from "./chunk-FF4KLI5W.js";
 import {
   estimateRecallTokens
-} from "./chunk-YQNADJCT.js";
+} from "./chunk-CMZLMIZI.js";
 import {
   namespaceCollectionName
 } from "./chunk-LASA46TQ.js";
+import {
+  namespaceIdentityFromToken
+} from "./chunk-ZFXCQPNO.js";
 import {
   recordObjectiveStateSnapshotsFromObservedMessages
 } from "./chunk-BMFZLLNI.js";
@@ -61,7 +67,7 @@ import {
 } from "./chunk-EIR5VLIH.js";
 import {
   buildGraphSnapshot
-} from "./chunk-7V2SGZ3H.js";
+} from "./chunk-NE566K4E.js";
 import {
   wrapWorkLayerContext
 } from "./chunk-EI6V5UXY.js";
@@ -85,14 +91,14 @@ import {
   buildBriefing,
   parseBriefingFocus,
   parseBriefingWindow
-} from "./chunk-CMN5AWAZ.js";
+} from "./chunk-J2KFC47S.js";
 import {
   parseEntityFile
-} from "./chunk-QYGIQ5NM.js";
+} from "./chunk-SHHT4JTC.js";
 import {
   DEFAULT_RECALL_DISCLOSURE,
   isRecallDisclosure
-} from "./chunk-FPNQF475.js";
+} from "./chunk-3F7RMHC4.js";
 import {
   inferMemoryStatus,
   toMemoryPathRel
@@ -110,7 +116,7 @@ import {
 import {
   filterTrajectoriesByLookbackDays,
   readCausalTrajectoryRecords
-} from "./chunk-TQOU3VAT.js";
+} from "./chunk-SSOMTUCA.js";
 import {
   canReadNamespace,
   canWriteNamespace,
@@ -141,6 +147,9 @@ import {
   iterateOfflineSyncSnapshotFileRecords,
   readOfflineSyncFileContentChunk
 } from "./chunk-ZLDUQWT2.js";
+import {
+  SecureStoreLockedError
+} from "./chunk-ILXTATKK.js";
 import {
   evaluateActionConfidence
 } from "./chunk-AH2JUU6X.js";
@@ -449,6 +458,42 @@ function formatProcedureStatsText(report) {
 import * as nodePath from "path";
 var EngramAccessInputError = class extends Error {
 };
+function qmdCollectionPathParts(resultPath) {
+  if (!resultPath || nodePath.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 = nodePath.resolve(storageDir);
+  const addCandidate = (candidate) => {
+    const resolved = nodePath.resolve(candidate);
+    if (isPathInsideStorageRoot(storageRoot, resolved)) {
+      candidates.add(resolved);
+    }
+  };
+  const addRelativeCandidates = (relativePath) => {
+    const normalized = relativePath.replace(/\\/g, "/").replace(/^\/+/, "");
+    if (!normalized) return;
+    addCandidate(nodePath.join(storageRoot, normalized));
+    if (/^\d{4}-\d{2}-\d{2}\//.test(normalized)) {
+      addCandidate(nodePath.join(storageRoot, "facts", normalized));
+    }
+  };
+  if (nodePath.isAbsolute(resultPath)) {
+    addCandidate(resultPath);
+  } else {
+    addRelativeCandidates(resultPath);
+  }
+  return [...candidates];
+}
 var cachedPackageVersion = null;
 async function getPackageVersion() {
   if (cachedPackageVersion !== null) return cachedPackageVersion;
@@ -874,6 +919,7 @@ var EngramAccessService = class {
       queryLen: options.query.length,
       memoryIds,
       namespace,
+      recallNamespaces: [namespace],
       traceId: options.snapshot.traceId,
       plannerMode: options.normalizedMode,
       requestedMode: options.requestedMode && options.requestedMode !== "auto" ? options.requestedMode : void 0,
@@ -922,8 +968,108 @@ var EngramAccessService = class {
     const namespace = snapshot.namespace ? this.resolveNamespace(snapshot.namespace) : this.orchestrator.config.defaultNamespace;
     const storage = await this.orchestrator.getStorage(namespace);
     const storageDir = storage.dir;
+    const recallNamespaces = Array.from(
+      new Set(
+        [
+          namespace,
+          ...Array.isArray(snapshot.recallNamespaces) ? snapshot.recallNamespaces.map((ns) => this.resolveNamespace(ns)) : [],
+          this.orchestrator.config.defaultNamespace,
+          this.orchestrator.config.sharedNamespace,
+          ...(this.orchestrator.config.namespacePolicies ?? []).map((p) => p.name)
+        ].filter((ns) => typeof ns === "string" && ns.length > 0)
+      )
+    );
     const results = [];
     const seen = /* @__PURE__ */ new Set();
+    const collectionNamespaceFromPrefix = (collectionPrefix) => {
+      const baseCollection = this.orchestrator.config.qmdCollection;
+      if (collectionPrefix === baseCollection) return this.orchestrator.config.defaultNamespace;
+      const namespaceSuffix = collectionPrefix.startsWith(`${baseCollection}--`) ? collectionPrefix.slice(baseCollection.length + 2) : "";
+      if (!namespaceSuffix) return null;
+      const decoded = namespaceIdentityFromToken(namespaceSuffix);
+      if (decoded !== null) return decoded || this.orchestrator.config.defaultNamespace;
+      if (namespaceSuffix.startsWith("ns--")) {
+        const legacyNamespace = namespaceSuffix.slice("ns--".length).trim();
+        return legacyNamespace || null;
+      }
+      return null;
+    };
+    const readResultPath = async (memoryPath) => {
+      const parts = qmdCollectionPathParts(memoryPath);
+      const coldCollection = this.orchestrator.config.qmdColdCollection ?? "openclaw-engram-cold";
+      if (parts && parts.collection === coldCollection) {
+        const storages = [];
+        const seenStorageDirs = /* @__PURE__ */ new Set();
+        const addStorage = (candidateStorage) => {
+          const candidateDir = nodePath.resolve(candidateStorage.dir);
+          if (seenStorageDirs.has(candidateDir)) return;
+          seenStorageDirs.add(candidateDir);
+          storages.push({ storage: candidateStorage, dir: candidateDir });
+        };
+        addStorage(storage);
+        for (const recallNamespace of recallNamespaces) {
+          try {
+            addStorage(await this.orchestrator.getStorage(recallNamespace));
+          } catch {
+            continue;
+          }
+        }
+        for (const candidateStorage of storages) {
+          try {
+            const coldRoot = nodePath.join(candidateStorage.dir, "cold");
+            for (const candidatePath of qmdResultPathCandidates(
+              coldRoot,
+              parts.relativePath
+            )) {
+              const memory = await candidateStorage.storage.readMemoryByPath(candidatePath);
+              if (memory) return { memory, baseDir: candidateStorage.dir };
+            }
+          } catch (err) {
+            if (err instanceof SecureStoreLockedError) throw err;
+            continue;
+          }
+        }
+        return null;
+      }
+      const collectionNamespace = parts ? collectionNamespaceFromPrefix(parts.collection) : null;
+      if (parts && collectionNamespace) {
+        try {
+          const collectionStorage = await this.orchestrator.getStorage(collectionNamespace);
+          for (const candidate of qmdResultPathCandidates(
+            collectionStorage.dir,
+            parts.relativePath
+          )) {
+            const memory = await collectionStorage.readMemoryByPath(candidate);
+            if (memory) return { memory, baseDir: collectionStorage.dir };
+          }
+          return null;
+        } catch (err) {
+          if (err instanceof SecureStoreLockedError) throw err;
+          return null;
+        }
+      }
+      if (nodePath.isAbsolute(memoryPath)) {
+        const ownerStorage = await this.storageForAbsoluteRecallPath(
+          memoryPath,
+          namespace,
+          recallNamespaces
+        );
+        if (!ownerStorage) return null;
+        for (const candidate of qmdResultPathCandidates(
+          ownerStorage.dir,
+          memoryPath
+        )) {
+          const memory = await ownerStorage.storage.readMemoryByPath(candidate);
+          if (memory) return { memory, baseDir: ownerStorage.dir };
+        }
+        return null;
+      }
+      for (const candidate of qmdResultPathCandidates(storageDir, memoryPath)) {
+        const memory = await storage.readMemoryByPath(candidate);
+        if (memory) return { memory, baseDir: storageDir };
+      }
+      return null;
+    };
     const rawExcerptsResult = await this.fetchRawExcerpts(
       disclosure,
       rawContext ? { ...rawContext, namespace } : null
@@ -931,13 +1077,14 @@ var EngramAccessService = class {
     const rawExcerpts = rawExcerptsResult ?? void 0;
     for (const memoryPath of snapshot.resultPaths ?? []) {
       if (!memoryPath || seen.has(memoryPath)) continue;
-      const memory = await storage.readMemoryByPath(memoryPath);
-      if (!memory) continue;
+      const resolved = await readResultPath(memoryPath);
+      if (!resolved) continue;
+      const { memory, baseDir } = resolved;
       seen.add(memoryPath);
       results.push(
         this.serializeMemorySummary(
           memory,
-          storageDir,
+          baseDir,
           disclosure,
           // Attach the (possibly empty) raw excerpts to the first raw
           // result; subsequent results do not duplicate the array.
@@ -961,6 +1108,48 @@ var EngramAccessService = class {
     }
     return results;
   }
+  async storageForAbsoluteRecallPath(memoryPath, primaryNamespace, recallNamespaces = []) {
+    const resolvedPath = nodePath.resolve(memoryPath);
+    const memoryRoot = nodePath.resolve(this.orchestrator.config.memoryDir);
+    const namespacesRoot = nodePath.join(memoryRoot, "namespaces");
+    const configuredNamespaces = /* @__PURE__ */ new Set();
+    configuredNamespaces.add(primaryNamespace);
+    for (const namespace of recallNamespaces) {
+      configuredNamespaces.add(namespace);
+    }
+    configuredNamespaces.add(this.orchestrator.config.defaultNamespace);
+    configuredNamespaces.add(this.orchestrator.config.sharedNamespace);
+    if (isPathInsideStorageRoot(namespacesRoot, resolvedPath)) {
+      const relativeToNamespaces = nodePath.relative(namespacesRoot, resolvedPath);
+      const [namespaceSegment] = relativeToNamespaces.split(/[\\/]/);
+      if (namespaceSegment) {
+        configuredNamespaces.add(
+          namespaceIdentityFromToken(namespaceSegment) ?? namespaceSegment
+        );
+      }
+    }
+    for (const policy of this.orchestrator.config.namespacePolicies ?? []) {
+      configuredNamespaces.add(policy.name);
+    }
+    const matches = [];
+    for (const ns of configuredNamespaces) {
+      if (!ns) continue;
+      let candidateStorage;
+      try {
+        candidateStorage = await this.orchestrator.getStorage(ns);
+      } catch {
+        continue;
+      }
+      const candidateRoot = nodePath.resolve(candidateStorage.dir);
+      if (!isPathInsideStorageRoot(candidateRoot, resolvedPath)) continue;
+      if (candidateRoot === memoryRoot && isPathInsideStorageRoot(namespacesRoot, resolvedPath)) {
+        continue;
+      }
+      matches.push({ storage: candidateStorage, dir: candidateRoot });
+    }
+    matches.sort((a, b) => b.dir.length - a.dir.length);
+    return matches[0] ?? null;
+  }
   /**
    * Fetch raw transcript excerpts from the LCM archive for `disclosure ===
    * "raw"` recalls (issue #677 PR 2/4).  Returns `null` for non-raw recall
@@ -1152,7 +1341,9 @@ var EngramAccessService = class {
     const memories = (request.memories ?? "").trim();
     const namespace = this.resolveRecallNamespace(request.namespace, request.sessionKey);
     if (memories.length === 0) {
-      return this.orchestrator.generateDaySummaryAuto(namespace);
+      return this.orchestrator.generateDaySummaryAuto(namespace, {
+        timeZone: request.timeZone
+      });
     }
     return this.orchestrator.generateDaySummary(memories);
   }
@@ -4458,4 +4649,4 @@ export {
   shapeMemorySummary,
   EngramAccessService
 };
-//# sourceMappingURL=chunk-XM6M6DHG.js.map
+//# sourceMappingURL=chunk-52XI77OQ.js.map