@geminixiang/mikan 1.0.0-beta.76 → 1.0.0-beta.78

package/dist/adapters/slack/bot.js

@@ -38,13 +38,7 @@ function hasBotIdentity(message) {
 }
 const USER_MESSAGE_SUBTYPES = new Set([undefined, "file_share"]);
 const BOT_MESSAGE_SUBTYPES = new Set([...USER_MESSAGE_SUBTYPES, "bot_message"]);
-/**
- * Slack's per-call limit on `markdown_text`: "Limit this field to 12,000
- * characters." mikan allows far more in a message, so streamed text is split
- * to fit rather than truncated.
- */
 const MAX_STREAM_TEXT_CHARS = 12_000;
-/** Slices `text` into pieces that each fit one streaming call. */
 export function chunkStreamText(text, limit = MAX_STREAM_TEXT_CHARS) {
     if (text.length <= limit)
         return [text];
@@ -54,8 +48,6 @@ export function chunkStreamText(text, limit = MAX_STREAM_TEXT_CHARS) {
     }
     return chunks;
 }
-// web-api v8 throws WebAPIRateLimitedError; the duck-typed shapes cover
-// platform `data.error === "rate_limited"` / 429 responses and older callers.
 function slackIsRateLimited(err) {
     if (err instanceof WebAPIRateLimitedError)
         return true;
@@ -97,23 +89,13 @@ function buildSlackAppMessageText(event) {
     const deduped = parts.filter((part, index) => parts.indexOf(part) === index);
     return deduped.join("\n");
 }
-// ---------------------------------------------------------------------------
-// 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);
@@ -126,7 +108,6 @@ function isRetryableAttachmentDownloadError(error) {
     return error.status === 408 || error.status === 429 || error.status >= 500;
 }
 export class SlackMessagingBot {
-    /** Host office dir for a Slack conversation. */
     conversationDir(channelId) {
         return this.workspace.office(createOfficeAddress("slack", channelId)).dir;
     }
@@ -222,17 +203,10 @@ export class SlackMessagingBot {
         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();
-        /** Which threads belong to the assistant pane, and their last known context. */
         this.assistantThreads = new AssistantThreadRegistry();
-        /**
-         * Native response streams opened recently. Per bot rather than per module:
-         * the rate tier applies per workspace, and this bot is the connection to
-         * one — which also means a test constructing a bot gets a fresh budget
-         * instead of inheriting whatever ran before it.
-         */
         this.streamStarts = new StreamStartLimiter();
         this.stopped = false;
         this.queues = new Map();
@@ -243,8 +217,6 @@ export class SlackMessagingBot {
         this.botToken = config.botToken;
         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.webClient = new WebClient(config.botToken);
@@ -257,9 +229,6 @@ export class SlackMessagingBot {
     setEventScheduler(scheduler) {
         this.eventScheduler = scheduler;
     }
-    // ==========================================================================
-    // Public API
-    // ==========================================================================
     async start() {
         this.stopped = false;
         const auth = await this.webClient.auth.test();
@@ -271,9 +240,6 @@ export class SlackMessagingBot {
             return;
         log.logInfo(`Loaded ${this.channels.size} channels, ${this.users.size} users`);
         this.backfillChannelKinds();
-        // 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.startupTs = (Date.now() / 1000).toFixed(6);
         this.setupEventHandlers();
         await this.socketClient.start();
@@ -313,11 +279,6 @@ export class SlackMessagingBot {
         }
         return source.replace(this.ownMentionRegex, "").trim();
     }
-    /**
-     * Response-source `<@userName>` mentions become native `<@U…>` here — the
-     * one conversion every outgoing response path funnels through. Slack only
-     * links and notifies on raw user ids.
-     */
     resolveMentions(text) {
         return resolveSlackMentions(text, this.users.values());
     }
@@ -334,14 +295,12 @@ export class SlackMessagingBot {
         });
     }
     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;
@@ -399,13 +358,6 @@ export class SlackMessagingBot {
             return channelId;
         });
     }
-    /**
-     * Fetch recent messages from a channel, oldest first. Without `threadTs`
-     * this is one `conversations.history` page of top-level messages (thread
-     * replies are not expanded); with it, one `conversations.replies` page of
-     * that thread's replies, excluding the parent. Callers page forward by
-     * passing the last returned `ts` as `oldest`.
-     */
     async fetchHistory(channel, options) {
         const limit = Math.min(Math.max(options?.limit ?? 200, 1), 999);
         const threadTs = options?.threadTs;
@@ -425,9 +377,6 @@ export class SlackMessagingBot {
             const messages = (result.messages ?? []);
             const mapped = messages
                 .filter((msg) => !!msg.ts)
-                // conversations.replies leads with the thread parent; the caller asked
-                // for the replies to it, and including it would re-ingest the bot's
-                // own message on every poll.
                 .filter((msg) => msg.ts !== threadTs)
                 .map((msg) => {
                 const user = msg.user ? this.users.get(msg.user) : undefined;
@@ -444,12 +393,9 @@ export class SlackMessagingBot {
                     message.userName = user.userName;
                 return message;
             });
-            // history returns newest-first, replies oldest-first; the contract is
-            // oldest-first either way.
             return threadTs ? mapped : mapped.toReversed();
         });
     }
-    /** Refresh and list the workspace's active users (`users.list`). */
     async listUsers() {
         await slackRetry(() => this.fetchUsers());
         return this.getAllUsers().map((user) => ({
@@ -472,28 +418,9 @@ export class SlackMessagingBot {
             recordSlackUpdate(this, { channel, ts }, text, payload, { success: true });
         });
     }
-    /**
-     * Claim one native stream, or decline. Declining is not an error: the caller
-     * falls back to edit-based updates, which is a working answer rather than a
-     * degraded one, and costs no request against the tighter start tier.
-     */
     tryReserveStreamStart() {
         return this.streamStarts.tryReserve();
     }
-    /**
-     * Open a stream, carrying text of any length.
-     *
-     * Slack caps `markdown_text` at 12,000 characters per call, and a long first
-     * render exceeds that easily — mikan allows 35,000 in a message. Rather than
-     * truncating (losing the answer) or failing (falling back to edit mode for
-     * the whole response), the opening call takes the first slice and the rest
-     * follows as appends before this resolves. The caller sees one operation
-     * that sent everything, so the renderer's idea of what has been streamed
-     * stays true.
-     *
-     * Splitting mid-word or mid-fence is harmless here: a stream concatenates,
-     * so Slack renders the reassembled text, not the pieces.
-     */
     async startMessageStream(channel, text, threadTs, recipientUserId) {
         const [head, ...tail] = chunkStreamText(text);
         const ts = await slackRetry(async () => {
@@ -513,7 +440,6 @@ export class SlackMessagingBot {
             await this.appendStreamChunk(channel, ts, part);
         return ts;
     }
-    /** Append a delta of any length, split to the per-call cap. */
     async appendMessageStream(channel, ts, text) {
         for (const part of chunkStreamText(text)) {
             await this.appendStreamChunk(channel, ts, part);
@@ -524,8 +450,6 @@ export class SlackMessagingBot {
             await this.webClient.apiCall("chat.appendStream", {
                 channel,
                 ts,
-                // A mention split across stream deltas stays unresolved here; the
-                // canonical final render (updateMessage) resolves the full text.
                 markdown_text: this.resolveMentions(text),
             });
         });
@@ -540,10 +464,6 @@ 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) {
         const key = `${channel}:${threadTs}`;
         const previous = this.statusUpdates.get(key) ?? Promise.resolve();
@@ -565,11 +485,8 @@ export class SlackMessagingBot {
                 this.statusUpdates.delete(key);
         }
     }
-    /** Offer starting points in a new assistant thread. */
     async setAssistantSuggestedPrompts(channel, threadTs, prompts) {
         return slackRetry(async () => {
-            // Omitting thread_ts pins the prompts to the DM itself, which is what
-            // the agent surface wants: there is no thread yet when it opens.
             await this.webClient.assistant.threads.setSuggestedPrompts({
                 channel_id: channel,
                 ...(threadTs ? { thread_ts: threadTs } : {}),
@@ -577,7 +494,6 @@ export class SlackMessagingBot {
             });
         });
     }
-    /** Name an assistant thread, which is what the sidebar conversation list shows. */
     async setAssistantTitle(channel, threadTs, title) {
         return slackRetry(async () => {
             await this.webClient.assistant.threads.setTitle({
@@ -587,7 +503,6 @@ export class SlackMessagingBot {
             });
         });
     }
-    /** The assistant surface's view of this bot, handed to the lifecycle handlers. */
     assistantOps() {
         return {
             postInThread: (channel, threadTs, text) => this.postInThread(channel, threadTs, text),
@@ -596,10 +511,6 @@ export class SlackMessagingBot {
             channelName: (channelId) => this.channels.get(channelId)?.name,
         };
     }
-    /**
-     * A new conversation opened in the assistant pane. Slack waits for the app
-     * to speak first here; staying silent is what makes the pane look broken.
-     */
     handleAssistantThreadStarted({ event, ack }) {
         ack();
         const payload = event;
@@ -607,12 +518,6 @@ export class SlackMessagingBot {
             return;
         void handleAssistantThreadStarted(this.assistantOps(), this.assistantThreads, payload.assistant_thread);
     }
-    /**
-     * The person navigated to another channel while the pane is open. Slack
-     * sends this as `assistant_thread_context_changed` under `assistant_view`
-     * and `app_context_changed` under `agent_view`; the payload differs enough
-     * to normalize here rather than in the handler.
-     */
     handleAgentContextChangedEvent({ event, ack, }) {
         ack();
         const payload = event;
@@ -695,17 +600,10 @@ 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) {
         if (this.stopped)
             return false;
-        const conversationId = event.conversationId;
+        const conversationId = event.address.conversationId;
         const queue = this.getQueue(conversationId);
         if (queue.size() >= 5) {
             log.logWarning(`Event queue full for ${conversationId}, discarding: ${event.text.substring(0, 50)}`);
@@ -775,9 +673,6 @@ export class SlackMessagingBot {
             }
         });
     }
-    // ==========================================================================
-    // Private - Event Handlers
-    // ==========================================================================
     getQueue(channelId) {
         let queue = this.queues.get(channelId);
         if (!queue) {
@@ -815,14 +710,6 @@ 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";
@@ -839,13 +726,6 @@ export class SlackMessagingBot {
             return "public_channel";
         return undefined;
     }
-    /**
-     * Office visibility follows the recorded channel kind, and an unrecorded
-     * kind fails closed to private (ADR 0008). Offices created before kinds
-     * were recorded would therefore lose public status until their next
-     * message; the channel list loaded at startup already knows every kind, so
-     * record it for all registered Slack offices now. Metadata only.
-     */
     backfillChannelKinds() {
         let recorded = 0;
         for (const record of listRegisteredOffices(this.workspace.stateDir)) {
@@ -869,14 +749,12 @@ export class SlackMessagingBot {
             log.logInfo(`Recorded channel kind for ${recorded} Slack offices`);
     }
     processSlackMessageIntake(options) {
-        const kind = this.channelKindFor(options.event.conversationId);
+        const kind = this.channelKindFor(options.event.address.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));
             }
         }
@@ -902,8 +780,6 @@ export class SlackMessagingBot {
             createContext: (event) => this.createContext(event),
             deferAttachmentsUntilRun: true,
         }).then((outcome) => {
-            // Slack logs eagerly via logUserMessage; when intake does not enqueue,
-            // nothing awaits the attachment download, so absorb its failure here.
             if (outcome !== "enqueued")
                 absorbAttachmentFailure();
         }, (err) => {
@@ -958,7 +834,6 @@ export class SlackMessagingBot {
                         {
                             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",
@@ -968,10 +843,6 @@ export class SlackMessagingBot {
             }
         }
     }
-    /**
-     * Scheduled jobs of the opener's own DM office only: the App Home is a
-     * personal surface, so other offices' schedules are not listed here.
-     */
     appendScheduledJobs(blocks, dmChannelId) {
         const periodicEvents = dmChannelId && this.eventScheduler
             ? this.eventScheduler.periodicEvents(createOfficeAddress("slack", dmChannelId))
@@ -1043,9 +914,6 @@ export class SlackMessagingBot {
             platform: "slack",
             conversationId,
             id: ts,
-            // One session identity per dispatch: the caller's thread-resolved key.
-            // Defaulting to the top-level conversation here while the event carried
-            // a thread key made the same run answer to two different sessions.
             sessionKey: options.sessionKey ?? conversationId,
             conversationKind: options.ephemeralChannelId ? "shared" : "direct",
             userId,
@@ -1137,12 +1005,6 @@ export class SlackMessagingBot {
         });
         return { event, context };
     }
-    /**
-     * Generic slash-command route: synthesize the command text per the
-     * manifest's SlackSlashRoute data and dispatch to the handler. Every
-     * routed command — including `/pi-new` — reaches its CommandHandler
-     * through runtime dispatch; the adapter holds no per-command behavior.
-     */
     async routeSlashCommand(route, payload) {
         const { event, context } = this.buildSlashCommandEvent(payload, {
             includeText: route.includeText,
@@ -1179,16 +1041,12 @@ export class SlackMessagingBot {
         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) => {
             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) => {
             void this.intake.run(() => this.handleAgentContextChangedEvent(payload));
         });
@@ -1201,13 +1059,10 @@ export class SlackMessagingBot {
     }
     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).
         const sessionKey = resolveSlackSessionKey(e.channel, e.thread_ts);
         const mentionText = this.stripOwnMention(e.text);
         const slackEvent = createConversationEvent({
@@ -1224,7 +1079,6 @@ export class SlackMessagingBot {
             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) => {
@@ -1249,8 +1103,6 @@ export class SlackMessagingBot {
             ack();
             return false;
         }
-        // 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) {
@@ -1269,13 +1121,6 @@ export class SlackMessagingBot {
         ack();
         return false;
     }
-    /**
-     * Handle a DM message that may be about a background task without spending
-     * a model turn: a pure status question is answered from observation, and a
-     * supplement is steered into the running task. Jev decides which (falling
-     * back to the regex status shortcut); anything else returns false so the
-     * message becomes an ordinary conversation turn.
-     */
     async deliverTaskUpdate(event, attachmentsPromise) {
         if (matchMagicWord(event.text) === "stop" || event.text.startsWith("/"))
             return false;
@@ -1290,8 +1135,6 @@ export class SlackMessagingBot {
                 return false;
             const active = tasks.filter((t) => t.status === "running" || t.status === "stopping");
             const user = this.users.get(event.user);
-            // A message carrying files is never a pure status question; in a task
-            // thread it is a supplement, at top level an ordinary turn.
             const intent = event.attachments?.length
                 ? event.thread_ts
                     ? "steer"
@@ -1312,8 +1155,6 @@ export class SlackMessagingBot {
                 return true;
             }
             if (intent === "steer") {
-                // In a thread the message already targets that task; at top level it
-                // can only be steered when exactly one task is running.
                 const target = event.thread_ts
                     ? context.message
                     : active.length === 1
@@ -1337,17 +1178,6 @@ export class SlackMessagingBot {
         }
         return false;
     }
-    /**
-     * Ask Jev a single typed yes/no question about whether this unaddressed
-     * shared-channel message (top-level or thread reply) addresses mikan. The
-     * scored state carries the surrounding scope from log.jsonl, since a bare
-     * thread reply cannot be judged from its own text. Only called in `jev`
-     * auto-reply mode, and only awaited by the caller in that mode, so
-     * `on`/`off` stay synchronous (magic-word `stop` handling depends on that).
-     * Any failure (including a missing `OPENROUTER_API_KEY`) fails closed to
-     * "not addressed" so a misconfiguration cannot make the bot noisy in a
-     * shared channel.
-     */
     async evaluateJevAddressed(event) {
         if (!event.text.trim() || matchMagicWord(event.text) === "stop")
             return false;
@@ -1373,7 +1203,7 @@ export class SlackMessagingBot {
                 surface: "slack_auto_reply_jev",
                 operation: "evaluate",
                 severity: "warning",
-                context: { conversationId: event.conversationId },
+                context: { conversationId: event.address.conversationId },
             });
             return false;
         }
@@ -1382,22 +1212,14 @@ export class SlackMessagingBot {
         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 classify a DM as an unaddressed
-        // channel message that never triggers.
         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 sessionKey = isDM ? resolveSlackSessionKey(e.channel, e.thread_ts) : undefined;
-        // Name the conversation from the first thing the person said. Guarded on
-        // the assistant registry, so classic DM threads are untouched, and it
-        // claims the title once per thread.
         if (isDM && e.thread_ts && e.text) {
             void titleAssistantThread(this.assistantOps(), this.assistantThreads, e.channel, e.thread_ts, this.stripOwnMention(e.text));
         }
@@ -1415,7 +1237,6 @@ export class SlackMessagingBot {
             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) => {
@@ -1426,10 +1247,6 @@ export class SlackMessagingBot {
         }
         const activeSessionKey = slackEvent.sessionKey ?? resolveSlackSessionKey(e.channel, e.thread_ts);
         slackEvent.sessionKey = activeSessionKey;
-        // Task threads always go through the task gate. Top-level DMs do only
-        // while a task is running (so supplements can be steered) or when the
-        // regex already recognises a status question about a finished one, so
-        // idle DMs never pay a Jev round-trip.
         const taskControl = isDM &&
             (e.thread_ts
                 ? this.isTaskThread(e.channel, e.thread_ts)
@@ -1439,9 +1256,6 @@ export class SlackMessagingBot {
             if (await this.deliverTaskUpdate(slackEvent, attachmentsPromise))
                 return;
         }
-        // Shared-channel messages without a mention, top-level or in a thread,
-        // all go through the same auto-reply gate; jev mode sees the surrounding
-        // scope so thread follow-ups are judged in context rather than dropped.
         const autoReplyMode = isDM
             ? "off"
             : slackConversationAutoReplyMode(this.workspace.office(slackEvent.address));
@@ -1490,10 +1304,6 @@ export class SlackMessagingBot {
     handleAppHomeOpened({ event, ack }) {
         const e = event;
         ack();
-        // Under agent_view this is how Slack says "the person opened the app's
-        // DM" — the signal assistant_thread_started used to carry. It fires on
-        // every open, not once per conversation, so this path refreshes the
-        // pinned prompts and deliberately does not greet.
         if (e.tab === "messages") {
             if (e.channel) {
                 void handleAgentDmOpened(this.assistantOps(), this.assistantThreads, e.channel, e.context);
@@ -1523,18 +1333,12 @@ export class SlackMessagingBot {
             return;
         }
         ack();
-        // Prefer the verbatim key from `value`; the action_id fallback only
-        // serves buttons rendered before `value` existed and misdecodes session
-        // keys whose conversation id contains "_".
         const sessionKey = action.value ?? action.action_id.replace("force_stop_", "").replace(/_/g, ":");
         const userId = body.user?.id;
         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(createOfficeAddress("slack", channelId), sessionKey);
-        // Notify in channel
         await this.postMessage(channelId, formatForceStopped("slack", userId ?? "unknown"));
-        // Refresh home tab
         if (userId) {
             this.openDirectConversation(userId)
                 .then((dmChannelId) => this.webClient.views.publish({
@@ -1623,11 +1427,6 @@ export class SlackMessagingBot {
             return this.handler.handleEvent(event, this, this.createContext(slackEvent));
         });
     }
-    /**
-     * Download Slack message files into the office's attachments directory.
-     * The Slack contract is all-or-error: any failed download throws after the
-     * successful ones are on disk, so callers still log the message text.
-     */
     async processAttachments(channelId, files, timestamp) {
         const items = [];
         for (const file of files) {
@@ -1639,7 +1438,6 @@ export class SlackMessagingBot {
             }
             items.push({
                 name: file.name,
-                // Slack timestamps are float seconds; the stored filename uses ms.
                 timestampMs: Math.floor(parseFloat(timestamp) * 1000),
                 download: (destPath) => this.downloadSlackFile(url, destPath),
             });
@@ -1654,7 +1452,6 @@ export class SlackMessagingBot {
         }
         return saved;
     }
-    /** Authorized download with retry; Slack file URLs require the bot token. */
     async downloadSlackFile(url, destPath) {
         await withRetry(async () => {
             const response = await fetch(url, {
@@ -1667,9 +1464,6 @@ export class SlackMessagingBot {
             await writeFile(destPath, Buffer.from(buffer));
         }, { maxAttempts: 3, baseDelayMs: 250, isRateLimited: isRetryableAttachmentDownloadError });
     }
-    /**
-     * Log a user message to log.jsonl after attachments are ready.
-     */
     async logUserMessage(event) {
         const user = this.users.get(event.user);
         let attachments = [];
@@ -1682,8 +1476,6 @@ export class SlackMessagingBot {
                 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,
@@ -1720,9 +1512,6 @@ export class SlackMessagingBot {
         });
         return attachments;
     }
-    // ==========================================================================
-    // Private - Backfill
-    // ==========================================================================
     async getExistingTimestamps(channelId) {
         const logPath = join(this.conversationDir(channelId), "log.jsonl");
         const timestamps = new Set();
@@ -1750,14 +1539,12 @@ export class SlackMessagingBot {
                 return false;
             return BOT_MESSAGE_SUBTYPES.has(message.subtype) && hasMessageContent(message);
         }
-        // Unlike live intake, historical human posts need text or files, not just blocks.
         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))
@@ -1770,8 +1557,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,
@@ -1782,15 +1569,12 @@ 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
+                return false;
             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 && hasBotIdentity(msg);
@@ -1819,7 +1603,6 @@ 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.conversationDir(channelId), "log.jsonl");
@@ -1839,7 +1622,6 @@ 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]) {
                 await new Promise((resolve) => setTimeout(resolve, 500));
             }
@@ -1847,9 +1629,6 @@ export class SlackMessagingBot {
         const durationMs = Date.now() - startTime;
         log.logBackfillComplete(totalMessages, durationMs);
     }
-    // ==========================================================================
-    // Private - Fetch Users/Channels
-    // ==========================================================================
     async fetchUsers() {
         let cursor;
         do {
@@ -1869,7 +1648,6 @@ export class SlackMessagingBot {
         } while (cursor);
     }
     async fetchChannels() {
-        // Fetch public/private channels
         let cursor;
         do {
             const result = await this.webClient.conversations.list({
@@ -1891,7 +1669,6 @@ export class SlackMessagingBot {
             }
             cursor = result.response_metadata?.next_cursor;
         } while (cursor);
-        // Also fetch DM channels (IMs)
         cursor = undefined;
         do {
             const result = await this.webClient.conversations.list({
@@ -1903,7 +1680,6 @@ export class SlackMessagingBot {
             for (const im of ims ?? []) {
                 if (!im.id)
                     continue;
-                // 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 });