@remnic/core 9.3.634 → 9.3.635

package/dist/search/index.js

@@ -2,13 +2,13 @@ import {
   createConversationIndexRuntime,
   createConversationSearchBackend,
   createSearchBackend
-} from "../chunk-YRMKDTKF.js";
+} from "../chunk-RAGXUVQW.js";
 import {
   RemoteSearchBackend
 } from "../chunk-JOASJWQR.js";
 import {
   EmbedHelper
-} from "../chunk-EWLQPEO6.js";
+} from "../chunk-RN7MUWON.js";
 import {
   LanceDbBackend
 } from "../chunk-3MAONBX3.js";
@@ -29,14 +29,14 @@ import "../chunk-Q6YIJGXJ.js";
 import "../chunk-ORFGK3XI.js";
 import "../chunk-OIF36KGD.js";
 import "../chunk-7DTASS5T.js";
-import "../chunk-TZVQQTG4.js";
+import "../chunk-DEDTFRH2.js";
 import "../chunk-FAV25DUZ.js";
-import "../chunk-3ONXXHQO.js";
-import "../chunk-PVGDJXVK.js";
 import "../chunk-NNVTUXEB.js";
+import "../chunk-3ONXXHQO.js";
 import "../chunk-CPPS65WS.js";
 import "../chunk-JUC24CTX.js";
 import "../chunk-2ODBA7MQ.js";
