feat(slack): umbrella Slack UX upgrade — buttons, status, reactions, slash commands

Single Slack adapter PR pulling together the in-thread interactivity primitives
the team will need on a shared instance:

- Interactive Block Kit Approve/Reject buttons on approval gates
- Cancel button on a per-run status message edited in place as DAG nodes progress
- Lifecycle reactions on the triggering message (🔄 → ✅ / ❌)
- Native `/archon` and `/archon-workflow` slash commands (Socket Mode, no URL needed)
- `_part i/n_` annotations on long replies split across multiple messages
- Italic cost/token footer after direct-chat replies and on terminal workflow status

Approve/Reject/Cancel buttons call existing platform-agnostic operations
(approveWorkflow / rejectWorkflow / abandonWorkflow); no schema or workflow
engine changes. Authorization re-uses the existing SLACK_ALLOWED_USER_IDS
whitelist for button clicks and slash commands.

Per-user attribution in thread context is intentionally deferred to a separate
PR — it needs a user_id column on conversations/messages/workflow_runs and
orchestrator plumbing.

Author: Wirasm

packages/adapters/src/chat/slack/adapter.ts

@@ -2,12 +2,14 @@
  * Slack platform adapter using @slack/bolt with Socket Mode
  * Handles message sending with markdown block formatting for AI responses
  */
-import { App, LogLevel } from '@slack/bolt';
+import { App, LogLevel, type SlashCommand } from '@slack/bolt';
 import type { IPlatformAdapter, MessageMetadata } from '@archon/core';
+import type { TokenUsage } from '@archon/providers/types';
 import { createLogger } from '@archon/paths';
 import { isSlackUserAuthorized } from './auth';
 import { parseAllowedUserIds } from './auth';
 import { splitIntoParagraphChunks } from '../../utils/message-splitting';
+import { formatCostFooter } from './blocks';
 import type { SlackMessageEvent } from './types';
 
 /** Lazy-initialized logger (deferred so test mocks can intercept createLogger) */
