fix: tighten hot-path session memory hygiene

Author: vicary

src/handlers/event.test.ts

@@ -68,7 +68,6 @@ class MockSessionManager {
       groupId,
       userGroupId,
       injectedMemories: false,
-      lastInjectionFactUuids: [],
       visibleFactUuids: [],
       messageCount: 0,
       pendingMessages: [],
@@ -263,7 +262,7 @@ class MockRedisCache {
   touchedGroupIds: string[] = [];
   metaByGroupId = new Map<
     string,
-    { lastQuery?: string; lastRefresh?: number; factUuids: string[] }
+    { lastQuery?: string; lastRefresh?: number }
   >();
 
   async touch(groupId: string) {
@@ -485,7 +484,6 @@ describe("event handler", () => {
     const redisCache = new MockRedisCache();
     redisCache.metaByGroupId.set("group-1", {
       lastQuery: "resume refresh from redis",
-      factUuids: [],
     });
     const graphitiAsync = new MockGraphitiAsync();
 
@@ -644,7 +642,6 @@ describe("event handler", () => {
     const redisCache = new MockRedisCache();
     redisCache.metaByGroupId.set("group-1", {
       lastQuery: "refresh after compact restart",
-      factUuids: [],
     });
     const graphitiAsync = new MockGraphitiAsync();
 

src/index.ts

@@ -96,6 +96,7 @@ export const graphiti: Plugin = (input: PluginInput) => {
     redisEvents,
     redisSnapshot,
     redisCache,
+    graphitiClient,
     {
       idleRetentionMs: config.falkordb.sessionTtlSeconds * 1000,
     },

src/services/graphiti-async.ts

@@ -25,9 +25,7 @@ export class GraphitiAsyncService {
       const entry: PersistentMemoryCacheEntry = {
         query: "primer",
         refreshedAt: Date.now(),
-        facts: [],
         nodes: [],
-        factUuids: [],
         nodeRefs: [],
         episodeSummaries: episodes.map((episode) =>
           `${episode.name}: ${episode.content}`.slice(0, 240)
@@ -63,9 +61,7 @@ export class GraphitiAsyncService {
       await this.cache.set(groupId, {
         query: normalized,
         refreshedAt: Date.now(),
-        facts,
         nodes,
-        factUuids: facts.map((fact) => fact.uuid),
         nodeRefs: nodes.map((node) => node.uuid),
       });
     })().catch((err) => logger.debug("Graphiti cache refresh failed", err))
@@ -83,7 +79,7 @@ export class GraphitiAsyncService {
           this.cache.get(groupId),
           this.cache.getMeta(groupId),
         ]);
-        const refreshQuery = current?.query || meta?.lastQuery;
+        const refreshQuery = meta?.lastQuery || current?.query;
         if (refreshQuery) this.scheduleCacheRefresh(groupId, refreshQuery);
       }
     })().catch((err) => logger.debug("Graphiti drain failed", err)).finally(

src/services/hot-tier-slice.test.ts

@@ -5,11 +5,24 @@ import { createCompactingHandler } from "../handlers/compacting.ts";
 import { createMessagesHandler } from "../handlers/messages.ts";
 import { SessionManager } from "../session.ts";
 import { BatchDrainService } from "./batch-drain.ts";
+import { GraphitiAsyncService } from "./graphiti-async.ts";
 import { RedisCacheService } from "./redis-cache.ts";
 import { RedisClient } from "./redis-client.ts";
 import { RedisEventsService } from "./redis-events.ts";
 import { RedisSnapshotService } from "./redis-snapshot.ts";
 
+const createGraphitiStub = () => ({
+  getEpisodes() {
+    return Promise.resolve([]);
+  },
+  searchMemoryFacts() {
+    return Promise.resolve([]);
+  },
+  searchNodes() {
+    return Promise.resolve([]);
+  },
+});
+
 describe("hot-tier vertical slice", () => {
   it("records local state, prepares injection, transforms messages, and serves compaction context without live MCP", async () => {
     const redis = new RedisClient({ endpoint: "redis://unused" });
@@ -24,9 +37,7 @@ describe("hot-tier vertical slice", () => {
     await redisCache.set("group-1", {
       query: "Continue the overhaul",
       refreshedAt: Date.now(),
-      facts: [{ uuid: "fact-1", fact: "Graphiti remains async" }],
       nodes: [{ uuid: "node-1", name: "ContextOverhaul" }],
-      factUuids: ["fact-1"],
       nodeRefs: ["node-1"],
     });
 
@@ -37,6 +48,8 @@ describe("hot-tier vertical slice", () => {
       redisEvents,
       redisSnapshot,
       redisCache,
+      createGraphitiStub() as never,
+      {} as never,
     );
     manager.setParentId("session-1", null);
     manager.setState(
@@ -86,9 +99,9 @@ describe("hot-tier vertical slice", () => {
       transformOutput.messages[0].parts[0].text,
       "<session_memory",
     );
-    assertStringIncludes(
-      transformOutput.messages[0].parts[0].text,
-      "<persistent_memory",
+    assertEquals(
+      transformOutput.messages[0].parts[0].text.includes("<persistent_memory"),
+      false,
     );
 
     const events = await redisEvents.getRecentSessionEvents(
@@ -126,6 +139,8 @@ describe("hot-tier vertical slice", () => {
       redisEvents,
       redisSnapshot,
       redisCache,
+      createGraphitiStub() as never,
+      {} as never,
     );
     manager.setParentId("session-1", null);
     manager.setState(
@@ -304,6 +319,53 @@ describe("hot-tier vertical slice", () => {
     });
   });
 
+  it("prefers remembered metadata query over stale cached query after drain success", async () => {
+    const redis = new RedisClient({ endpoint: "redis://unused" });
+    const redisCache = new RedisCacheService(redis, {
+      ttlSeconds: 300,
+      driftThreshold: 0.5,
+    });
+
+    await redisCache.set("group-1", {
+      query: "older cached query",
+      refreshedAt: Date.now() - 60_000,
+      nodes: [],
+      nodeRefs: [],
+    });
+    await redisCache.rememberRefreshQuery("group-1", "newer remembered query");
+
+    const refreshCalls: Array<{ groupId: string; query: string }> = [];
+    const graphitiAsync = new GraphitiAsyncService(
+      {
+        getEpisodes() {
+          return Promise.resolve([]);
+        },
+        searchMemoryFacts() {
+          return Promise.resolve([]);
+        },
+        searchNodes(input: { query: string; groupIds: string[] }) {
+          refreshCalls.push({ groupId: input.groupIds[0], query: input.query });
+          return Promise.resolve([]);
+        },
+      } as never,
+      redisCache,
+      {
+        drainGroup() {
+          return Promise.resolve({ status: "success" as const });
+        },
+      } as never,
+    );
+
+    graphitiAsync.scheduleDrain("group-1");
+    await new Promise((resolve) => setTimeout(resolve, 0));
+    await new Promise((resolve) => setTimeout(resolve, 0));
+
+    assertEquals(refreshCalls, [{
+      groupId: "group-1",
+      query: "newer remembered query",
+    }]);
+  });
+
   it("classifies drift deterministically at the configured threshold boundary", () => {
     const redis = new RedisClient({ endpoint: "redis://unused" });
     const redisCache = new RedisCacheService(redis, {
@@ -314,17 +376,13 @@ describe("hot-tier vertical slice", () => {
     const aligned = redisCache.classifyRefresh({
       query: "alpha beta",
       refreshedAt: Date.now(),
-      facts: [],
       nodes: [],
-      factUuids: [],
       nodeRefs: [],
     }, "alpha beta gamma delta");
     const drifted = redisCache.classifyRefresh({
       query: "alpha beta",
       refreshedAt: Date.now(),
-      facts: [],
       nodes: [],
-      factUuids: [],
       nodeRefs: [],
     }, "alpha delta epsilon");
 
@@ -352,6 +410,8 @@ describe("hot-tier vertical slice", () => {
       redisEvents,
       redisSnapshot,
       redisCache,
+      createGraphitiStub() as never,
+      {} as never,
     );
     manager.setParentId("session-1", null);
     manager.setState(
@@ -362,9 +422,7 @@ describe("hot-tier vertical slice", () => {
     await redisCache.set("group-1", {
       query: "primer",
       refreshedAt: Date.now(),
-      facts: [],
       nodes: [],
-      factUuids: [],
       nodeRefs: [],
       episodeSummaries: ["Primer episode"],
     });
@@ -378,9 +436,7 @@ describe("hot-tier vertical slice", () => {
     await redisCache.set("group-1", {
       query: "older query",
       refreshedAt: Date.now() - 301_000,
-      facts: [{ uuid: "fact-1", fact: "Stale fact" }],
       nodes: [],
-      factUuids: ["fact-1"],
       nodeRefs: [],
     });
     const stalePrepared = await manager.prepareInjection(
@@ -406,14 +462,11 @@ describe("hot-tier vertical slice", () => {
     await redisCache.set("group-1", {
       query: "architecture token",
       refreshedAt: Date.now(),
-      facts: [{
-        uuid: "fact-1",
-        fact:
-          "Exact token ALPHA-RECALL-42 identifies the architecture decision",
+      nodes: [{
+        uuid: "node-1",
+        name: "ALPHA-RECALL-42 architecture decision",
       }],
-      nodes: [],
-      factUuids: ["fact-1"],
-      nodeRefs: [],
+      nodeRefs: ["node-1"],
     });
 
     const sameGroupManager = new SessionManager(
@@ -423,6 +476,8 @@ describe("hot-tier vertical slice", () => {
       redisEvents,
       redisSnapshot,
       redisCache,
+      createGraphitiStub() as never,
+      {} as never,
     );
     sameGroupManager.setParentId("session-b", null);
     sameGroupManager.setState(
@@ -437,6 +492,8 @@ describe("hot-tier vertical slice", () => {
       redisEvents,
       redisSnapshot,
       redisCache,
+      createGraphitiStub() as never,
+      {} as never,
     );
     otherGroupManager.setParentId("session-c", null);
     otherGroupManager.setState(
@@ -475,9 +532,7 @@ describe("hot-tier vertical slice", () => {
     await redisCache.set("group-1", {
       query: "old recall topic",
       refreshedAt: Date.now() - 301_000,
-      facts: [{ uuid: "fact-1", fact: "Stale but still useful recall fact" }],
       nodes: [],
-      factUuids: ["fact-1"],
       nodeRefs: [],
     });
 
@@ -488,6 +543,8 @@ describe("hot-tier vertical slice", () => {
       redisEvents,
       redisSnapshot,
       redisCache,
+      createGraphitiStub() as never,
+      {} as never,
     );
     manager.setParentId("session-1", null);
     manager.setState(