fix(heartbeat): suppress no-op system event replies

pfrederiksen · pfrederiksen · commit 2116d312abc1 · 2026-04-28T21:04:51.000Z
Suppress exact silent/no-op sentinel outputs from heartbeat and system-event handoffs so HEARTBEAT_OK and NO_REPLY-style responses do not leak as visible messages. Keep meaningful exec completion summaries deliverable.\n\nFixes #73149.
diff --git a/src/auto-reply/tokens.ts b/src/auto-reply/tokens.ts
@@ -2,6 +2,11 @@ import { escapeRegExp } from "../shared/regexp.js";
 
 export const HEARTBEAT_TOKEN = "HEARTBEAT_OK";
 export const SILENT_REPLY_TOKEN = "NO_REPLY";
+export const NO_OP_SENTINEL_REPLY_TOKENS = [
+  SILENT_REPLY_TOKEN,
+  "NO_NEW_AUDIO",
+  "SESSION_WATCHDOG_OK",
+] as const;
 
 const silentExactRegexByToken = new Map<string, RegExp>();
 const silentTrailingRegexByToken = new Map<string, RegExp>();
@@ -78,6 +83,33 @@ export function isSilentReplyPayloadText(
   return isSilentReplyText(text, token) || isSilentReplyEnvelopeText(text, token);
 }
 
