@remnic/core 9.46.1 → 9.47.0

package/dist/{chunk-RCU25Z66.js → chunk-IXH2U2QT.js}

@@ -158,12 +158,18 @@ import {
   supersessionKeysForFact
 } from "./chunk-DNHVPZOD.js";
 import {
-  ExtractionDeadlineError
+  ExtractionDeadlineError,
+  isActivityDigestPath,
+  isArtifactMemoryPath,
+  isMeetingRecordPath
 } from "./chunk-N3LL5NEU.js";
 import {
   ExtractionLivenessWarnThrottle,
   computeExtractionLivenessStatus
 } from "./chunk-3SG4FGDV.js";
+import {
+  isExternalWikiCollectionName
+} from "./chunk-JV3C2MNQ.js";
 import {
   sanitizeMemoryContent
 } from "./chunk-5GKPFL3S.js";
@@ -192,10 +198,10 @@ import {
 } from "./chunk-SYOIVK7K.js";
 import {
   defaultNamespaceAtFlatRoot,
+  memorySearchThroughScope,
   mergeMemorySearchDefaultFallback,
-  resolveMemorySearchDefaultFallback,
-  runMemorySearchFanout
-} from "./chunk-7HXCF4RE.js";
+  resolveMemorySearchDefaultFallback
+} from "./chunk-IXEBUYO4.js";
 import {
   PendingObserveExtractionTracker,
   pendingObserveScopeHint
@@ -321,6 +327,9 @@ import {
 import {
   SecureStoreLockedError
 } from "./chunk-XQ3HXAQH.js";
+import {
+  ALL_CATEGORY_DIRS
+} from "./chunk-VS2IYZRU.js";
 import {
   recordCitationUsage
 } from "./chunk-NINSR6LX.js";
@@ -4793,10 +4802,110 @@ function buildNotificationSummary(plan) {
   return `${plan.classification}: ${plan.request.text.slice(0, 60)}${plan.request.text.length > 60 ? "..." : ""} (${target})`;
 }
 
+// src/orchestration/generic-recall-paths.ts
+import path6 from "path";
+var CATEGORY_MEMORY_ROOTS = Object.fromEntries(
+  ALL_CATEGORY_DIRS.map((directory) => [directory, true])
+);
+var RESERVED_ARCHIVE_ROOTS = { archive: true, namespaces: true };
+function isQmdCollectionPrefix(prefix, collection, source) {
+  if (typeof collection !== "string" || collection.length === 0) return false;
+  if (prefix.startsWith(`${collection}--`)) return true;
+  if (prefix !== collection) return false;
+  if (source === "qmd") return true;
+  return !Object.hasOwn(CATEGORY_MEMORY_ROOTS, prefix) && !Object.hasOwn(RESERVED_ARCHIVE_ROOTS, prefix);
+}
+function normalizeQmdUriPath(relativePath, source) {
+  if (source !== "qmd" || !relativePath.startsWith("qmd://")) return relativePath;
+  try {
+    const parsed = new URL(relativePath);
+    if (parsed.protocol !== "qmd:" || !parsed.hostname) return relativePath;
+    const collection = decodeURIComponent(parsed.hostname);
+    const pathname = decodeURIComponent(parsed.pathname.replace(/^\/+/, ""));
+    return pathname ? `${collection}/${pathname}` : collection;
+  } catch {
+    return relativePath;
+  }
+}
+function stripQmdCollectionPrefix(relativePath, policy, source) {
+  const normalized = path6.posix.normalize(normalizeQmdUriPath(relativePath, source).replace(/\\/g, "/"));
+  const slashIndex = normalized.indexOf("/");
+  if (slashIndex <= 0 || slashIndex >= normalized.length - 1) return normalized;
+  const prefix = normalized.slice(0, slashIndex);
+  const matchesHotCollection = isQmdCollectionPrefix(prefix, policy.qmdCollection, source);
+  const matchesColdCollection = isQmdCollectionPrefix(prefix, policy.qmdColdCollection, source);
+  return matchesHotCollection || matchesColdCollection ? normalized.slice(slashIndex + 1) : normalized;
+}
+function isTopLevelArchivePath(filePath, policy = {}, source = "filesystem") {
+  const isAbsolutePath = path6.isAbsolute(filePath);
+  const relative2 = policy.memoryDir && isAbsolutePath ? path6.relative(policy.memoryDir, path6.resolve(filePath)) : filePath;
+  const normalized = !isAbsolutePath ? stripQmdCollectionPrefix(relative2, policy, source) : relative2;
+  return /^(?:archive|namespaces[\\/][^\\/]+[\\/]archive)(?:[\\/]|$)/i.test(normalized);
+}
+function isExternalWikiQmdPath(filePath, source) {
+  if (source !== "qmd") return false;
+  const normalized = normalizeQmdUriPath(filePath, source).replace(/\\/g, "/");
+  const slashIndex = normalized.indexOf("/");
+  const collection = slashIndex === -1 ? normalized : normalized.slice(0, slashIndex);
+  return isExternalWikiCollectionName(collection);
+}
+function isSearchExcludedPath(filePath, policy = {}, source = "filesystem") {
+  if (isExternalWikiQmdPath(filePath, source)) return true;
+  for (const candidate of collectionSpellings(filePath, policy, source)) {
+    if (isArtifactMemoryPath(candidate) || isNamespacedActivityDigestPath(candidate, policy.memoryDir) || isMeetingRecordPath(candidate)) {
+      return true;
+    }
+  }
+  return false;
+}
+function isNamespacedActivityDigestPath(candidate, memoryDir) {
+  if (isActivityDigestPath(candidate, memoryDir)) return true;
+  if (memoryDir === void 0 || memoryDir.length === 0) return false;
+  const relative2 = path6.relative(memoryDir, path6.resolve(memoryDir, candidate));
+  const namespaced = /^namespaces[\\/]([^\\/]+)[\\/](.*)$/.exec(relative2);
+  if (namespaced === null) return false;
+  return isActivityDigestPath(namespaced[2] ?? "", memoryDir);
+}
+function collectionSpellings(filePath, policy, source) {
+  if (path6.isAbsolute(filePath)) return [filePath];
+  if (source === "qmd" && filePath.startsWith("qmd://")) {
+    const normalized2 = path6.posix.normalize(normalizeQmdUriPath(filePath, source).replace(/\\/g, "/"));
+    const slashIndex2 = normalized2.indexOf("/");
+    return slashIndex2 <= 0 || slashIndex2 >= normalized2.length - 1 ? [normalized2] : [normalized2, normalized2.slice(slashIndex2 + 1)];
+  }
+  const normalized = path6.posix.normalize(
+    normalizeQmdUriPath(filePath, source).replace(/\\/g, "/")
+  );
+  const stripped = stripQmdCollectionPrefix(filePath, policy, source);
+  const spellings = [stripped];
+  if (stripped !== normalized) return spellings;
+  const slashIndex = stripped.indexOf("/");
+  if (slashIndex <= 0 || slashIndex >= stripped.length - 1) return spellings;
+  const prefix = stripped.slice(0, slashIndex);
+  const requested = policy.requestedCollection;
+  if (prefix !== requested && (Object.hasOwn(CATEGORY_MEMORY_ROOTS, prefix) || Object.hasOwn(RESERVED_ARCHIVE_ROOTS, prefix))) {
+    return spellings;
+  }
+  spellings.push(stripped.slice(slashIndex + 1));
+  return spellings;
+}
+function isGenericRecallExcludedPath(filePath, policy = {}, source = "filesystem") {
+  return isSearchExcludedPath(filePath, policy, source) || // Recall-only: archived memories are cold, but an explicit search is one
+  // of the surfaces they remain reachable through.
+  isTopLevelArchivePath(filePath, policy, source);
+}
+function filterRecallCandidates(candidates, options) {
+  const pathPolicy = options.pathPolicy ?? (options.memoryRoot === void 0 ? void 0 : { memoryDir: options.memoryRoot });
+  const scopedByNamespace = options.namespacesEnabled ? candidates.filter(
+    (r) => options.recallNamespaces.includes(r.namespace ?? options.resolveNamespace(r.path))
+  ) : candidates;
+  return scopedByNamespace.filter((r) => !isGenericRecallExcludedPath(r.path, pathPolicy, "qmd")).slice(0, Math.max(0, options.limit));
+}
+
 // src/procedural/procedure-miner.ts
 import { createHash as createHash3 } from "crypto";
 import { mkdir as mkdir2, rm, stat } from "fs/promises";
-import path6 from "path";
+import path7 from "path";
 
 // src/procedural/reinforcement-core.ts
 function clusterByKey(items, keyFn) {
@@ -4849,8 +4958,8 @@ function sleep(ms) {
   return new Promise((resolve4) => setTimeout(resolve4, ms));
 }
 async function acquireClusterWriteLock(memoryDir, clusterHash) {
-  const lockRoot = path6.join(path6.resolve(memoryDir), "state", "procedure-miner-locks");
-  const lockDir = path6.join(lockRoot, `${clusterHash}.lock`);
+  const lockRoot = path7.join(path7.resolve(memoryDir), "state", "procedure-miner-locks");
+  const lockDir = path7.join(lockRoot, `${clusterHash}.lock`);
   await mkdir2(lockRoot, { recursive: true });
   const startedAt = Date.now();
   let attempts = 0;
@@ -4881,7 +4990,7 @@ async function acquireClusterWriteLock(memoryDir, clusterHash) {
   }
 }
 async function withClusterWriteLock(memoryDir, clusterHash, fn) {
-  const inProcessKey = `${path6.resolve(memoryDir)}:${clusterHash}`;
+  const inProcessKey = `${path7.resolve(memoryDir)}:${clusterHash}`;
   const previous = inProcessClusterWriteLocks.get(inProcessKey) ?? Promise.resolve();
   let releaseInProcess;
   const current = previous.catch(() => void 0).then(
@@ -5338,10 +5447,10 @@ function formatZodIssues(error) {
   const parts = [];
   for (const issue of error.issues) {
     const hasNumeric = issue.path.some((p) => typeof p === "number");
-    const path9 = hasNumeric ? issue.path.filter((p) => typeof p === "string").join(".") || "(root)" : issue.path.length > 0 ? issue.path.join(".") : "(root)";
+    const path10 = hasNumeric ? issue.path.filter((p) => typeof p === "string").join(".") || "(root)" : issue.path.length > 0 ? issue.path.join(".") : "(root)";
     const options = enumOptionsFromIssue(issue);
     const suffix = options ? `. Valid: ${options.join(", ")}` : "";
-    parts.push(`${path9}: ${issue.message}${suffix}`);
+    parts.push(`${path10}: ${issue.message}${suffix}`);
   }
   return parts.length > 0 ? `request validation failed: ${parts.join("; ")}` : "request validation failed";
 }
@@ -5480,7 +5589,7 @@ function resolveQueryNamespaceWritablePreflight(caps, params, authenticatedPrinc
 }
 
 // src/admin/admin-surfaces.ts
-import path7 from "path";
+import path8 from "path";
 var REDACTED = "<redacted>";
 var SENSITIVE_KEY_RE = /(token|secret|password|api[_-]?key|bearer|authorization|credential|private[_-]?key)/i;
 var BEARER_VALUE_RE = /^(bearer|sk-|pk-|xox[bp]-|AKIA)/i;
@@ -5763,7 +5872,7 @@ async function auditTranscripts(memoryDir) {
     movedEntries: file.groups.reduce((sum, group) => sum + group.entryCount, 0),
     unmovableLines: file.unmovableLines
   }));
-  const mixedOtherDefault = files.some((file) => file.sourceRelPath.split(path7.sep).includes("other"));
+  const mixedOtherDefault = files.some((file) => file.sourceRelPath.split(path8.sep).includes("other"));
   const summary = plan.movedEntries === 0 ? "No mixed-session transcript data detected; nothing to migrate." : `Found ${plan.movedEntries} entries across ${plan.distinctSessions} distinct sessions stranded in shared/legacy directories. Run the CLI migration command to re-home them.`;
   return {
     generatedAt: plan.generatedAt,
@@ -8129,7 +8238,7 @@ import { createHash as createHash5 } from "crypto";
 import * as nodePath2 from "path";
 
 // src/orchestration/recall-result-formatter.ts
-import path8 from "path";
+import path9 from "path";
 function renderConnectorLabel(connector) {
   if (!isValidConnectorId(connector)) return null;
   return connector.length <= CONNECTOR_LABEL_MAX_LENGTH ? connector : `${connector.slice(0, CONNECTOR_LABEL_MAX_LENGTH - 1)}\u2026`;
@@ -8151,15 +8260,15 @@ function resolveEffectiveIdentityInjectionMode(options) {
   return { mode: options.configuredMode, shouldInject: true };
 }
 function displayResultPath(resultPath, memoryDir, namespace) {
-  if (!path8.isAbsolute(resultPath)) return resultPath;
-  const root = path8.resolve(memoryDir);
-  const nsRoot = path8.join(root, "namespaces");
-  if (namespace && (resultPath === nsRoot || resultPath.startsWith(nsRoot + path8.sep))) {
-    const afterNs = path8.relative(nsRoot, resultPath).split(path8.sep).slice(1).join("/");
+  if (!path9.isAbsolute(resultPath)) return resultPath;
+  const root = path9.resolve(memoryDir);
+  const nsRoot = path9.join(root, "namespaces");
+  if (namespace && (resultPath === nsRoot || resultPath.startsWith(nsRoot + path9.sep))) {
+    const afterNs = path9.relative(nsRoot, resultPath).split(path9.sep).slice(1).join("/");
     if (afterNs) return `${namespace}/${afterNs}`;
   }
-  const rel = path8.relative(root, resultPath);
-  return rel && !rel.startsWith("..") && !path8.isAbsolute(rel) ? rel.split(path8.sep).join("/") : resultPath;
+  const rel = path9.relative(root, resultPath);
+  return rel && !rel.startsWith("..") && !path9.isAbsolute(rel) ? rel.split(path9.sep).join("/") : resultPath;
 }
 function displaySafeBudgetsApplied(budgetsApplied, memoryDir) {
   if (!budgetsApplied?.includedMemoryPaths) return budgetsApplied;
@@ -12146,41 +12255,40 @@ var EngramAccessService = class {
   }
   // ── Memory search & debug ─────────────────────────────────────────────
   async memorySearch(request) {
-    const { query, namespace, maxResults, principal } = request;
-    const collection = request.collection?.trim();
-    if (request.collection !== void 0 && !collection) {
-      throw new EngramAccessInputError("collection must be a non-empty string");
-    }
-    let results;
-    if (!resolveNamespaceCapabilities(this.orchestrator.config).namespaces) {
-      this.resolveReadableNamespace(namespace, principal);
-      results = collection === "global" ? await this.orchestrator.qmd.searchGlobal(query, maxResults) : await this.orchestrator.qmd.search(query, collection, maxResults);
-    } else {
-      const readableNamespaces = await this.resolveReadableNamespacesForSearch(namespace, principal);
-      const namespaces = this.resolveMemorySearchNamespacesForCollection(
-        collection,
-        readableNamespaces,
-        namespace?.trim() ? void 0 : principal
-      );
-      results = await runMemorySearchFanout({
-        query,
-        namespaces,
-        maxResults,
-        principal,
-        requestedNamespace: namespace,
-        collection,
-        search: (params) => this.orchestrator.searchAcrossNamespaces(params)
-      });
-    }
-    return {
-      query,
-      results: results.map((r) => ({
-        path: r.path,
-        score: r.score,
-        snippet: (r.snippet ?? "").slice(0, 800)
-      })),
-      count: results.length
-    };
+    const { qmd, config } = this.orchestrator;
+    return memorySearchThroughScope(
+      {
+        namespacesEnabled: resolveNamespaceCapabilities(config).namespaces,
+        // `0` is preserved, never coerced: a zero limit is a runtime
+        // compatibility guarantee (AGENTS.md guardrail 4), and it means the
+        // same thing here as an explicit `maxResults: 0` from the caller - an
+        // empty result with no backend call. Anything non-numeric falls back
+        // to the documented default.
+        defaultBudget: typeof config.qmdMaxResults === "number" ? config.qmdMaxResults : 10,
+        // Search-specific: artifacts and the other dedicated surfaces stay
+        // out, but ARCHIVED memories remain findable - explicit search is one
+        // of the surfaces the lifecycle reserves them for.
+        isExcluded: (memoryPath) => isSearchExcludedPath(
+          memoryPath,
+          // The caller's own collection disambiguates a prefix that is also
+          // a memory category name (`collection: "facts"`).
+          { ...config, requestedCollection: request.collection?.trim() || void 0 },
+          "qmd"
+        ),
+        authorizeFlatCorpus: (namespace, principal) => {
+          this.resolveReadableNamespace(namespace, principal);
+        },
+        authorizeNamespaces: async (namespace, principal, collection) => this.resolveMemorySearchNamespacesForCollection(
+          collection,
+          await this.resolveReadableNamespacesForSearch(namespace, principal),
+          namespace?.trim() ? void 0 : principal
+        ),
+        searchAcrossNamespaces: (params) => this.orchestrator.searchAcrossNamespaces(params),
+        searchGlobal: (query, maxResults) => qmd.searchGlobal(query, maxResults),
+        search: (query, collection, maxResults) => qmd.search(query, collection, maxResults)
+      },
+      request
+    );
   }
   async memoryProfile(namespace, principal) {
     const resolvedNs = this.resolveReadableNamespace(namespace, principal);
@@ -12702,7 +12810,7 @@ var EngramAccessService = class {
     const resolvedNamespace = this.resolveReadableNamespace(options.namespace, options.principal);
     const storage = await offlineSyncStorageForSnapshot(this.orchestrator, resolvedNamespace);
     const storageHash = createHash6("sha256").update(storage.dir).digest("hex").slice(0, 16);
-    const deletions = [...await storage.readDeletionRevisions()].map(([path9, mtimeMs]) => ({ path: path9, mtimeMs }));
+    const deletions = [...await storage.readDeletionRevisions()].map(([path10, mtimeMs]) => ({ path: path10, mtimeMs }));
     const snapshotBuilder = options.includeContent === false && options.baseFiles && options.baseFiles.length > 0 ? buildOfflineSyncSnapshotFromBase : buildOfflineSyncSnapshot;
     const snapshot = await snapshotBuilder({
       root: storage.dir,
@@ -12727,7 +12835,7 @@ var EngramAccessService = class {
     const storageHash = createHash6("sha256").update(storage.dir).digest("hex").slice(0, 16);
     const deletions = await filterOfflineSyncDeletionRevisions({
       root: storage.dir,
-      deletions: [...await storage.readDeletionRevisions()].map(([path9, mtimeMs]) => ({ path: path9, mtimeMs })),
+      deletions: [...await storage.readDeletionRevisions()].map(([path10, mtimeMs]) => ({ path: path10, mtimeMs })),
       includeTranscripts: options.includeTranscripts !== false,
       userExcludeRegexps: this.offlineSyncUserExcludes
     });
@@ -13376,6 +13484,9 @@ export {
   CorrectionContractError,
   detectPassiveCorrections,
   capturePassiveCorrections,
+  isTopLevelArchivePath,
+  isGenericRecallExcludedPath,
+  filterRecallCandidates,
   clusterByKey,
   computeProcedureStats,
   formatProcedureStatsText,
@@ -13412,4 +13523,4 @@ export {
   EngramAccessService,
   AccessAdminOpsSurface
 };
-//# sourceMappingURL=chunk-RCU25Z66.js.map
+//# sourceMappingURL=chunk-IXH2U2QT.js.map