Summary

Fixes #19373.

When Slack streaming is enabled, sendMessageSlack() is called fire-and-forget inside the draft stream. The deliver callback in dispatch.ts then reads draftStream.messageId() to decide whether it can finalize via preview-edit — but the send hasn't resolved yet, so messageId() returns undefined. This causes canFinalizeViaPreviewEdit to evaluate false, and the dispatcher falls through to normal delivery, posting a duplicate message.

This PR adds await draftStream?.flush() before the messageId() read so the in-flight send resolves first.

Root Cause

In dispatchPreparedSlackMessage (dispatch.ts), the deliver callback evaluates:

const draftMessageId = draftStream?.messageId();
const canFinalizeViaPreviewEdit = draftMessageId && draftChannelId && ...;

But messageId() is only populated after the draft stream's sendMessageSlack() promise resolves. Since the send is fire-and-forget (kicked off by stream.update()), there's a race: if the deliver callback runs before the send completes, messageId() returns undefined and the message is delivered normally — duplicating the streamed draft.

The Discord handler already does await flushDraft() before reading messageId (at message-handler.process.ts:555), but the Slack handler was missing the equivalent call.

Changes

src/slack/monitor/message-handler/dispatch.ts — Add flush before messageId read:

       }

+      // Flush any in-flight draft send so messageId() is populated.
+      // Without this, a race between the fire-and-forget sendMessageSlack()
+      // and the deliver callback can cause canFinalizeViaPreviewEdit to
+      // evaluate false, resulting in a duplicate Slack message.
+      await draftStream?.flush();
+
       const mediaCount = payload.mediaUrls?.length ?? (payload.mediaUrl ? 1 : 0);
       const draftMessageId = draftStream?.messageId();

src/slack/draft-stream.test.ts — Two new tests:

+  it("flush resolves in-flight send so messageId is available (race condition fix)", async () => {
+    // Creates a deferred send, starts flush, verifies messageId is undefined,
+    // resolves the send, then verifies messageId is populated
+  });
+
+  it("flush is safe to call when no draft has been started", async () => {
+    // Verifies flush is a no-op when no update has been called
+  });

Comparison with #20248 and #20623

The key difference from #20248: that PR flushes before the final deliverReplies call, but the canFinalizeViaPreviewEdit evaluation happens before delivery. If messageId() is still undefined at evaluation time, the code has already decided to skip preview-edit and deliver normally — flushing afterward doesn't prevent the duplicate. This PR flushes before the evaluation, which is the correct fix point.

Test Plan

• 2 new tests in src/slack/draft-stream.test.ts
• flush resolves in-flight send so messageId is available — verifies the race condition fix
• flush is safe to call when no draft has been started — verifies no-op safety

Related

• Closes [Bug]: Slack Duplicate Reply Message #19373
• Related: Bot sends duplicate replies on Slack #22242, Bug: Slack Socket Mode posts duplicate message on initial @-mention #22254
• Competing: fix(slack): flush draft stream before final reply to preserve messag ordering #20248, fix(slack): duplicate replies and missing streaming recipient params #20623

Greptile Summary

Adds await draftStream?.flush() before reading messageId() in the deliver callback to ensure in-flight draft sends complete before the canFinalizeViaPreviewEdit check. Without this flush, a race condition causes messageId() to return undefined, preventing preview-edit finalization and resulting in duplicate Slack messages.

• Fixes race condition where fire-and-forget sendMessageSlack() hasn't resolved when messageId() is checked
• Matches Discord handler pattern (line 559 in message-handler.process.ts)
• Includes two well-structured tests verifying flush behavior and safety

Confidence Score: 5/5

• This PR is safe to merge with no risk
• The fix is minimal, well-tested, and follows an established pattern from Discord. The race condition is clearly identified and the solution directly addresses the root cause by ensuring the async send completes before reading the result.
• No files require special attention

_{Last reviewed commit: 132c809}

Rebase History