@geminixiang/mikan 1.0.0-beta.45 → 1.0.0-beta.47

package/dist/adapters/slack/bot.js

@@ -1,6 +1,5 @@
 import { SocketModeClient } from "@slack/socket-mode";
 import { WebAPIRateLimitedError, WebClient } from "@slack/web-api";
-import { readEnv } from "../../env-manifest.js";
 import { existsSync, readFileSync } from "node:fs";
 import { readFile, writeFile } from "node:fs/promises";
 import { basename, join } from "node:path";
@@ -8,12 +7,12 @@ import { createConversationEvent, createConversationMessage, } from "../../adapt
 import { createOfficeAddress } from "../../office/index.js";
 import { COMMAND_MANIFEST } from "../../commands/manifest.js";
 import { resolveConversationSettings } from "../../config.js";
-import { parseExtActionId } from "../../harness/extensions/registry.js";
 import * as log from "../../log.js";
 import { isRecord, readTextFileIfExists } from "../../utils/file-guards.js";
 import { PRODUCT_NAME, formatForceStopped } from "../../platform-messages.js";
-import { appendBotResponseLog, appendChannelLog, MessagingEventQueue, saveIncomingAttachments, withRetry, } from "../shared.js";
+import { appendBotResponseLog, appendChannelLog, MessagingEventQueue, MessagingIntakeTracker, saveIncomingAttachments, withRetry, } from "../shared.js";
 import { processMessageIntake } from "../intake.js";
+import { recordPlatformChannelKind, } from "../../workspace-projection/index.js";
 import { AssistantThreadRegistry, handleAgentContextChanged, handleAgentDmOpened, handleAssistantThreadStarted, titleAssistantThread, } from "./assistant.js";
 import { createSlackAdapters } from "./context.js";
 import { hasMaterializedChatSession, registerThreadSession, } from "../../sessions/chat-history-sync.js";
@@ -140,7 +139,9 @@ export class SlackMessagingBot {
          * instead of inheriting whatever ran before it.
          */
         this.streamStarts = new StreamStartLimiter();
+        this.stopped = false;
         this.queues = new Map();
+        this.intake = new MessagingIntakeTracker("Slack");
         this.eventsWatcher = null;
         this.handler = handler;
         this.workspace = config.workspace;
@@ -160,11 +161,14 @@ export class SlackMessagingBot {
     // 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
@@ -177,6 +181,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);
     }
