@geminixiang/mikan 1.0.0-beta.9 → 1.0.0-beta.91

package/dist/adapters/slack/bot.js

@@ -1,22 +1,60 @@
 import { SocketModeClient } from "@slack/socket-mode";
-import { WebClient } from "@slack/web-api";
-import { existsSync, readFileSync } from "fs";
-import { readFile } from "fs/promises";
-import { basename, join } from "path";
-import { resolveConversationSettings } from "../../config.js";
+import { WebAPIRateLimitedError, WebClient } from "@slack/web-api";
+import { existsSync, readFileSync } from "node:fs";
+import { basename } from "node:path";
+import { createConversationEvent, createConversationMessage, createOfficeAddress, listRegisteredOffices, } from "../../office/index.js";
+import { COMMAND_MANIFEST } from "../commands/manifest.js";
+import { slackConversationAutoReplyMode, resolveConversationSettings, } from "../../settings/index.js";
+import { evaluateWithJev, JevNotConfiguredError } from "../../harness/jev.js";
 import * as log from "../../log.js";
-import { PRODUCT_NAME, formatForceStopped, formatNothingRunning } from "../../platform-messages.js";
-import { appendBotResponseLog, appendChannelLog, MessagingEventQueue, resolveOnlyScopedStopTarget, resolveStopTarget, withRetry, } from "../shared.js";
-import { processMessageIntake } from "../intake.js";
+import { readTextFileNoFollowIfExists } from "../../file-guards.js";
+import { PRODUCT_NAME, formatForceStopped } from "../messages.js";
+import { appendBotResponseLog, appendChannelLog, MessagingEventQueue, MessagingIntakeTracker, AttachmentRejectedError, saveIncomingAttachments, writeResponseToFile, withRetry, } from "../shared.js";
+import { matchMagicWord, processMessageIntake } from "../intake.js";
+import { readPlatformChannelKind, recordPlatformChannelKind } from "../../office/projection.js";
+import { AssistantThreadRegistry, handleAgentContextChanged, handleAgentDmOpened, handleAssistantThreadStarted, titleAssistantThread, } from "./assistant.js";
 import { createSlackAdapters } from "./context.js";
-import { hasMaterializedChatSession, registerThreadSession, } from "../../sessions/agent-memory-file-manager.js";
+import { hasMaterializedChatSession, registerThreadSession, } from "../../sessions/chat-history-sync.js";
+import { conversationIdOf } from "../../sessions/session-key.js";
 import { isSlackThreadSessionKey, planSlackAdapterSession, planSlackEventAnchorRun, resolveSlackSessionKey, } from "./session.js";
-import { reportUserFacingError } from "../../observability/sentry.js";
-import { renderSlackBlocks } from "./blocks.js";
+import { reportUserFacingError } from "../../observability/index.js";
+import { recordSlackUpdate } from "./update-diagnostics.js";
+import { renderSlackBlocks, resolveSlackMentions } from "./blocks.js";
+import { querySlackTasks, formatTaskStatus, readTaskRoots, isTaskStatusQuestion, } from "./task-status.js";
+import { buildAutoReplyState, JEV_ADDRESSED_INSTRUCTIONS } from "./auto-reply-context.js";
+import { buildTaskIntentState, classifyTaskIntent } from "./task-intent.js";
+import { StreamStartLimiter } from "./stream-limits.js";
+import { errorMessage, isRecord } from "../../unknown-values.js";
 const SLACK_EVENT_ANCHOR_TEXT = "Working on it...";
