let mockedReplyThreadTs: string | undefined = THREAD_TS;

let mockedReplyThreadTsSequence: Array<string | undefined> | undefined;

let mockedSlackReplyBlocks: unknown[] | undefined;

let mockedSlackIsThreadReply = true;

let capturedTyping:

| {

start: () => Promise<void>;

vi.mock("../../threading.js", () => ({

resolveSlackThreadTargets: () => ({

statusThreadTs: THREAD_TS,

isThreadReply: true,

isThreadReply: mockedSlackIsThreadReply,

}),

}));

mockedReplyThreadTs = THREAD_TS;

mockedReplyThreadTsSequence = undefined;

mockedSlackReplyBlocks = undefined;

mockedSlackIsThreadReply = true;

mockedDispatchSequence = [{ kind: "final", payload: { text: FINAL_REPLY_TEXT } }];

mockedQueuedDispatchCounts = { tool: 0, block: 0, final: 0 };

mockedProgressEvents = [];

expectDeliverReplyCall(0, FINAL_REPLY_TEXT);

});

it("does not create a Slack thread for top-level messages when replyToMode is off", async () => {

mockedSlackStreamingMode = "off";

mockedSlackIsThreadReply = false;

await dispatchPreparedSlackMessage(createPreparedSlackMessage({ replyToMode: "off" }));

expect(deliverRepliesMock).toHaveBeenCalledTimes(1);

expectDeliverReplyCall(0, FINAL_REPLY_TEXT, { replyThreadTs: undefined });

});

it("stays in an existing Slack thread when replyToMode is off", async () => {

mockedSlackStreamingMode = "off";

mockedSlackIsThreadReply = true;

await dispatchPreparedSlackMessage(createPreparedSlackMessage({ replyToMode: "off" }));

expect(deliverRepliesMock).toHaveBeenCalledTimes(1);

expectDeliverReplyCall(0, FINAL_REPLY_TEXT, { replyThreadTs: THREAD_TS });

});

it("passes accepted Slack bot messages through the shared bot loop guard", async () => {

const base = {

cfg: {

return;

}

const replyThreadTs = resolveDeliveryThreadTs(params);

const deliveryReplyThreadTs =

replyDeliveryMode === "off" && !forcedReplyThreadTs && !isThreadReply

? undefined

: replyThreadTs;

if (

deliveryTracker.hasDelivered({

kind: params.kind,

payload: params.payload,

threadTs: replyThreadTs,

threadTs: deliveryReplyThreadTs,

})

) {

logVerbose("slack: suppressed duplicate normal delivery within the same turn");

accountId: account.accountId,

runtime,

textLimit: ctx.textLimit,

replyThreadTs,

replyThreadTs: deliveryReplyThreadTs,

replyToMode: replyDeliveryMode,

...(slackIdentity ? { identity: slackIdentity } : {}),

...(slackMessageMetadata ? { metadata: slackMessageMetadata } : {}),

const deliveredThreadTs = resolveDeliveredSlackReplyThreadTs({

replyToMode: replyDeliveryMode,

payloadReplyToId: params.payload.replyToId,

replyThreadTs,

replyThreadTs: deliveryReplyThreadTs,

});

// Record the thread ts only after confirmed delivery success.

rememberDeliveredThreadTs(params.kind, deliveredThreadTs);

replyPlan.markSent();

deliveryTracker.markDelivered({

kind: params.kind,

payload: params.payload,

threadTs: replyThreadTs,

threadTs: deliveryReplyThreadTs,

});

};

expect(prepared.ctxPayload.TransportThreadId).toBeUndefined();

});

it("keeps Slack assistant DM thread targets when replyToMode is off", async () => {

const prepared = await prepareMessageWith(

createDefaultSlackCtx(),

createSlackAccount({ replyToMode: "off" }),

createSlackMessage({

ts: "10.100",

parent_user_id: "B1",

text: "assistant thread message",

assistant_thread: {

channel_id: "D123",

thread_ts: "10.000",

context: {

channel_id: "C999",

team_id: "T1",

},

},

}),

);

assertPrepared(prepared);

const payload = prepared.ctxPayload as typeof prepared.ctxPayload & Record<string, unknown>;

expect(prepared.ctxPayload.SessionKey).toBe("agent:main:main:thread:10.000");

expect(prepared.ctxPayload.MessageThreadId).toBe("10.000");

expect(prepared.forcedReplyThreadTs).toBe("10.000");

expect(payload.SlackAssistantThread).toBe(true);

expect(payload.SlackAssistantThreadContextChannelId).toBe("C999");

expect(payload.SlackAssistantThreadContextTeamId).toBe("T1");

expect(prepared.ctxPayload.TransportThreadId).toBeUndefined();

});

it("does not force Slack assistant context onto top-level channel replies when replyToMode is off", async () => {

const prepared = await prepareMessageWith(

createDefaultSlackCtx(),

createSlackAccount({ replyToMode: "off" }),

createSlackMessage({

channel: "C123",

channel_type: "channel",

ts: "10.100",

text: "<@B1> top-level assistant context",

assistant_thread: {

channel_id: "D123",

thread_ts: "10.000",

context: {

channel_id: "C999",

team_id: "T1",

},

},

}),

);

assertPrepared(prepared);

const payload = prepared.ctxPayload as typeof prepared.ctxPayload & Record<string, unknown>;

expect(prepared.forcedReplyThreadTs).toBeUndefined();

expect(payload.SlackAssistantThread).toBe(true);

expect(payload.SlackAssistantThreadContextChannelId).toBe("C999");

expect(payload.SlackAssistantThreadContextTeamId).toBe("T1");

});

it("prefers Slack assistant message context over stale lifecycle cache", async () => {

const ctx = createDefaultSlackCtx();

ctx.saveSlackAssistantThreadContext({

sessionKey,

historyKey,

} = routing;

const isAssistantThreadMessage = Boolean(isDirectMessage && messageAssistantThreadContext);

const shouldForceAssistantReplyThread = Boolean(

assistantThreadContext?.threadTs &&

(isThreadReply || isAssistantThreadMessage || replyToMode !== "off"),

);

const forcedAssistantReplyThreadTs = shouldForceAssistantReplyThread

? assistantThreadContext?.threadTs

: undefined;

if (runtimeBinding && shouldLogVerbose()) {

logVerbose(

`slack: routed via bound conversation ${runtimeBinding.conversation.conversationId} -> ${runtimeBinding.targetSessionKey}`,

: undefined,

},

replyToMode,

...(assistantThreadContext?.threadTs

? { forcedReplyThreadTs: assistantThreadContext.threadTs }

: {}),

...(forcedAssistantReplyThreadTs ? { forcedReplyThreadTs: forcedAssistantReplyThreadTs } : {}),

...(assistantThreadContext

? { slackMessageMetadata: buildSlackAssistantThreadMetadata(assistantThreadContext) }

: {}),