@@ -559,8 +573,8 @@ export class SlackMessagingBot {
     getMessagingInfo() {
         return {
             name: "slack",
+            ...(this.teamId ? { workspaceId: this.teamId } : {}),
             trustModel: "membership",
-            bareExtensionCommands: true,
             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) => ({
@@ -581,6 +595,8 @@ export class SlackMessagingBot {
      * Returns true if enqueued, false if queue is full (max 5).
      */
     enqueueEvent(event) {
+        if (this.stopped)
+            return false;
         const conversationId = event.conversationId;
         const queue = this.getQueue(conversationId);
         if (queue.size() >= 5) {
@@ -588,7 +604,7 @@ export class SlackMessagingBot {
             return false;
         }
         log.logInfo(`Enqueueing event for ${conversationId}: ${event.text.substring(0, 50)}`);
-        queue.enqueue(async () => {
+        return queue.enqueue(async () => {
             let anchorTs;
             if (!event.thread_ts) {
                 try {
@@ -623,7 +639,7 @@ export class SlackMessagingBot {
             const runQueueKey = planSlackAdapterSession(eventForRun, {
                 initialMessageTs: eventPlan.initialMessageTs,
             }).sessionKey;
-            this.getQueue(runQueueKey).enqueue(async () => {
+            const run = async () => {
                 const slackEvent = createConversationEvent({
                     platform: "slack",
                     address: eventForRun.address,
@@ -643,9 +659,13 @@ export class SlackMessagingBot {
                     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
@@ -654,6 +674,8 @@ export class SlackMessagingBot {
         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;
@@ -672,13 +694,48 @@ export class SlackMessagingBot {
             sessionKey,
         });
     }
+    /**
+     * Slack's own conversation vocabulary for this channel, from the metadata
+     * fetchChannels() already loads. Externally shared channels report
+     * "external" regardless of privacy — platform-public within one workspace
+     * is the sharing condition, and a channel visible to another organization
+     * does not satisfy it. Unknown channels return undefined (never recorded,
+     * so the projection keeps its isolated default).
+     */
+    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;
+    }
     processSlackMessageIntake(options) {
+        const kind = this.channelKindFor(options.event.conversationId);
+        if (kind) {
+            try {
+                recordPlatformChannelKind(this.workspace.office(options.event.address), kind);
+            }
+            catch (err) {
+                // A failed snapshot must not block the message; the projection just
+                // keeps its previous (or isolated default) posture.
+                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));
             });
         };
-        processMessageIntake({
+        return processMessageIntake({
             eventBase: options.event,
             office: this.workspace.office(options.event.address),
             isAutoReplyCandidate: options.isAutoReplyCandidate,
@@ -702,22 +759,7 @@ export class SlackMessagingBot {
             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",
@@ -732,67 +774,49 @@ 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 = conversationIdOf(session.sessionKey);
-                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 },
+                            // `value` preserves the raw key; action_id is only a unique route.
+                            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 },
-                                // The raw session key travels in `value` (Slack returns it
-                                // verbatim); the action_id only routes and must be unique per
-                                // view, so it carries a sanitized copy of the key. Never
-                                // decode the key from the action_id — the `:`↔`_` rewrite is
-                                // irreversible for conversation ids that contain `_` (GitHub's
-                                // GH_owner_repo_number do, by design).
-                                action_id: `force_stop_${session.sessionKey.replace(/:/g, "_")}`,
-                                value: session.sessionKey,
-                                style: "danger",
-                            },
-                        ],
-                    });
-                }
             }
         }
-        // --- Cron jobs ---
+    }
+    appendScheduledJobs(blocks) {
         const periodicEvents = this.eventsWatcher?.getPeriodicEvents() ?? [];
         blocks.push({ type: "divider" }, {
             type: "header",
@@ -807,34 +831,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() {
+        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);
         blocks.push({ type: "divider" }, {
             type: "context",
             elements: [
@@ -843,7 +879,8 @@ export class SlackMessagingBot {
         });
         return { type: "home", blocks: blocks };
     }
-    createCommandAdapters(conversationId, userId, userName, text, ts, options = {}) {
+    createCommandAdapters(input) {
+        const { conversationId, userId, userName, text, ts, ...options } = input;
         const message = createConversationMessage({
             platform: "slack",
             conversationId,
@@ -937,9 +974,16 @@ export class SlackMessagingBot {
             ...(threadTs ? { thread_ts: threadTs } : {}),
             sessionKey,
         });
-        const context = this.createCommandAdapters(conversationId, payload.user_id, userName, commandText, eventTs, isDirectMessage
-            ? { threadTs, sessionKey }
-            : { ephemeralChannelId: conversationId, threadTs, sessionKey });
+        const context = this.createCommandAdapters({
+            conversationId,
+            userId: payload.user_id,
+            userName,
+            text: commandText,
+            ts: eventTs,
+            ...(isDirectMessage
+                ? { threadTs, sessionKey }
+                : { ephemeralChannelId: conversationId, threadTs, sessionKey }),
+        });
         return { event, context };
     }
     /**
@@ -972,31 +1016,39 @@ export class SlackMessagingBot {
         this.socketClient.on("unable_to_socket_mode_start", (err) => {
             log.logWarning("Slack socket unable_to_start", err ? String(err) : "");
         });
-        // Which events Slack actually delivers is otherwise unknowable from here:
-        // a listener that never fires looks the same whether the subscription is
-        // missing, the app needs reinstalling, or the surface never emits it at
-        // all. Off by default — this is one line per event on a busy workspace.
-        if (readEnv("SLACK_TRACE_EVENTS")) {
-            this.socketClient.on("slack_event", ({ type, body }) => {
-                const inner = body?.event;
-                log.logInfo(`Slack socket event: ${type ?? "?"}${inner?.type ? ` → ${inner.type}` : ""}${inner?.tab ? ` (tab: ${inner.tab})` : ""}`);
-            });
-        }
-        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("app_mention", (payload) => {
+            void this.intake.run(() => this.handleAppMention(payload));
+        });
+        this.socketClient.on("message", (payload) => {
+            void this.intake.run(() => this.handleMessageEvent(payload));
+        });
+        this.socketClient.on("slash_commands", (payload) => {
+            void this.intake.run(() => this.handleSlashCommand(payload));
+        });
+        this.socketClient.on("app_home_opened", (payload) => {
+            void this.intake.run(() => this.handleAppHomeOpened(payload));
+        });
         // The assistant surface's lifecycle. Both events were already subscribed
         // in the app manifest and then dropped on the floor, which is why the pane
         // opened empty and the sidebar filled with untitled conversations.
-        this.socketClient.on("assistant_thread_started", (payload) => this.handleAssistantThreadStarted(payload));
-        this.socketClient.on("assistant_thread_context_changed", (payload) => this.handleAgentContextChangedEvent(payload));
+        this.socketClient.on("assistant_thread_started", (payload) => {
+            void this.intake.run(() => this.handleAssistantThreadStarted(payload));
+        });
+        this.socketClient.on("assistant_thread_context_changed", (payload) => {
+            void this.intake.run(() => this.handleAgentContextChangedEvent(payload));
+        });
         // agent_view's spelling of the same signal.
-        this.socketClient.on("app_context_changed", (payload) => this.handleAgentContextChangedEvent(payload));
-        this.socketClient.on("block_actions", (payload) => void this.handleBlockAction(payload));
-        this.socketClient.on("interactive", (payload) => void this.handleBlockAction(payload));
+        this.socketClient.on("app_context_changed", (payload) => {
+            void this.intake.run(() => this.handleAgentContextChangedEvent(payload));
+        });
+        this.socketClient.on("block_actions", (payload) => {
+            void this.intake.run(() => this.handleBlockAction(payload));
+        });
+        this.socketClient.on("interactive", (payload) => {
+            void this.intake.run(() => this.handleBlockAction(payload));
+        });
     }
-    handleAppMention({ event, ack }) {
+    async handleAppMention({ event, ack, }) {
         const e = event;
         // Skip DMs (handled by message event)
         if (e.channel.startsWith("D")) {
@@ -1030,7 +1082,7 @@ export class SlackMessagingBot {
             ack();
             return;
         }
-        this.processSlackMessageIntake({
+        const intake = this.processSlackMessageIntake({
             event: slackEvent,
             attachmentsPromise,
             queueKey: this.resolveQueueKey(e.channel, sessionKey),
@@ -1038,50 +1090,46 @@ export class SlackMessagingBot {
             addressed: true,
         });
         ack();
-    }
-    handleMessageEvent({ event, ack }) {
-        const e = event;
-        const hasFiles = !!e.files && e.files.length > 0;
-        const hasSlackContent = !!e.text || hasFiles || !!e.blocks?.length || !!e.attachments?.length;
-        const isOwnMessagingBotMessage = (!!e.user && e.user === this.botUserId) || (!!this.botId && e.bot_id === this.botId);
-        if (isOwnMessagingBotMessage) {
+        await intake;
+    }
+    admitHumanMessage(event, ack) {
+        const hasSlackContent = !!event.text ||
+            !!event.files?.length ||
+            !!event.blocks?.length ||
+            !!event.attachments?.length;
+        const isOwnMessage = event.user === this.botUserId || (!!this.botId && event.bot_id === this.botId);
+        if (isOwnMessage) {
             ack();
-            return;
+            return false;
         }
-        // API posts made with a user token carry the posting app's bot_id/app_id
-        // alongside the human `user` — bot_id alone does not make the author a
-        // bot. Only treat the message as bot-authored when the author is not a
-        // known human user (bot users have is_bot=true; unknown authors stay on
-        // the conservative bot path so loop protection holds).
-        const authorIsKnownHuman = !!e.user && this.users.get(e.user)?.isBot === false;
-        const isExternalMessagingBotMessage = e.subtype === "bot_message" || (!!e.bot_id && !authorIsKnownHuman);
-        if (isExternalMessagingBotMessage) {
-            if (e.subtype !== undefined && e.subtype !== "bot_message" && e.subtype !== "file_share") {
-                ack();
-                return;
-            }
-            if (!hasSlackContent) {
-                ack();
-                return;
+        // User-token posts carry bot_id/app_id beside the human user. Only unknown
+        // authors and known bot users take the external-bot loop-protection path.
+        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 = event.subtype === undefined ||
+                event.subtype === "bot_message" ||
+                event.subtype === "file_share";
+            if (supportedSubtype && hasSlackContent) {
+                void this.logExternalMessagingBotMessage(event).catch((err) => {
+                    log.logWarning("Failed to log Slack bot message", String(err));
+                });
             }
-            void this.logExternalMessagingBotMessage(e).catch((err) => {
-                log.logWarning("Failed to log Slack bot message", String(err));
-            });
-            ack();
-            return;
-        }
-        if (!e.user) {
-            ack();
-            return;
-        }
-        if (e.subtype !== undefined && e.subtype !== "file_share") {
             ack();
-            return;
+            return false;
         }
-        if (!hasSlackContent) {
-            ack();
+        const isSupportedUserMessage = !!event.user &&
+            (event.subtype === undefined || event.subtype === "file_share") &&
+            hasSlackContent;
+        if (isSupportedUserMessage)
+            return true;
+        ack();
+        return false;
+    }
+    async handleMessageEvent({ event, ack, }) {
+        const e = event;
+        if (!this.admitHumanMessage(e, ack))
             return;
-        }
         // message.im normally carries channel_type "im", but fall back to the
         // D-prefix convention (used by handleAppMention and session keys) so a
         // missing channel_type cannot silently demote a DM to an auto-reply
@@ -1139,7 +1187,7 @@ export class SlackMessagingBot {
         // message ts as a thread session (`channel:ts`) instead of the persistent
         // top-level channel session.
         slackEvent.sessionKey = activeSessionKey;
-        this.processSlackMessageIntake({
+        const intake = this.processSlackMessageIntake({
             event: slackEvent,
             attachmentsPromise,
             queueKey: this.resolveQueueKey(e.channel, activeSessionKey),
@@ -1147,6 +1195,7 @@ export class SlackMessagingBot {
             addressed: isDM,
         });
         ack();
+        await intake;
     }
     async handleSlashCommand({ body, ack, }) {
         const payload = body;
@@ -1160,16 +1209,19 @@ export class SlackMessagingBot {
             return;
         if (!entry.slackRoute)
             return;
-        this.routeSlashCommand(entry.slackRoute, {
-            command,
-            text,
-            channel_id,
-            user_id,
-            user_name,
-            thread_ts,
-        }).catch((err) => {
+        try {
+            await this.routeSlashCommand(entry.slackRoute, {
+                command,
+                text,
+                channel_id,
+                user_id,
+                user_name,
+                thread_ts,
+            });
+        }
+        catch (err) {
             log.logWarning("Slack slash command error", err instanceof Error ? err.message : String(err));
-        });
+        }
     }
     handleAppHomeOpened({ event, ack }) {
         const e = event;
@@ -1242,36 +1294,6 @@ export class SlackMessagingBot {
             : undefined;
         const threadTs = container.thread_ts;
         const sessionKey = resolveSlackSessionKey(channelId, threadTs);
-        // Extension-owned actions (ext:<slug>: namespaced by api.blockkit.post)
-        // dispatch exclusively to the extension's onAction handler — no agent
-        // run, no chat-history entry. They never fall through to the model: an
-        // unconsumed namespaced action means the extension is gone, and its
-        // routing id would only confuse an agent run.
-        const extAction = parseExtActionId(action.action_id ?? "");
-        if (extAction) {
-            this.getQueue(this.resolveQueueKey(channelId, sessionKey)).enqueue(async () => {
-                const consumed = await this.handler.handleExtensionAction({
-                    address: createOfficeAddress("slack", channelId),
-                    sessionKey,
-                    conversationKind: channelId.startsWith("D") ? "direct" : "shared",
-                    slug: extAction.slug,
-                    action: {
-                        actionId: extAction.actionId,
-                        value: action.value ?? selectedOption?.value ?? selectedOption?.text?.text,
-                        selectedValues: selectedOptions?.map((option) => option.value ?? option.text?.text ?? ""),
-                        userId,
-                        userName: body.user?.username ?? body.user?.name,
-                        conversationId: channelId,
-                        messageTs: container.message_ts,
-                        threadTs,
-                    },
-                });
-                if (!consumed) {
-                    log.logWarning(`[${channelId}] Dropped extension action ${action.action_id}`, `no handler registered by extension "${extAction.slug}"`);
-                }
-            });
-            return;
-        }
         const selectedText = selectedOption?.text?.text ?? selectedOption?.value;
         const selectedTexts = selectedOptions?.map((option) => option.text?.text ?? option.value);
         const valueText = selectedTexts?.length
@@ -1607,7 +1629,12 @@ export class SlackMessagingBot {
             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 });
+                        this.channels.set(c.id, {
+                            id: c.id,
+                            name: c.name,
+                            ...(typeof c.is_private === "boolean" ? { isPrivate: c.is_private } : {}),
+                            ...(c.is_shared || c.is_ext_shared ? { isExternallyShared: true } : {}),
+                        });
                     }
                 }
             }