+function normalizeSentinelReplyText(text: string): string {
+  return text
+    .trim()
+    .replace(/<[^>]*>/g, " ")
+    .replace(/&nbsp;/gi, " ")
+    .replace(/^[*`~_]+/, "")
+    .replace(/[*`~_]+$/, "")
+    .trim();
+}
+
+export function isNoOpSentinelReplyText(
+  text: string | undefined,
+  opts: { includeHeartbeat?: boolean } = {},
+): boolean {
+  if (!text) {
+    return false;
+  }
+  if (isSilentReplyPayloadText(text)) {
+    return true;
+  }
+  const normalized = normalizeSentinelReplyText(text);
+  if (opts.includeHeartbeat && isSilentReplyText(normalized, HEARTBEAT_TOKEN)) {
+    return true;
+  }
+  return NO_OP_SENTINEL_REPLY_TOKENS.some((token) => isSilentReplyText(normalized, token));
+}
+
 /**
  * Strip a trailing silent reply token from mixed-content text.
  * Returns the remaining text with the token removed (trimmed).
diff --git a/src/infra/heartbeat-runner.respects-ackmaxchars-heartbeat-acks.test.ts b/src/infra/heartbeat-runner.respects-ackmaxchars-heartbeat-acks.test.ts
@@ -1,5 +1,5 @@
 import fs from "node:fs/promises";
-import { describe, expect, it, vi } from "vitest";
+import { beforeEach, describe, expect, it, vi } from "vitest";
 import type { OpenClawConfig } from "../config/config.js";
 import { runHeartbeatOnce, type HeartbeatDeps } from "./heartbeat-runner.js";
 import { installHeartbeatRunnerTestRuntime } from "./heartbeat-runner.test-harness.js";
@@ -9,8 +9,10 @@ import {
   withTempHeartbeatSandbox,
   withTempTelegramHeartbeatSandbox,
 } from "./heartbeat-runner.test-utils.js";
+import { enqueueSystemEvent, resetSystemEventsForTest } from "./system-events.js";
 
 installHeartbeatRunnerTestRuntime();
+beforeEach(() => resetSystemEventsForTest());
 
 describe("runHeartbeatOnce ack handling", () => {
   const WHATSAPP_GROUP = "120363140186826074@g.us";
@@ -302,6 +304,102 @@ describe("runHeartbeatOnce ack handling", () => {
     });
   });
 
+  it("suppresses exact no-op sentinel heartbeat replies", async () => {
+    await withTempHeartbeatSandbox(async ({ tmpDir, storePath, replySpy }) => {
+      const cfg = await createSeededWhatsAppHeartbeatConfig({
+        tmpDir,
+        storePath,
+      });
+
+      const sendWhatsApp = createMessageSendSpy();
+      const cases = ["NO_REPLY", "NO_NEW_AUDIO", "SESSION_WATCHDOG_OK"];
+      for (const replyText of cases) {
+        replySpy.mockResolvedValueOnce({ text: replyText });
+        await runHeartbeatOnce({
+          cfg,
+          deps: {
+            ...makeWhatsAppDeps({ sendWhatsApp }),
+            getReplyFromConfig: replySpy,
+          },
+        });
+      }
+
+      expect(sendWhatsApp).not.toHaveBeenCalled();
+    });
+  });
+
+  it("suppresses exact HEARTBEAT_OK from exec system event handoff", async () => {
+    await withTempHeartbeatSandbox(async ({ tmpDir, storePath, replySpy }) => {
+      const cfg = await createSeededWhatsAppHeartbeatConfig({
+        tmpDir,
+        storePath,
+      });
+      const sessionKey = await seedMainSessionStore(storePath, cfg, {
+        lastChannel: "whatsapp",
+        lastProvider: "whatsapp",
+        lastTo: WHATSAPP_GROUP,
+      });
+      enqueueSystemEvent("Exec completed (abc12345, code 0) :: no output", {
+        sessionKey,
+        contextKey: "exec:abc12345",
+      });
+
+      replySpy.mockResolvedValue({ text: "HEARTBEAT_OK" });
+      const sendWhatsApp = createMessageSendSpy();
+
+      await runHeartbeatOnce({
+        cfg,
+        reason: "exec-event",
+        deps: {
+          ...makeWhatsAppDeps({ sendWhatsApp }),
+          getReplyFromConfig: replySpy,
+        },
+      });
+
+      expect(sendWhatsApp).not.toHaveBeenCalled();
+    });
+  });
+
+  it("keeps meaningful exec system event summaries", async () => {
+    await withTempHeartbeatSandbox(async ({ tmpDir, storePath, replySpy }) => {
+      const cfg = await createSeededWhatsAppHeartbeatConfig({
+        tmpDir,
+        storePath,
+      });
+      const sessionKey = await seedMainSessionStore(storePath, cfg, {
+        lastChannel: "whatsapp",
+        lastProvider: "whatsapp",
+        lastTo: WHATSAPP_GROUP,
+      });
+      enqueueSystemEvent("Exec completed (abc12345, code 0) :: uploaded report.txt", {
+        sessionKey,
+        contextKey: "exec:abc12345",
+      });
+
+      replySpy.mockResolvedValue({ text: "Command completed: uploaded report.txt" });
+      const sendWhatsApp = createMessageSendSpy();
+
+      await runHeartbeatOnce({
+        cfg,
+        reason: "exec-event",
+        deps: {
+          ...makeWhatsAppDeps({ sendWhatsApp }),
+          getReplyFromConfig: replySpy,
+        },
+      });
+
+      expect(sendWhatsApp).toHaveBeenCalledTimes(1);
+      expect(sendWhatsApp).toHaveBeenCalledWith(
+        WHATSAPP_GROUP,
+        "Command completed: uploaded report.txt",
+        expect.any(Object),
+      );
+      const calledCtx = replySpy.mock.calls[0]?.[0] as { Body?: string; Provider?: string };
+      expect(calledCtx.Provider).toBe("exec-event");
+      expect(calledCtx.Body).toContain("Please relay the command output to the user");
+    });
+  });
+
   it("does not regress updatedAt when restoring heartbeat sessions", async () => {
     await withTempHeartbeatSandbox(async ({ tmpDir, storePath, replySpy }) => {
       const originalUpdatedAt = 1000;
diff --git a/src/infra/heartbeat-runner.ts b/src/infra/heartbeat-runner.ts
@@ -24,7 +24,7 @@ import {
   stripHeartbeatToken,
   type HeartbeatTask,
 } from "../auto-reply/heartbeat.js";
-import { HEARTBEAT_TOKEN } from "../auto-reply/tokens.js";
+import { HEARTBEAT_TOKEN, isNoOpSentinelReplyText } from "../auto-reply/tokens.js";
 import type { ReplyPayload } from "../auto-reply/types.js";
 import { getChannelPlugin } from "../channels/plugins/index.js";
 import type {
@@ -498,11 +498,19 @@ function normalizeHeartbeatReply(
   payload: ReplyPayload,
   responsePrefix: string | undefined,
   ackMaxChars: number,
+  opts: { systemEvent?: boolean } = {},
 ) {
   const rawText = typeof payload.text === "string" ? payload.text : "";
   const textForStrip = stripLeadingHeartbeatResponsePrefix(rawText, responsePrefix);
+  if (isNoOpSentinelReplyText(textForStrip, { includeHeartbeat: true })) {
+    return {
+      shouldSkip: true,
+      text: "",
+      hasMedia: resolveSendableOutboundReplyParts(payload).hasMedia,
+    };
+  }
   const stripped = stripHeartbeatToken(textForStrip, {
-    mode: "heartbeat",
+    mode: opts.systemEvent ? "message" : "heartbeat",
     maxAckChars: ackMaxChars,
   });
   const hasMedia = resolveSendableOutboundReplyParts(payload).hasMedia;
@@ -1106,20 +1114,10 @@ export async function runHeartbeatOnce(opts: {
     }
 
     const ackMaxChars = resolveHeartbeatAckMaxChars(cfg, heartbeat);
-    const normalized = normalizeHeartbeatReply(replyPayload, responsePrefix, ackMaxChars);
-    // For exec completion events, don't skip even if the response looks like HEARTBEAT_OK.
-    // The model should be responding with exec results, not ack tokens.
-    // Also, if normalized.text is empty due to token stripping but we have exec completion,
-    // fall back to the original reply text.
-    const execFallbackText =
-      hasExecCompletion && !normalized.text.trim() && replyPayload.text?.trim()
-        ? replyPayload.text.trim()
-        : null;
-    if (execFallbackText) {
-      normalized.text = execFallbackText;
-      normalized.shouldSkip = false;
-    }
-    const shouldSkipMain = normalized.shouldSkip && !normalized.hasMedia && !hasExecCompletion;
+    const normalized = normalizeHeartbeatReply(replyPayload, responsePrefix, ackMaxChars, {
+      systemEvent: hasExecCompletion || hasCronEvents,
+    });
+    const shouldSkipMain = normalized.shouldSkip && !normalized.hasMedia;
     if (shouldSkipMain && reasoningPayloads.length === 0) {
       await restoreHeartbeatUpdatedAt({
         storePath,