+import "../chunk-PVGDJXVK.js";
 import "../chunk-PZ5AY32C.js";
 export {
   EmbedHelper,

package/dist/search/lancedb-backend.js

@@ -4,8 +4,8 @@ import {
 import "../chunk-Q4CAQGKQ.js";
 import "../chunk-CINZGPSJ.js";
 import "../chunk-FAV25DUZ.js";
-import "../chunk-PVGDJXVK.js";
 import "../chunk-2ODBA7MQ.js";
+import "../chunk-PVGDJXVK.js";
 import "../chunk-PZ5AY32C.js";
 export {
   LanceDbBackend

package/dist/search/meilisearch-backend.js

@@ -4,8 +4,8 @@ import {
 import "../chunk-Q4CAQGKQ.js";
 import "../chunk-CINZGPSJ.js";
 import "../chunk-FAV25DUZ.js";
-import "../chunk-PVGDJXVK.js";
 import "../chunk-2ODBA7MQ.js";
+import "../chunk-PVGDJXVK.js";
 import "../chunk-PZ5AY32C.js";
 export {
   MeilisearchBackend

package/dist/search/orama-backend.js

@@ -5,8 +5,8 @@ import {
 import "../chunk-Q4CAQGKQ.js";
 import "../chunk-CINZGPSJ.js";
 import "../chunk-FAV25DUZ.js";
-import "../chunk-PVGDJXVK.js";
 import "../chunk-2ODBA7MQ.js";
+import "../chunk-PVGDJXVK.js";
 import "../chunk-PZ5AY32C.js";
 export {
   OramaBackend,

package/dist/shared-context/manager.d.ts

@@ -22,9 +22,9 @@ declare const SharedFeedbackEntrySchema: z.ZodObject<{
     date: string;
     agent: string;
     reason: string;
-    confidence?: number | undefined;
     workflow?: string | undefined;
     tags?: string[] | undefined;
+    confidence?: number | undefined;
     severity?: "high" | "low" | "medium" | undefined;
     outcome?: string | undefined;
     refs?: string[] | undefined;
@@ -36,9 +36,9 @@ declare const SharedFeedbackEntrySchema: z.ZodObject<{
     date: string;
     agent: string;
     reason: string;
-    confidence?: number | undefined;
     workflow?: string | undefined;
     tags?: string[] | undefined;
+    confidence?: number | undefined;
     severity?: "high" | "low" | "medium" | undefined;
     outcome?: string | undefined;
     refs?: string[] | undefined;

package/dist/transfer/types.d.ts

@@ -313,13 +313,13 @@ declare const CapsuleBlockSchema: z.ZodObject<{
         peerProfiles: boolean;
     }>;
 }, "strip", z.ZodTypeAny, {
+    schemaVersion: string;
     includes: {
         procedural: boolean;
         taxonomy: boolean;
         identityAnchors: boolean;
         peerProfiles: boolean;
     };
-    schemaVersion: string;
     id: string;
     description: string;
     version: string;
@@ -334,13 +334,13 @@ declare const CapsuleBlockSchema: z.ZodObject<{
         directAnswerEnabled: boolean;
     };
 }, {
+    schemaVersion: string;
     includes: {
         procedural: boolean;
         taxonomy: boolean;
         identityAnchors: boolean;
         peerProfiles: boolean;
     };
-    schemaVersion: string;
     id: string;
     description: string;
     version: string;
@@ -464,13 +464,13 @@ declare const ExportManifestV2Schema: z.ZodObject<{
             peerProfiles: boolean;
         }>;
     }, "strip", z.ZodTypeAny, {
+        schemaVersion: string;
         includes: {
             procedural: boolean;
             taxonomy: boolean;
             identityAnchors: boolean;
             peerProfiles: boolean;
         };
-        schemaVersion: string;
         id: string;
         description: string;
         version: string;
@@ -485,13 +485,13 @@ declare const ExportManifestV2Schema: z.ZodObject<{
             directAnswerEnabled: boolean;
         };
     }, {
+        schemaVersion: string;
         includes: {
             procedural: boolean;
             taxonomy: boolean;
             identityAnchors: boolean;
             peerProfiles: boolean;
         };
-        schemaVersion: string;
         id: string;
         description: string;
         version: string;
@@ -518,13 +518,13 @@ declare const ExportManifestV2Schema: z.ZodObject<{
     pluginVersion: string;
     includesTranscripts: boolean;
     capsule: {
+        schemaVersion: string;
         includes: {
             procedural: boolean;
             taxonomy: boolean;
             identityAnchors: boolean;
             peerProfiles: boolean;
         };
-        schemaVersion: string;
         id: string;
         description: string;
         version: string;
@@ -551,13 +551,13 @@ declare const ExportManifestV2Schema: z.ZodObject<{
     pluginVersion: string;
     includesTranscripts: boolean;
     capsule: {
+        schemaVersion: string;
         includes: {
             procedural: boolean;
             taxonomy: boolean;
             identityAnchors: boolean;
             peerProfiles: boolean;
         };
-        schemaVersion: string;
         id: string;
         description: string;
         version: string;
@@ -683,13 +683,13 @@ declare const ExportBundleV2Schema: z.ZodObject<{
                 peerProfiles: boolean;
             }>;
         }, "strip", z.ZodTypeAny, {
+            schemaVersion: string;
             includes: {
                 procedural: boolean;
                 taxonomy: boolean;
                 identityAnchors: boolean;
                 peerProfiles: boolean;
             };
-            schemaVersion: string;
             id: string;
             description: string;
             version: string;
@@ -704,13 +704,13 @@ declare const ExportBundleV2Schema: z.ZodObject<{
                 directAnswerEnabled: boolean;
             };
         }, {
+            schemaVersion: string;
             includes: {
                 procedural: boolean;
                 taxonomy: boolean;
                 identityAnchors: boolean;
                 peerProfiles: boolean;
             };
-            schemaVersion: string;
             id: string;
             description: string;
             version: string;
@@ -737,13 +737,13 @@ declare const ExportBundleV2Schema: z.ZodObject<{
         pluginVersion: string;
         includesTranscripts: boolean;
         capsule: {
+            schemaVersion: string;
             includes: {
                 procedural: boolean;
                 taxonomy: boolean;
                 identityAnchors: boolean;
                 peerProfiles: boolean;
             };
-            schemaVersion: string;
             id: string;
             description: string;
             version: string;
@@ -770,13 +770,13 @@ declare const ExportBundleV2Schema: z.ZodObject<{
         pluginVersion: string;
         includesTranscripts: boolean;
         capsule: {
+            schemaVersion: string;
             includes: {
                 procedural: boolean;
                 taxonomy: boolean;
                 identityAnchors: boolean;
                 peerProfiles: boolean;
             };
-            schemaVersion: string;
             id: string;
             description: string;
             version: string;
@@ -815,13 +815,13 @@ declare const ExportBundleV2Schema: z.ZodObject<{
         pluginVersion: string;
         includesTranscripts: boolean;
         capsule: {
+            schemaVersion: string;
             includes: {
                 procedural: boolean;
                 taxonomy: boolean;
                 identityAnchors: boolean;
                 peerProfiles: boolean;
             };
-            schemaVersion: string;
             id: string;
             description: string;
             version: string;
@@ -854,13 +854,13 @@ declare const ExportBundleV2Schema: z.ZodObject<{
         pluginVersion: string;
         includesTranscripts: boolean;
         capsule: {
+            schemaVersion: string;
             includes: {
                 procedural: boolean;
                 taxonomy: boolean;
                 identityAnchors: boolean;
                 peerProfiles: boolean;
             };
-            schemaVersion: string;
             id: string;
             description: string;
             version: string;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@remnic/core",
-  "version": "9.3.634",
+  "version": "9.3.635",
   "description": "Framework-agnostic Remnic memory engine — orchestrator, storage, extraction, search, trust zones",
   "type": "module",
   "main": "dist/index.js",

package/src/access-mcp.ts

@@ -1433,7 +1433,7 @@ export class EngramMcpServer {
             query: { type: "string" },
             namespace: { type: "string" },
             maxResults: { type: "number" },
-            collection: { type: "string", description: "QMD collection (omit for memory, 'global' for all)" },
+            collection: { type: "string", description: "QMD collection. With namespaces enabled, omitted, base, and 'global' searches stay scoped to readable namespaces; namespace-derived collections require matching namespace access." },
           },
           required: ["query"],
           additionalProperties: false,

package/src/access-service-namespace.test.ts

@@ -6,6 +6,7 @@ import path from "node:path";
 import test from "node:test";
 
 import { EngramAccessInputError, EngramAccessService } from "./access-service.js";
+import { namespaceCollectionName } from "./namespaces/search.js";
 import type { StorageManager } from "./storage.js";
 import type { PluginConfig } from "./types.js";
 
@@ -25,6 +26,8 @@ function makeConfig(): PluginConfig {
     daySum: { enabled: false },
     searchBackend: "orama",
     qmd: { enabled: false },
+    qmdCollection: "test-memory",
+    qmdMaxResults: 10,
     nativeKnowledge: { enabled: false },
     recall: { budget: {} },
     consolidation: { enabled: false },
@@ -50,14 +53,35 @@ function makeService(): {
   (service as unknown as {
     orchestrator: {
       config: PluginConfig;
+      qmd: {
+        search(query: string, collection?: string, maxResults?: number): Promise<unknown[]>;
+        searchGlobal(query: string, maxResults?: number): Promise<unknown[]>;
+      };
       getStorage(namespace: string): Promise<StorageManager>;
+      searchAcrossNamespaces(params: {
+        query: string;
+        namespaces?: string[];
+        maxResults?: number;
+        mode?: string;
+      }): Promise<unknown[]>;
     };
   }).orchestrator = {
     config: makeConfig(),
+    qmd: {
+      async search() {
+        throw new Error("qmd.search should not run in namespace mode");
+      },
+      async searchGlobal() {
+        throw new Error("qmd.searchGlobal should not run in namespace mode");
+      },
+    },
     async getStorage(namespace: string): Promise<StorageManager> {
       getStorageCalls.push(namespace);
       return storage;
     },
+    async searchAcrossNamespaces() {
+      return [];
+    },
   };
 
   return { service, storage, getStorageCalls };
@@ -126,6 +150,294 @@ test("memoryBrowse resolves namespace storage for read principals", async () =>
   assert.deepEqual(getStorageCalls, ["team"]);
 });
 
+test("memorySearch without an explicit namespace uses readable recall namespaces", async () => {
+  const { service } = makeService();
+  let searchParams: unknown;
+  (service as unknown as {
+    orchestrator: {
+      searchAcrossNamespaces(params: unknown): Promise<Array<{ path: string; score: number; snippet: string }>>;
+    };
+  }).orchestrator.searchAcrossNamespaces = async (params) => {
+    searchParams = params;
+    return [{ path: "default/facts/a.md", score: 0.7, snippet: "matched" }];
+  };
+
+  const result = await service.memorySearch({
+    query: "deployment notes",
+    maxResults: 3,
+    principal: "reader",
+  });
+
+  assert.deepEqual(searchParams, {
+    query: "deployment notes",
+    namespaces: ["default", "shared"],
+    maxResults: 3,
+    mode: "search",
+  });
+  assert.equal(result.count, 1);
+});
+
+test("memorySearch with an explicit namespace searches only that readable namespace", async () => {
+  const { service } = makeService();
+  let searchParams: unknown;
+  (service as unknown as {
+    orchestrator: {
+      searchAcrossNamespaces(params: unknown): Promise<unknown[]>;
+    };
+  }).orchestrator.searchAcrossNamespaces = async (params) => {
+    searchParams = params;
+    return [];
+  };
+
+  await service.memorySearch({
+    query: "release note",
+    namespace: "team",
+    maxResults: 2,
+    principal: "reader",
+  });
+
+  assert.deepEqual(searchParams, {
+    query: "release note",
+    namespaces: ["team"],
+    maxResults: 2,
+    mode: "search",
+  });
+});
+
+test("memorySearch rejects unreadable namespaces before collection routing", async () => {
+  const { service } = makeService();
+  let searchCalls = 0;
+  (service as unknown as {
+    orchestrator: {
+      searchAcrossNamespaces(params: unknown): Promise<unknown[]>;
+    };
+  }).orchestrator.searchAcrossNamespaces = async () => {
+    searchCalls += 1;
+    return [];
+  };
+
+  await assert.rejects(
+    () =>
+      service.memorySearch({
+        query: "release note",
+        namespace: "team",
+        collection: namespaceCollectionName("test-memory", "team", {
+          defaultNamespace: "default",
+          useLegacyDefaultCollection: false,
+        }),
+        principal: "stranger",
+      }),
+    /namespace is not readable: team/,
+  );
+  assert.equal(searchCalls, 0);
+});
+
+test("memorySearch rejects empty collection names", async () => {
+  const { service } = makeService();
+  let searchCalls = 0;
+  (service as unknown as {
+    orchestrator: {
+      searchAcrossNamespaces(params: unknown): Promise<unknown[]>;
+    };
+  }).orchestrator.searchAcrossNamespaces = async () => {
+    searchCalls += 1;
+    return [];
+  };
+
+  await assert.rejects(
+    () =>
+      service.memorySearch({
+        query: "deployment notes",
+        collection: "   ",
+        principal: "reader",
+      }),
+    /collection must be a non-empty string/,
+  );
+  assert.equal(searchCalls, 0);
+});
+
+test("memorySearch treats global collection as ACL-scoped when namespaces are enabled", async () => {
+  const { service } = makeService();
+  let globalSearchCalls = 0;
+  let searchParams: unknown;
+  (service as unknown as {
+    orchestrator: {
+      qmd: {
+        searchGlobal(query: string, maxResults?: number): Promise<unknown[]>;
+      };
+      searchAcrossNamespaces(params: unknown): Promise<unknown[]>;
+    };
+  }).orchestrator.qmd.searchGlobal = async () => {
+    globalSearchCalls += 1;
+    return [];
+  };
+  (service as unknown as {
+    orchestrator: {
+      searchAcrossNamespaces(params: unknown): Promise<unknown[]>;
+    };
+  }).orchestrator.searchAcrossNamespaces = async (params) => {
+    searchParams = params;
+    return [];
+  };
+
+  await service.memorySearch({
+    query: "runbook",
+    collection: "global",
+    principal: "reader",
+  });
+
+  assert.equal(globalSearchCalls, 0);
+  assert.deepEqual(searchParams, {
+    query: "runbook",
+    namespaces: ["default", "shared"],
+    maxResults: undefined,
+    mode: "search",
+  });
+});
+
+test("memorySearch accepts a namespace-scoped collection for the requested namespace", async () => {
+  const { service } = makeService();
+  let searchParams: unknown;
+  (service as unknown as {
+    orchestrator: {
+      searchAcrossNamespaces(params: unknown): Promise<unknown[]>;
+    };
+  }).orchestrator.searchAcrossNamespaces = async (params) => {
+    searchParams = params;
+    return [];
+  };
+
+  await service.memorySearch({
+    query: "release note",
+    namespace: "team",
+    collection: namespaceCollectionName("test-memory", "team", {
+      defaultNamespace: "default",
+      useLegacyDefaultCollection: false,
+    }),
+    principal: "reader",
+  });
+
+  assert.deepEqual(searchParams, {
+    query: "release note",
+    namespaces: ["team"],
+    maxResults: undefined,
+    mode: "search",
+  });
+});
+
+test("memorySearch accepts a readable namespace-scoped collection without duplicate namespace", async () => {
+  const { service } = makeService();
+  let searchParams: unknown;
+  (service as unknown as {
+    orchestrator: {
+      searchAcrossNamespaces(params: unknown): Promise<unknown[]>;
+    };
+  }).orchestrator.searchAcrossNamespaces = async (params) => {
+    searchParams = params;
+    return [];
+  };
+
+  await service.memorySearch({
+    query: "release note",
+    collection: namespaceCollectionName("test-memory", "team", {
+      defaultNamespace: "default",
+      useLegacyDefaultCollection: false,
+    }),
+    principal: "reader",
+  });
+
+  assert.deepEqual(searchParams, {
+    query: "release note",
+    namespaces: ["team"],
+    maxResults: undefined,
+    mode: "search",
+  });
+});
+
+test("memorySearch rejects arbitrary custom collections when namespaces are enabled", async () => {
+  const { service } = makeService();
+  let qmdSearchCalls = 0;
+  (service as unknown as {
+    orchestrator: {
+      qmd: {
+        search(query: string, collection?: string, maxResults?: number): Promise<unknown[]>;
+      };
+    };
+  }).orchestrator.qmd.search = async () => {
+    qmdSearchCalls += 1;
+    return [];
+  };
+
+  await assert.rejects(
+    () =>
+      service.memorySearch({
+        query: "deployment notes",
+        collection: "custom-collection",
+        principal: "reader",
+      }),
+    /collection is not namespace-scoped for the requested principal/,
+  );
+  assert.equal(qmdSearchCalls, 0);
+});
+
+test("memorySearch honors custom collections when namespaces are disabled", async () => {
+  const { service } = makeService();
+  (service as unknown as { orchestrator: { config: PluginConfig } }).orchestrator.config = {
+    ...makeConfig(),
+    namespacesEnabled: false,
+  };
+  let qmdSearchArgs: unknown[] | undefined;
+  (service as unknown as {
+    orchestrator: {
+      qmd: {
+        search(query: string, collection?: string, maxResults?: number): Promise<unknown[]>;
+      };
+    };
+  }).orchestrator.qmd.search = async (...args) => {
+    qmdSearchArgs = args;
+    return [{ path: "facts/a.md", score: 0.5, snippet: "matched" }];
+  };
+
+  const result = await service.memorySearch({
+    query: "deployment notes",
+    collection: "custom-collection",
+    maxResults: 4,
+  });
+
+  assert.deepEqual(qmdSearchArgs, ["deployment notes", "custom-collection", 4]);
+  assert.equal(result.count, 1);
+});
+
+test("memorySearch rejects unsupported namespaces when namespaces are disabled", async () => {
+  const { service } = makeService();
+  (service as unknown as { orchestrator: { config: PluginConfig } }).orchestrator.config = {
+    ...makeConfig(),
+    namespacesEnabled: false,
+  };
+  let qmdSearchCalls = 0;
+  (service as unknown as {
+    orchestrator: {
+      qmd: {
+        search(query: string, collection?: string, maxResults?: number): Promise<unknown[]>;
+      };
+    };
+  }).orchestrator.qmd.search = async () => {
+    qmdSearchCalls += 1;
+    return [];
+  };
+
+  await assert.rejects(
+    () =>
+      service.memorySearch({
+        query: "deployment notes",
+        namespace: "team",
+        collection: "custom-collection",
+      }),
+    /unsupported namespace: team/,
+  );
+  assert.equal(qmdSearchCalls, 0);
+});
+
 test("offlineSyncFiles reports invalid requested paths as input errors", async () => {
   const { service } = makeService();
   (service as unknown as {