fix(slack): use normalized DM state for assistant thread roots

zozo123 · zozo123 · commit f082ac106a02 · 2026-05-18T00:00:31.000+03:00
diff --git a/CHANGELOG.md b/CHANGELOG.md
@@ -1750,6 +1750,7 @@ Docs: https://docs.openclaw.ai
 - Browser/chrome-mcp: read Chrome DevTools MCP screenshot output from the extension-suffixed path, fixing ENOENT on screenshot capture. Fixes #77222. (#74685) Thanks @barbarhan.
 
 - macOS/launchd: set generated Gateway LaunchAgent plists to `ProcessType=Interactive` so the gateway keeps timely execution during idle periods. Fixes #58061; refs #62294 and closed duplicate #66992. (#62308) Thanks @bryanpearson and @zssggle-rgb.
+- Slack: preserve Agents & Assistants DM root thread context for tool and subagent replies even when Slack omits or misreports `channel_type`, while leaving non-DM self-thread roots top-level. Fixes #63659. Thanks @zozo123.
 - Plugins/install: honor the beta update channel for onboarding and doctor-managed plugin installs by requesting floating npm and ClawHub specs with `@beta` while keeping persistent install records on the catalog default. Thanks @vincentkoc.
 - WhatsApp/onboarding: canonicalize setup and pairing allowlist entries to WhatsApp's digit-only phone ids while still accepting E.164, JID, and `whatsapp:` inputs, so personal-phone allowlists match WhatsApp Web sender ids after setup. Thanks @vincentkoc.
 - Gateway/startup: load provider plugins that own explicitly configured image, video, or music generation defaults so generation tools become live after gateway restart instead of remaining catalog-only. Fixes #77244. Thanks @buyuangtampan, @Nikoxx99, and @vincentkoc.
diff --git a/extensions/slack/src/monitor/message-handler/prepare-routing.ts b/extensions/slack/src/monitor/message-handler/prepare-routing.ts
@@ -179,7 +179,7 @@ export function resolveSlackRoutingContext(params: {
 
   const chatType = isDirectMessage ? "direct" : isGroupDm ? "group" : "channel";
   const replyToMode = resolveSlackReplyToMode(account, chatType);
-  const threadContext = resolveSlackThreadContext({ message, replyToMode });
+  const threadContext = resolveSlackThreadContext({ message, replyToMode, isDirectMessage });
   const threadTs = threadContext.incomingThreadTs;
   const isThreadReply = threadContext.isThreadReply;
   // Keep true thread replies thread-scoped, while top-level DMs keep their
diff --git a/extensions/slack/src/monitor/message-handler/prepare.test.ts b/extensions/slack/src/monitor/message-handler/prepare.test.ts
@@ -1329,6 +1329,39 @@ Second paragraph should still reach the agent after Slack's preview cutoff.`;
     expectMainScopedDmClassification(prepared);
   });
 
+  it("preserves MessageThreadId for normalized DM assistant thread roots", async () => {
+    const cases: Array<{
+      name: string;
+      message: SlackMessageEvent;
+    }> = [
+      {
+        name: "raw im",
+        message: createMainScopedDmMessage({ channel_type: "im", thread_ts: "1.000" }),
+      },
+      {
+        name: "wrong channel_type",
+        message: createMainScopedDmMessage({ channel_type: "channel", thread_ts: "1.000" }),
+      },
+      {
+        name: "missing channel_type",
+        message: createMainScopedDmMessage({ thread_ts: "1.000" }),
+      },
+    ];
+    delete cases[2].message.channel_type;
+
+    for (const testCase of cases) {
+      const prepared = await prepareMessageWith(
+        createDmScopeMainSlackCtx(),
+        createSlackAccount(),
+        testCase.message,
+      );
+
+      expectMainScopedDmClassification(prepared, { includeFromCheck: testCase.name !== "raw im" });
+      expect(prepared!.ctxPayload.MessageThreadId).toBe("1.000");
+      expect(prepared!.ctxPayload.ReplyToId).toBe("1.000");
+    }
+  });
+
   it("sets MessageThreadId for top-level messages when replyToMode=all", async () => {
     const prepared = await prepareMessageWith(
       createReplyToAllSlackCtx(),
diff --git a/extensions/slack/src/monitor/message-handler/prepare.thread-session-key.test.ts b/extensions/slack/src/monitor/message-handler/prepare.thread-session-key.test.ts
@@ -347,6 +347,7 @@ describe("thread-level session keys", () => {
     });
 
     expect(routing.sessionKey).toBe("agent:main:slack:channel:c123");
+    expect(routing.threadContext.messageThreadId).toBeUndefined();
   });
 
   it("does not seed top-level group DM mentions into thread sessions", () => {
@@ -634,4 +635,46 @@ describe("thread-level session keys", () => {
       unregisterSessionBindingAdapter({ channel: "slack", accountId: "default", adapter });
     }
   });
+
+  it("preserves distinct MessageThreadIds for concurrent assistant DM roots", () => {
+    const ctx = buildCtx({ replyToMode: "off", dmScope: "per-channel-peer" });
+    const account = buildAccount("off");
+
+    const first = resolveSlackRoutingContext({
+      ctx,
+      account,
+      message: {
+        channel: "D456",
+        channel_type: "channel",
+        user: "U3",
+        text: "first assistant root",
+        ts: "1770408530.000000",
+        thread_ts: "1770408530.000000",
+      } as SlackMessageEvent,
+      isDirectMessage: true,
+      isGroupDm: false,
+      isRoom: false,
+      isRoomish: false,
+    });
+    const second = resolveSlackRoutingContext({
+      ctx,
+      account,
+      message: {
+        channel: "D456",
+        user: "U3",
+        text: "second assistant root",
+        ts: "1770408531.000000",
+        thread_ts: "1770408531.000000",
+      } as SlackMessageEvent,
+      isDirectMessage: true,
+      isGroupDm: false,
+      isRoom: false,
+      isRoomish: false,
+    });
+
+    expect(first.sessionKey).toBe("agent:main:slack:direct:u3");
+    expect(second.sessionKey).toBe(first.sessionKey);
+    expect(first.threadContext.messageThreadId).toBe("1770408530.000000");
+    expect(second.threadContext.messageThreadId).toBe("1770408531.000000");
+  });
 });
