fix(plugin): inject graphiti memory into user message

Author: vicary

dnt.ts

@@ -45,7 +45,12 @@ await build({
     types: "./esm/mod.d.ts",
     opencode: {
       type: "plugin",
-      hooks: ["chat.message", "event", "experimental.session.compacting"],
+      hooks: [
+        "chat.message",
+        "event",
+        "experimental.session.compacting",
+        "experimental.chat.messages.transform",
+      ],
     },
   },
 });

src/handlers/chat.ts

@@ -32,6 +32,8 @@ export function createChatHandler(deps: ChatHandlerDeps) {
       contextLimit: number;
       lastInjectionFactUuids: string[];
       cachedMemoryContext?: string;
+      cachedFactUuids?: string[];
+      visibleFactUuids?: string[];
     },
     messageText: string,
     useUserScope: boolean,
@@ -80,6 +82,36 @@ export function createChatHandler(deps: ChatHandlerDeps) {
       facts: userFacts,
       nodes: userNodes,
     });
+
+    const visibleSet = new Set(state.visibleFactUuids ?? []);
+    const beforeProjectFacts = projectContext.facts.length;
+    const beforeUserFacts = userContext.facts.length;
+    projectContext.facts = projectContext.facts.filter((fact) =>
+      !visibleSet.has(fact.uuid)
+    );
+    userContext.facts = userContext.facts.filter((fact) =>
+      !visibleSet.has(fact.uuid)
+    );
+    logger.debug("Filtered visible facts from injection", {
+      visibleCount: visibleSet.size,
+      filteredProjectFacts: beforeProjectFacts - projectContext.facts.length,
+      filteredUserFacts: beforeUserFacts - userContext.facts.length,
+      remainingProjectFacts: projectContext.facts.length,
+      remainingUserFacts: userContext.facts.length,
+    });
+
+    if (
+      projectContext.facts.length === 0 &&
+      userContext.facts.length === 0 &&
+      projectContext.nodes.length === 0 &&
+      userContext.nodes.length === 0
+    ) {
+      logger.debug("All facts filtered; skipping context cache", {
+        groupId: state.groupId,
+        userGroupId: state.userGroupId,
+      });
+      return;
+    }
     const projectContextString = formatMemoryContext(
       projectContext.facts,
       projectContext.nodes,
@@ -144,10 +176,11 @@ export function createChatHandler(deps: ChatHandlerDeps) {
     ];
     const factUuids = seedFactUuids ?? Array.from(new Set(allFactUuids));
     state.cachedMemoryContext = memoryContext;
+    state.cachedFactUuids = factUuids;
     logger.info(
       `Cached ${projectFacts.length + userFacts.length} facts and ${
         projectNodes.length + userNodes.length
-      } nodes for system prompt injection`,
+      } nodes for user message injection`,
     );
     state.lastInjectionFactUuids = factUuids;
   };

src/handlers/event.ts

@@ -92,6 +92,9 @@ export function createEventHandler(deps: EventHandlerDeps) {
             userGroupId: defaultUserGroupId,
             injectedMemories: false,
             lastInjectionFactUuids: [],
+            cachedMemoryContext: undefined,
+            cachedFactUuids: undefined,
+            visibleFactUuids: [],
             messageCount: 0,
             pendingMessages: [],
             contextLimit: 200_000,

src/handlers/messages.ts

@@ -0,0 +1,104 @@
+import type { Hooks } from "@opencode-ai/plugin";
+import { extractVisibleUuids } from "../services/context.ts";
+import { logger } from "../services/logger.ts";
+import type { SessionManager } from "../session.ts";
+
+type MessagesTransformHook = NonNullable<
+  Hooks["experimental.chat.messages.transform"]
+>;
+type MessagesTransformInput = Parameters<MessagesTransformHook>[0];
+type MessagesTransformOutput = Parameters<MessagesTransformHook>[1];
+
+export interface MessagesHandlerDeps {
+  sessionManager: SessionManager;
+}
+
+export function createMessagesHandler(deps: MessagesHandlerDeps) {
+  const { sessionManager } = deps;
+
+  // deno-lint-ignore require-await
+  return async (
+    _input: MessagesTransformInput,
+    output: MessagesTransformOutput,
+  ) => {
+    const lastUserEntry = [...output.messages]
+      .reverse()
+      .find((message) => message.info.role === "user");
+    if (!lastUserEntry) return;
+
+    const sessionID = lastUserEntry.info.sessionID;
+    const state = sessionManager.getState(sessionID);
+    if (!state?.isMain) {
+      logger.debug("Skipping memory injection; not main session", {
+        sessionID,
+      });
+      return;
+    }
+
+    const allVisibleUuids: string[] = [];
+    for (const entry of output.messages) {
+      for (const part of entry.parts) {
+        if (part.type === "text" && "text" in part) {
+          const uuids = extractVisibleUuids((part as { text: string }).text);
+          if (uuids.length > 0) {
+            logger.debug("Found <memory> block UUIDs", {
+              sessionID,
+              uuids,
+              messageID: entry.info.id,
+            });
+          }
+          allVisibleUuids.push(...uuids);
+        }
+      }
+    }
+    state.visibleFactUuids = [...new Set(allVisibleUuids)];
+    logger.debug("Updated visibleFactUuids from message scan", {
+      sessionID,
+      visibleCount: state.visibleFactUuids.length,
+    });
+
+    if (!state.cachedMemoryContext) {
+      logger.debug("Skipping memory injection; no cached context", {
+        sessionID,
+      });
+      return;
+    }
+
+    const textPart = lastUserEntry.parts.find(
+      (part): part is typeof part & { type: "text"; text: string } =>
+        part.type === "text" && "text" in part,
+    );
+    if (!textPart) {
+      logger.debug("Skipping memory injection; no text part", {
+        sessionID,
+      });
+      return;
+    }
+
+    if (textPart.text.includes("<memory")) {
+      logger.debug("Skipping memory injection; already injected", {
+        sessionID,
+      });
+      state.cachedMemoryContext = undefined;
+      state.cachedFactUuids = undefined;
+      return;
+    }
+
+    const uuids = state.cachedFactUuids ?? [];
+    const uuidAttr = uuids.length > 0 ? ` data-uuids="${uuids.join(",")}"` : "";
+    const memoryBlock =
+      `<memory${uuidAttr}>\n${state.cachedMemoryContext}\n</memory>`;
+
+    textPart.text = `${memoryBlock}\n\n${textPart.text}`;
+
+    logger.info("Injected memory context into last user message", {
+      sessionID,
+      factCount: uuids.length,
+      blockLength: memoryBlock.length,
+      preview: state.cachedMemoryContext.slice(0, 100),
+    });
+
+    state.cachedMemoryContext = undefined;
+    state.cachedFactUuids = undefined;
+  };
+}

src/handlers/system.ts

@@ -102,6 +102,7 @@ describe("index", () => {
   // 2. Tests for event handlers (session.created, session.compacted, session.idle, etc.)
   // 3. Tests for chat.message hook (memory injection, buffering)
   // 4. Tests for experimental.session.compacting hook
+  // 5. Tests for experimental.chat.messages.transform hook
   //
   // These tests should be added after Phase 2 refactoring, when the plugin logic
   // is extracted into testable units. For now, the individual helper functions

src/index.test.ts

@@ -3,7 +3,7 @@ import { loadConfig } from "./config.ts";
 import { createChatHandler } from "./handlers/chat.ts";
 import { createCompactingHandler } from "./handlers/compacting.ts";
 import { createEventHandler } from "./handlers/event.ts";
-import { createSystemHandler } from "./handlers/system.ts";
+import { createMessagesHandler } from "./handlers/messages.ts";
 import { GraphitiClient } from "./services/client.ts";
 import { logger } from "./services/logger.ts";
 import { SessionManager } from "./session.ts";
@@ -63,7 +63,7 @@ export const graphiti: Plugin = async (input: PluginInput) => {
       defaultGroupId,
       factStaleDays: config.factStaleDays,
     }),
-    "experimental.chat.system.transform": createSystemHandler({
+    "experimental.chat.messages.transform": createMessagesHandler({
       sessionManager,
     }),
   };

src/index.ts

@@ -179,3 +179,19 @@ export function formatMemoryContext(
 
   return sections.join("\n");
 }
+
+/**
+ * Extract fact UUIDs from all <memory data-uuids="..."> blocks in a text string.
+ */
+export function extractVisibleUuids(text: string): string[] {
+  const uuids: string[] = [];
+  const regex = /<memory[^>]*\bdata-uuids="([^"]*)"[^>]*>/g;
+  let match;
+  while ((match = regex.exec(text)) !== null) {
+    const raw = match[1];
+    if (raw) {
+      uuids.push(...raw.split(",").filter(Boolean));
+    }
+  }
+  return uuids;
+}

src/services/context.ts

@@ -19,8 +19,12 @@ export type SessionState = {
   injectedMemories: boolean;
   /** Fact UUIDs included in the last memory injection. */
   lastInjectionFactUuids: string[];
-  /** Cached formatted memory context for system prompt injection. */
+  /** Cached formatted memory context for user message injection. */
   cachedMemoryContext?: string;
+  /** Fact UUIDs from cached context, for embedding in <memory> tag. */
+  cachedFactUuids?: string[];
+  /** Fact UUIDs currently visible in <memory> blocks across all messages. */
+  visibleFactUuids: string[];
   /** Count of messages observed in this session. */
   messageCount: number;
   /** Buffered message strings awaiting flush. */
@@ -110,6 +114,8 @@ export class SessionManager {
         injectedMemories: false,
         lastInjectionFactUuids: [],
         cachedMemoryContext: undefined,
+        cachedFactUuids: undefined,
+        visibleFactUuids: [],
         messageCount: 0,
         pendingMessages: [],
         contextLimit: 200_000,