fix(heartbeat): stop pending final replay

steipete · steipete · commit e1d6f32aef81 · 2026-05-28T00:00:49.000+01:00
diff --git a/src/auto-reply/get-reply-options.types.ts b/src/auto-reply/get-reply-options.types.ts
@@ -64,8 +64,6 @@ export type GetReplyOptions = {
   onTypingCleanup?: () => void;
   onTypingController?: (typing: TypingController) => void;
   isHeartbeat?: boolean;
-  /** If true, heartbeat turns do not replay durable pending final text directly. */
-  suppressPendingFinalDeliveryReplay?: boolean;
   /** Policy-level typing control for run classes (user/system/internal/heartbeat). */
   typingPolicy?: TypingPolicy;
   /** Force-disable typing indicators for this run (system/internal/cross-channel routes). */
diff --git a/src/auto-reply/reply/get-reply.fast-path.test.ts b/src/auto-reply/reply/get-reply.fast-path.test.ts
@@ -2,10 +2,6 @@ import fs from "node:fs/promises";
 import os from "node:os";
 import path from "node:path";
 import { afterEach, beforeAll, beforeEach, describe, expect, it, vi } from "vitest";
-import {
-  INTERNAL_RUNTIME_CONTEXT_BEGIN,
-  INTERNAL_RUNTIME_CONTEXT_END,
-} from "../../agents/internal-runtime-context.js";
 import type { OpenClawConfig } from "../../config/config.js";
 import {
   buildFastReplyCommandContext,
@@ -203,7 +199,7 @@ describe("getReplyFromConfig fast test bootstrap", () => {
     expect(vi.mocked(runPreparedReplyMock)).toHaveBeenCalledOnce();
   });
 
-  it("clears stale ack-only heartbeat pending delivery before replay", async () => {
+  it("clears stale ack-only heartbeat pending delivery before running heartbeat", async () => {
     const home = await fs.mkdtemp(path.join(os.tmpdir(), "openclaw-heartbeat-pending-clear-"));
     const storePath = path.join(home, "sessions.json");
     const sessionKey = "agent:main:telegram:123";
@@ -243,7 +239,7 @@ describe("getReplyFromConfig fast test bootstrap", () => {
     expect(stored.pendingFinalDeliveryAttemptCount).toBeUndefined();
   });
 
-  it("uses ackMaxChars when replaying stale heartbeat pending delivery", async () => {
+  it("keeps non-ack heartbeat pending delivery without direct replay", async () => {
     const home = await fs.mkdtemp(path.join(os.tmpdir(), "openclaw-heartbeat-pending-replay-"));
     const storePath = path.join(home, "sessions.json");
     const sessionKey = "agent:main:telegram:123";
@@ -272,57 +268,15 @@ describe("getReplyFromConfig fast test bootstrap", () => {
 
     await expect(
       getReplyFromConfig(buildGetReplyCtx(), { isHeartbeat: true }, cfg),
-    ).resolves.toEqual({ text: "short" });
+    ).resolves.toEqual({ text: "ok" });
 
     const stored = JSON.parse(await fs.readFile(storePath, "utf8"))[sessionKey];
     expect(stored.pendingFinalDelivery).toBe(true);
-    expect(stored.pendingFinalDeliveryText).toBe("short");
-    expect(stored.pendingFinalDeliveryAttemptCount).toBe(1);
-  });
-
-  it("sanitizes stale heartbeat pending delivery before replay", async () => {
-    const home = await fs.mkdtemp(path.join(os.tmpdir(), "openclaw-heartbeat-pending-sanitize-"));
-    const storePath = path.join(home, "sessions.json");
-    const sessionKey = "agent:main:telegram:123";
-    await fs.writeFile(
-      storePath,
-      JSON.stringify({
-        [sessionKey]: {
-          sessionId: "pending-dirty-remainder",
-          updatedAt: Date.now(),
-          pendingFinalDelivery: true,
-          pendingFinalDeliveryText: [
-            "HEARTBEAT_OK",
-            INTERNAL_RUNTIME_CONTEXT_BEGIN,
-            "internal recovery detail",
-            INTERNAL_RUNTIME_CONTEXT_END,
-            "notify the user",
-          ].join("\n"),
-        },
-      }),
-      "utf8",
-    );
-    const cfg = withFastReplyConfig({
-      agents: {
-        defaults: {
-          model: "openai/gpt-5.5",
-          workspace: home,
-          heartbeat: { ackMaxChars: 0 },
-        },
-      },
-      session: { store: storePath },
-    } as OpenClawConfig);
-
-    await expect(
-      getReplyFromConfig(buildGetReplyCtx(), { isHeartbeat: true }, cfg),
-    ).resolves.toEqual({ text: "notify the user" });
-
-    const stored = JSON.parse(await fs.readFile(storePath, "utf8"))[sessionKey];
-    expect(stored.pendingFinalDeliveryText).toBe("notify the user");
-    expect(stored.pendingFinalDeliveryAttemptCount).toBe(1);
+    expect(stored.pendingFinalDeliveryText).toBe("HEARTBEAT_OK short");
+    expect(stored.pendingFinalDeliveryAttemptCount).toBeUndefined();
   });
 
-  it("does not replay stale heartbeat pending delivery when suppression is requested", async () => {
+  it("does not replay stale heartbeat pending delivery", async () => {
     const home = await fs.mkdtemp(path.join(os.tmpdir(), "openclaw-heartbeat-pending-suppress-"));
     const storePath = path.join(home, "sessions.json");
     const sessionKey = "agent:main:telegram:123";
@@ -351,12 +305,10 @@ describe("getReplyFromConfig fast test bootstrap", () => {
     } as OpenClawConfig);
 
     await expect(
-      getReplyFromConfig(
-        buildGetReplyCtx(),
-        { isHeartbeat: true, suppressPendingFinalDeliveryReplay: true },
-        cfg,
-      ),
-    ).resolves.toEqual({ text: "ok" });
+      getReplyFromConfig(buildGetReplyCtx(), { isHeartbeat: true }, cfg),
+    ).resolves.toEqual({
+      text: "ok",
+    });
 
     const stored = JSON.parse(await fs.readFile(storePath, "utf8"))[sessionKey];
     expect(stored.pendingFinalDelivery).toBe(true);
diff --git a/src/auto-reply/reply/get-reply.ts b/src/auto-reply/reply/get-reply.ts
@@ -532,36 +532,6 @@ export async function getReplyFromConfig(
             },
           });
         }
-      } else if (opts.suppressPendingFinalDeliveryReplay !== true) {
-        const updatedAt = Date.now();
-        const attemptCount = (sessionEntry.pendingFinalDeliveryAttemptCount ?? 0) + 1;
-        sessionEntry.pendingFinalDeliveryLastAttemptAt = updatedAt;
-        sessionEntry.pendingFinalDeliveryAttemptCount = attemptCount;
-        sessionEntry.pendingFinalDeliveryLastError = null;
-        const replayText = sanitizePendingFinalDeliveryText(heartbeatPending.replayText);
-        sessionEntry.pendingFinalDeliveryText = replayText;
-        sessionEntry.updatedAt = updatedAt;
-        if (sessionKey && sessionStore) {
-          sessionStore[sessionKey] = sessionEntry;
-        }
-        if (sessionKey && storePath) {
-          const { applySessionStoreEntryPatch } = await import("../../config/sessions.js");
-          await applySessionStoreEntryPatch({
-            storePath,
-            sessionKey,
-            skipMaintenance: true,
-            takeCacheOwnership: true,
-            patch: {
-              pendingFinalDeliveryText: replayText,
-              pendingFinalDeliveryLastAttemptAt: updatedAt,
-              pendingFinalDeliveryAttemptCount: attemptCount,
-              pendingFinalDeliveryLastError: null,
-              updatedAt,
-            },
-          });
-        }
-        logResolverTiming("completed", "pending_final_delivery_replay");
-        return { text: replayText };
       }
     }
   }
diff --git a/src/infra/heartbeat-runner.skips-busy-session-lane.test.ts b/src/infra/heartbeat-runner.skips-busy-session-lane.test.ts
@@ -484,7 +484,6 @@ describe("heartbeat runner skips when target session lane is busy", () => {
       expect(replySpy).toHaveBeenCalledOnce();
       expect(replySpy.mock.calls[0]?.[1]).toMatchObject({
         isHeartbeat: true,
-        suppressPendingFinalDeliveryReplay: true,
       });
       expect(sendTelegram).not.toHaveBeenCalled();
     });
diff --git a/src/infra/heartbeat-runner.ts b/src/infra/heartbeat-runner.ts
@@ -1758,7 +1758,6 @@ export async function runHeartbeatOnce(opts: {
       heartbeat?.lightContext === true ? "lightweight" : undefined;
     const replyOpts = {
       isHeartbeat: true,
-      suppressPendingFinalDeliveryReplay: true,
       ...(heartbeatModelOverride ? { heartbeatModelOverride } : {}),
       suppressToolErrorWarnings,
       ...(usesHeartbeatResponseTool ? { enableHeartbeatTool: true, forceHeartbeatTool: true } : {}),
