openclaw
diff --git a/‎src/agents/embedded-agent-messaging.types.ts‎
Lines changed: 2 additions & 0 deletions b/‎src/agents/embedded-agent-messaging.types.ts‎
Lines changed: 2 additions & 0 deletions
diff --git a/‎src/agents/embedded-agent-subscribe.handlers.tools.test.ts‎
Lines changed: 40 additions & 0 deletions b/‎src/agents/embedded-agent-subscribe.handlers.tools.test.ts‎
Lines changed: 40 additions & 0 deletions
diff --git a/‎src/agents/embedded-agent-subscribe.handlers.tools.ts‎
Lines changed: 7 additions & 0 deletions b/‎src/agents/embedded-agent-subscribe.handlers.tools.ts‎
Lines changed: 7 additions & 0 deletions
diff --git a/‎src/auto-reply/reply-payload.ts‎
Lines changed: 16 additions & 0 deletions b/‎src/auto-reply/reply-payload.ts‎
Lines changed: 16 additions & 0 deletions
@@ -16,6 +16,8 @@ export type MessagingToolSend = {
   hasRichContent?: true;
   /** Present only when Codex classified this current-source delivery intent. */
   sourceReplyFinal?: boolean;
+  /** Terminal/progress intent for a successful message_tool_only send. */
+  messageToolOnlyFinal?: boolean;
 };
 
 export type MessagingToolSourceReplyPayload = Pick<
 
@@ -1613,6 +1613,46 @@ describe("handleToolExecutionEnd mutating failure recovery", () => {
     ]);
   });
 
+  it("records message-tool-only terminal and progress intent on successful sends", async () => {
+    const { ctx } = createTestContext();
+    ctx.params.sourceReplyDeliveryMode = "message_tool_only";
+
+    for (const [toolCallId, final] of [
+      ["tool-message-terminal", undefined],
+      ["tool-message-progress", false],
+    ] as const) {
+      await handleToolExecutionStart(
+        ctx as never,
+        {
+          type: "tool_execution_start",
+          toolName: "message",
+          toolCallId,
+          args: {
+            action: "send",
+            provider: "telegram",
+            to: "chat-current",
+            text: toolCallId,
+            ...(final !== undefined ? { final } : {}),
+          },
+        } as never,
+      );
+      await handleToolExecutionEnd(
+        ctx as never,
+        {
+          type: "tool_execution_end",
+          toolName: "message",
+          toolCallId,
+          isError: false,
+          result: { details: { messageId: `${toolCallId}-result` } },
+        } as never,
+      );
+    }
+
+    expect(ctx.state.messagingToolSentTargets.map((target) => target.messageToolOnlyFinal)).toEqual(
+      [true, false],
+    );
+  });
+
   it("records reply target evidence without treating it as terminal send evidence", async () => {
     const { ctx } = createTestContext();
     const toolCallId = "tool-message-reply-target";
 
@@ -1405,6 +1405,12 @@ export async function handleToolExecutionEnd(
       isError: isToolError,
     });
   const messageText = isMessagingSend ? readMessagingText(startArgs) : undefined;
+  const messageToolOnlyFinal =
+    isMessagingSend && ctx.params.sourceReplyDeliveryMode === "message_tool_only"
+      ? typeof startArgs.final === "boolean"
+        ? startArgs.final
+        : true
+      : undefined;
   const argumentMediaUrls = isMessagingSend ? collectMessagingMediaUrlsFromRecord(startArgs) : [];
   const hasRichContent = isMessagingSend && hasMessagingRichContent(startArgs);
   const messageTarget = hasMessagingTargetEvidence
@@ -1440,6 +1446,7 @@ export async function handleToolExecutionEnd(
       ...(messageText ? { text: messageText } : {}),
       ...(committedMediaUrls.length > 0 ? { mediaUrls: committedMediaUrls.slice() } : {}),
       ...(hasRichContent ? { hasRichContent: true as const } : {}),
+      ...(messageToolOnlyFinal !== undefined ? { messageToolOnlyFinal } : {}),
     });
     ctx.trimMessagingToolSent();
   }
 
@@ -228,6 +228,13 @@ export type ReplyPayloadMetadata = {
     channel: string;
     accountId?: string;
   };
+  /**
+   * A generic message tool delivery already reached the same provider/target
+   * route as this reply. Heartbeat uses this route-scoped evidence to avoid
+   * sending fallback narration after the message tool has delivered the
+   * visible response.
+   */
+  messageToolDeliveredForReplyRoute?: boolean;
   /**
    * Internal OpenClaw notices generated after a runtime/provider failure are
    * not assistant source replies. Dispatch may deliver them even when normal
@@ -291,6 +298,15 @@ export function markReplyPayloadForSourceSuppressionDelivery<T extends object>(p
   });
 }
 
+/** Marks a payload whose visible reply was already delivered by a message tool on this route. */
+export function markReplyPayloadForMessageToolDeliveryForReplyRoute<T extends object>(
+  payload: T,
+): T {
+  return setReplyPayloadMetadata(payload, {
+    messageToolDeliveredForReplyRoute: true,
+  });
+}
+
 export function markCommandReplyForDelivery(
   reply: ReplyPayload | ReplyPayload[] | undefined,
 ): ReplyPayload | ReplyPayload[] | undefined {