@geminixiang/mama 0.2.0-beta.1 → 0.2.0-beta.3

package/dist/adapters/slack/bot.js

@@ -3,10 +3,11 @@ import { WebClient } from "@slack/web-api";
 import { appendFileSync, existsSync, mkdirSync, readFileSync } from "fs";
 import { readFile } from "fs/promises";
 import { basename, join } from "path";
-import { parseLoginCommand } from "../../login.js";
 import * as log from "../../log.js";
-import { PRODUCT_NAME, formatAlreadyWorking, formatForceStopped, formatNothingRunning, } from "../../ui-copy.js";
+import { PRODUCT_NAME, formatForceStopped, formatNothingRunning } from "../../ui-copy.js";
 import { createSlackAdapters } from "./context.js";
+import { hasMaterializedSlackBranchSession } from "./branch-manager.js";
+import { resolveSlackSessionKey } from "./session.js";
 // ============================================================================
 // Exponential backoff utility for Slack API calls
 // ============================================================================
@@ -94,21 +95,6 @@ export class SlackBot {
     setEventsWatcher(watcher) {
         this.eventsWatcher = watcher;
     }
-    toBotEvent(event) {
-        return {
-            type: event.type,
-            conversationId: event.channel,
-            ts: event.ts,
-            thread_ts: event.thread_ts,
-            user: event.user,
-            text: event.text,
-            attachments: event.attachments?.map((attachment) => ({
-                name: attachment.original,
-                localPath: attachment.localPath,
-            })),
-            sessionKey: event.sessionKey,
-        };
-    }
     // ==========================================================================
     // Public API
     // ==========================================================================
@@ -136,15 +122,30 @@ export class SlackBot {
     getAllChannels() {
         return Array.from(this.channels.values());
     }
-    async postMessage(conversationId, text) {
+    async postMessage(channel, text) {
         return withRetry(async () => {
-            const result = await this.webClient.chat.postMessage({ channel: conversationId, text });
+            const result = await this.webClient.chat.postMessage({ channel, text });
             return result.ts;
         });
     }
-    async updateMessage(conversationId, ts, text) {
+    async postEphemeral(channel, user, text) {
+        return withRetry(async () => {
+            await this.webClient.chat.postEphemeral({ channel, user, text });
+        });
+    }
+    async openDirectMessage(userId) {
+        return withRetry(async () => {
+            const result = await this.webClient.conversations.open({ users: userId });
+            const channelId = result.channel?.id;
+            if (!channelId) {
+                throw new Error(`Failed to open DM for user ${userId}`);
+            }
+            return channelId;
+        });
+    }
+    async updateMessage(channel, ts, text) {
         return withRetry(async () => {
-            await this.webClient.chat.update({ channel: conversationId, ts, text });
+            await this.webClient.chat.update({ channel, ts, text });
         });
     }
     async deleteMessage(channel, ts) {
@@ -214,10 +215,10 @@ export class SlackBot {
      * This is the ONLY place messages are written to log.jsonl
      */
     logToFile(channel, entry) {
-        const channelDir = join(this.workingDir, channel);
-        if (!existsSync(channelDir))
-            mkdirSync(channelDir, { recursive: true });
-        appendFileSync(join(channelDir, "log.jsonl"), `${JSON.stringify(entry)}\n`);
+        const dir = join(this.workingDir, channel);
+        if (!existsSync(dir))
+            mkdirSync(dir, { recursive: true });
+        appendFileSync(join(dir, "log.jsonl"), `${JSON.stringify(entry)}\n`);
     }
     /**
      * Log a bot response to log.jsonl
@@ -243,6 +244,9 @@ export class SlackBot {
                 userName: u.userName,
                 displayName: u.displayName,
             })),
+            diagnostics: {
+                showUsageSummary: true,
+            },
         };
     }
     // ==========================================================================
@@ -253,20 +257,27 @@ export class SlackBot {
      * Returns true if enqueued, false if queue is full (max 5).
      */
     enqueueEvent(event) {
-        const queue = this.getQueue(event.conversationId);
+        const conversationId = event.conversationId;
+        const queue = this.getQueue(conversationId);
         if (queue.size() >= 5) {
-            log.logWarning(`Event queue full for ${event.conversationId}, discarding: ${event.text.substring(0, 50)}`);
+            log.logWarning(`Event queue full for ${conversationId}, discarding: ${event.text.substring(0, 50)}`);
             return false;
         }
-        log.logInfo(`Enqueueing event for ${event.conversationId}: ${event.text.substring(0, 50)}`);
+        log.logInfo(`Enqueueing event for ${conversationId}: ${event.text.substring(0, 50)}`);
         queue.enqueue(() => {
             const slackEvent = {
-                type: "mention",
-                channel: event.conversationId,
+                type: event.type,
+                conversationId,
+                conversationKind: event.conversationKind,
+                channel: conversationId,
                 ts: event.ts,
                 thread_ts: event.thread_ts,
                 user: event.user,
                 text: event.text,
+                attachments: event.attachments?.map((attachment) => ({
+                    original: attachment.name,
+                    localPath: attachment.localPath,
+                })),
                 sessionKey: event.sessionKey,
             };
             const adapters = createSlackAdapters(slackEvent, this, true);
@@ -285,6 +296,13 @@ export class SlackBot {
         }
         return queue;
     }
+    resolveQueueKey(conversationId, sessionKey) {
+        if (!sessionKey.includes(":"))
+            return sessionKey;
+        return hasMaterializedSlackBranchSession(join(this.workingDir, conversationId), sessionKey)
+            ? sessionKey
+            : conversationId;
+    }
     // eslint-disable-next-line @typescript-eslint/no-explicit-any
     buildHomeView() {
         // eslint-disable-next-line @typescript-eslint/no-explicit-any
@@ -387,21 +405,22 @@ export class SlackBot {
             });
         }
         else {
-            const timestampFormatter = new Intl.DateTimeFormat(undefined, {
-                month: "short",
-                day: "numeric",
-                hour: "2-digit",
-                minute: "2-digit",
-            });
             for (const ev of periodicEvents) {
                 const channelLabel = ev.platform === "slack"
                     ? (() => {
-                        const channel = this.channels.get(ev.channelId);
-                        const channelName = channel ? `#${channel.name}` : ev.channelId;
+                        const channel = this.channels.get(ev.conversationId);
+                        const channelName = channel ? `#${channel.name}` : ev.conversationId;
                         return `${ev.platform}:${channelName}`;
                     })()
-                    : `${ev.platform}:${ev.channelId}`;
-                const nextStr = ev.nextRun ? timestampFormatter.format(new Date(ev.nextRun)) : "—";
+                    : `${ev.platform}:${ev.conversationId}`;
+                const nextStr = ev.nextRun
+                    ? new Date(ev.nextRun).toLocaleString("en-US", {
+                        month: "short",
+                        day: "numeric",
+                        hour: "2-digit",
+                        minute: "2-digit",
+                    })
+                    : "—";
                 blocks.push({
                     type: "section",
                     text: {
@@ -425,18 +444,223 @@ export class SlackBot {
      * When stop is called from a thread, the thread session (channelId:thread_ts) might
      * not be running — but the channel session (channelId) might be, because the bot's
      * reply to a top-level mention creates a thread. Check both, prefer thread first.
+     *
+     * For top-level stop requests, fall back to the only running scoped thread session in
+     * this conversation when there is exactly one candidate. This keeps DM/channel stop
+     * useful after thread sessions were introduced without guessing between multiple threads.
      */
     resolveStopTarget(channelId, threadTs) {
         if (threadTs) {
-            const threadKey = `${channelId}:${threadTs}`;
+            const threadKey = resolveSlackSessionKey(channelId, threadTs);
             if (this.handler.isRunning(threadKey))
                 return threadKey;
-            // Fall back to channel session — the thread may have been spawned by a top-level run
             if (this.handler.isRunning(channelId))
                 return channelId;
             return null;
         }
-        return this.handler.isRunning(channelId) ? channelId : null;
+        if (this.handler.isRunning(channelId))
+            return channelId;
+        const runningInConversation = this.handler
+            .getRunningSessions()
+            .map((session) => session.sessionKey)
+            .filter((sessionKey) => sessionKey.startsWith(`${channelId}:`));
+        return runningInConversation.length === 1 ? runningInConversation[0] : null;
+    }
+    createDirectCommandAdapters(conversationId, userId, userName, text, ts) {
+        const message = {
+            id: ts,
+            sessionKey: conversationId,
+            conversationKind: "direct",
+            userId,
+            userName,
+            text,
+            attachments: [],
+        };
+        const responseCtx = {
+            respond: async (responseText) => {
+                const messageTs = await this.postMessage(conversationId, responseText);
+                this.logBotResponse(conversationId, responseText, messageTs);
+            },
+            replaceResponse: async (responseText) => {
+                const messageTs = await this.postMessage(conversationId, responseText);
+                this.logBotResponse(conversationId, responseText, messageTs);
+            },
+            respondDiagnostic: async (responseText) => {
+                const messageTs = await this.postMessage(conversationId, responseText);
+                this.logBotResponse(conversationId, responseText, messageTs);
+            },
+            respondToolResult: async (result) => {
+                const duration = (result.durationMs / 1000).toFixed(1);
+                const text = `${result.isError ? "Error" : "Done"} ${result.toolName} (${duration}s)\n${result.result}`;
+                const messageTs = await this.postMessage(conversationId, text);
+                this.logBotResponse(conversationId, text, messageTs);
+            },
+            setTyping: async () => { },
+            setWorking: async () => { },
+            uploadFile: async (filePath, title) => {
+                await this.uploadFile(conversationId, filePath, title);
+            },
+            deleteResponse: async () => { },
+        };
+        return {
+            message,
+            responseCtx,
+            platform: this.getPlatformInfo(),
+        };
+    }
+    createPrivateSessionCommandAdapters(conversationId, userId, userName, text, ts, options) {
+        const message = {
+            id: ts,
+            sessionKey: conversationId,
+            conversationKind: options.ephemeralChannelId ? "shared" : "direct",
+            userId,
+            userName,
+            text,
+            attachments: [],
+        };
+        let hasResponded = false;
+        const respondPrivately = async (responseText) => {
+            if (options.ephemeralChannelId) {
+                await this.postEphemeral(options.ephemeralChannelId, userId, responseText);
+                return;
+            }
+            const messageTs = await this.postMessage(conversationId, responseText);
+            this.logBotResponse(conversationId, responseText, messageTs);
+        };
+        const responseCtx = {
+            respond: async (responseText) => {
+                hasResponded = true;
+                await respondPrivately(responseText);
+            },
+            replaceResponse: async (responseText) => {
+                if (!hasResponded) {
+                    hasResponded = true;
+                }
+                await respondPrivately(responseText);
+            },
+            respondDiagnostic: async (responseText) => {
+                await respondPrivately(responseText);
+            },
+            respondToolResult: async (result) => {
+                const duration = (result.durationMs / 1000).toFixed(1);
+                const formatted = `${result.isError ? "Error" : "Done"} ${result.toolName} (${duration}s)\n${result.result}`;
+                await respondPrivately(formatted);
+            },
+            setTyping: async () => { },
+            setWorking: async () => { },
+            uploadFile: async (filePath, title) => {
+                await this.uploadFile(conversationId, filePath, title);
+            },
+            deleteResponse: async () => { },
+        };
+        return {
+            message,
+            responseCtx,
+            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;
+        const createdAt = new Date();
+        const eventTs = (createdAt.getTime() / 1000).toFixed(6);
+        const sourceChannelId = payload.channel_id;
+        const isDirectMessage = sourceChannelId.startsWith("D");
+        const targetChannelId = isDirectMessage
+            ? sourceChannelId
+            : await this.openDirectMessage(payload.user_id);
+        const userName = payload.user_name ?? this.getUser(payload.user_id)?.userName;
+        this.logToFile(targetChannelId, {
+            date: createdAt.toISOString(),
+            ts: eventTs,
+            user: payload.user_id,
+            userName,
+            text: commandText,
+            attachments: [],
+            isBot: false,
+        });
+        if (!isDirectMessage) {
+            await this.postEphemeral(sourceChannelId, payload.user_id, `我已私訊你 ${PRODUCT_NAME} 的登入連結，請到私訊完成設定。`);
+        }
+        const event = {
+            type: "dm",
+            conversationId: targetChannelId,
+            conversationKind: "direct",
+            ts: eventTs,
+            user: payload.user_id,
+            text: commandText,
+            attachments: [],
+            sessionKey: targetChannelId,
+        };
+        const adapters = this.createDirectCommandAdapters(targetChannelId, payload.user_id, userName, commandText, eventTs);
+        await this.handler.handleEvent(event, this, adapters, false);
+    }
+    async routeSlashNewCommand(payload) {
+        const conversationId = payload.channel_id;
+        if (!conversationId.startsWith("D")) {
+            await this.postEphemeral(conversationId, payload.user_id, `為了避免誤清除共享上下文，${payload.command} 目前只能在與 ${PRODUCT_NAME} 的私訊中使用。`);
+            return;
+        }
+        const createdAt = new Date();
+        const eventTs = (createdAt.getTime() / 1000).toFixed(6);
+        const userName = payload.user_name ?? this.getUser(payload.user_id)?.userName;
+        this.logToFile(conversationId, {
+            date: createdAt.toISOString(),
+            ts: eventTs,
+            user: payload.user_id,
+            userName,
+            text: payload.command,
+            attachments: [],
+            isBot: false,
+        });
+        const commandBot = this.createSlashCommandBot(conversationId);
+        await this.handler.handleNew(conversationId, conversationId, commandBot);
+    }
+    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,
+        });
+        const sessionKey = conversationId;
+        const event = {
+            type: "dm",
+            conversationId,
+            conversationKind: isDirectMessage ? "direct" : "shared",
+            ts: eventTs,
+            user: payload.user_id,
+            text: commandText,
+            attachments: [],
+            sessionKey,
+        };
+        const adapters = this.createPrivateSessionCommandAdapters(conversationId, payload.user_id, userName, commandText, eventTs, isDirectMessage ? {} : { ephemeralChannelId: conversationId });
+        await this.handler.handleEvent(event, this, adapters, false);
     }
     setupEventHandlers() {
         // Channel @mentions
@@ -449,9 +673,11 @@ export class SlackBot {
             }
             // Top-level mentions use a persistent channel session.
             // Thread replies get their own isolated session (channelId:thread_ts).
-            const sessionKey = e.thread_ts ? `${e.channel}:${e.thread_ts}` : e.channel;
+            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,
@@ -460,12 +686,13 @@ export class SlackBot {
                 files: e.files,
                 sessionKey,
             };
-            // SYNC: Log to log.jsonl (ALWAYS, even for old messages)
-            // Also downloads attachments in background and stores local paths
-            slackEvent.attachments = this.logUserMessage(slackEvent);
+            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;
             }
@@ -478,25 +705,17 @@ export class SlackBot {
                 else {
                     this.postMessage(e.channel, formatNothingRunning("slack"));
                 }
+                void attachmentsPromise.catch((err) => {
+                    log.logWarning("Failed to log Slack message", String(err));
+                });
                 ack();
                 return;
             }
-            // Check for login command
-            if (parseLoginCommand(slackEvent.text)) {
-                void this.handler.handleLogin("slack", e.user, e.channel, this, slackEvent.text, false);
-                ack();
-                return;
-            }
-            // SYNC: Check if busy (per-thread)
-            if (this.handler.isRunning(sessionKey)) {
-                this.postMessage(e.channel, formatAlreadyWorking("slack", "@mama stop", { scope: "thread" }));
-            }
-            else {
-                this.getQueue(sessionKey).enqueue(() => {
-                    const adapters = createSlackAdapters(slackEvent, this, false);
-                    return this.handler.handleEvent(this.toBotEvent(slackEvent), this, adapters, false);
-                });
-            }
+            this.getQueue(this.resolveQueueKey(e.channel, sessionKey)).enqueue(async () => {
+                slackEvent.attachments = await attachmentsPromise;
+                const adapters = createSlackAdapters(slackEvent, this, false);
+                return this.handler.handleEvent(slackEvent, this, adapters, false);
+            });
             ack();
         });
         // All messages (for logging) + DMs (for triggering)
@@ -516,28 +735,34 @@ export class SlackBot {
                 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 && !!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: (e.text || "").replace(/<@[A-Z0-9]+>/gi, "").trim(),
                 files: e.files,
-                sessionKey: isDM ? e.channel : undefined,
+                sessionKey,
             };
-            // SYNC: Log to log.jsonl (ALL messages - channel chatter and DMs)
-            // Also downloads attachments in background and stores local paths
-            slackEvent.attachments = this.logUserMessage(slackEvent);
+            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;
             }
@@ -551,41 +776,79 @@ export class SlackBot {
                 else {
                     this.postMessage(e.channel, formatNothingRunning("slack"));
                 }
+                void attachmentsPromise.catch((err) => {
+                    log.logWarning("Failed to log Slack message", String(err));
+                });
                 ack();
                 return;
             }
-            // Only trigger handler for DMs
-            if (isDM) {
-                const dmSessionKey = slackEvent.sessionKey;
+            // Trigger handler for DMs and bare replies inside shared-channel threads.
+            if (isDM || isSharedThreadReply) {
+                const activeSessionKey = slackEvent.sessionKey ?? resolveSlackSessionKey(e.channel, e.thread_ts);
                 // Check for stop command - execute immediately, don't queue!
                 if (slackEvent.text.toLowerCase().trim() === "stop") {
-                    if (this.handler.isRunning(dmSessionKey)) {
-                        this.handler.handleStop(dmSessionKey, e.channel, this); // Don't await, don't queue
+                    const stopTarget = this.resolveStopTarget(e.channel, e.thread_ts);
+                    if (stopTarget) {
+                        this.handler.handleStop(stopTarget, e.channel, this); // Don't await, don't queue
                     }
                     else {
                         this.postMessage(e.channel, formatNothingRunning("slack"));
                     }
+                    void attachmentsPromise.catch((err) => {
+                        log.logWarning("Failed to log Slack message", String(err));
+                    });
                     ack();
                     return;
                 }
-                // Check for login command
-                if (parseLoginCommand(slackEvent.text)) {
-                    void this.handler.handleLogin("slack", e.user, e.channel, this, slackEvent.text, true);
-                    ack();
-                    return;
-                }
-                if (this.handler.isRunning(dmSessionKey)) {
-                    this.postMessage(e.channel, formatAlreadyWorking("slack", "stop"));
-                }
-                else {
-                    this.getQueue(dmSessionKey).enqueue(() => {
-                        const adapters = createSlackAdapters(slackEvent, this, false);
-                        return this.handler.handleEvent(this.toBotEvent(slackEvent), this, adapters, false);
-                    });
-                }
+                this.getQueue(this.resolveQueueKey(e.channel, activeSessionKey)).enqueue(async () => {
+                    slackEvent.attachments = await attachmentsPromise;
+                    const adapters = createSlackAdapters(slackEvent, this, false);
+                    return this.handler.handleEvent(slackEvent, this, adapters, false);
+                });
+            }
+            else {
+                void attachmentsPromise.catch((err) => {
+                    log.logWarning("Failed to log Slack message", String(err));
+                });
             }
             ack();
         });
+        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({
+                    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,
+                        channel_id: payload.channel_id,
+                        user_id: payload.user_id,
+                        user_name: payload.user_name,
+                    })
+                    : payload.command === "/pi-session"
+                        ? this.routeSlashSessionCommand({
+                            command: payload.command,
+                            channel_id: payload.channel_id,
+                            user_id: payload.user_id,
+                            user_name: payload.user_name,
+                        })
+                        : 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;
@@ -616,8 +879,7 @@ export class SlackBot {
             // Use handler's forceStop method
             this.handler.forceStop(sessionKey);
             // Notify in channel
-            const actorLabel = userId ? `<@${userId}>` : "someone";
-            await this.postMessage(channelId, formatForceStopped("slack", actorLabel));
+            await this.postMessage(channelId, formatForceStopped("slack", userId ?? "unknown"));
             // Refresh home tab
             if (userId) {
                 this.webClient.views
@@ -632,14 +894,12 @@ export class SlackBot {
         });
     }
     /**
-     * Log a user message to log.jsonl (SYNC)
-     * Downloads attachments in background via store
+     * Log a user message to log.jsonl after attachments are ready.
      */
-    logUserMessage(event) {
+    async logUserMessage(event) {
         const user = this.users.get(event.user);
-        // Process attachments - queues downloads in background
         const attachments = event.files
-            ? this.store.processAttachments(event.channel, event.files, event.ts)
+            ? await this.store.processAttachments(event.channel, event.files, event.ts)
             : [];
         this.logToFile(event.channel, {
             date: new Date(parseFloat(event.ts) * 1000).toISOString(),
@@ -724,13 +984,13 @@ export class SlackBot {
             const user = this.users.get(msg.user);
             // Strip @mentions from text (same as live messages)
             const text = (msg.text || "").replace(/<@[A-Z0-9]+>/gi, "").trim();
-            // Process attachments - queues downloads in background
             const attachments = msg.files
-                ? this.store.processAttachments(channelId, msg.files, msg.ts)
+                ? await this.store.processAttachments(channelId, msg.files, msg.ts)
                 : [];
             this.logToFile(channelId, {
                 date: new Date(parseFloat(msg.ts) * 1000).toISOString(),
                 ts: msg.ts,
+                threadTs: msg.thread_ts,
                 user: isMamaMessage ? "bot" : msg.user,
                 userName: isMamaMessage ? undefined : user?.userName,
                 displayName: isMamaMessage ? undefined : user?.displayName,