fix(slack): finalize TTS hook ownership

steipete · rishitamrakar · steipete · commit 7619a2dee566 · 2026-06-13T13:24:35.000+01:00
Co-authored-by: Rishi Tamrakar &lt;rishi.ktamrakar@gmail.com&gt;
diff --git a/extensions/slack/src/monitor/message-handler/dispatch.preview-fallback.test.ts b/extensions/slack/src/monitor/message-handler/dispatch.preview-fallback.test.ts
@@ -834,7 +834,8 @@ vi.mock("../config.runtime.js", () => ({
 
 vi.mock("../replies.js", () => ({
   createSlackReplyDeliveryPlan: () => ({
-    peekThreadTs: () => mockedReplyThreadTsSequence?.[0] ?? mockedReplyThreadTs,
+    peekThreadTs: () =>
+      mockedReplyThreadTsSequence ? mockedReplyThreadTsSequence[0] : mockedReplyThreadTs,
     nextThreadTs: () =>
       mockedReplyThreadTsSequence ? mockedReplyThreadTsSequence.shift() : mockedReplyThreadTs,
     markSent: () => {},
@@ -3094,6 +3095,51 @@ describe("dispatchPreparedSlackMessage preview fallback", () => {
     ]);
   });
 
+  it("defers hooks and suppresses duplicate TTS finals when flush creates the preview id", async () => {
+    let flushed = false;
+    const draftStream = {
+      ...createDraftStreamStub(),
+      flush: vi.fn(async () => {
+        flushed = true;
+      }),
+      clear: vi.fn(noopAsync),
+      discardPending: vi.fn(noopAsync),
+      seal: vi.fn(noopAsync),
+      messageId: () => (flushed ? "171234.567" : undefined),
+    };
+    createSlackDraftStreamMock.mockReturnValueOnce(draftStream);
+    finalizeSlackPreviewEditMock.mockResolvedValueOnce(undefined);
+    mockedSlackIsThreadReply = false;
+    mockedReplyThreadTsSequence = [undefined, undefined];
+    const payload = {
+      text: "Spoken answer",
+      mediaUrl: "https://example.com/tts.mp3",
+      audioAsVoice: true,
+      spokenText: "Spoken answer",
+      ttsSupplement: { spokenText: "Spoken answer" },
+    };
+    mockedDispatchSequence = [
+      { kind: "final", payload },
+      { kind: "final", payload },
+    ];
+
+    await dispatchPreparedSlackMessage(
+      createPreparedSlackMessage({
+        message: { thread_ts: undefined },
+        replyToMode: "first",
+      }),
+    );
+
+    expect(finalizeSlackPreviewEditMock).toHaveBeenCalledTimes(1);
+    expect(deliverRepliesMock).toHaveBeenCalledTimes(1);
+    const delivered = requireRecord(
+      requireMockCall(deliverRepliesMock, 0, "deliver replies")[0],
+      "deliver replies params",
+    );
+    expectRecordFields(delivered, { replyThreadTs: THREAD_TS });
+    expect(emitSlackMessageSentHooksMock).not.toHaveBeenCalled();
+  });
+
   it("suppresses duplicate TTS supplement finals after preview finalization", async () => {
     const draftStream = {
       ...createDraftStreamStub(),
@@ -3104,6 +3150,8 @@ describe("dispatchPreparedSlackMessage preview fallback", () => {
     };
     createSlackDraftStreamMock.mockReturnValueOnce(draftStream);
     finalizeSlackPreviewEditMock.mockResolvedValueOnce(undefined);
+    mockedSlackIsThreadReply = false;
+    mockedReplyThreadTsSequence = [undefined];
     const payload = {
       text: "Spoken answer",
       mediaUrl: "https://example.com/tts.mp3",
@@ -3116,14 +3164,20 @@ describe("dispatchPreparedSlackMessage preview fallback", () => {
       { kind: "final", payload },
     ];
 
-    await dispatchPreparedSlackMessage(createPreparedSlackMessage());
+    await dispatchPreparedSlackMessage(
+      createPreparedSlackMessage({
+        message: { thread_ts: undefined },
+        replyToMode: "first",
+      }),
+    );
 
     expect(finalizeSlackPreviewEditMock).toHaveBeenCalledTimes(1);
     expect(deliverRepliesMock).toHaveBeenCalledTimes(1);
     const delivered = requireRecord(
       requireMockCall(deliverRepliesMock, 0, "deliver replies")[0],
       "deliver replies params",
     );
+    expectRecordFields(delivered, { replyThreadTs: THREAD_TS });
     expect(delivered.replies).toEqual([
       {
         mediaUrl: "https://example.com/tts.mp3",
diff --git a/extensions/slack/src/monitor/message-handler/dispatch.ts b/extensions/slack/src/monitor/message-handler/dispatch.ts
@@ -805,6 +805,19 @@ export async function dispatchPreparedSlackMessage(prepared: PreparedSlackMessag
     }
   };
   const deliveryTracker = createSlackEventDeliveryTracker();
+  const markPreviewPayloadDelivered = (params: {
+    kind: ReplyDispatchKind;
+    payload: ReplyPayload;
+    threadTs: string | undefined;
+  }) => {
+    deliveryTracker.markDelivered(params);
+    // Single-use reply modes move later same-turn payloads off the preview
+    // thread, so protect both delivery keys from duplicates.
+    const nextThreadTs = replyPlan.peekThreadTs();
+    if (nextThreadTs !== params.threadTs) {
+      deliveryTracker.markDelivered({ ...params, threadTs: nextThreadTs });
+    }
+  };
   const resolveDeliveryThreadTs = (params: {
     kind: ReplyDispatchKind;
     forcedThreadTs?: string;
@@ -908,7 +921,7 @@ export async function dispatchPreparedSlackMessage(prepared: PreparedSlackMessag
     payload: ReplyPayload;
     kind: ReplyDispatchKind;
     forcedThreadTs?: string;
-  }): Promise<void> => {
+  }): Promise<string | undefined> => {
     if (params.payload.isReasoning === true) {
       return;
     }
@@ -925,7 +938,7 @@ export async function dispatchPreparedSlackMessage(prepared: PreparedSlackMessag
       })
     ) {
       logVerbose("slack: suppressed duplicate normal delivery within the same turn");
-      return;
+      return deliveryReplyThreadTs;
     }
     await deliverReplies({
       cfg: ctx.cfg,
@@ -958,6 +971,7 @@ export async function dispatchPreparedSlackMessage(prepared: PreparedSlackMessag
       payload: params.payload,
       threadTs: deliveryReplyThreadTs,
     });
+    return deliveryReplyThreadTs;
   };
 
   const deliverBufferedStreamFallback = async (params: {
@@ -1311,7 +1325,7 @@ export async function dispatchPreparedSlackMessage(prepared: PreparedSlackMessag
           kind: info.kind,
           forcedThreadTs: finalThreadTs,
         });
-        deliveryTracker.markDelivered({ kind: info.kind, payload, threadTs: finalThreadTs });
+        markPreviewPayloadDelivered({ kind: info.kind, payload, threadTs: finalThreadTs });
         return;
       }
     }
@@ -1363,14 +1377,16 @@ export async function dispatchPreparedSlackMessage(prepared: PreparedSlackMessag
             ...(edit.blocks?.length ? { blocks: edit.blocks } : {}),
             threadTs: edit.threadTs,
           });
-          emitSlackMessageSentHooks({
-            ...messageSentHookContext,
-            to: messageSentHookTarget,
-            accountId: account.accountId,
-            content: trimmedFinalText,
-            success: true,
-            messageId: preview.messageId,
-          });
+          if (!ttsSupplement) {
+            emitSlackMessageSentHooks({
+              ...messageSentHookContext,
+              to: messageSentHookTarget,
+              accountId: account.accountId,
+              content: trimmedFinalText,
+              success: true,
+              messageId: preview.messageId,
+            });
+          }
           draftPreviewCommitted = true;
           observedFinalReplyDelivery = true;
         },
@@ -1382,14 +1398,25 @@ export async function dispatchPreparedSlackMessage(prepared: PreparedSlackMessag
           const finalThreadTs = usedReplyThreadTs ?? statusThreadTs;
           observedReplyDelivery = true;
           replyPlan.markSent();
-          deliveryTracker.markDelivered({ kind: info.kind, payload, threadTs: finalThreadTs });
+          // Supplemental TTS media is the terminal delivery for the logical
+          // payload. Marking the preview first would suppress that media send.
+          if (!ttsSupplement) {
+            markPreviewPayloadDelivered({ kind: info.kind, payload, threadTs: finalThreadTs });
+          }
         },
         buildSupplementalPayload: () =>
           ttsSupplement ? buildTtsSupplementMediaPayload(payload) : undefined,
         deliverSupplemental: async (supplementalPayload) => {
-          await deliverNormally({
+          const previewThreadTs = usedReplyThreadTs ?? statusThreadTs;
+          const supplementalThreadTs = await deliverNormally({
             payload: supplementalPayload,
             kind: info.kind,
+            forcedThreadTs: previewThreadTs,
+          });
+          markPreviewPayloadDelivered({
+            kind: info.kind,
+            payload,
+            threadTs: supplementalThreadTs,
           });
         },
         logPreviewEditFailure: (err) => {
