@geminixiang/mikan 0.3.0-beta.0 → 0.3.1

package/dist/adapters/slack/bot.js

@@ -238,6 +238,16 @@ export class SlackBot {
             return result.ts;
         });
     }
+    async postBlocks(channel, text, blocks) {
+        return slackRetry(async () => {
+            const result = await this.webClient.chat.postMessage({
+                channel,
+                text,
+                blocks: blocks,
+            });
+            return result.ts;
+        });
+    }
     async uploadFile(channel, filePath, title, threadTs) {
         return slackRetry(async () => {
             const fileName = title || basename(filePath);
@@ -254,8 +264,11 @@ export class SlackBot {
     logToFile(channel, entry) {
         appendChannelLog(this.workingDir, channel, entry);
     }
-    logBotResponse(channel, text, ts, threadTs) {
-        appendBotResponseLog(this.workingDir, channel, text, ts, threadTs);
+    logBotResponse(channel, text, ts, threadTs, slackBlocks) {
+        appendBotResponseLog(this.workingDir, channel, text, ts, threadTs, {
+            platform: "slack",
+            ...(slackBlocks ? { slackBlocks } : {}),
+        });
     }
     getPlatformInfo() {
         return {
@@ -370,14 +383,6 @@ export class SlackBot {
             sessionKey,
         });
     }
-    shouldTriggerSharedThreadReply(channelId, threadTs) {
-        if (!threadTs)
-            return false;
-        const sessionKey = resolveSlackSessionKey(channelId, threadTs);
-        if (this.handler.isRunning(sessionKey))
-            return true;
-        return this.hasKnownThreadSession(channelId, sessionKey);
-    }
     buildHomeView() {
         const blocks = [
             {
@@ -586,31 +591,19 @@ export class SlackBot {
             platform: this.getPlatformInfo(),
         };
     }
-    createSlashCommandBot(conversationId, threadTs) {
-        return {
-            start: async () => { },
-            postMessage: async (_channel, text) => {
-                if (threadTs) {
-                    return this.postInThread(conversationId, threadTs, text);
-                }
-                return this.postMessage(conversationId, text);
-            },
-            updateMessage: async (channel, ts, text) => {
-                await this.updateMessage(channel, ts, text);
-            },
-            enqueueEvent: (event) => this.enqueueEvent(event),
-            getPlatformInfo: () => this.getPlatformInfo(),
-        };
-    }
-    async routeSlashLoginCommand(payload) {
-        const commandSuffix = payload.text?.trim();
-        const commandText = commandSuffix ? `${payload.command} ${commandSuffix}` : payload.command;
+    buildSlashCommandEvent(payload, options = {}) {
+        const conversationId = payload.channel_id;
+        const isDirectMessage = conversationId.startsWith("D");
         const createdAt = new Date();
         const eventTs = (createdAt.getTime() / 1000).toFixed(6);
-        const sourceChannelId = payload.channel_id;
-        const isDirectMessage = sourceChannelId.startsWith("D");
         const userName = payload.user_name ?? this.getUser(payload.user_id)?.userName;
-        this.logToFile(sourceChannelId, {
+        const commandSuffix = options.includeText ? payload.text?.trim() : undefined;
+        const commandText = commandSuffix ? `${payload.command} ${commandSuffix}` : payload.command;
+        const threadTs = options.thread ? payload.thread_ts : undefined;
+        const sessionKey = options.thread
+            ? resolveSlackSessionKey(conversationId, threadTs)
+            : conversationId;
+        this.logToFile(conversationId, {
             date: createdAt.toISOString(),
             ts: eventTs,
             user: payload.user_id,
@@ -618,18 +611,43 @@ export class SlackBot {
             text: commandText,
             attachments: [],
             isBot: false,
+            ...(threadTs ? { threadTs } : {}),
         });
         const event = {
-            type: isDirectMessage ? "dm" : "private_command",
-            conversationId: sourceChannelId,
+            type: options.type ?? (isDirectMessage ? "dm" : "mention"),
+            conversationId,
             conversationKind: isDirectMessage ? "direct" : "shared",
             ts: eventTs,
             user: payload.user_id,
             text: commandText,
             attachments: [],
-            sessionKey: sourceChannelId,
+            ...(threadTs ? { thread_ts: threadTs } : {}),
+            sessionKey,
         };
-        const adapters = this.createCommandAdapters(sourceChannelId, payload.user_id, userName, commandText, eventTs, isDirectMessage ? {} : { ephemeralChannelId: sourceChannelId });
+        const adapters = this.createCommandAdapters(conversationId, payload.user_id, userName, commandText, eventTs, isDirectMessage ? { threadTs } : { ephemeralChannelId: conversationId, threadTs });
+        return { event, adapters };
+    }
+    createSlashCommandBot(conversationId, threadTs) {
+        return {
+            start: async () => { },
+            postMessage: async (_channel, text) => {
+                if (threadTs) {
+                    return this.postInThread(conversationId, threadTs, text);
+                }
+                return this.postMessage(conversationId, text);
+            },
+            updateMessage: async (channel, ts, text) => {
+                await this.updateMessage(channel, ts, text);
+            },
+            enqueueEvent: (event) => this.enqueueEvent(event),
+            getPlatformInfo: () => this.getPlatformInfo(),
+        };
+    }
+    async routeSlashLoginCommand(payload) {
+        const { event, adapters } = this.buildSlashCommandEvent(payload, {
+            type: payload.channel_id.startsWith("D") ? "dm" : "private_command",
+            includeText: true,
+        });
         await this.handler.handleEvent(event, this, adapters);
     }
     async routeSlashNewCommand(payload) {
@@ -654,34 +672,7 @@ export class SlackBot {
         await this.handler.handleNewCommand(conversationId, conversationId, commandBot);
     }
     async routeSlashModelCommand(payload) {
-        const conversationId = payload.channel_id;
-        const isDirectMessage = conversationId.startsWith("D");
-        const createdAt = new Date();
-        const eventTs = (createdAt.getTime() / 1000).toFixed(6);
-        const userName = payload.user_name ?? this.getUser(payload.user_id)?.userName;
-        const commandSuffix = payload.text?.trim();
-        const commandText = commandSuffix ? `${payload.command} ${commandSuffix}` : payload.command;
-        this.logToFile(conversationId, {
-            date: createdAt.toISOString(),
-            ts: eventTs,
-            user: payload.user_id,
-            userName,
-            text: commandText,
-            attachments: [],
-            isBot: false,
-        });
-        const sessionKey = conversationId;
-        const event = {
-            type: isDirectMessage ? "dm" : "mention",
-            conversationId,
-            conversationKind: isDirectMessage ? "direct" : "shared",
-            ts: eventTs,
-            user: payload.user_id,
-            text: commandText,
-            attachments: [],
-            sessionKey,
-        };
-        const adapters = this.createCommandAdapters(conversationId, payload.user_id, userName, commandText, eventTs, isDirectMessage ? {} : { ephemeralChannelId: conversationId });
+        const { event, adapters } = this.buildSlashCommandEvent(payload, { includeText: true });
         await this.handler.handleEvent(event, this, adapters);
     }
     async routeSlashSandboxCommand(payload) {
@@ -691,71 +682,11 @@ export class SlackBot {
         await this.routeSlashModelCommand(payload);
     }
     async routeSlashSessionCommand(payload) {
-        const conversationId = payload.channel_id;
-        const isDirectMessage = conversationId.startsWith("D");
-        const createdAt = new Date();
-        const eventTs = (createdAt.getTime() / 1000).toFixed(6);
-        const userName = payload.user_name ?? this.getUser(payload.user_id)?.userName;
-        const commandText = payload.command;
-        this.logToFile(conversationId, {
-            date: createdAt.toISOString(),
-            ts: eventTs,
-            user: payload.user_id,
-            userName,
-            text: commandText,
-            attachments: [],
-            isBot: false,
-            threadTs: payload.thread_ts,
-        });
-        const sessionKey = resolveSlackSessionKey(conversationId, payload.thread_ts);
-        const event = {
-            type: isDirectMessage ? "dm" : "mention",
-            conversationId,
-            conversationKind: isDirectMessage ? "direct" : "shared",
-            ts: eventTs,
-            user: payload.user_id,
-            text: commandText,
-            attachments: [],
-            thread_ts: payload.thread_ts,
-            sessionKey,
-        };
-        const adapters = this.createCommandAdapters(conversationId, payload.user_id, userName, commandText, eventTs, isDirectMessage
-            ? { threadTs: payload.thread_ts }
-            : { ephemeralChannelId: conversationId, threadTs: payload.thread_ts });
+        const { event, adapters } = this.buildSlashCommandEvent(payload, { thread: true });
         await this.handler.handleEvent(event, this, adapters);
     }
     async routeSlashAdminCommand(payload) {
-        const conversationId = payload.channel_id;
-        const isDirectMessage = conversationId.startsWith("D");
-        const createdAt = new Date();
-        const eventTs = (createdAt.getTime() / 1000).toFixed(6);
-        const userName = payload.user_name ?? this.getUser(payload.user_id)?.userName;
-        const commandText = payload.command;
-        this.logToFile(conversationId, {
-            date: createdAt.toISOString(),
-            ts: eventTs,
-            user: payload.user_id,
-            userName,
-            text: commandText,
-            attachments: [],
-            isBot: false,
-            threadTs: payload.thread_ts,
-        });
-        const sessionKey = resolveSlackSessionKey(conversationId, payload.thread_ts);
-        const event = {
-            type: isDirectMessage ? "dm" : "mention",
-            conversationId,
-            conversationKind: isDirectMessage ? "direct" : "shared",
-            ts: eventTs,
-            user: payload.user_id,
-            text: commandText,
-            attachments: [],
-            thread_ts: payload.thread_ts,
-            sessionKey,
-        };
-        const adapters = this.createCommandAdapters(conversationId, payload.user_id, userName, commandText, eventTs, isDirectMessage
-            ? { threadTs: payload.thread_ts }
-            : { ephemeralChannelId: conversationId, threadTs: payload.thread_ts });
+        const { event, adapters } = this.buildSlashCommandEvent(payload, { thread: true });
         await this.handler.handleEvent(event, this, adapters);
     }
     setupEventHandlers() {
@@ -768,92 +699,80 @@ export class SlackBot {
         this.socketClient.on("unable_to_socket_mode_start", (err) => {
             log.logWarning("Slack socket unable_to_start", err ? String(err) : "");
         });
-        // Channel @mentions
-        this.socketClient.on("app_mention", ({ event, ack }) => {
-            const e = event;
-            // Skip DMs (handled by message event)
-            if (e.channel.startsWith("D")) {
-                ack();
-                return;
-            }
-            // Top-level mentions use a persistent channel session.
-            // Thread replies get their own isolated session (channelId:thread_ts).
-            const sessionKey = resolveSlackSessionKey(e.channel, e.thread_ts);
-            const slackEvent = {
-                type: "mention",
-                conversationId: e.channel,
-                conversationKind: "shared",
-                channel: e.channel,
-                ts: e.ts,
-                thread_ts: e.thread_ts,
-                user: e.user,
-                text: this.stripOwnMention(e.text),
-                files: e.files,
-                sessionKey,
-            };
-            const attachmentsPromise = this.logUserMessage(slackEvent);
-            // Only trigger processing for messages AFTER startup (not replayed old messages)
-            if (this.startupTs && e.ts < this.startupTs) {
-                log.logInfo(`[${e.channel}] Logged old message (pre-startup), not triggering: ${slackEvent.text.substring(0, 30)}`);
-                void attachmentsPromise.catch((err) => {
-                    log.logWarning("Failed to log Slack message", String(err));
-                });
-                ack();
-                return;
+        this.socketClient.on("app_mention", (payload) => this.handleAppMention(payload));
+        this.socketClient.on("message", (payload) => this.handleMessageEvent(payload));
+        this.socketClient.on("slash_commands", (payload) => void this.handleSlashCommand(payload));
+        this.socketClient.on("app_home_opened", (payload) => this.handleAppHomeOpened(payload));
+        this.socketClient.on("block_actions", (payload) => void this.handleBlockAction(payload));
+        this.socketClient.on("interactive", (payload) => void this.handleBlockAction(payload));
+    }
+    handleAppMention({ event, ack }) {
+        const e = event;
+        // Skip DMs (handled by message event)
+        if (e.channel.startsWith("D")) {
+            ack();
+            return;
+        }
+        // Top-level mentions use a persistent channel session.
+        // Thread replies get their own isolated session (channelId:thread_ts).
+        const sessionKey = resolveSlackSessionKey(e.channel, e.thread_ts);
+        const mentionText = this.stripOwnMention(e.text);
+        const slackEvent = {
+            type: "mention",
+            conversationId: e.channel,
+            conversationKind: "shared",
+            channel: e.channel,
+            ts: e.ts,
+            thread_ts: e.thread_ts,
+            user: e.user,
+            text: mentionText || "Please respond to the recent conversation context.",
+            files: e.files,
+            sessionKey,
+        };
+        const attachmentsPromise = this.logUserMessage(slackEvent);
+        // Only trigger processing for messages AFTER startup (not replayed old messages)
+        if (this.startupTs && e.ts < this.startupTs) {
+            log.logInfo(`[${e.channel}] Logged old message (pre-startup), not triggering: ${slackEvent.text.substring(0, 30)}`);
+            void attachmentsPromise.catch((err) => {
+                log.logWarning("Failed to log Slack message", String(err));
+            });
+            ack();
+            return;
+        }
+        // Check for stop command - execute immediately, don't queue!
+        if (this.isStopText(slackEvent.text)) {
+            const stopTarget = this.resolveStopTarget(e.channel, e.thread_ts);
+            if (stopTarget) {
+                this.handler.handleStop(stopTarget, e.channel, this);
             }
-            // Check for stop command - execute immediately, don't queue!
-            if (this.isStopText(slackEvent.text)) {
-                const stopTarget = this.resolveStopTarget(e.channel, e.thread_ts);
-                if (stopTarget) {
-                    this.handler.handleStop(stopTarget, e.channel, this);
-                }
-                else {
-                    this.postMessage(e.channel, formatNothingRunning("slack"));
-                }
-                void attachmentsPromise.catch((err) => {
-                    log.logWarning("Failed to log Slack message", String(err));
-                });
-                ack();
-                return;
+            else {
+                this.postMessage(e.channel, formatNothingRunning("slack"));
             }
-            this.getQueue(this.resolveQueueKey(e.channel, sessionKey)).enqueue(async () => {
-                slackEvent.attachments = await attachmentsPromise;
-                const adapters = createSlackAdapters(slackEvent, this);
-                return this.handler.handleEvent(slackEvent, this, adapters);
+            void attachmentsPromise.catch((err) => {
+                log.logWarning("Failed to log Slack message", String(err));
             });
             ack();
+            return;
+        }
+        this.getQueue(this.resolveQueueKey(e.channel, sessionKey)).enqueue(async () => {
+            slackEvent.attachments = await attachmentsPromise;
+            const adapters = createSlackAdapters(slackEvent, this);
+            return this.handler.handleEvent(slackEvent, this, adapters);
         });
-        // All messages (for logging) + DMs (for triggering)
-        this.socketClient.on("message", ({ event, ack }) => {
-            const e = event;
-            const hasFiles = !!e.files && e.files.length > 0;
-            const hasSlackContent = !!e.text || hasFiles || !!e.blocks?.length || !!e.attachments?.length;
-            const isOwnBotMessage = (!!e.user && e.user === this.botUserId) || (!!this.botId && e.bot_id === this.botId);
-            if (isOwnBotMessage) {
-                ack();
-                return;
-            }
-            const isExternalBotMessage = !!e.bot_id || e.subtype === "bot_message";
-            if (isExternalBotMessage) {
-                if (e.subtype !== undefined && e.subtype !== "bot_message" && e.subtype !== "file_share") {
-                    ack();
-                    return;
-                }
-                if (!hasSlackContent) {
-                    ack();
-                    return;
-                }
-                void this.logExternalBotMessage(e).catch((err) => {
-                    log.logWarning("Failed to log Slack bot message", String(err));
-                });
-                ack();
-                return;
-            }
-            if (!e.user) {
-                ack();
-                return;
-            }
-            if (e.subtype !== undefined && e.subtype !== "file_share") {
+        ack();
+    }
+    handleMessageEvent({ event, ack }) {
+        const e = event;
+        const hasFiles = !!e.files && e.files.length > 0;
+        const hasSlackContent = !!e.text || hasFiles || !!e.blocks?.length || !!e.attachments?.length;
+        const isOwnBotMessage = (!!e.user && e.user === this.botUserId) || (!!this.botId && e.bot_id === this.botId);
+        if (isOwnBotMessage) {
+            ack();
+            return;
+        }
+        const isExternalBotMessage = !!e.bot_id || e.subtype === "bot_message";
+        if (isExternalBotMessage) {
+            if (e.subtype !== undefined && e.subtype !== "bot_message" && e.subtype !== "file_share") {
                 ack();
                 return;
             }
@@ -861,203 +780,300 @@ export class SlackBot {
                 ack();
                 return;
             }
-            const isDM = e.channel_type === "im";
-            const conversationKind = isDM ? "direct" : "shared";
-            const isBotMention = e.text?.includes(`<@${this.botUserId}>`);
-            // Skip channel @mentions - already handled by app_mention event
-            if (!isDM && isBotMention) {
-                ack();
-                return;
-            }
-            const isSharedThreadReply = !isDM && this.shouldTriggerSharedThreadReply(e.channel, e.thread_ts);
-            const sessionKey = isDM || isSharedThreadReply ? resolveSlackSessionKey(e.channel, e.thread_ts) : undefined;
-            const slackEvent = {
-                type: isDM ? "dm" : "mention",
-                conversationId: e.channel,
-                conversationKind,
-                channel: e.channel,
-                ts: e.ts,
-                thread_ts: e.thread_ts,
-                user: e.user,
-                text: this.stripOwnMention(e.text),
-                files: e.files,
-                sessionKey,
-            };
-            const attachmentsPromise = this.logUserMessage(slackEvent);
-            // Only trigger processing for messages AFTER startup (not replayed old messages)
-            if (this.startupTs && e.ts < this.startupTs) {
-                log.logInfo(`[${e.channel}] Skipping old message (pre-startup): ${slackEvent.text.substring(0, 30)}`);
-                void attachmentsPromise.catch((err) => {
-                    log.logWarning("Failed to log Slack message", String(err));
-                });
-                ack();
-                return;
-            }
-            // Stop command for DM or shared-channel thread reply (app_mention handles "@mikan stop").
-            if ((isDM || (!isDM && e.thread_ts)) && this.isStopText(slackEvent.text)) {
-                const stopTarget = this.resolveStopTarget(e.channel, e.thread_ts);
-                if (stopTarget) {
-                    this.handler.handleStop(stopTarget, e.channel, this);
-                }
-                else {
-                    this.postMessage(e.channel, formatNothingRunning("slack"));
-                }
-                void attachmentsPromise.catch((err) => {
-                    log.logWarning("Failed to log Slack message", String(err));
-                });
-                ack();
-                return;
+            void this.logExternalBotMessage(e).catch((err) => {
+                log.logWarning("Failed to log Slack bot message", String(err));
+            });
+            ack();
+            return;
+        }
+        if (!e.user) {
+            ack();
+            return;
+        }
+        if (e.subtype !== undefined && e.subtype !== "file_share") {
+            ack();
+            return;
+        }
+        if (!hasSlackContent) {
+            ack();
+            return;
+        }
+        const isDM = e.channel_type === "im";
+        const conversationKind = isDM ? "direct" : "shared";
+        const isBotMention = e.text?.includes(`<@${this.botUserId}>`);
+        // Skip channel @mentions - already handled by app_mention event
+        if (!isDM && isBotMention) {
+            ack();
+            return;
+        }
+        const isThreadReply = !!e.thread_ts;
+        const sessionKey = isDM ? resolveSlackSessionKey(e.channel, e.thread_ts) : undefined;
+        const slackEvent = {
+            type: isDM ? "dm" : "mention",
+            conversationId: e.channel,
+            conversationKind,
+            channel: e.channel,
+            ts: e.ts,
+            thread_ts: e.thread_ts,
+            user: e.user,
+            text: this.stripOwnMention(e.text),
+            files: e.files,
+            sessionKey,
+        };
+        const attachmentsPromise = this.logUserMessage(slackEvent);
+        // Only trigger processing for messages AFTER startup (not replayed old messages)
+        if (this.startupTs && e.ts < this.startupTs) {
+            log.logInfo(`[${e.channel}] Skipping old message (pre-startup): ${slackEvent.text.substring(0, 30)}`);
+            void attachmentsPromise.catch((err) => {
+                log.logWarning("Failed to log Slack message", String(err));
+            });
+            ack();
+            return;
+        }
+        // Stop command for DM only (app_mention handles shared-channel "@mikan stop").
+        if (isDM && this.isStopText(slackEvent.text)) {
+            const stopTarget = this.resolveStopTarget(e.channel, e.thread_ts);
+            if (stopTarget) {
+                this.handler.handleStop(stopTarget, e.channel, this);
             }
-            const enqueueTriggered = () => {
-                const activeSessionKey = slackEvent.sessionKey ?? resolveSlackSessionKey(e.channel, e.thread_ts);
-                // Auto-reply top-level channel messages start with no sessionKey because
-                // they are only candidates until the policy allows them. Once triggered,
-                // persist the resolved key on the event; otherwise the runtime fallback
-                // treats the message ts as a thread session (`channel:ts`) instead of the
-                // persistent top-level channel session.
-                slackEvent.sessionKey = activeSessionKey;
-                this.getQueue(this.resolveQueueKey(e.channel, activeSessionKey)).enqueue(async () => {
-                    slackEvent.attachments = await attachmentsPromise;
-                    const adapters = createSlackAdapters(slackEvent, this);
-                    return this.handler.handleEvent(slackEvent, this, adapters);
-                });
-            };
-            const logOnly = () => {
-                void attachmentsPromise.catch((err) => {
-                    log.logWarning("Failed to log Slack message", String(err));
-                });
-            };
-            if (isDM || isSharedThreadReply) {
-                enqueueTriggered();
-                ack();
-                return;
+            else {
+                this.postMessage(e.channel, formatNothingRunning("slack"));
             }
-            // Shared-channel non-mention, non-thread: gate via auto-reply policy.
-            // evaluateAutoReplyPolicy never throws — judge errors/timeouts surface as
-            // trigger:false with a distinct reason, and the user message has already
-            // been queued for logging via logUserMessage above.
-            evaluateAutoReplyPolicy({
-                event: slackEvent,
-                workingDir: this.workingDir,
-            }).then((triggerResult) => {
-                if (triggerResult.trigger)
-                    enqueueTriggered();
-                else
-                    logOnly();
+            void attachmentsPromise.catch((err) => {
+                log.logWarning("Failed to log Slack message", String(err));
+            });
+            ack();
+            return;
+        }
+        const enqueueTriggered = () => {
+            const activeSessionKey = slackEvent.sessionKey ?? resolveSlackSessionKey(e.channel, e.thread_ts);
+            // Auto-reply top-level channel messages start with no sessionKey because
+            // they are only candidates until the policy allows them. Once triggered,
+            // persist the resolved key on the event; otherwise the runtime fallback
+            // treats the message ts as a thread session (`channel:ts`) instead of the
+            // persistent top-level channel session.
+            slackEvent.sessionKey = activeSessionKey;
+            this.getQueue(this.resolveQueueKey(e.channel, activeSessionKey)).enqueue(async () => {
+                slackEvent.attachments = await attachmentsPromise;
+                const adapters = createSlackAdapters(slackEvent, this);
+                return this.handler.handleEvent(slackEvent, this, adapters);
             });
+        };
+        const logOnly = () => {
+            void attachmentsPromise.catch((err) => {
+                log.logWarning("Failed to log Slack message", String(err));
+            });
+        };
+        if (isDM) {
+            enqueueTriggered();
+            ack();
+            return;
+        }
+        if (isThreadReply) {
+            logOnly();
             ack();
+            return;
+        }
+        // Shared-channel non-mention top-level messages: gate via auto-reply policy.
+        // evaluateAutoReplyPolicy never throws — judge errors/timeouts surface as
+        // trigger:false with a distinct reason, and the user message has already
+        // been queued for logging via logUserMessage above.
+        evaluateAutoReplyPolicy({
+            event: slackEvent,
+            workingDir: this.workingDir,
+        }).then((triggerResult) => {
+            if (triggerResult.trigger)
+                enqueueTriggered();
+            else
+                logOnly();
         });
-        this.socketClient.on("slash_commands", async ({ body, ack }) => {
-            const payload = body;
-            await ack();
-            if (!payload.command || !payload.channel_id || !payload.user_id) {
-                return;
-            }
-            const handlerPromise = payload.command === "/pi-login"
-                ? this.routeSlashLoginCommand({
+        ack();
+    }
+    async handleSlashCommand({ body, ack, }) {
+        const payload = body;
+        await ack();
+        if (!payload.command || !payload.channel_id || !payload.user_id) {
+            return;
+        }
+        const handlerPromise = payload.command === "/pi-login"
+            ? this.routeSlashLoginCommand({
+                command: payload.command,
+                text: payload.text,
+                channel_id: payload.channel_id,
+                user_id: payload.user_id,
+                user_name: payload.user_name,
+            })
+            : payload.command === "/pi-new"
+                ? this.routeSlashNewCommand({
                     command: payload.command,
-                    text: payload.text,
                     channel_id: payload.channel_id,
                     user_id: payload.user_id,
                     user_name: payload.user_name,
                 })
-                : payload.command === "/pi-new"
-                    ? this.routeSlashNewCommand({
+                : payload.command === "/pi-session"
+                    ? this.routeSlashSessionCommand({
                         command: payload.command,
                         channel_id: payload.channel_id,
                         user_id: payload.user_id,
                         user_name: payload.user_name,
+                        thread_ts: payload.thread_ts,
                     })
-                    : payload.command === "/pi-session"
-                        ? this.routeSlashSessionCommand({
+                    : payload.command === "/pi-model"
+                        ? this.routeSlashModelCommand({
                             command: payload.command,
+                            text: payload.text,
                             channel_id: payload.channel_id,
                             user_id: payload.user_id,
                             user_name: payload.user_name,
-                            thread_ts: payload.thread_ts,
                         })
-                        : payload.command === "/pi-model"
-                            ? this.routeSlashModelCommand({
+                        : payload.command === "/pi-sandbox"
+                            ? this.routeSlashSandboxCommand({
                                 command: payload.command,
                                 text: payload.text,
                                 channel_id: payload.channel_id,
                                 user_id: payload.user_id,
                                 user_name: payload.user_name,
                             })
-                            : payload.command === "/pi-sandbox"
-                                ? this.routeSlashSandboxCommand({
+                            : payload.command === "/pi-auto-reply"
+                                ? this.routeSlashAutoReplyCommand({
                                     command: payload.command,
                                     text: payload.text,
                                     channel_id: payload.channel_id,
                                     user_id: payload.user_id,
                                     user_name: payload.user_name,
                                 })
-                                : payload.command === "/pi-auto-reply"
-                                    ? this.routeSlashAutoReplyCommand({
+                                : payload.command === "/pi-admin"
+                                    ? this.routeSlashAdminCommand({
                                         command: payload.command,
-                                        text: payload.text,
                                         channel_id: payload.channel_id,
                                         user_id: payload.user_id,
                                         user_name: payload.user_name,
+                                        thread_ts: payload.thread_ts,
                                     })
-                                    : payload.command === "/pi-admin"
-                                        ? this.routeSlashAdminCommand({
-                                            command: payload.command,
-                                            channel_id: payload.channel_id,
-                                            user_id: payload.user_id,
-                                            user_name: payload.user_name,
-                                            thread_ts: payload.thread_ts,
-                                        })
-                                        : null;
-            if (!handlerPromise) {
-                return;
-            }
-            handlerPromise.catch((err) => {
-                log.logWarning("Slack slash command error", err instanceof Error ? err.message : String(err));
-            });
+                                    : null;
+        if (!handlerPromise) {
+            return;
+        }
+        handlerPromise.catch((err) => {
+            log.logWarning("Slack slash command error", err instanceof Error ? err.message : String(err));
         });
-        // App Home tab
-        this.socketClient.on("app_home_opened", ({ event, ack }) => {
-            const e = event;
+    }
+    handleAppHomeOpened({ event, ack }) {
+        const e = event;
+        ack();
+        if (e.tab !== "home")
+            return;
+        this.webClient.views
+            .publish({
+            user_id: e.user,
+            view: this.buildHomeView(),
+        })
+            .catch((err) => {
+            log.logWarning(`Failed to publish App Home view`, String(err));
+        });
+    }
+    async handleBlockAction({ body, ack }) {
+        const action = body.actions?.[0];
+        if (!action) {
             ack();
-            if (e.tab !== "home")
-                return;
+            return;
+        }
+        if (!action.action_id?.startsWith("force_stop_")) {
+            ack();
+            this.handleSlackInteraction(body, action);
+            return;
+        }
+        ack();
+        const sessionKey = action.action_id.replace("force_stop_", "").replace(/_/g, ":");
+        const userId = body.user?.id;
+        const channelId = body.container?.channel_id || sessionKey.split(":")[0];
+        log.logInfo(`[Force Stop] User ${userId} requested force stop for ${sessionKey}`);
+        // Use handler's forceStop method
+        this.handler.forceStop(sessionKey);
+        // Notify in channel
+        await this.postMessage(channelId, formatForceStopped("slack", userId ?? "unknown"));
+        // Refresh home tab
+        if (userId) {
             this.webClient.views
                 .publish({
-                user_id: e.user,
+                user_id: userId,
                 view: this.buildHomeView(),
             })
                 .catch((err) => {
-                log.logWarning(`Failed to publish App Home view`, String(err));
+                log.logWarning(`Failed to refresh App Home view`, String(err));
             });
+        }
+    }
+    handleSlackInteraction(body, action) {
+        const container = body.container ?? {};
+        const channelId = container.channel_id;
+        const userId = body.user?.id;
+        if (!channelId || !userId)
+            return;
+        const selectedOption = action.selected_option;
+        const selectedOptions = Array.isArray(action.selected_options)
+            ? action.selected_options
+            : undefined;
+        const selectedText = selectedOption?.text?.text ?? selectedOption?.value;
+        const selectedTexts = selectedOptions?.map((option) => option.text?.text ?? option.value);
+        const valueText = selectedTexts?.length
+            ? selectedTexts.join(", ")
+            : (selectedText ?? action.value ?? action.action_id);
+        const text = `[Slack action] ${action.action_id}: ${valueText}`;
+        const ts = `action:${Date.now()}`;
+        const threadTs = container.thread_ts;
+        const sessionKey = resolveSlackSessionKey(channelId, threadTs);
+        this.logToFile(channelId, {
+            date: new Date().toISOString(),
+            ts,
+            ...(threadTs ? { threadTs } : {}),
+            user: userId,
+            userName: body.user?.username ?? body.user?.name,
+            text,
+            attachments: [],
+            isBot: false,
+            platform: "slack",
+            slackInteraction: {
+                type: "block_actions",
+                actionId: action.action_id,
+                blockId: action.block_id,
+                actionType: action.type,
+                value: action.value,
+                selectedOption: selectedOption
+                    ? { text: selectedOption.text?.text, value: selectedOption.value }
+                    : undefined,
+                selectedOptions: selectedOptions?.map((option) => ({
+                    text: option.text?.text,
+                    value: option.value,
+                })),
+                messageTs: container.message_ts,
+            },
         });
-        // Handle button clicks (Force Stop)
-        this.socketClient.on("block_actions", async ({ body, ack }) => {
-            const action = body.actions?.[0];
-            if (!action || !action.action_id?.startsWith("force_stop_")) {
-                ack();
-                return;
-            }
-            ack();
-            const sessionKey = action.action_id.replace("force_stop_", "").replace(/_/g, ":");
-            const userId = body.user?.id;
-            const channelId = body.container?.channel_id || sessionKey.split(":")[0];
-            log.logInfo(`[Force Stop] User ${userId} requested force stop for ${sessionKey}`);
-            // Use handler's forceStop method
-            this.handler.forceStop(sessionKey);
-            // Notify in channel
-            await this.postMessage(channelId, formatForceStopped("slack", userId ?? "unknown"));
-            // Refresh home tab
-            if (userId) {
-                this.webClient.views
-                    .publish({
-                    user_id: userId,
-                    view: this.buildHomeView(),
-                })
-                    .catch((err) => {
-                    log.logWarning(`Failed to refresh App Home view`, String(err));
-                });
-            }
+        const event = {
+            type: "slack_action",
+            conversationId: channelId,
+            conversationKind: channelId.startsWith("D") ? "direct" : "shared",
+            ts,
+            user: userId,
+            text,
+            attachments: [],
+            ...(threadTs ? { thread_ts: threadTs } : {}),
+            sessionKey,
+        };
+        this.getQueue(this.resolveQueueKey(channelId, sessionKey)).enqueue(async () => {
+            const slackEvent = {
+                type: event.conversationKind === "direct" ? "dm" : "mention",
+                conversationId: channelId,
+                conversationKind: event.conversationKind,
+                channel: channelId,
+                ts,
+                thread_ts: threadTs,
+                user: userId,
+                text,
+                attachments: [],
+                sessionKey,
+            };
+            return this.handler.handleEvent(event, this, createSlackAdapters(slackEvent, this));
         });
     }
     /**