Agents: add before_message_write persistence regression tests

src/agents/session-tool-result-guard.e2e.test.ts

@@ -261,6 +261,63 @@ describe("installSessionToolResultGuard", () => {
     expect(text).toBe(originalText);
   });
 
+  it("blocks persistence when before_message_write returns block=true", () => {
+    const sm = SessionManager.inMemory();
+    installSessionToolResultGuard(sm, {
+      beforeMessageWriteHook: () => ({ block: true }),
+    });
+
+    sm.appendMessage(
+      asAppendMessage({
+        role: "user",
+        content: "hidden",
+        timestamp: Date.now(),
+      }),
+    );
+
+    expect(getPersistedMessages(sm)).toHaveLength(0);
+  });
+
+  it("applies before_message_write message mutations before persistence", () => {
+    const sm = SessionManager.inMemory();
+    installSessionToolResultGuard(sm, {
+      beforeMessageWriteHook: ({ message }) => {
+        if ((message as { role?: string }).role !== "toolResult") {
+          return undefined;
+        }
+        return {
+          message: {
+            ...(message as unknown as Record<string, unknown>),
+            content: [{ type: "text", text: "rewritten by hook" }],
+          } as unknown as AgentMessage,
+        };
+      },
+    });
+
+    appendToolResultText(sm, "original");
+
+    const text = getToolResultText(getPersistedMessages(sm));
+    expect(text).toBe("rewritten by hook");
+  });
+
+  it("applies before_message_write to synthetic tool-result flushes", () => {
+    const sm = SessionManager.inMemory();
+    const guard = installSessionToolResultGuard(sm, {
+      beforeMessageWriteHook: ({ message }) => {
+        if ((message as { role?: string }).role !== "toolResult") {
+          return undefined;
+        }
+        return { block: true };
+      },
+    });
+
+    sm.appendMessage(toolCallMessage);
+    guard.flushPendingToolResults();
+
+    const messages = getPersistedMessages(sm);
+    expect(messages.map((m) => m.role)).toEqual(["assistant"]);
+  });
+
   it("applies message persistence transform to user messages", () => {
     const sm = SessionManager.inMemory();
     installSessionToolResultGuard(sm, {

src/agents/session-tool-result-guard.tool-result-persist-hook.e2e.test.ts

@@ -129,3 +129,51 @@ describe("tool_result_persist hook", () => {
     expect(toolResult.details).toBeTruthy();
   });
 });
+
+describe("before_message_write hook", () => {
+  it("continues persistence when a before_message_write hook throws", () => {
+    const tmp = fs.mkdtempSync(path.join(os.tmpdir(), "openclaw-before-write-"));
+    process.env.OPENCLAW_BUNDLED_PLUGINS_DIR = "/nonexistent/bundled/plugins";
+
+    const plugin = writeTempPlugin({
+      dir: tmp,
+      id: "before-write-throws",
+      body: `export default { id: "before-write-throws", register(api) {
+  api.on("before_message_write", () => {
+    throw new Error("boom");
+  }, { priority: 10 });
+} };`,
+    });
+
+    const registry = loadOpenClawPlugins({
+      cache: false,
+      workspaceDir: tmp,
+      config: {
+        plugins: {
+          load: { paths: [plugin] },
+          allow: ["before-write-throws"],
+        },
+      },
+    });
+    initializeGlobalHookRunner(registry);
+
+    const sm = guardSessionManager(SessionManager.inMemory(), {
+      agentId: "main",
+      sessionKey: "main",
+    });
+    const appendMessage = sm.appendMessage.bind(sm) as unknown as (message: AgentMessage) => void;
+    appendMessage({
+      role: "user",
+      content: "hello",
+      timestamp: Date.now(),
+    } as AgentMessage);
+
+    const messages = sm
+      .getEntries()
+      .filter((e) => e.type === "message")
+      .map((e) => (e as { message: AgentMessage }).message);
+
+    expect(messages).toHaveLength(1);
+    expect(messages[0]?.role).toBe("user");
+  });
+});