@remnic/core 9.43.0 → 9.44.0

package/src/orchestrator-convergence-refresh.test.ts

@@ -0,0 +1,114 @@
+import assert from "node:assert/strict";
+import { mkdtemp, rm } from "node:fs/promises";
+import os from "node:os";
+import path from "node:path";
+import test from "node:test";
+
+import { readProjectedMemoryBrowse } from "./memory-projection-store.js";
+import { Orchestrator } from "./orchestrator.js";
+import { StorageManager } from "./storage.js";
+
+test("refreshNamespacesAfterConvergence runs one strict QMD batch and rebuilds each namespace projection once", async () => {
+  const teamDir = await mkdtemp(path.join(os.tmpdir(), "remnic-convergence-team-"));
+  const sharedDir = await mkdtemp(path.join(os.tmpdir(), "remnic-convergence-shared-"));
+  try {
+    const teamStorage = new StorageManager(teamDir);
+    const sharedStorage = new StorageManager(sharedDir);
+    const teamMemory = await teamStorage.writeMemory("fact", "A received team fact.", {
+      source: "test",
+    });
+    const sharedMemory = await sharedStorage.writeMemory("fact", "A received shared fact.", {
+      source: "test",
+    });
+    const qmdCalls: Array<{
+      namespaces: string[];
+      options: { strict?: boolean } | undefined;
+    }> = [];
+    const storageCalls: string[] = [];
+    const orchestrator = Object.create(Orchestrator.prototype) as Orchestrator;
+    const internals = orchestrator as unknown as {
+      config: { defaultNamespace: string };
+      namespaceSearchRouter: {
+        updateNamespacesDetailed(
+          namespaces: string[],
+          execution?: unknown,
+          options?: { strict?: boolean }
+        ): Promise<{ backendCount: number; eligibleNamespaces: string[] }>;
+      };
+      getStorage(namespace: string): Promise<StorageManager>;
+    };
+    internals.config = { defaultNamespace: "default" };
+    internals.namespaceSearchRouter = {
+      async updateNamespacesDetailed(namespaces, _execution, options) {
+        qmdCalls.push({ namespaces, options });
+        return { backendCount: 1, eligibleNamespaces: namespaces };
+      },
+    };
+    const storageByNamespace = new Map([
+      ["team", teamStorage],
+      ["shared", sharedStorage],
+    ]);
+    internals.getStorage = async (namespace) => {
+      storageCalls.push(namespace);
+      const storage = storageByNamespace.get(namespace);
+      assert.ok(storage);
+      return storage;
+    };
+    const refreshSurface = orchestrator as unknown as {
+      refreshNamespacesAfterConvergence(namespaces: readonly string[]): Promise<void>;
+    };
+
+    await refreshSurface.refreshNamespacesAfterConvergence(["team", "shared", "team"]);
+
+    assert.deepEqual(qmdCalls, [
+      {
+        namespaces: ["team", "shared"],
+        options: { strict: true },
+      },
+    ]);
+    assert.deepEqual(storageCalls, ["team", "shared"]);
+    const teamProjection = readProjectedMemoryBrowse(teamDir, { limit: 10, offset: 0 });
+    const sharedProjection = readProjectedMemoryBrowse(sharedDir, { limit: 10, offset: 0 });
+    assert.equal(teamProjection?.memories[0]?.id, teamMemory.id);
+    assert.equal(sharedProjection?.memories[0]?.id, sharedMemory.id);
+  } finally {
+    await Promise.all([rm(teamDir, { recursive: true, force: true }), rm(sharedDir, { recursive: true, force: true })]);
+  }
+});
+
+test("refreshNamespacesAfterConvergence rebuilds projection when search is disabled", async () => {
+  const memoryDir = await mkdtemp(path.join(os.tmpdir(), "remnic-convergence-no-search-"));
+  try {
+    const storage = new StorageManager(memoryDir);
+    const memory = await storage.writeMemory("fact", "A received fact without search enabled.", {
+      source: "test",
+    });
+    const orchestrator = Object.create(Orchestrator.prototype) as Orchestrator;
+    const internals = orchestrator as unknown as {
+      namespaceSearchRouter: {
+        updateNamespacesDetailed(
+          namespaces: string[],
+          execution?: unknown,
+          options?: { strict?: boolean }
+        ): Promise<{ backendCount: number; eligibleNamespaces: string[] }>;
+      };
+      getStorage(namespace: string): Promise<StorageManager>;
+    };
+    internals.namespaceSearchRouter = {
+      async updateNamespacesDetailed() {
+        return { backendCount: 0, eligibleNamespaces: [] };
+      },
+    };
+    internals.getStorage = async () => storage;
+    const refreshSurface = orchestrator as unknown as {
+      refreshNamespacesAfterConvergence(namespaces: readonly string[]): Promise<void>;
+    };
+
+    await refreshSurface.refreshNamespacesAfterConvergence(["default"]);
+
+    const projection = readProjectedMemoryBrowse(memoryDir, { limit: 10, offset: 0 });
+    assert.equal(projection?.memories[0]?.id, memory.id);
+  } finally {
+    await rm(memoryDir, { recursive: true, force: true });
+  }
+});

package/src/orchestrator.ts

@@ -218,6 +218,7 @@ import {
   runPatternReinforcement,
   type PatternReinforcementResult,
 } from "./maintenance/pattern-reinforcement.js";
+import { refreshConvergedNamespaces } from "./convergence-refresh.js";
 import { ModelRegistry } from "./model-registry.js";
 import { applyRuntimeRetrievalPolicy, expandQuery } from "./retrieval.js";
 import {
@@ -1278,11 +1279,11 @@ export class Orchestrator {
     return await this.namespaceSearchRouter.healthForNamespace(namespace, execution);
   }
 
-  private isSearchAvailableForNamespaceRouting(): boolean {
-    if (resolveNamespaceCapabilities(this.config).namespaces) return true;
-    return this.qmd.isAvailable();
+  async refreshNamespacesAfterConvergence(namespaces: readonly string[]): Promise<void> {
+    return refreshConvergedNamespaces(namespaces, this.namespaceSearchRouter, this.getStorage.bind(this));
   }
 
+
   invalidateLiveContentHashIndex(): void {
     this.contentHashIndex = null;
     this.contentHashIndexesByStorageDir.clear();
@@ -1530,7 +1531,7 @@ export class Orchestrator {
     });
     this.contradictionLinkingCoordinator = new ContradictionLinkingCoordinator({
       getConfig: () => this.config,
-      isSearchAvailable: () => this.isSearchAvailableForNamespaceRouting(),
+      isSearchAvailable: () => resolveNamespaceCapabilities(this.config).namespaces || this.qmd.isAvailable(),
       searchAcrossNamespaces: (options) => this.searchAcrossNamespaces(options),
       extractMemoryIdsFromResults: (results) => this.extractMemoryIdsFromResults(results),
       namespaceFromPath: (p) => this.namespaceFromPath(p),