@@ -19,11 +21,22 @@ function getLog(): ReturnType<typeof createLogger> {
 
 const MAX_MARKDOWN_BLOCK_LENGTH = 12000; // Slack markdown block limit
 
+/** Slack channel + message ts pair used for reactions and edits. */
+export interface SlackMessageRef {
+  channel: string;
+  ts: string;
+}
+
+/** Cap on the in-memory triggering-message map to prevent unbounded growth. */
+const MAX_TRACKED_TRIGGERS = 1000;
+
 export class SlackAdapter implements IPlatformAdapter {
   private app: App;
   private streamingMode: 'stream' | 'batch';
   private messageHandler: ((event: SlackMessageEvent) => Promise<void>) | null = null;
   private allowedUserIds: string[];
+  /** Maps conversation ID → triggering Slack message so the bridge can react / edit. */
+  private triggeringMessages = new Map<string, SlackMessageRef>();
 
   constructor(botToken: string, appToken: string, mode: 'stream' | 'batch' = 'batch') {
     this.app = new App({
@@ -48,7 +61,8 @@ export class SlackAdapter implements IPlatformAdapter {
   /**
    * Send a message to a Slack channel/thread
    * Uses markdown block for proper formatting of AI responses
-   * Automatically splits messages longer than 12000 characters
+   * Automatically splits messages longer than 12000 characters and footers each
+   * chunk with `_part i/n_` so users know the output was wrapped.
    */
   async sendMessage(
     channelId: string,
@@ -63,16 +77,20 @@ export class SlackAdapter implements IPlatformAdapter {
       : [channelId, undefined];
 
     if (message.length <= MAX_MARKDOWN_BLOCK_LENGTH) {
-      // Use markdown block for proper formatting
       await this.sendWithMarkdownBlock(channel, message, threadTs);
-    } else {
-      // Long message: split by paragraphs
-      getLog().debug({ messageLength: message.length }, 'slack.message_splitting');
-      const chunks = splitIntoParagraphChunks(message, MAX_MARKDOWN_BLOCK_LENGTH - 500);
+      return;
+    }
 
-      for (const chunk of chunks) {
-        await this.sendWithMarkdownBlock(channel, chunk, threadTs);
-      }
+    getLog().debug({ messageLength: message.length }, 'slack.message_splitting');
+    // Reserve headroom for the trailing "_part i/n_" footer. The longest footer
+    // appears on the largest split (e.g. 7 chunks → "_part 7/7_") and is well
+    // under 32 chars, so a 64-char reserve is comfortable.
+    const chunks = splitIntoParagraphChunks(message, MAX_MARKDOWN_BLOCK_LENGTH - 500 - 64);
+    const total = chunks.length;
+    for (let i = 0; i < total; i++) {
+      const body = chunks[i] ?? '';
+      const annotated = total > 1 ? `${body}\n\n_part ${i + 1}/${total}_` : body;
+      await this.sendWithMarkdownBlock(channel, annotated, threadTs);
     }
   }
 
@@ -111,6 +129,40 @@ export class SlackAdapter implements IPlatformAdapter {
     }
   }
 
+  /**
+   * Append a small italic cost / token footer after a direct-chat assistant
+   * turn. Posted as a context block so it visually de-emphasises vs the
+   * assistant reply. No-op when there's nothing meaningful to surface.
+   */
+  async sendResultFooter(
+    conversationId: string,
+    info: { cost?: number; tokens?: TokenUsage; stopReason?: string }
+  ): Promise<void> {
+    const text = formatCostFooter(info);
+    if (!text) return;
+
+    const [channel, threadTs] = conversationId.includes(':')
+      ? conversationId.split(':')
+      : [conversationId, undefined];
+
+    try {
+      await this.app.client.chat.postMessage({
+        channel,
+        thread_ts: threadTs,
+        text,
+        blocks: [
+          {
+            type: 'context',
+            elements: [{ type: 'mrkdwn', text }],
+          },
+        ],
+      });
+    } catch (error) {
+      // Cost footer is informational only — never let it fail the conversation.
+      getLog().warn({ err: error as Error, channel }, 'slack.result_footer_failed');
+    }
+  }
+
   /**
    * Get the Bolt App instance
    */
@@ -132,6 +184,37 @@ export class SlackAdapter implements IPlatformAdapter {
     return 'slack';
   }
 
+  /**
+   * Returns the channel/ts of the inbound user message that triggered the
+   * given conversation, if we have it. Workflow bridge uses this to add
+   * lifecycle reactions to the user's mention/DM.
+   */
+  getTriggeringMessage(conversationId: string): SlackMessageRef | undefined {
+    return this.triggeringMessages.get(conversationId);
+  }
+
+  /** Drop the cached triggering message for a conversation (e.g. on workflow terminal). */
+  clearTriggeringMessage(conversationId: string): void {
+    this.triggeringMessages.delete(conversationId);
+  }
+
+  /** Test seam: expose the configured whitelist to the workflow bridge. */
+  getAllowedUserIds(): string[] {
+    return this.allowedUserIds;
+  }
+
+  private trackTrigger(conversationId: string, ref: SlackMessageRef): void {
+    // Defensive cap so chat-only conversations that never run a workflow
+    // can't grow the map without bound.
+    if (this.triggeringMessages.size >= MAX_TRACKED_TRIGGERS) {
+      const oldest = this.triggeringMessages.keys().next().value;
+      if (oldest !== undefined) {
+        this.triggeringMessages.delete(oldest);
+      }
+    }
+    this.triggeringMessages.set(conversationId, ref);
+  }
+
   /**
    * Check if a message is in a thread
    */
@@ -260,6 +343,10 @@ export class SlackAdapter implements IPlatformAdapter {
           ts: event.ts,
           thread_ts: event.thread_ts,
         };
+        this.trackTrigger(this.getConversationId(messageEvent), {
+          channel: event.channel,
+          ts: event.ts,
+        });
         // Fire-and-forget - errors handled by caller
         void this.messageHandler(messageEvent);
       }
@@ -296,14 +383,130 @@ export class SlackAdapter implements IPlatformAdapter {
           ts: event.ts,
           thread_ts: 'thread_ts' in event ? event.thread_ts : undefined,
         };
+        this.trackTrigger(this.getConversationId(messageEvent), {
+          channel: event.channel,
+          ts: event.ts,
+        });
         void this.messageHandler(messageEvent);
       }
     });
 
+    // Slash commands: /archon (general) and /archon-workflow (workflow control)
+    this.app.command('/archon', async ({ command, ack, respond, client }) => {
+      await ack();
+      await this.handleSlashCommand(command, respond, client, 'archon');
+    });
+    this.app.command('/archon-workflow', async ({ command, ack, respond, client }) => {
+      await ack();
+      await this.handleSlashCommand(command, respond, client, 'archon-workflow');
+    });
+
     await this.app.start();
     getLog().info('slack.bot_started');
   }
 
+  /**
+   * Forward a slash command into the same message-handling flow used by
+   * @mention. Slash commands carry no message ts of their own, so we first
+   * post a visible "seed" message in the channel — its ts becomes the thread
+   * root for everything that follows, giving slash-driven runs the same
+   * threading model as @mention runs.
+   */
+  private async handleSlashCommand(
+    command: SlashCommand,
+    respond: (msg: { response_type: 'ephemeral' | 'in_channel'; text: string }) => Promise<unknown>,
+    client: App['client'],
+    kind: 'archon' | 'archon-workflow'
+  ): Promise<void> {
+    const actorId = command.user_id;
+    if (!isSlackUserAuthorized(actorId, this.allowedUserIds)) {
+      getLog().info(
+        { maskedUserId: `${actorId.slice(0, 4)}***`, kind },
+        'slack.slash_unauthorized'
+      );
+      await respond({
+        response_type: 'ephemeral',
+        text: 'Sorry — you are not on the allowed user list for this Archon instance.',
+      });
+      return;
+    }
+
+    if (!this.messageHandler) {
+      await respond({
+        response_type: 'ephemeral',
+        text: 'Archon is starting up — try again in a moment.',
+      });
+      return;
+    }
+
+    const raw = (command.text ?? '').trim();
+    if (!raw) {
+      const help =
+        kind === 'archon-workflow'
+          ? 'Usage: `/archon-workflow <subcommand>` — e.g. `list`, `status`, `run <name> <args>`, `approve <id>`, `reject <id> <reason>`, `abandon <id>`.'
+          : 'Usage: `/archon <message>` — talk to Archon in this channel.';
+      await respond({ response_type: 'ephemeral', text: help });
+      return;
+    }
+
+    const messageText = kind === 'archon-workflow' ? `/workflow ${raw}` : raw;
+
+    // Post a visible seed message so the bot's responses thread cleanly under
+    // a parent. The seed quotes the invoking user and the command they ran,
+    // mirroring how @mention surfaces the original message in the thread.
+    let seedTs: string | undefined;
+    try {
+      const seedText =
+        kind === 'archon-workflow'
+          ? `<@${actorId}> ran \`/archon-workflow ${raw}\``
+          : `<@${actorId}> via /archon: ${raw}`;
+      const posted = await client.chat.postMessage({
+        channel: command.channel_id,
+        text: seedText,
+      });
+      seedTs = posted.ts ?? undefined;
+    } catch (error) {
+      getLog().warn(
+        { err: error as Error, channel: command.channel_id, kind },
+        'slack.slash_seed_post_failed'
+      );
+      await respond({
+        response_type: 'ephemeral',
+        text: 'Could not post in this channel — is the bot invited here?',
+      });
+      return;
+    }
+
+    if (!seedTs) {
+      await respond({
+        response_type: 'ephemeral',
+        text: 'Could not start the conversation (Slack returned no message id).',
+      });
+      return;
+    }
+
+    const messageEvent: SlackMessageEvent = {
+      text: messageText,
+      user: actorId,
+      channel: command.channel_id,
+      ts: seedTs,
+    };
+    this.trackTrigger(this.getConversationId(messageEvent), {
+      channel: command.channel_id,
+      ts: seedTs,
+    });
+
+    await respond({
+      response_type: 'ephemeral',
+      text:
+        kind === 'archon-workflow'
+          ? `Running \`/workflow ${raw}\` — see thread for output.`
+          : `Running \`${raw}\` — see thread for output.`,
+    });
+
+    void this.messageHandler(messageEvent);
+  }
+
   /**
    * Stop the bot gracefully
    */