@remnic/core 9.7.14 → 9.8.0

package/src/faithfulness-graph-guard.test.ts

@@ -26,6 +26,8 @@ import { readEdges } from "./graph.js";
 import type { ExtractionResult, PluginConfig } from "./types.js";
 import type { LocalLlmClient } from "./local-llm.js";
 import type { BufferTurn, ConversationThread } from "./types.js";
+import type { PersistExtractionFn } from "./testing/orchestrator-lite.js";
+import type { StorageManager } from "./storage.js";
 
 /**
  * Stub local LLM whose `chatCompletion` only answers faithfulness-gate calls
@@ -126,33 +128,18 @@ test("pending_review fact gets no graph edge; an active fact with the same entit
       faithfulnessStubLocalLlm((c) =>
         c.includes("closed permanently") ? "unsupported" : "entailed",
       );
-    const storage = await (orchestrator as unknown as {
-      getStorage: (ns: string) => Promise<{
-        ensureDirectories: () => Promise<void>;
-        readAllMemories: () => Promise<
-          Array<{
-            path: string;
-            frontmatter: { id: string; status?: string };
-          }>
-        >;
-      }>;
-    }).getStorage("default");
+    // getStorage + persistExtraction are private; reach them through a named production-typed surface.
+    const persist = orchestrator as unknown as {
+      getStorage: (ns: string) => Promise<StorageManager>;
+      persistExtraction: PersistExtractionFn;
+    };
+    const storage = await persist.getStorage("default");
     await storage.ensureDirectories();
 
     const sourceText =
       "The widget factory produces widgets. It launched last year. The team is small.";
 
-    const ids0 = await (orchestrator as unknown as {
-      persistExtraction: (
-        r: ExtractionResult,
-        s: unknown,
-        t: unknown,
-        ctx: unknown,
-        bn: unknown,
-        plan: unknown,
-        src: string,
-      ) => Promise<string[]>;
-    }).persistExtraction(
+    const { persistedIds: ids0 } = await persist.persistExtraction(
       factResult("The widget factory produces widgets daily.", "widget-factory"),
       storage,
       null,
@@ -166,17 +153,7 @@ test("pending_review fact gets no graph edge; an active fact with the same entit
 
     // fact1 → unsupported (pending_review). Under the bug it would originate an
     // entity edge to fact0; under the guard it must NOT.
-    const ids1 = await (orchestrator as unknown as {
-      persistExtraction: (
-        r: ExtractionResult,
-        s: unknown,
-        t: unknown,
-        ctx: unknown,
-        bn: unknown,
-        plan: unknown,
-        src: string,
-      ) => Promise<string[]>;
-    }).persistExtraction(
+    const { persistedIds: ids1 } = await persist.persistExtraction(
       factResult(
         "The widget factory closed permanently.",
         "widget-factory",
@@ -216,17 +193,7 @@ test("pending_review fact gets no graph edge; an active fact with the same entit
 
     // Control: an ACTIVE fact with the same entityRef DOES create entity edges
     // (proving the graph is wired and only pending_review is excluded).
-    const ids2 = await (orchestrator as unknown as {
-      persistExtraction: (
-        r: ExtractionResult,
-        s: unknown,
-        t: unknown,
-        ctx: unknown,
-        bn: unknown,
-        plan: unknown,
-        src: string,
-      ) => Promise<string[]>;
-    }).persistExtraction(
+    const { persistedIds: ids2 } = await persist.persistExtraction(
       factResult("The widget factory reopened this quarter.", "widget-factory"),
       storage,
       null,
@@ -312,26 +279,6 @@ function twoFactResult(
   } as unknown as ExtractionResult;
 }
 
-interface StorageLike {
-  ensureDirectories: () => Promise<void>;
-  dir: string;
-  readAllMemories: () => Promise<
-    Array<{ path: string; frontmatter: { id: string; status?: string } }>
-  >;
-}
-
-interface PersistExtractionSig {
-  (
-    r: ExtractionResult,
-    s: unknown,
-    t: string | null,
-    ctx: unknown,
-    bn: unknown,
-    plan: unknown,
-    src: string,
-  ): Promise<string[]>;
-}
-
 test("pending_review id must NOT enter persisted thread episodes across a cross-flush (#1635)", async () => {
   const { orchestrator, memoryDir } = await makeThreadHarness();
   try {
@@ -342,7 +289,7 @@ test("pending_review id must NOT enter persisted thread episodes across a cross-
       );
 
     const getStorage = orchestrator as unknown as {
-      getStorage: (ns: string) => Promise<StorageLike>;
+      getStorage: (ns: string) => Promise<StorageManager>;
     };
     const storage = await getStorage.getStorage("default");
     await storage.ensureDirectories();
@@ -365,10 +312,10 @@ test("pending_review id must NOT enter persisted thread episodes across a cross-
     assert.ok(threadId, "thread established via processTurn");
 
     const persist = orchestrator as unknown as {
-      persistExtraction: PersistExtractionSig;
+      persistExtraction: PersistExtractionFn;
       appendPersistedThreadEpisodes: (
         threadId: string,
-        persistedIds: string[],
+        persistedIds: string[]
       ) => Promise<void>;
     };
 
@@ -376,7 +323,7 @@ test("pending_review id must NOT enter persisted thread episodes across a cross-
       "The widget factory reopened this quarter after being closed permanently last year.";
 
     // --- Flush 1: an active fact + a pending_review fact, same thread ---
-    const flush1 = await persist.persistExtraction(
+    const { persistedIds: flush1 } = await persist.persistExtraction(
       twoFactResult(
         "The widget factory reopened this quarter.", "wf-active",
         "The widget factory closed permanently last year.", "wf-pending",
@@ -419,7 +366,7 @@ test("pending_review id must NOT enter persisted thread episodes across a cross-
     );
 
     // --- Flush 2: an active fact in the SAME thread ---
-    const flush2 = await persist.persistExtraction(
+    const { persistedIds: flush2 } = await persist.persistExtraction(
       factResult("The widget factory hired ten new engineers.", "wf-active"),
       storage,
       threadId,

package/src/graph-recall.test.ts

@@ -6,8 +6,39 @@ import {
   type GraphRecallOptions,
   runGraphRecall,
 } from "./graph-recall.js";
+import { mergeGraphExpandedResults } from "./orchestration/graph-recall-coordinator.js";
 import type { MemoryEdgeSource } from "./graph-retrieval.js";
 
+test("mergeGraphExpandedResults preserves same paths from different namespaces", () => {
+  const merged = mergeGraphExpandedResults(
+    [
+      {
+        docid: "default-memory",
+        path: "facts/same-id.md",
+        namespace: "default",
+        snippet: "default",
+        score: 0.8,
+      },
+      {
+        docid: "project-memory",
+        path: "facts/same-id.md",
+        namespace: "project-x",
+        snippet: "project",
+        score: 0.7,
+      },
+    ],
+    [],
+  );
+
+  assert.deepEqual(
+    merged.map((result) => [result.namespace, result.path]),
+    [
+      ["default", "facts/same-id.md"],
+      ["project-x", "facts/same-id.md"],
+    ],
+  );
+});
+
 const DEFAULT_CONFIG: GraphRecallConfig = {
   recallGraphEnabled: true,
   recallGraphDamping: 0.85,

package/src/graph.test.ts

@@ -1,5 +1,5 @@
 import assert from "node:assert/strict";
-import { mkdir, mkdtemp, rm, writeFile } from "node:fs/promises";
+import { appendFile, mkdir, mkdtemp, rename, rm, writeFile } from "node:fs/promises";
 import os from "node:os";
 import path from "node:path";
 import test from "node:test";
@@ -20,6 +20,7 @@ function makeGraphConfig(): GraphConfig {
     graphLateralInhibitionTopM: 0,
     graphTraversalConfidenceFloor: 0.2,
     graphTraversalPageRankIterations: 0,
+    graphEdgeCacheIncrementalEnabled: true,
   };
 }
 
@@ -132,3 +133,138 @@ async function writeGraphEdges(memoryDir: string, edges: GraphEdge[]): Promise<v
   await mkdir(path.dirname(filePath), { recursive: true });
   await writeFile(filePath, `${edges.map((edge) => JSON.stringify(edge)).join("\n")}\n`, "utf-8");
 }
+
+// ---------------------------------------------------------------------------
+// Incremental edge cache (issue #1904). onMemoryWritten pushes single-writer
+// appends into the warm cache in place and reloads only on a peer append.
+// These use a delete-the-file-then-traverse probe instead of a readAllEdges
+// spy: it proves the same invariant more robustly (a reload would read the
+// now-missing file and return nothing, so surviving edges prove no reload).
+// ---------------------------------------------------------------------------
+
+const onWriteOpts = {
+  entityRef: "Acme",
+  content: "",
+  created: "2026-01-01T00:00:00.000Z",
+};
+
+test("#1904: onMemoryWritten pushes appended edges into the warm cache in place (no reload)", async () => {
+  const memoryDir = await mkdtemp(path.join(os.tmpdir(), "remnic-graph-incr-"));
+  try {
+    await writeGraphEdges(memoryDir, [makeEdge("seed", "old-sibling")]);
+    const graph = new GraphIndex(memoryDir, makeGraphConfig());
+    // Warm the edge cache (records the file-size baseline).
+    await graph.spreadingActivation(["seed"]);
+    // Single-writer append through the write path.
+    await graph.onMemoryWritten({
+      ...onWriteOpts,
+      memoryPath: "facts/new.md",
+      entitySiblings: ["facts/sibling.md"],
+    });
+    // Delete the on-disk file: a full reload would now find nothing. The warm
+    // cache must still serve the just-appended edge, proving it was pushed in
+    // place rather than reconstructed from disk.
+    await rm(graphFilePath(memoryDir, "entity"), { force: true });
+    const activated = await graph.spreadingActivation(["facts/new.md"]);
+    const paths = new Set(activated.map((candidate) => candidate.path));
+    assert.ok(
+      paths.has("facts/sibling.md"),
+      "the in-place-pushed edge must remain traversable after the file is removed (no reload)",
+    );
+  } finally {
+    await rm(memoryDir, { recursive: true, force: true });
+  }
+});
+
+test("#1904: onMemoryWritten reloads the edge cache when a peer appended (size mismatch)", async () => {
+  const memoryDir = await mkdtemp(path.join(os.tmpdir(), "remnic-graph-peer-"));
+  try {
+    await writeGraphEdges(memoryDir, [makeEdge("seed", "old-sibling")]);
+    const graph = new GraphIndex(memoryDir, makeGraphConfig());
+    await graph.spreadingActivation(["seed"]); // warm + size baseline
+    // A peer process appends directly to the file, bypassing this GraphIndex so
+    // its size baseline does not account for the extra bytes.
+    const peerEdge = makeEdge("facts/new.md", "facts/peer.md");
+    await appendFile(graphFilePath(memoryDir, "entity"), `${JSON.stringify(peerEdge)}\n`, "utf8");
+    // Our own append: on-disk size now exceeds baseline + our bytes → mismatch.
+    await graph.onMemoryWritten({
+      ...onWriteOpts,
+      memoryPath: "facts/new.md",
+      entitySiblings: ["facts/sibling.md"],
+    });
+    // The size mismatch must have nulled the cache; the next traversal reloads
+    // and sees BOTH the peer edge and our edge. A stale in-place push would have
+    // missed the peer edge entirely.
+    const activated = await graph.spreadingActivation(["facts/new.md"]);
+    const paths = new Set(activated.map((candidate) => candidate.path));
+    assert.ok(paths.has("facts/peer.md"), "peer-appended edge must appear after the coherence reload");
+    assert.ok(paths.has("facts/sibling.md"), "our appended edge must also appear after the reload");
+  } finally {
+    await rm(memoryDir, { recursive: true, force: true });
+  }
+});
+
+test("#1904: graphEdgeCacheIncrementalEnabled=false nulls the edge cache on every write (legacy)", async () => {
+  const memoryDir = await mkdtemp(path.join(os.tmpdir(), "remnic-graph-legacy-"));
+  try {
+    await writeGraphEdges(memoryDir, [makeEdge("seed", "old-sibling")]);
+    const graph = new GraphIndex(memoryDir, { ...makeGraphConfig(), graphEdgeCacheIncrementalEnabled: false });
+    await graph.spreadingActivation(["seed"]); // warm
+    await graph.onMemoryWritten({
+      ...onWriteOpts,
+      memoryPath: "facts/new.md",
+      entitySiblings: ["facts/sibling.md"],
+    });
+    // Legacy: the cache was nulled, so the next traversal reloads from disk.
+    // Remove the file first — a nulled cache reloads nothing, proving the write
+    // did not extend a warm cache in place.
+    await rm(graphFilePath(memoryDir, "entity"), { force: true });
+    const activated = await graph.spreadingActivation(["facts/new.md"]);
+    const paths = new Set(activated.map((candidate) => candidate.path));
+    assert.ok(
+      !paths.has("facts/sibling.md"),
+      "legacy mode must null the cache on every write (nothing served after the file is removed)",
+    );
+  } finally {
+    await rm(memoryDir, { recursive: true, force: true });
+  }
+});
+
+test("#1904: onMemoryWritten reloads when an equal-length atomic rewrite changed the inode (Codex)", async () => {
+  const memoryDir = await mkdtemp(path.join(os.tmpdir(), "remnic-graph-rewrite-"));
+  try {
+    // Initial edge: seed -> old-sibling. An atomic rewrite later swaps the
+    // target to "new-sibling" (also 11 chars), so the JSONL line length is
+    // unchanged — a size-only check could not detect this. The temp+rename
+    // the decay writer uses changes the inode, which the identity check MUST
+    // treat as a divergence and force a reload.
+    await writeGraphEdges(memoryDir, [makeEdge("seed", "old-sibling")]);
+    const graph = new GraphIndex(memoryDir, makeGraphConfig());
+    await graph.spreadingActivation(["seed"]); // warm + identity baseline
+    // Peer (decay-style) equal-length atomic rewrite via temp + rename.
+    const file = graphFilePath(memoryDir, "entity");
+    const rewritten = `${JSON.stringify(makeEdge("seed", "new-sibling"))}\n`;
+    const tmp = `${file}.${process.pid}.${Date.now()}.tmp`;
+    await writeFile(tmp, rewritten, "utf8");
+    await rename(tmp, file);
+    // Our own append: the inode changed (temp+rename), so the cache must null
+    // and the next traversal must reload — making the rewritten target visible.
+    await graph.onMemoryWritten({
+      ...onWriteOpts,
+      memoryPath: "facts/new.md",
+      entitySiblings: ["facts/sibling.md"],
+    });
+    const activated = await graph.spreadingActivation(["seed"]);
+    const paths = new Set(activated.map((candidate) => candidate.path));
+    assert.ok(
+      paths.has("new-sibling"),
+      "an equal-length atomic rewrite changed the inode and must force a reload so the new target appears",
+    );
+    assert.ok(
+      !paths.has("old-sibling"),
+      "the pre-rewrite target must not linger (a stale in-place push would have kept it)",
+    );
+  } finally {
+    await rm(memoryDir, { recursive: true, force: true });
+  }
+});