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

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(),

});

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", () => {

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");

});

});

expect(context.replyToId).toBe("123");

});

it("sets messageThreadId for DM assistant thread-root messages regardless of replyToMode", () => {

for (const replyToMode of ["off", "first", "batched"] as const) {

const context = resolveSlackThreadContext({

replyToMode,

isDirectMessage: true,

message: {

type: "message",

channel: "D1",

channel_type: "im",

ts: "123",

thread_ts: "123",

},

});

expect(context.isThreadReply).toBe(false);

// thread_ts == ts in a DM: Agents & Assistants root — preserve thread

// context so tool calls (subagent results) thread correctly.

expect(context.messageThreadId).toBe("123");

expect(context.replyToId).toBe("123");

}

});

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",

channel_type: "channel",

ts: "123",

thread_ts: "123",

},

});

expect(context.isThreadReply).toBe(false);

// thread_ts == ts in a channel: auto-created top-level thread_ts should

// NOT force threaded mode — only DM assistant threads get the override.

expect(context.messageThreadId).toBeUndefined();

expect(context.replyToId).toBe("123");

}

});

it("prefers thread_ts as messageThreadId for replies", () => {

const context = resolveSlackThreadContext({

replyToMode: "off",

export function resolveSlackThreadContext(params: {

message: SlackMessageEvent | SlackAppMentionEvent;

replyToMode: ReplyToMode;

isDirectMessage?: boolean;

}): SlackThreadContext {

const incomingThreadTs = params.message.thread_ts;

const eventTs = params.message.event_ts;

const isThreadReply =

hasThreadTs && (incomingThreadTs !== messageTs || Boolean(params.message.parent_user_id));

const replyToId = incomingThreadTs ?? messageTs;

const messageThreadId = isThreadReply

? incomingThreadTs

: params.replyToMode === "all"

? messageTs

: undefined;

// 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

: undefined;

return {

incomingThreadTs,

messageTs,