-// Slack WebClient errors carry either `code: "rate_limited"` (retry-after) or
-// the legacy `data.error === "rate_limited"` / 429 status shape.
+function hasMessageContent(message, includeBlocks = true) {
+    const content = [message.text, message.files];
+    if (includeBlocks)
+        content.push(message.blocks, message.attachments);
+    return content.some((part) => !!part?.length);
+}
+function hasBotIdentity(message) {
+    return !!message.bot_id || message.subtype === "bot_message";
+}
+const USER_MESSAGE_SUBTYPES = new Set([undefined, "file_share"]);
+const BOT_MESSAGE_SUBTYPES = new Set([...USER_MESSAGE_SUBTYPES, "bot_message"]);
+const MAX_STREAM_TEXT_CHARS = 12_000;
+export function chunkStreamText(text, limit = MAX_STREAM_TEXT_CHARS) {
+    if (text.length <= limit)
+        return [text];
+    const chunks = [];
+    for (let index = 0; index < text.length; index += limit) {
+        chunks.push(text.slice(index, index + limit));
+    }
+    return chunks;
+}
+function slackErrorCode(error) {
+    if (!isRecord(error) || !isRecord(error.data))
+        return undefined;
+    return typeof error.data.error === "string" ? error.data.error : undefined;
+}
 function slackIsRateLimited(err) {
+    if (err instanceof WebAPIRateLimitedError)
+        return true;
     if (err.code === "rate_limited")
         return true;
     const data = err.data;
@@ -47,75 +85,200 @@ function collectSlackText(value, parts) {
     collectSlackText(obj.elements, parts);
     collectSlackText(obj.blocks, parts);
 }
+function unescapeSlackText(text) {
+    return text.replace(/&lt;/g, "<").replace(/&gt;/g, ">").replace(/&amp;/g, "&");
+}
 function buildSlackAppMessageText(event) {
     const parts = [];
     collectSlackText(event.text, parts);
     collectSlackText(event.blocks, parts);
     collectSlackText(event.attachments, parts);
     const deduped = parts.filter((part, index) => parts.indexOf(part) === index);
-    return deduped.join("\n");
+    return unescapeSlackText(deduped.join("\n"));
+}
+export function italicizeLines(text) {
+    return text
+        .split("\n")
+        .map((line) => (line.trim() ? `_${line}_` : line))
+        .join("\n");
+}
+const RECENT_MESSAGE_KEYS = 2000;
+function withLoggedAck(event, payload) {
+    return {
+        ...payload,
+        ack: () => payload.ack().catch((error) => {
+            log.logWarning(`Slack ack failed for ${event}; Slack may redeliver it`, errorMessage(error));
+        }),
+    };
 }
-// ---------------------------------------------------------------------------
-// Shared mrkdwn truncation helper
-// ---------------------------------------------------------------------------
 const MRKDWN_CONTEXT_TEXT_LIMIT = 3000;
-/**
- * Build a Slack context block whose text is capped at the mrkdwn limit.
- * Used for muted diagnostics and ephemeral command responses.
- */
 export function buildMrkdwnContextBlock(text) {
     const blockText = text.length > MRKDWN_CONTEXT_TEXT_LIMIT
         ? text.substring(0, MRKDWN_CONTEXT_TEXT_LIMIT - 20) + "\n_(truncated)_"
         : text;
     return { type: "context", elements: [{ type: "mrkdwn", text: blockText }] };
 }
-// ============================================================================
-// SlackMessagingBot
-// ============================================================================
+class AttachmentDownloadHttpError extends Error {
+    constructor(message, status) {
+        super(message);
+        this.status = status;
+    }
+}
+function isRetryableAttachmentDownloadError(error) {
+    if (error instanceof AttachmentRejectedError)
+        return false;
+    if (!(error instanceof AttachmentDownloadHttpError))
+        return true;
+    return error.status === 408 || error.status === 429 || error.status >= 500;
+}
+function assertSlackFileUrl(url) {
+    const { protocol, hostname } = new URL(url);
+    if (protocol === "https:" && (hostname === "slack.com" || hostname.endsWith(".slack.com")))
+        return;
+    throw new AttachmentRejectedError(`refusing to send the bot token to ${hostname}`);
+}
 export class SlackMessagingBot {
+    office(channelId) {
+        return this.workspace.office(createOfficeAddress("slack", channelId));
+    }
+    conversationDir(channelId) {
+        return this.office(channelId).dir;
+    }
+    resolveReplyMode(address) {
+        return (resolveConversationSettings(this.workspace.office(address)).slack?.replyMode ?? "top-level");
+    }
     createContext(event) {
-        return createSlackAdapters(event, this, {
-            replyMode: resolveConversationSettings(join(this.workingDir, event.conversationId)).slack?.replyMode ??
-                "top-level",
+        const context = createSlackAdapters(event, this, {
+            replyMode: this.resolveReplyMode(event.address),
         });
+        if (event.conversationKind === "direct") {
+            context.responder.getTaskStatus = (key) => querySlackTasks(this.office(event.channel), event.channel, this.handler
+                .getRunningSessions()
+                .filter((s) => s.address.platform === "slack" && s.address.conversationId === event.channel), key);
+        }
+        if (event.conversationKind === "direct" &&
+            event.thread_ts &&
+            this.isTaskThread(event.channel, event.thread_ts)) {
+            let notified = false;
+            context.responder.notifyCompletion = async () => {
+                if (notified)
+                    return;
+                const text = `<@${event.user}> 這一輪處理已結束，請查看上方結果。`;
+                const ts = await this.postInThread(event.channel, event.thread_ts, text);
+                notified = true;
+                this.logBotResponse(event.channel, text, ts, event.thread_ts);
+            };
+        }
+        if (event.conversationKind === "direct" && !event.thread_ts) {
+            context.responder.startTask = async (message, task) => {
+                if (this.stopped)
+                    throw new Error("Slack is shutting down; task was not started.");
+                await context.responder.deleteResponse();
+                const root = await this.postMessage(event.channel, message);
+                this.logToFile(event.channel, {
+                    date: new Date().toISOString(),
+                    ts: root,
+                    user: "bot",
+                    text: message,
+                    isMessagingBot: true,
+                    taskRoot: true,
+                });
+                const sessionKey = resolveSlackSessionKey(event.channel, root);
+                try {
+                    await registerThreadSession({
+                        office: this.office(event.channel),
+                        sessionKey,
+                    });
+                    const child = {
+                        ...event,
+                        ts: `task:${root}`,
+                        thread_ts: root,
+                        sessionKey,
+                        text: task,
+                    };
+                    if (!this.getQueue(sessionKey).enqueue(async () => {
+                        try {
+                            await this.handler.handleEvent({
+                                ...child,
+                                attachments: child.attachments?.map((a) => ({
+                                    name: a.original,
+                                    localPath: a.localPath,
+                                })),
+                            }, this, this.createContext(child));
+                        }
+                        catch (error) {
+                            reportUserFacingError(error, {
+                                domain: "mikan",
+                                surface: "task_handoff",
+                                operation: "start_task_run",
+                                severity: "error",
+                                platform: "slack",
+                                context: { conversationId: event.channel, sessionKey, threadTs: root },
+                            });
+                            await this.postInThread(event.channel, root, "Task could not start. Please reply here to try again.");
+                            throw error;
+                        }
+                    }))
+                        throw new Error("Task queue is closed.");
+                }
+                catch (error) {
+                    await this.updateMessage(event.channel, root, `${message}\n\nTask could not start.`);
+                    throw error;
+                }
+                return sessionKey;
+            };
+        }
+        return context;
     }
     constructor(handler, config) {
+        this.statusUpdates = new Map();
         this.botUserId = null;
         this.botId = null;
         this.teamId = null;
         this.ownMentionRegex = null;
-        this.startupTs = null; // Messages older than this are just logged, not processed
+        this.startupTs = null;
         this.users = new Map();
         this.channels = new Map();
+        this.assistantThreads = new AssistantThreadRegistry();
+        this.streamStarts = new StreamStartLimiter();
+        this.stopped = false;
         this.queues = new Map();
-        this.eventsWatcher = null;
+        this.intake = new MessagingIntakeTracker("Slack");
+        this.recentMessageKeys = new Set();
+        this.agentSurfaceUnavailable = false;
+        this.eventScheduler = null;
         this.handler = handler;
-        this.workingDir = config.workingDir;
-        this.store = config.store;
-        this.socketClient = new SocketModeClient({
-            appToken: config.appToken,
-            // Default 5s is too tight: brief event-loop stalls (e.g. backfill, sync fs)
-            // cause false pong timeouts; 4 in a row makes Slack drop the socket.
-            clientPingTimeout: 12_000,
+        this.workspace = config.workspace;
+        this.botToken = config.botToken;
+        this.fetchFn = config.fetch ?? ((input, init) => fetch(input, init));
+        this.socketClient =
+            config.socket ??
+                new SocketModeClient({
+                    appToken: config.appToken,
+                    clientPingTimeout: 12_000,
+                });
+        this.webClient = config.webApi ?? new WebClient(config.botToken, { fetch: config.fetch });
+        this.statusClient = new WebClient(config.botToken, {
+            timeout: 3000,
+            retryConfig: { retries: 0 },
+            rejectRateLimitedCalls: true,
+            fetch: config.fetch,
         });
-        this.webClient = new WebClient(config.botToken);
     }
-    setEventsWatcher(watcher) {
-        this.eventsWatcher = watcher;
+    setEventScheduler(scheduler) {
+        this.eventScheduler = scheduler;
     }
-    // ==========================================================================
-    // Public API
-    // ==========================================================================
     async start() {
+        this.stopped = false;
         const auth = await this.webClient.auth.test();
         this.botUserId = auth.user_id;
         this.botId = typeof auth.bot_id === "string" ? auth.bot_id : null;
         this.teamId = typeof auth.team_id === "string" ? auth.team_id : null;
         await Promise.all([this.fetchUsers(), this.fetchChannels()]);
+        if (this.stopped)
+            return;
         log.logInfo(`Loaded ${this.channels.size} channels, ${this.users.size} users`);
-        // Record startup time before opening the socket. Slack may replay older events;
-        // those should be logged but not processed. Backfill runs in the background up
-        // to this timestamp so startup is not blocked by one history call per channel.
+        this.backfillChannelKinds();
         this.startupTs = (Date.now() / 1000).toFixed(6);
         this.setupEventHandlers();
         await this.socketClient.start();
@@ -124,6 +287,16 @@ export class SlackMessagingBot {
             log.logWarning("Slack backfill failed", String(error));
         });
     }
+    async stop() {
+        this.stopped = true;
+        try {
+            await this.socketClient.disconnect();
+        }
+        finally {
+            await this.intake.close();
+            await Promise.all([...this.queues.values()].map((queue) => queue.close()));
+        }
+    }
     getUser(userId) {
         return this.users.get(userId);
     }
@@ -137,7 +310,7 @@ export class SlackMessagingBot {
         return Array.from(this.channels.values());
     }
     stripOwnMention(text) {
-        const source = text ?? "";
+        const source = unescapeSlackText(text ?? "");
         if (!this.botUserId)
             return source.trim();
         if (!this.ownMentionRegex || !this.ownMentionRegex.source.includes(this.botUserId)) {
@@ -145,54 +318,64 @@ export class SlackMessagingBot {
         }
         return source.replace(this.ownMentionRegex, "").trim();
     }
-    async postMessage(channel, text) {
+    resolveMentions(text) {
+        return resolveSlackMentions(text, this.users.values());
+    }
+    async postMessage(channel, text, threadTs, identity) {
         return slackRetry(async () => {
-            const payload = { channel, ...renderSlackBlocks(text) };
+            const payload = {
+                channel,
+                thread_ts: threadTs,
+                username: identity?.username,
+                icon_emoji: identity?.iconEmoji,
+                ...renderSlackBlocks(this.resolveMentions(text)),
+            };
             const result = await this.webClient.chat.postMessage(payload);
             return result.ts;
         });
     }
     async addReaction(channel, messageTs, emoji) {
-        // Slack reaction names are colon-free short names; strip any wrapping colons.
         const name = emoji.replace(/^:|:$/g, "");
         await slackRetry(async () => {
             try {
                 await this.webClient.reactions.add({ channel, timestamp: messageTs, name });
             }
             catch (err) {
-                // Re-reacting with the same emoji is not an error worth surfacing.
                 if (err?.data?.error === "already_reacted")
                     return;
                 throw err;
             }
         });
     }
-    async postEphemeral(channel, user, text, threadTs) {
+    async postEphemeral(channel, user, text, threadTs, blocks) {
         return slackRetry(async () => {
             await this.webClient.chat.postEphemeral({
                 channel,
                 user,
                 text,
-                ...(threadTs ? { thread_ts: threadTs } : {}),
+                blocks: blocks,
+                thread_ts: threadTs || undefined,
             });
         });
     }
     async postEphemeralBlocks(channel, user, text, blocks, threadTs) {
+        return this.postEphemeral(channel, user, text, threadTs, blocks);
+    }
+    async postMessageBlocks(channel, text, blocks, threadTs) {
         return slackRetry(async () => {
-            await this.webClient.chat.postEphemeral({
+            const payload = {
                 channel,
-                user,
                 text,
                 blocks: blocks,
-                ...(threadTs ? { thread_ts: threadTs } : {}),
-            });
+                thread_ts: threadTs,
+            };
+            const result = await this.webClient.chat.postMessage(payload);
+            return result.ts;
         });
     }
-    async postMessageBlocks(channel, text, blocks) {
+    async updateMessageBlocks(channel, ts, text, blocks) {
         return slackRetry(async () => {
-            const payload = { channel, text, blocks: blocks };
-            const result = await this.webClient.chat.postMessage(payload);
-            return result.ts;
+            await this.webClient.chat.update({ channel, ts, text, blocks: blocks });
         });
     }
     async postPrivate(conversationId, userId, text) {
@@ -200,12 +383,12 @@ export class SlackMessagingBot {
     }
     async postPrivateDiagnostic(conversationId, userId, text, options) {
         if (options?.style !== "muted") {
-            await this.postEphemeral(conversationId, userId, options?.style === "error" ? `_${text}_` : text);
+            await this.postEphemeral(conversationId, userId, options?.style === "error" ? italicizeLines(text) : text);
             return;
         }
         await this.postEphemeralBlocks(conversationId, userId, text, [buildMrkdwnContextBlock(text)]);
     }
-    async openDirectMessage(userId) {
+    async openDirectConversation(userId) {
         return slackRetry(async () => {
             const result = await this.webClient.conversations.open({ users: userId });
             const channelId = result.channel?.id;
@@ -215,33 +398,101 @@ export class SlackMessagingBot {
             return channelId;
         });
     }
+    async fetchHistory(channel, options) {
+        const limit = Math.min(Math.max(options?.limit ?? 200, 1), 999);
+        const threadTs = options?.threadTs;
+        return slackRetry(async () => {
+            const result = threadTs
+                ? await this.webClient.conversations.replies({
+                    channel,
+                    ts: threadTs,
+                    oldest: options?.oldest || undefined,
+                    inclusive: options?.oldest ? false : undefined,
+                    limit,
+                })
+                : await this.webClient.conversations.history({
+                    channel,
+                    oldest: options?.oldest || undefined,
+                    inclusive: options?.oldest ? false : undefined,
+                    limit,
+                });
+            const messages = (result.messages ?? []);
+            const mapped = messages
+                .filter((msg) => !!msg.ts)
+                .filter((msg) => msg.ts !== threadTs)
+                .map((msg) => {
+                const user = msg.user ? this.users.get(msg.user) : undefined;
+                const message = {
+                    ts: msg.ts,
+                    text: unescapeSlackText(msg.text ?? ""),
+                    isBot: !!msg.bot_id || msg.subtype === "bot_message" || user?.isBot === true,
+                };
+                if (msg.thread_ts && msg.thread_ts !== msg.ts)
+                    message.threadTs = msg.thread_ts;
+                if (msg.user)
+                    message.userId = msg.user;
+                if (user)
+                    message.userName = user.userName;
+                return message;
+            });
+            return threadTs ? mapped : mapped.toReversed();
+        });
+    }
+    async listUsers() {
+        await slackRetry(() => this.fetchUsers());
+        return this.getAllUsers().map((user) => ({
+            id: user.id,
+            userName: user.userName,
+            displayName: user.displayName,
+            isBot: user.isBot === true,
+        }));
+    }
     async updateMessage(channel, ts, text) {
         return slackRetry(async () => {
-            const payload = { channel, ts, ...renderSlackBlocks(text) };
-            await this.webClient.chat.update(payload);
+            const payload = { channel, ts, ...renderSlackBlocks(this.resolveMentions(text)) };
+            try {
+                await this.webClient.chat.update(payload);
+            }
+            catch (error) {
+                recordSlackUpdate(this, { channel, ts }, text, payload, { error });
+                throw error;
+            }
+            recordSlackUpdate(this, { channel, ts }, text, payload, { success: true });
         });
     }
+    tryReserveStreamStart() {
+        return this.streamStarts.tryReserve();
+    }
     async startMessageStream(channel, text, threadTs, recipientUserId) {
-        return slackRetry(async () => {
+        const [head, ...tail] = chunkStreamText(text);
+        const ts = await slackRetry(async () => {
             const result = await this.webClient.apiCall("chat.startStream", {
                 channel,
-                markdown_text: text,
-                ...(threadTs ? { thread_ts: threadTs } : {}),
-                ...(this.teamId ? { recipient_team_id: this.teamId } : {}),
-                ...(recipientUserId ? { recipient_user_id: recipientUserId } : {}),
+                markdown_text: this.resolveMentions(head ?? ""),
+                thread_ts: threadTs || undefined,
+                recipient_team_id: this.teamId || undefined,
+                recipient_user_id: recipientUserId || undefined,
             });
-            const ts = result.ts;
-            if (!ts)
+            const streamTs = result.ts;
+            if (!streamTs)
                 throw new Error("Slack chat.startStream did not return ts");
-            return ts;
+            return streamTs;
         });
+        for (const part of tail)
+            await this.appendStreamChunk(channel, ts, part);
+        return ts;
     }
     async appendMessageStream(channel, ts, text) {
+        for (const part of chunkStreamText(text)) {
+            await this.appendStreamChunk(channel, ts, part);
+        }
+    }
+    async appendStreamChunk(channel, ts, text) {
         return slackRetry(async () => {
             await this.webClient.apiCall("chat.appendStream", {
                 channel,
                 ts,
-                markdown_text: text,
+                markdown_text: this.resolveMentions(text),
             });
         });
     }
@@ -255,38 +506,93 @@ export class SlackMessagingBot {
             await this.webClient.chat.delete({ channel, ts });
         });
     }
-    // ==========================================================================
-    // Slack Assistant API (AI assistant experience)
-    // ==========================================================================
-    /** Set the status for an assistant thread (shows "thinking" state) */
     async setAssistantStatus(channel, threadTs, status) {
-        return slackRetry(async () => {
-            await this.webClient.assistant.threads.setStatus({
+        const key = `${channel}:${threadTs}`;
+        const previous = this.statusUpdates.get(key) ?? Promise.resolve();
+        const update = previous
+            .catch(() => undefined)
+            .then(async () => {
+            await this.statusClient.assistant.threads.setStatus({
                 channel_id: channel,
                 thread_ts: threadTs,
                 status,
             });
         });
+        this.statusUpdates.set(key, update);
+        try {
+            await update;
+        }
+        finally {
+            if (this.statusUpdates.get(key) === update)
+                this.statusUpdates.delete(key);
+        }
     }
-    async postInThread(channel, threadTs, text) {
-        return slackRetry(async () => {
-            const payload = { channel, thread_ts: threadTs, ...renderSlackBlocks(text) };
-            const result = await this.webClient.chat.postMessage(payload);
-            return result.ts;
-        });
+    async setAssistantSuggestedPrompts(channel, threadTs, prompts) {
+        if (this.agentSurfaceUnavailable)
+            return;
+        try {
+            await slackRetry(async () => {
+                await this.webClient.assistant.threads.setSuggestedPrompts({
+                    channel_id: channel,
+                    thread_ts: threadTs || undefined,
+                    prompts,
+                });
+            });
+        }
+        catch (error) {
+            if (slackErrorCode(error) !== "not_agent_app")
+                throw error;
+            this.agentSurfaceUnavailable = true;
+            log.logInfo("Slack app is not an agent app; suggested prompts are disabled");
+        }
     }
-    async postInThreadBlocks(channel, threadTs, text, blocks) {
+    async setAssistantTitle(channel, threadTs, title) {
         return slackRetry(async () => {
-            const payload = {
-                channel,
+            await this.webClient.assistant.threads.setTitle({
+                channel_id: channel,
                 thread_ts: threadTs,
-                text, // fallback for notifications
-                blocks: blocks,
-            };
-            const result = await this.webClient.chat.postMessage(payload);
-            return result.ts;
+                title,
+            });
         });
     }
+    assistantOps() {
+        return {
+            postInThread: (channel, threadTs, text) => this.postInThread(channel, threadTs, text),
+            setSuggestedPrompts: (channel, threadTs, prompts) => this.setAssistantSuggestedPrompts(channel, threadTs, prompts),
+            setTitle: (channel, threadTs, title) => this.setAssistantTitle(channel, threadTs, title),
+            channelName: (channelId) => this.channels.get(channelId)?.name,
+        };
+    }
+    handleAssistantThreadStarted({ event, ack }) {
+        ack();
+        const payload = event;
+        if (!payload.assistant_thread)
+            return;
+        void handleAssistantThreadStarted(this.assistantOps(), this.assistantThreads, payload.assistant_thread);
+    }
+    handleAgentContextChangedEvent({ event, ack }) {
+        ack();
+        const payload = event;
+        if (payload.assistant_thread) {
+            handleAgentContextChanged(this.assistantThreads, payload.assistant_thread);
+            return;
+        }
+        const channelId = payload.channel_id ?? payload.channel;
+        if (channelId) {
+            handleAgentContextChanged(this.assistantThreads, {
+                channel_id: channelId,
+                context: payload.context,
+            });
+        }
+    }
+    async postInThread(channel, threadTs, text, identity) {
+        return identity
+            ? this.postMessage(channel, text, threadTs, identity)
+            : this.postMessage(channel, text, threadTs);
+    }
+    async postInThreadBlocks(channel, threadTs, text, blocks) {
+        return this.postMessageBlocks(channel, text, blocks, threadTs);
+    }
     async uploadFile(channel, filePath, title, threadTs) {
         return slackRetry(async () => {
             const fileName = title || basename(filePath);
@@ -301,18 +607,41 @@ export class SlackMessagingBot {
         });
     }
     logToFile(channel, entry) {
-        appendChannelLog(this.workingDir, channel, entry);
+        appendChannelLog(this.workspace.office(createOfficeAddress("slack", channel)), entry);
     }
-    logBotResponse(channel, text, ts, threadTs, slackBlocks) {
-        appendBotResponseLog(this.workingDir, channel, text, ts, threadTs, {
+    logBotResponse(channel, text, ts, threadTs, { slackBlocks, answer } = {}) {
+        appendBotResponseLog(this.workspace.office(createOfficeAddress("slack", channel)), text, ts, threadTs, {
             platform: "slack",
-            ...(slackBlocks ? { slackBlocks } : {}),
+            slackBlocks,
+            ...answer,
         });
     }
+    ownsBlockKitMessage(channel, ts, threadTs) {
+        const content = readTextFileNoFollowIfExists(this.office(channel).logPath);
+        if (content === undefined)
+            return false;
+        for (const line of content.trim().split("\n").toReversed()) {
+            try {
+                const entry = JSON.parse(line);
+                if (!isRecord(entry) || entry.ts !== ts)
+                    continue;
+                return (entry.isMessagingBot === true &&
+                    entry.platform === "slack" &&
+                    Array.isArray(entry.slackBlocks) &&
+                    entry.threadTs === threadTs);
+            }
+            catch {
+                continue;
+            }
+        }
+        return false;
+    }
     getMessagingInfo() {
         return {
             name: "slack",
-            formattingGuide: "## Slack Formatting (mrkdwn, NOT Markdown)\nBold: *text*, Italic: _text_, Code: `code`, Block: ```code```, Links: <url|text>\nDo NOT use **double asterisks** or [markdown](links).",
+            workspaceId: this.teamId || undefined,
+            trustModel: "membership",
+            formattingGuide: "## Slack Formatting\nWrite standard Markdown/GFM: **bold**, _italic_, ~~strike~~, `code`, fenced code blocks, [links](url), lists, and pipe tables (rendered as native Slack tables).\nDo NOT use Slack mrkdwn syntax like *single-asterisk bold* or <url|label> links.",
             channels: this.getAllChannels().map((c) => ({ id: c.id, name: c.name })),
             users: this.getAllUsers().map((u) => ({
                 id: u.id,
@@ -324,29 +653,18 @@ export class SlackMessagingBot {
             },
         };
     }
-    // ==========================================================================
-    // Events Integration
-    // ==========================================================================
-    /**
-     * Enqueue an event for processing. Always queues (no "already working" rejection).
-     * Returns true if enqueued, false if queue is full (max 5).
-     */
     enqueueEvent(event) {
-        const conversationId = event.conversationId;
-        const queue = this.getQueue(conversationId);
-        if (queue.size() >= 5) {
-            log.logWarning(`Event queue full for ${conversationId}, discarding: ${event.text.substring(0, 50)}`);
+        if (this.stopped)
             return false;
-        }
-        log.logInfo(`Enqueueing event for ${conversationId}: ${event.text.substring(0, 50)}`);
-        queue.enqueue(async () => {
+        const conversationId = event.address.conversationId;
+        return this.getQueue(conversationId).offerEvent(event, async () => {
             let anchorTs;
             if (!event.thread_ts) {
                 try {
                     anchorTs = await this.postMessage(conversationId, SLACK_EVENT_ANCHOR_TEXT);
                 }
                 catch (err) {
-                    log.logWarning(`Failed to post Slack event anchor for ${conversationId}`, err instanceof Error ? err.message : String(err));
+                    log.logWarning(`Failed to post Slack event anchor for ${conversationId}`, errorMessage(err));
                     reportUserFacingError(err, {
                         domain: "events",
                         surface: "event_delivery",
@@ -366,16 +684,18 @@ export class SlackMessagingBot {
             const eventPlan = planSlackEventAnchorRun(event, anchorTs);
             const eventForRun = eventPlan.event;
             if (eventPlan.initialMessageTs && eventForRun.sessionKey) {
-                registerThreadSession({
-                    conversationDir: join(this.workingDir, conversationId),
+                await registerThreadSession({
+                    office: this.office(conversationId),
                     sessionKey: eventForRun.sessionKey,
                 });
             }
             const runQueueKey = planSlackAdapterSession(eventForRun, {
                 initialMessageTs: eventPlan.initialMessageTs,
             }).sessionKey;
-            this.getQueue(runQueueKey).enqueue(async () => {
-                const slackEvent = {
+            const run = async () => {
+                const slackEvent = createConversationEvent({
+                    platform: "slack",
+                    address: eventForRun.address,
                     type: eventForRun.type,
                     conversationId,
                     conversationKind: eventForRun.conversationKind,
@@ -384,78 +704,140 @@ export class SlackMessagingBot {
                     thread_ts: eventForRun.thread_ts,
                     user: eventForRun.user,
                     text: eventForRun.text,
-                    attachments: eventForRun.attachments?.map((attachment) => ({
-                        original: attachment.name,
-                        localPath: attachment.localPath,
-                    })),
+                    attachments: eventForRun.attachments,
                     sessionKey: eventForRun.sessionKey,
-                };
+                });
                 const context = createSlackAdapters(slackEvent, this, {
                     initialMessageTs: eventPlan.initialMessageTs,
-                    replyMode: resolveConversationSettings(join(this.workingDir, eventForRun.conversationId)).slack
-                        ?.replyMode ?? "top-level",
+                    replyMode: this.resolveReplyMode(eventForRun.address),
                 });
                 return this.handler.handleEvent(eventForRun, this, context);
-            });
+            };
+            const runQueue = this.getQueue(runQueueKey);
+            if (!runQueue.enqueue(run)) {
+                await runQueue.close();
+                await run();
+            }
         });
-        return true;
     }
-    // ==========================================================================
-    // Private - Event Handlers
-    // ==========================================================================
     getQueue(channelId) {
         let queue = this.queues.get(channelId);
         if (!queue) {
             queue = new MessagingEventQueue("Slack");
+            if (this.stopped)
+                void queue.close();
             this.queues.set(channelId, queue);
         }
         return queue;
     }
-    resolveQueueKey(conversationId, sessionKey) {
+    async resolveQueueKey(conversationId, sessionKey) {
         if (!isSlackThreadSessionKey(sessionKey))
             return sessionKey;
-        if (this.handler.isRunning(sessionKey))
+        if (this.handler.isRunning(createOfficeAddress("slack", conversationId), sessionKey)) {
             return sessionKey;
-        return this.hasKnownThreadSession(conversationId, sessionKey) ? sessionKey : conversationId;
+        }
+        return (await this.hasKnownThreadSession(conversationId, sessionKey))
+            ? sessionKey
+            : conversationId;
+    }
+    isTaskThread(channel, root) {
+        return readTaskRoots(this.office(channel)).has(root);
+    }
+    hasRunningTaskThread(channel) {
+        const roots = readTaskRoots(this.office(channel));
+        if (!roots.size)
+            return false;
+        return this.handler
+            .getRunningSessions()
+            .some((s) => s.address.platform === "slack" &&
+            s.address.conversationId === channel &&
+            [...roots.keys()].some((root) => resolveSlackSessionKey(channel, root) === s.sessionKey));
     }
     hasKnownThreadSession(conversationId, sessionKey) {
         return hasMaterializedChatSession({
-            conversationDir: join(this.workingDir, conversationId),
+            office: this.office(conversationId),
             sessionKey,
         });
     }
+    channelKindFor(channelId) {
+        if (channelId.startsWith("D"))
+            return "im";
+        const channel = this.channels.get(channelId);
+        if (!channel)
+            return undefined;
+        if (channel.name.startsWith("DM:"))
+            return "im";
+        if (channel.isExternallyShared)
+            return "external";
+        if (channel.isPrivate === true)
+            return "private_channel";
+        if (channel.isPrivate === false)
+            return "public_channel";
+        return undefined;
+    }
+    backfillChannelKinds() {
+        let recorded = 0;
+        for (const record of listRegisteredOffices(this.workspace.stateDir)) {
+            if (record.platform !== "slack")
+                continue;
+            const kind = this.channelKindFor(record.conversationId);
+            if (!kind)
+                continue;
+            try {
+                const office = this.workspace.office(record);
+                if (readPlatformChannelKind(office) === kind)
+                    continue;
+                recordPlatformChannelKind(office, kind);
+                recorded++;
+            }
+            catch (err) {
+                log.logWarning("Failed to backfill Slack channel kind", String(err));
+            }
+        }
+        if (recorded > 0)
+            log.logInfo(`Recorded channel kind for ${recorded} Slack offices`);
+    }
     processSlackMessageIntake(options) {
-        void processMessageIntake({
+        const kind = this.channelKindFor(options.event.address.conversationId);
+        if (kind) {
+            try {
+                recordPlatformChannelKind(this.workspace.office(options.event.address), kind);
+            }
+            catch (err) {
+                log.logWarning("Failed to record Slack channel kind", String(err));
+            }
+        }
+        const absorbAttachmentFailure = () => {
+            void options.attachmentsPromise.catch((err) => {
+                log.logWarning("Failed to log Slack message", String(err));
+            });
+        };
+        return processMessageIntake({
             eventBase: options.event,
-            workingDir: this.workingDir,
-            isAutoReplyCandidate: options.isAutoReplyCandidate,
+            addressed: options.addressed,
+            magicWord: {
+                addressed: options.magicWordAddressed ?? options.addressed,
+                scopeFallback: "top-level",
+            },
+            busyPolicy: "queue",
             logEntryBase: {},
             processAttachments: () => options.attachmentsPromise,
             queueKey: options.queueKey,
-            enqueue: (queueKey, work) => this.getQueue(queueKey).enqueue(work),
+            enqueue: (queueKey, work) => this.getQueue(queueKey).admit(work),
+            react: (emoji) => this.addReaction(options.event.channel, options.event.ts, emoji),
             handler: this.handler,
             bot: this,
             createContext: (event) => this.createContext(event),
-            onNotTriggered: options.onNotTriggered,
             deferAttachmentsUntilRun: true,
+        }).then((outcome) => {
+            if (outcome !== "enqueued")
+                absorbAttachmentFailure();
+        }, (err) => {
+            log.logWarning("Slack message intake failed", String(err));
+            absorbAttachmentFailure();
         });
     }
-    buildHomeView() {
-        const blocks = [
-            {
-                type: "section",
-                text: {
-                    type: "mrkdwn",
-                    text: `*${PRODUCT_NAME}*\nStart a new task or check on running work.`,
-                },
-                accessory: {
-                    type: "image",
-                    image_url: "https://media1.tenor.com/m/lfDATg4Bhc0AAAAC/happy-cat.gif",
-                    alt_text: PRODUCT_NAME,
-                },
-            },
-        ];
-        // --- Running tasks ---
+    appendRunningTasks(blocks) {
         const runningSessions = this.handler.getRunningSessions();
         blocks.push({ type: "divider" }, {
             type: "header",
@@ -470,61 +852,51 @@ export class SlackMessagingBot {
                 type: "context",
                 elements: [{ type: "mrkdwn", text: "_No tasks running right now._" }],
             });
+            return;
         }
-        else {
-            // Threshold for "stuck" detection (10 minutes)
-            const STUCK_THRESHOLD_MS = 10 * 60 * 1000;
-            for (const session of runningSessions) {
-                const channelId = session.sessionKey.split(":")[0];
-                const channel = this.channels.get(channelId);
-                const channelName = channel ? `#${channel.name}` : channelId;
-                const elapsed = Math.floor((Date.now() - session.startedAt) / 60000);
-                const elapsedStr = elapsed < 1 ? "<1 min" : `${elapsed} min`;
-                // Check if task might be stuck
-                const lastActivity = session.lastActivityAt ? Date.now() - session.lastActivityAt : 0;
-                const isStuck = lastActivity > STUCK_THRESHOLD_MS;
-                const statusText = isStuck ? "_stuck_" : "_running_";
-                // Build status line: channel · status · time · step
-                let statusLine = `${statusText} · ${elapsedStr}`;
-                if (session.currentTool) {
-                    statusLine += ` · ${session.currentTool}`;
-                }
-                if (isStuck && lastActivity > 0) {
-                    const inactiveMin = Math.floor(lastActivity / 60000);
-                    statusLine += ` · idle ${inactiveMin}m`;
-                }
-                // Use context block for gray small text (like "No scheduled jobs.")
+        const stuckThresholdMs = 10 * 60 * 1000;
+        for (const session of runningSessions) {
+            const channelId = conversationIdOf(session.sessionKey);
+            const channelName = this.channels.get(channelId)?.name;
+            const elapsed = Math.floor((Date.now() - session.startedAt) / 60000);
+            const elapsedStr = elapsed < 1 ? "<1 min" : `${elapsed} min`;
+            const lastActivity = session.lastActivityAt ? Date.now() - session.lastActivityAt : 0;
+            const isStuck = lastActivity > stuckThresholdMs;
+            let statusLine = `${isStuck ? "_stuck_" : "_running_"} · ${elapsedStr}`;
+            if (session.currentTool)
+                statusLine += ` · ${session.currentTool}`;
+            if (isStuck)
+                statusLine += ` · idle ${Math.floor(lastActivity / 60000)}m`;
+            blocks.push({
+                type: "context",
+                elements: [
+                    {
+                        type: "mrkdwn",
+                        text: `*${channelName ? `#${channelName}` : channelId}* · ${statusLine}`,
+                    },
+                ],
+            });
+            if (isStuck) {
                 blocks.push({
                     type: "context",
                     elements: [
+                        { type: "mrkdwn", text: " " },
                         {
-                            type: "mrkdwn",
-                            text: `*${channelName}* · ${statusLine}`,
+                            type: "button",
+                            text: { type: "plain_text", text: "Force Stop", emoji: true },
+                            action_id: `force_stop_${session.sessionKey.replace(/:/g, "_")}`,
+                            value: session.sessionKey,
+                            style: "danger",
                         },
                     ],
                 });
-                // Add Force Stop button as separate element if stuck
-                if (isStuck) {
-                    blocks.push({
-                        type: "context",
-                        elements: [
-                            {
-                                type: "mrkdwn",
-                                text: " ",
-                            },
-                            {
-                                type: "button",
-                                text: { type: "plain_text", text: "Force Stop", emoji: true },
-                                action_id: `force_stop_${session.sessionKey.replace(/:/g, "_")}`,
-                                style: "danger",
-                            },
-                        ],
-                    });
-                }
             }
         }
-        // --- Cron jobs ---
-        const periodicEvents = this.eventsWatcher?.getPeriodicEvents() ?? [];
+    }
+    appendScheduledJobs(blocks, dmChannelId) {
+        const periodicEvents = dmChannelId && this.eventScheduler
+            ? this.eventScheduler.periodicEvents(createOfficeAddress("slack", dmChannelId))
+            : [];
         blocks.push({ type: "divider" }, {
             type: "header",
             text: {
@@ -538,34 +910,46 @@ export class SlackMessagingBot {
                 type: "context",
                 elements: [{ type: "mrkdwn", text: "_No scheduled jobs._" }],
             });
+            return;
         }
-        else {
-            for (const ev of periodicEvents) {
-                const channelLabel = ev.platform === "slack"
-                    ? (() => {
-                        const channel = this.channels.get(ev.conversationId);
-                        const channelName = channel ? `#${channel.name}` : ev.conversationId;
-                        return `${ev.platform}:${channelName}`;
-                    })()
-                    : `${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: {
-                        type: "mrkdwn",
-                        text: `*${ev.text}*\n└ \`${ev.schedule}\` · ${channelLabel} · Next: ${nextStr}`,
-                    },
-                });
-            }
+        for (const event of periodicEvents) {
+            const channel = event.platform === "slack" ? this.channels.get(event.conversationId) : undefined;
+            const channelId = channel ? `#${channel.name}` : event.conversationId;
+            const channelLabel = `${event.platform}:${channelId}`;
+            const nextRun = event.nextRun
+                ? new Date(event.nextRun).toLocaleString("en-US", {
+                    month: "short",
+                    day: "numeric",
+                    hour: "2-digit",
+                    minute: "2-digit",
+                })
+                : "—";
+            blocks.push({
+                type: "section",
+                text: {
+                    type: "mrkdwn",
+                    text: `*${event.text}*\n└ \`${event.schedule}\` · ${channelLabel} · Next: ${nextRun}`,
+                },
+            });
         }
-        // --- Footer ---
+    }
+    buildHomeView(dmChannelId) {
+        const blocks = [
+            {
+                type: "section",
+                text: {
+                    type: "mrkdwn",
+                    text: `*${PRODUCT_NAME}*\nStart a new task or check on running work.`,
+                },
+                accessory: {
+                    type: "image",
+                    image_url: "https://media1.tenor.com/m/lfDATg4Bhc0AAAAC/happy-cat.gif",
+                    alt_text: PRODUCT_NAME,
+                },
+            },
+        ];
+        this.appendRunningTasks(blocks);
+        this.appendScheduledJobs(blocks, dmChannelId);
         blocks.push({ type: "divider" }, {
             type: "context",
             elements: [
@@ -574,58 +958,38 @@ export class SlackMessagingBot {
         });
         return { type: "home", blocks: blocks };
     }
-    resolveStopTarget(channelId, threadTs) {
-        const directTarget = resolveStopTarget({
-            handler: this.handler,
-            conversationId: channelId,
-            sessionKey: resolveSlackSessionKey(channelId, threadTs),
-        });
-        if (directTarget)
-            return directTarget;
-        if (threadTs)
-            return null;
-        return resolveOnlyScopedStopTarget(this.handler, channelId);
-    }
-    isStopText(text) {
-        const normalized = text.trim().toLowerCase();
-        return normalized === "stop" || normalized === "/stop";
-    }
-    createCommandAdapters(conversationId, userId, userName, text, ts, options = {}) {
-        const message = {
+    createCommandAdapters(input) {
+        const { conversationId, userId, userName, text, ts, ...options } = input;
+        const message = createConversationMessage({
+            platform: "slack",
+            conversationId,
             id: ts,
-            sessionKey: conversationId,
+            sessionKey: options.sessionKey ?? conversationId,
             conversationKind: options.ephemeralChannelId ? "shared" : "direct",
             userId,
             userName,
             text,
             attachments: [],
-        };
-        const respond = async (responseText) => {
-            if (options.ephemeralChannelId) {
-                await this.postEphemeral(options.ephemeralChannelId, userId, responseText, options.threadTs);
-                return;
-            }
-            const messageTs = await this.postMessage(conversationId, responseText);
-            this.logBotResponse(conversationId, responseText, messageTs);
-        };
-        const respondMuted = async (responseText) => {
-            const blocks = [buildMrkdwnContextBlock(responseText)];
+        });
+        const respond = async (responseText, blocks) => {
             if (options.ephemeralChannelId) {
-                await this.postEphemeralBlocks(options.ephemeralChannelId, userId, responseText, blocks, options.threadTs);
+                await this.postEphemeral(options.ephemeralChannelId, userId, responseText, options.threadTs, blocks);
                 return;
             }
-            const messageTs = await this.postMessageBlocks(conversationId, responseText, blocks);
+            const messageTs = blocks
+                ? await this.postMessageBlocks(conversationId, responseText, blocks)
+                : await this.postMessage(conversationId, responseText);
             this.logBotResponse(conversationId, responseText, messageTs);
         };
         const responder = {
             respond,
-            replaceResponse: respond,
+            replaceResponse: (responseText) => respond(responseText),
             respondDiagnostic: async (responseText, responseOptions) => {
                 if (responseOptions?.style === "muted") {
-                    await respondMuted(responseText);
+                    await respond(responseText, [buildMrkdwnContextBlock(responseText)]);
                     return;
                 }
-                await respond(responseOptions?.style === "error" ? `_${responseText}_` : responseText);
+                await respond(responseOptions?.style === "error" ? italicizeLines(responseText) : responseText);
             },
             respondToolResult: async (result) => {
                 const duration = (result.durationMs / 1000).toFixed(1);
@@ -639,6 +1003,7 @@ export class SlackMessagingBot {
             deleteResponse: async () => { },
         };
         return {
+            address: message.address,
             message,
             responder,
             platform: this.getMessagingInfo(),
@@ -664,66 +1029,42 @@ export class SlackMessagingBot {
             text: commandText,
             attachments: [],
             isMessagingBot: false,
-            ...(threadTs ? { threadTs } : {}),
+            threadTs: threadTs || undefined,
         });
-        const event = {
-            type: options.type ?? (isDirectMessage ? "dm" : "mention"),
+        const event = createConversationEvent({
+            platform: "slack",
             conversationId,
+            type: options.type ?? (isDirectMessage ? "dm" : "mention"),
             conversationKind: isDirectMessage ? "direct" : "shared",
             ts: eventTs,
             user: payload.user_id,
             text: commandText,
             attachments: [],
-            ...(threadTs ? { thread_ts: threadTs } : {}),
+            thread_ts: threadTs || undefined,
             sessionKey,
-        };
-        const context = this.createCommandAdapters(conversationId, payload.user_id, userName, commandText, eventTs, isDirectMessage ? { threadTs } : { ephemeralChannelId: conversationId, threadTs });
-        return { event, context };
-    }
-    async routeSlashLoginCommand(payload) {
-        const { event, context } = this.buildSlashCommandEvent(payload, {
-            type: payload.channel_id.startsWith("D") ? "dm" : "private_command",
-            includeText: true,
         });
-        await this.handler.handleEvent(event, this, context);
-    }
-    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,
+        const context = this.createCommandAdapters({
+            conversationId,
+            userId: payload.user_id,
             userName,
-            text: payload.command,
-            attachments: [],
-            isMessagingBot: false,
+            text: commandText,
+            ts: eventTs,
+            ephemeralChannelId: isDirectMessage ? undefined : conversationId,
+            threadTs,
+            sessionKey,
         });
-        const commandMessagingBot = {
-            start: async () => { },
-            postMessage: async (_channel, text) => this.postMessage(conversationId, text),
-            updateMessage: async (channel, ts, text) => this.updateMessage(channel, ts, text),
-            enqueueEvent: (event) => this.enqueueEvent(event),
-            getMessagingInfo: () => this.getMessagingInfo(),
-        };
-        await this.handler.handleNewCommand(conversationId, conversationId, commandMessagingBot);
-    }
-    async routeSlashModelCommand(payload) {
-        const { event, context } = this.buildSlashCommandEvent(payload, { includeText: true });
-        await this.handler.handleEvent(event, this, context);
-    }
-    async routeSlashSessionCommand(payload) {
-        const { event, context } = this.buildSlashCommandEvent(payload, { thread: true });
-        await this.handler.handleEvent(event, this, context);
+        return { event, context };
     }
-    async routeSlashAdminCommand(payload) {
-        const { event, context } = this.buildSlashCommandEvent(payload, { thread: true });
+    async routeSlashCommand(route, payload) {
+        const { event, context } = this.buildSlashCommandEvent(payload, {
+            includeText: route.includeText,
+            thread: route.thread,
+            type: route.privateCommand
+                ? payload.channel_id.startsWith("D")
+                    ? "dm"
+                    : "private_command"
+                : undefined,
+        });
         await this.handler.handleEvent(event, this, context);
     }
     setupEventHandlers() {
@@ -736,38 +1077,57 @@ export class SlackMessagingBot {
         this.socketClient.on("unable_to_socket_mode_start", (err) => {
             log.logWarning("Slack socket unable_to_start", err ? String(err) : "");
         });
-        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 on = (event, handle) => this.socketClient.on(event, (payload) => this.intake.run(() => handle(withLoggedAck(event, payload))));
+        on("app_mention", (payload) => this.handleAppMention(payload));
+        on("message", (payload) => this.handleMessageEvent(payload));
+        on("slash_commands", (payload) => this.handleSlashCommand(payload));
+        on("app_home_opened", (payload) => this.handleAppHomeOpened(payload));
+        on("assistant_thread_started", (payload) => this.handleAssistantThreadStarted(payload));
+        on("assistant_thread_context_changed", (payload) => this.handleAgentContextChangedEvent(payload));
+        on("app_context_changed", (payload) => this.handleAgentContextChangedEvent(payload));
+        const blockAction = ({ body, ack }) => this.handleBlockAction({ body: body, ack });
+        on("block_actions", blockAction);
+        on("interactive", blockAction);
+    }
+    isRedelivery(kind, channel, ts) {
+        const key = `${kind}:${channel}:${ts}`;
+        if (this.recentMessageKeys.has(key))
+            return true;
+        this.recentMessageKeys.add(key);
+        if (this.recentMessageKeys.size > RECENT_MESSAGE_KEYS) {
+            const oldest = this.recentMessageKeys.values().next().value;
+            if (oldest !== undefined)
+                this.recentMessageKeys.delete(oldest);
+        }
+        return false;
+    }
+    async 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).
+        if (this.isRedelivery("app_mention", e.channel, e.ts)) {
+            log.logInfo(`[${e.channel}] Ignoring redelivered mention ${e.ts}`);
+            await ack();
+            return;
+        }
         const sessionKey = resolveSlackSessionKey(e.channel, e.thread_ts);
         const mentionText = this.stripOwnMention(e.text);
-        const slackEvent = {
-            type: "mention",
+        const slackEvent = createConversationEvent({
+            platform: "slack",
             conversationId: e.channel,
+            type: "mention",
             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,
-        };
+            channel: e.channel,
+            files: e.files,
+        });
         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) => {
@@ -776,90 +1136,161 @@ export class SlackMessagingBot {
             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);
-            }
-            else {
-                this.postMessage(e.channel, formatNothingRunning("slack"));
-            }
-            void attachmentsPromise.catch((err) => {
-                log.logWarning("Failed to log Slack message", String(err));
-            });
-            ack();
-            return;
-        }
-        this.processSlackMessageIntake({
+        const intake = this.processSlackMessageIntake({
             event: slackEvent,
             attachmentsPromise,
-            queueKey: this.resolveQueueKey(e.channel, sessionKey),
-            isAutoReplyCandidate: false,
+            queueKey: await this.resolveQueueKey(e.channel, sessionKey),
+            addressed: true,
         });
         ack();
+        await intake;
     }
-    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 isOwnMessagingBotMessage = (!!e.user && e.user === this.botUserId) || (!!this.botId && e.bot_id === this.botId);
-        if (isOwnMessagingBotMessage) {
+    admitHumanMessage(event, ack) {
+        const hasSlackContent = hasMessageContent(event);
+        const isOwnMessage = event.user === this.botUserId || (!!this.botId && event.bot_id === this.botId);
+        if (isOwnMessage) {
             ack();
-            return;
+            return false;
         }
-        const isExternalMessagingBotMessage = !!e.bot_id || e.subtype === "bot_message";
-        if (isExternalMessagingBotMessage) {
-            if (e.subtype !== undefined && e.subtype !== "bot_message" && e.subtype !== "file_share") {
-                ack();
-                return;
+        const authorIsKnownHuman = !!event.user && this.users.get(event.user)?.isBot === false;
+        const isExternalMessage = event.subtype === "bot_message" || (!!event.bot_id && !authorIsKnownHuman);
+        if (isExternalMessage) {
+            const supportedSubtype = BOT_MESSAGE_SUBTYPES.has(event.subtype);
+            if (supportedSubtype && hasSlackContent) {
+                void this.logExternalMessagingBotMessage(event).catch((err) => {
+                    log.logWarning("Failed to log Slack bot message", String(err));
+                });
             }
-            if (!hasSlackContent) {
-                ack();
-                return;
+            ack();
+            return false;
+        }
+        const isSupportedUserMessage = !!event.user && USER_MESSAGE_SUBTYPES.has(event.subtype) && hasSlackContent;
+        if (isSupportedUserMessage)
+            return true;
+        ack();
+        return false;
+    }
+    async deliverTaskUpdate(event, attachmentsPromise) {
+        if (matchMagicWord(event.text) === "stop" || event.text.startsWith("/"))
+            return false;
+        event.attachments = await attachmentsPromise;
+        const context = this.createContext(event);
+        const post = (text) => event.thread_ts
+            ? this.postInThread(event.channel, event.thread_ts, text)
+            : this.postMessage(event.channel, text);
+        try {
+            const tasks = await context.responder.getTaskStatus(event.thread_ts ? event.sessionKey : undefined);
+            if (!tasks.length)
+                return false;
+            const active = tasks.filter((t) => t.status === "running" || t.status === "stopping");
+            const user = this.users.get(event.user);
+            const intent = event.attachments?.length
+                ? event.thread_ts
+                    ? "steer"
+                    : "request"
+                : await classifyTaskIntent(buildTaskIntentState(this.conversationDir(event.channel), event, {
+                    speaker: user?.displayName ?? user?.userName,
+                    tasks,
+                    resolveName: (id) => this.users.get(id)?.displayName ?? this.users.get(id)?.userName,
+                    botUserId: this.botUserId,
+                }), event.text, { conversationId: event.channel, inTaskThread: !!event.thread_ts });
+            if (intent === "status") {
+                const selection = event.thread_ts ? tasks : active.length ? active : tasks.slice(0, 1);
+                const text = selection.length > 1
+                    ? "目前有多個任務在處理，請到你想查詢的任務對話串詢問，避免弄錯。"
+                    : formatTaskStatus(selection);
+                const ts = await post(text);
+                this.logBotResponse(event.channel, text, ts, event.thread_ts);
+                return true;
+            }
+            if (intent === "steer") {
+                const target = event.thread_ts
+                    ? context.message
+                    : active.length === 1
+                        ? {
+                            ...context.message,
+                            sessionKey: active[0].sessionKey,
+                            threadTs: active[0].threadTs,
+                        }
+                        : undefined;
+                if (target && (await this.handler.steer?.(target))) {
+                    const text = "收到補充，會在下一個處理步驟納入；目前的操作不會立即中斷。";
+                    const ts = await post(text);
+                    this.logBotResponse(event.channel, text, ts, event.thread_ts);
+                    return true;
+                }
             }
-            void this.logExternalMessagingBotMessage(e).catch((err) => {
-                log.logWarning("Failed to log Slack bot message", String(err));
+        }
+        catch (error) {
+            await post(error instanceof Error ? error.message : "Could not deliver task update.");
+            return true;
+        }
+        return false;
+    }
+    async evaluateJevAddressed(event) {
+        if (!event.text.trim() || matchMagicWord(event.text) === "stop")
+            return false;
+        try {
+            const user = this.users.get(event.user);
+            const state = buildAutoReplyState(this.conversationDir(event.channel), event, {
+                speaker: user?.displayName ?? user?.userName,
+                resolveName: (id) => this.users.get(id)?.displayName ?? this.users.get(id)?.userName,
+                botUserId: this.botUserId,
             });
-            ack();
-            return;
+            const result = await evaluateWithJev(state, { addressed: { type: "boolean", instructions: JEV_ADDRESSED_INSTRUCTIONS } }, { caller: "slack_auto_reply" });
+            const probability = result.answers.addressed.probability;
+            log.logInfo(`[${event.channel}] jev auto-reply: probability=${probability.toFixed(2)} addressed=${probability > 0.5} text="${event.text.slice(0, 80)}"`);
+            return probability > 0.5;
         }
-        if (!e.user) {
-            ack();
-            return;
+        catch (err) {
+            if (err instanceof JevNotConfiguredError) {
+                log.logWarning("Slack auto-reply jev mode requires OPENROUTER_API_KEY; treating message as unaddressed", String(err));
+                return false;
+            }
+            reportUserFacingError(err, {
+                domain: "chat_platform",
+                surface: "slack_auto_reply_jev",
+                operation: "evaluate",
+                severity: "warning",
+                context: { conversationId: event.address.conversationId },
+            });
+            return false;
         }
-        if (e.subtype !== undefined && e.subtype !== "file_share") {
-            ack();
+    }
+    async handleMessageEvent({ event, ack }) {
+        const e = event;
+        if (!this.admitHumanMessage(e, ack))
             return;
-        }
-        if (!hasSlackContent) {
-            ack();
+        if (this.isRedelivery("message", e.channel, e.ts)) {
+            log.logInfo(`[${e.channel}] Ignoring redelivered message ${e.ts}`);
+            await ack();
             return;
         }
-        const isDM = e.channel_type === "im";
+        const isDM = e.channel_type === "im" || e.channel.startsWith("D");
         const conversationKind = isDM ? "direct" : "shared";
         const isMessagingBotMention = e.text?.includes(`<@${this.botUserId}>`);
-        // Skip channel @mentions - already handled by app_mention event
         if (!isDM && isMessagingBotMention) {
             ack();
             return;
         }
-        const isThreadReply = !!e.thread_ts;
         const sessionKey = isDM ? resolveSlackSessionKey(e.channel, e.thread_ts) : undefined;
-        const slackEvent = {
-            type: isDM ? "dm" : "mention",
+        if (isDM && e.thread_ts && e.text) {
+            void titleAssistantThread(this.assistantOps(), this.assistantThreads, e.channel, e.thread_ts, this.stripOwnMention(e.text));
+        }
+        const slackEvent = createConversationEvent({
+            platform: "slack",
             conversationId: e.channel,
+            type: (isDM ? "dm" : "mention"),
             conversationKind,
-            channel: e.channel,
             ts: e.ts,
             thread_ts: e.thread_ts,
             user: e.user,
             text: this.stripOwnMention(e.text),
-            files: e.files,
             sessionKey,
-        };
+            channel: e.channel,
+            files: e.files,
+        });
         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) => {
@@ -868,136 +1299,77 @@ export class SlackMessagingBot {
             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);
-            }
-            else {
-                this.postMessage(e.channel, formatNothingRunning("slack"));
-            }
-            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.processSlackMessageIntake({
-                event: slackEvent,
-                attachmentsPromise,
-                queueKey: this.resolveQueueKey(e.channel, activeSessionKey),
-                isAutoReplyCandidate: false,
-            });
-        };
-        const logOnly = () => {
-            void attachmentsPromise.catch((err) => {
-                log.logWarning("Failed to log Slack message", String(err));
-            });
-        };
-        if (isDM) {
-            enqueueTriggered();
-            ack();
-            return;
-        }
-        if (isThreadReply) {
-            logOnly();
+        const activeSessionKey = slackEvent.sessionKey ?? resolveSlackSessionKey(e.channel, e.thread_ts);
+        slackEvent.sessionKey = activeSessionKey;
+        const taskControl = isDM &&
+            (e.thread_ts
+                ? this.isTaskThread(e.channel, e.thread_ts)
+                : this.hasRunningTaskThread(e.channel) || isTaskStatusQuestion(slackEvent.text));
+        if (taskControl) {
             ack();
-            return;
+            if (await this.deliverTaskUpdate(slackEvent, attachmentsPromise))
+                return;
         }
-        const activeSessionKey = resolveSlackSessionKey(e.channel, e.thread_ts);
-        slackEvent.sessionKey = activeSessionKey;
-        this.processSlackMessageIntake({
+        const autoReplyMode = isDM
+            ? "off"
+            : slackConversationAutoReplyMode(this.workspace.office(slackEvent.address));
+        const autoReply = autoReplyMode === "on"
+            ? true
+            : autoReplyMode === "jev"
+                ? await this.evaluateJevAddressed(slackEvent)
+                : false;
+        const intake = this.processSlackMessageIntake({
             event: slackEvent,
             attachmentsPromise,
-            queueKey: this.resolveQueueKey(e.channel, activeSessionKey),
-            isAutoReplyCandidate: true,
-            onNotTriggered: logOnly,
+            queueKey: await this.resolveQueueKey(e.channel, activeSessionKey),
+            addressed: isDM || autoReply,
+            magicWordAddressed: isDM,
         });
-        ack();
+        if (!taskControl)
+            ack();
+        await intake;
     }
-    async handleSlashCommand({ body, ack, }) {
+    async handleSlashCommand({ body, ack }) {
         const payload = body;
         await ack();
         if (!payload.command || !payload.channel_id || !payload.user_id) {
             return;
         }
         const { command, text, channel_id, user_id, user_name, thread_ts } = payload;
-        let handlerPromise = null;
-        if (command === "/pi-login") {
-            handlerPromise = this.routeSlashLoginCommand({
-                command,
-                text,
-                channel_id,
-                user_id,
-                user_name,
-            });
-        }
-        else if (command === "/pi-new") {
-            handlerPromise = this.routeSlashNewCommand({ command, channel_id, user_id, user_name });
-        }
-        else if (command === "/pi-session") {
-            handlerPromise = this.routeSlashSessionCommand({
-                command,
-                channel_id,
-                user_id,
-                user_name,
-                thread_ts,
-            });
-        }
-        else if (command === "/pi-model") {
-            handlerPromise = this.routeSlashModelCommand({
-                command,
-                text,
-                channel_id,
-                user_id,
-                user_name,
-            });
-        }
-        else if (command === "/pi-sandbox" ||
-            command === "/pi-auto-reply" ||
-            command === "/pi-extensions") {
-            handlerPromise = this.routeSlashModelCommand({
+        const entry = COMMAND_MANIFEST.find((candidate) => candidate.slackCommand === command);
+        if (!entry)
+            return;
+        if (!entry.slackRoute)
+            return;
+        try {
+            await this.routeSlashCommand(entry.slackRoute, {
                 command,
                 text,
                 channel_id,
                 user_id,
                 user_name,
-            });
-        }
-        else if (command === "/pi-admin") {
-            handlerPromise = this.routeSlashAdminCommand({
-                command,
-                channel_id,
-                user_id,
-                user_name,
                 thread_ts,
             });
         }
-        if (!handlerPromise) {
-            return;
+        catch (err) {
+            log.logWarning("Slack slash command error", errorMessage(err));
         }
-        handlerPromise.catch((err) => {
-            log.logWarning("Slack slash command error", err instanceof Error ? err.message : String(err));
-        });
     }
     handleAppHomeOpened({ event, ack }) {
         const e = event;
         ack();
+        if (e.tab === "messages") {
+            if (e.channel) {
+                void handleAgentDmOpened(this.assistantOps(), this.assistantThreads, e.channel, e.context);
+            }
+            return;
+        }
         if (e.tab !== "home")
             return;
         this.webClient.views
             .publish({
             user_id: e.user,
-            view: this.buildHomeView(),
+            view: this.buildHomeView(e.channel),
         })
             .catch((err) => {
             log.logWarning(`Failed to publish App Home view`, String(err));
@@ -1011,31 +1383,28 @@ export class SlackMessagingBot {
         }
         if (!action.action_id?.startsWith("force_stop_")) {
             ack();
-            this.handleSlackInteraction(body, action);
+            await this.handleSlackInteraction(body, action);
             return;
         }
         ack();
-        const sessionKey = action.action_id.replace("force_stop_", "").replace(/_/g, ":");
+        const sessionKey = action.value ?? action.action_id.replace("force_stop_", "").replace(/_/g, ":");
         const userId = body.user?.id;
-        const channelId = body.container?.channel_id || sessionKey.split(":")[0];
+        const channelId = body.container?.channel_id || conversationIdOf(sessionKey);
         log.logInfo(`[Force Stop] User ${userId} requested force stop for ${sessionKey}`);
-        // Use handler's forceStop method
-        this.handler.forceStop(sessionKey);
-        // Notify in channel
+        this.handler.forceStop(createOfficeAddress("slack", channelId), sessionKey);
         await this.postMessage(channelId, formatForceStopped("slack", userId ?? "unknown"));
-        // Refresh home tab
         if (userId) {
-            this.webClient.views
-                .publish({
+            this.openDirectConversation(userId)
+                .then((dmChannelId) => this.webClient.views.publish({
                 user_id: userId,
-                view: this.buildHomeView(),
-            })
+                view: this.buildHomeView(dmChannelId),
+            }))
                 .catch((err) => {
                 log.logWarning(`Failed to refresh App Home view`, String(err));
             });
         }
     }
-    handleSlackInteraction(body, action) {
+    async handleSlackInteraction(body, action) {
         const container = body.container ?? {};
         const channelId = container.channel_id;
         const userId = body.user?.id;
@@ -1045,6 +1414,8 @@ export class SlackMessagingBot {
         const selectedOptions = Array.isArray(action.selected_options)
             ? action.selected_options
             : undefined;
+        const threadTs = container.thread_ts;
+        const sessionKey = resolveSlackSessionKey(channelId, threadTs);
         const selectedText = selectedOption?.text?.text ?? selectedOption?.value;
         const selectedTexts = selectedOptions?.map((option) => option.text?.text ?? option.value);
         const valueText = selectedTexts?.length
@@ -1052,12 +1423,10 @@ export class SlackMessagingBot {
             : (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 } : {}),
+            threadTs: threadTs || undefined,
             user: userId,
             userName: body.user?.username ?? body.user?.name,
             text,
@@ -1080,50 +1449,87 @@ export class SlackMessagingBot {
                 messageTs: container.message_ts,
             },
         });
-        const event = {
-            type: "slack_action",
+        const event = createConversationEvent({
+            platform: "slack",
             conversationId: channelId,
+            type: "slack_action",
             conversationKind: channelId.startsWith("D") ? "direct" : "shared",
             ts,
             user: userId,
             text,
             attachments: [],
-            ...(threadTs ? { thread_ts: threadTs } : {}),
+            thread_ts: threadTs || undefined,
             sessionKey,
-        };
-        this.getQueue(this.resolveQueueKey(channelId, sessionKey)).enqueue(async () => {
+        });
+        this.getQueue(await this.resolveQueueKey(channelId, sessionKey)).enqueue(async () => {
             const slackEvent = {
-                type: event.conversationKind === "direct" ? "dm" : "mention",
-                conversationId: channelId,
-                conversationKind: event.conversationKind,
+                ...createConversationEvent({
+                    platform: "slack",
+                    conversationId: channelId,
+                    type: (event.conversationKind === "direct" ? "dm" : "mention"),
+                    conversationKind: event.conversationKind,
+                    ts,
+                    thread_ts: threadTs,
+                    user: userId,
+                    text,
+                    attachments: [],
+                    sessionKey,
+                }),
                 channel: channelId,
-                ts,
-                thread_ts: threadTs,
-                user: userId,
-                text,
                 attachments: [],
-                sessionKey,
             };
             return this.handler.handleEvent(event, this, this.createContext(slackEvent));
         });
     }
-    /**
-     * Log a user message to log.jsonl after attachments are ready.
-     */
+    async processAttachments(channelId, files, timestamp) {
+        const items = [];
+        for (const file of files) {
+            const url = file.url_private_download || file.url_private;
+            if (!url)
+                continue;
+            if (!file.name) {
+                throw new Error(`Attachment missing name for URL: ${url}`);
+            }
+            items.push({
+                name: file.name,
+                timestampMs: Math.floor(parseFloat(timestamp) * 1000),
+                download: (destPath) => this.downloadSlackFile(url, destPath),
+            });
+        }
+        const office = this.workspace.office(createOfficeAddress("slack", channelId));
+        const { saved, failed } = await saveIncomingAttachments(office, items);
+        const firstFailure = failed[0];
+        if (firstFailure) {
+            const { name, error } = firstFailure;
+            const errorMsg = errorMessage(error);
+            throw new Error(`Failed to download attachment ${name}: ${errorMsg}`, { cause: error });
+        }
+        return saved;
+    }
+    async downloadSlackFile(url, destPath) {
+        assertSlackFileUrl(url);
+        await withRetry(async () => {
+            const response = await this.fetchFn(url, {
+                headers: { Authorization: `Bearer ${this.botToken}` },
+            });
+            if (!response.ok) {
+                throw new AttachmentDownloadHttpError(`HTTP ${response.status}: ${response.statusText}`, response.status);
+            }
+            await writeResponseToFile(response, destPath);
+        }, { maxAttempts: 3, baseDelayMs: 250, isRateLimited: isRetryableAttachmentDownloadError });
+    }
     async logUserMessage(event) {
         const user = this.users.get(event.user);
         let attachments = [];
         let attachmentError;
         if (event.files) {
             try {
-                attachments = await this.store.processAttachments(event.channel, event.files, event.ts);
+                attachments = await this.processAttachments(event.channel, event.files, event.ts);
             }
             catch (err) {
                 attachmentError = err;
             }
         }
-        // Always write the text log, even if attachment processing failed — we want
-        // a record of the user message regardless of file-handling errors.
         this.logToFile(event.channel, {
             date: new Date(parseFloat(event.ts) * 1000).toISOString(),
             ts: event.ts,
@@ -1141,7 +1547,7 @@ export class SlackMessagingBot {
     }
     async logExternalMessagingBotMessage(event) {
         const attachments = event.files
-            ? await this.store.processAttachments(event.channel, event.files, event.ts)
+            ? await this.processAttachments(event.channel, event.files, event.ts)
             : [];
         const botName = event.username ?? event.bot_profile?.name ?? event.bot_profile?.real_name ?? event.bot_id;
         this.logToFile(event.channel, {
@@ -1160,31 +1566,39 @@ export class SlackMessagingBot {
         });
         return attachments;
     }
-    // ==========================================================================
-    // Private - Backfill
-    // ==========================================================================
     async getExistingTimestamps(channelId) {
-        const logPath = join(this.workingDir, channelId, "log.jsonl");
+        const { logPath } = this.office(channelId);
         const timestamps = new Set();
-        if (!existsSync(logPath))
+        const content = readTextFileNoFollowIfExists(logPath);
+        if (content === undefined)
             return timestamps;
-        const content = await readFile(logPath, "utf-8");
         const lines = content.trim().split("\n").filter(Boolean);
         for (let i = 0; i < lines.length; i++) {
             try {
-                const entry = JSON.parse(lines[i]);
+                const entry = JSON.parse(lines[i] ?? "");
                 if (entry.ts)
                     timestamps.add(entry.ts);
             }
             catch (err) {
-                log.logWarning(`Skipping malformed log entry at ${logPath}:${i + 1}`, err instanceof Error ? err.message : String(err));
+                log.logWarning(`Skipping malformed log entry at ${logPath}:${i + 1}`, errorMessage(err));
             }
         }
         return timestamps;
     }
+    isBackfillableMessage(message) {
+        if (message.user === this.botUserId)
+            return true;
+        if (hasBotIdentity(message)) {
+            if (this.botId && message.bot_id === this.botId)
+                return false;
+            return BOT_MESSAGE_SUBTYPES.has(message.subtype) && hasMessageContent(message);
+        }
+        return (!!message.user &&
+            USER_MESSAGE_SUBTYPES.has(message.subtype) &&
+            hasMessageContent(message, false));
+    }
     async backfillChannel(channelId, upperBoundTs) {
         const existingTs = await this.getExistingTimestamps(channelId);
-        // Find the biggest ts in log.jsonl
         let lastLoggedTs;
         for (const ts of existingTs) {
             if (!lastLoggedTs || parseFloat(ts) > parseFloat(lastLoggedTs))
@@ -1197,8 +1611,8 @@ export class SlackMessagingBot {
         do {
             const result = await this.webClient.conversations.history({
                 channel: channelId,
-                oldest: lastLoggedTs, // Only fetch messages newer than what we have
-                latest: upperBoundTs, // Do not race live socket events after startup
+                oldest: lastLoggedTs,
+                latest: upperBoundTs,
                 inclusive: false,
                 limit: 1000,
                 cursor,
@@ -1209,40 +1623,15 @@ export class SlackMessagingBot {
             cursor = result.response_metadata?.next_cursor;
             pageCount++;
         } while (cursor && pageCount < maxPages);
-        // Filter: include mikan's messages, external app/bot messages, and user messages.
         const relevantMessages = allMessages.filter((msg) => {
             if (!msg.ts || existingTs.has(msg.ts))
-                return false; // Skip duplicates
-            if (msg.user === this.botUserId)
-                return true;
-            const isExternalMessagingBotMessage = !!msg.bot_id || msg.subtype === "bot_message";
-            if (isExternalMessagingBotMessage) {
-                if (this.botId && msg.bot_id === this.botId)
-                    return false;
-                if (msg.subtype !== undefined &&
-                    msg.subtype !== "bot_message" &&
-                    msg.subtype !== "file_share") {
-                    return false;
-                }
-                return (!!msg.text ||
-                    !!(msg.files && msg.files.length > 0) ||
-                    !!msg.blocks?.length ||
-                    !!msg.attachments?.length);
-            }
-            if (msg.subtype !== undefined && msg.subtype !== "file_share")
-                return false;
-            if (!msg.user)
-                return false;
-            if (!msg.text && (!msg.files || msg.files.length === 0))
                 return false;
-            return true;
+            return this.isBackfillableMessage(msg);
         });
-        // Reverse to chronological order
         relevantMessages.reverse();
-        // Log each message to log.jsonl
         for (const msg of relevantMessages) {
             const isMikanMessage = msg.user === this.botUserId;
-            const isExternalMessagingBotMessage = !isMikanMessage && (!!msg.bot_id || msg.subtype === "bot_message");
+            const isExternalMessagingBotMessage = !isMikanMessage && hasBotIdentity(msg);
             if (isExternalMessagingBotMessage) {
                 await this.logExternalMessagingBotMessage({ ...msg, channel: channelId, ts: msg.ts });
                 continue;
@@ -1250,7 +1639,7 @@ export class SlackMessagingBot {
             const user = this.users.get(msg.user);
             const text = this.stripOwnMention(msg.text);
             const attachments = msg.files
-                ? await this.store.processAttachments(channelId, msg.files, msg.ts)
+                ? await this.processAttachments(channelId, msg.files, msg.ts)
                 : [];
             this.logToFile(channelId, {
                 date: new Date(parseFloat(msg.ts) * 1000).toISOString(),
@@ -1268,11 +1657,9 @@ export class SlackMessagingBot {
     }
     async backfillAllChannels(upperBoundTs) {
         const startTime = Date.now();
-        // Only backfill channels that already have a log.jsonl (mikan has interacted with them before)
         const channelsToBackfill = [];
         for (const [channelId, channel] of this.channels) {
-            const logPath = join(this.workingDir, channelId, "log.jsonl");
-            if (existsSync(logPath)) {
+            if (existsSync(this.office(channelId).logPath)) {
                 channelsToBackfill.push([channelId, channel]);
             }
         }
@@ -1288,38 +1675,32 @@ export class SlackMessagingBot {
             catch (error) {
                 log.logWarning(`Failed to backfill #${channel.name}`, String(error));
             }
-            // Add delay between channels to avoid hitting Slack rate limits
-            if (channelId !== channelsToBackfill[channelsToBackfill.length - 1][0]) {
+            if (channelId !== channelsToBackfill[channelsToBackfill.length - 1]?.[0]) {
                 await new Promise((resolve) => setTimeout(resolve, 500));
             }
         }
         const durationMs = Date.now() - startTime;
         log.logBackfillComplete(totalMessages, durationMs);
     }
-    // ==========================================================================
-    // Private - Fetch Users/Channels
-    // ==========================================================================
     async fetchUsers() {
         let cursor;
         do {
             const result = await this.webClient.users.list({ limit: 200, cursor });
             const members = result.members;
-            if (members) {
-                for (const u of members) {
-                    if (u.id && u.name && !u.deleted) {
-                        this.users.set(u.id, {
-                            id: u.id,
-                            userName: u.name,
-                            displayName: u.real_name || u.name,
-                        });
-                    }
-                }
+            for (const u of members ?? []) {
+                if (!u.id || !u.name || u.deleted)
+                    continue;
+                this.users.set(u.id, {
+                    id: u.id,
+                    userName: u.name,
+                    displayName: u.real_name || u.name,
+                    isBot: !!u.is_bot,
+                });
             }
             cursor = result.response_metadata?.next_cursor;
         } while (cursor);
     }
     async fetchChannels() {
-        // Fetch public/private channels
         let cursor;
         do {
             const result = await this.webClient.conversations.list({
@@ -1329,16 +1710,18 @@ export class SlackMessagingBot {
                 cursor,
             });
             const channels = result.channels;
-            if (channels) {
-                for (const c of channels) {
-                    if (c.id && c.name && c.is_member) {
-                        this.channels.set(c.id, { id: c.id, name: c.name });
-                    }
-                }
+            for (const c of channels ?? []) {
+                if (!c.id || !c.name || !c.is_member)
+                    continue;
+                this.channels.set(c.id, {
+                    id: c.id,
+                    name: c.name,
+                    isPrivate: typeof c.is_private === "boolean" ? c.is_private : undefined,
+                    isExternallyShared: c.is_shared || c.is_ext_shared ? true : undefined,
+                });
             }
             cursor = result.response_metadata?.next_cursor;
         } while (cursor);
-        // Also fetch DM channels (IMs)
         cursor = undefined;
         do {
             const result = await this.webClient.conversations.list({
@@ -1347,15 +1730,12 @@ export class SlackMessagingBot {
                 cursor,
             });
             const ims = result.channels;
-            if (ims) {
-                for (const im of ims) {
-                    if (im.id) {
-                        // Use user's name as channel name for DMs
-                        const user = im.user ? this.users.get(im.user) : undefined;
-                        const name = user ? `DM:${user.userName}` : `DM:${im.id}`;
-                        this.channels.set(im.id, { id: im.id, name });
-                    }
-                }
+            for (const im of ims ?? []) {
+                if (!im.id)
+                    continue;
+                const user = im.user ? this.users.get(im.user) : undefined;
+                const name = user ? `DM:${user.userName}` : `DM:${im.id}`;
+                this.channels.set(im.id, { id: im.id, name });
             }
             cursor = result.response_metadata?.next_cursor;
         } while (cursor);