diff --git a/extensions/slack/src/threading.test.ts b/extensions/slack/src/threading.test.ts
@@ -92,6 +92,7 @@ describe("resolveSlackThreadTargets", () => {
     for (const replyToMode of ["off", "first", "batched"] as const) {
       const context = resolveSlackThreadContext({
         replyToMode,
+        isDirectMessage: true,
         message: {
           type: "message",
           channel: "D1",
@@ -109,10 +110,33 @@ describe("resolveSlackThreadTargets", () => {
     }
   });
 
+  it("uses normalized direct-message state for DM assistant thread-root messages", () => {
+    for (const channelType of ["channel", undefined] as const) {
+      const message = {
+        type: "message",
+        channel: "D1",
+        ts: "123",
+        thread_ts: "123",
+        ...(channelType ? { channel_type: channelType } : {}),
+      } as const;
+
+      const context = resolveSlackThreadContext({
+        replyToMode: "off",
+        isDirectMessage: true,
+        message,
+      });
+
+      expect(context.isThreadReply).toBe(false);
+      expect(context.messageThreadId).toBe("123");
+      expect(context.replyToId).toBe("123");
+    }
+  });
+
   it("does not set messageThreadId for channel thread-root messages with non-all replyToMode", () => {
     for (const replyToMode of ["off", "first", "batched"] as const) {
       const context = resolveSlackThreadContext({
         replyToMode,
+        isDirectMessage: false,
         message: {
           type: "message",
           channel: "C1",
diff --git a/extensions/slack/src/threading.ts b/extensions/slack/src/threading.ts
@@ -12,6 +12,7 @@ type SlackThreadContext = {
 export function resolveSlackThreadContext(params: {
   message: SlackMessageEvent | SlackAppMentionEvent;
   replyToMode: ReplyToMode;
+  isDirectMessage?: boolean;
 }): SlackThreadContext {
   const incomingThreadTs = params.message.thread_ts;
   const eventTs = params.message.event_ts;
@@ -20,21 +21,13 @@ export function resolveSlackThreadContext(params: {
   const isThreadReply =
     hasThreadTs && (incomingThreadTs !== messageTs || Boolean(params.message.parent_user_id));
   const replyToId = incomingThreadTs ?? messageTs;
-  // Preserve thread context for DM assistant thread-root messages
-  // (Slack Agents & Assistants DMs where thread_ts == ts on the initial
-  // message). Without this, tool calls that run during the same turn (subagent
-  // results) lose the thread identifier after the first reply because
-  // hasRepliedRef gets marked true, causing subsequent sendMessage calls to fall
-  // through to the top-level channel.
-  // Only apply for DM (im) channels — in channels/groups, an auto-created
-  // thread_ts == ts must not force threaded mode, since downstream
-  // buildSlackThreadingToolContext treats any MessageThreadId as an explicit
-  // thread target and overrides replyToMode to "all".
-  const isDmAssistantThread =
-    hasThreadTs && !isThreadReply && params.message.channel_type === "im";
-  const messageThreadId = isThreadReply
-    ? incomingThreadTs
-    : isDmAssistantThread
+  // Preserve thread context for Slack Agents & Assistants DM root messages
+  // where thread_ts == ts. Non-DM self-thread roots must stay unset because
+  // downstream tool threading treats MessageThreadId as an explicit thread
+  // target and overrides replyToMode to "all".
+  const isAssistantDmThreadRoot = hasThreadTs && !isThreadReply && params.isDirectMessage === true;
+  const messageThreadId =
+    isThreadReply || isAssistantDmThreadRoot
       ? incomingThreadTs
       : params.replyToMode === "all"
         ? messageTs
