@jungjaehoon/mama-os 0.53.1 → 0.58.0

package/dist/gateways/slack.js

@@ -1,507 +1,349 @@
 "use strict";
-/**
- * Slack Gateway for MAMA Standalone
- *
- * Provides Slack integration using Socket Mode for receiving and responding to messages.
- * Supports both DM and channel mentions with thread context preservation.
- */
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.SlackGateway = void 0;
+const node_crypto_1 = require("node:crypto");
+const node_fs_1 = require("node:fs");
+const node_path_1 = require("node:path");
 const socket_mode_1 = require("@slack/socket-mode");
 const web_api_1 = require("@slack/web-api");
-const message_splitter_js_1 = require("./message-splitter.js");
 const base_gateway_js_1 = require("./base-gateway.js");
-const attachment_utils_js_1 = require("./attachment-utils.js");
-const channel_history_js_1 = require("./channel-history.js");
-const log_sanitizer_js_1 = require("../utils/log-sanitizer.js");
-const tool_status_tracker_js_1 = require("./tool-status-tracker.js");
-const config_manager_js_1 = require("../cli/config/config-manager.js");
-const principal_js_1 = require("./principal.js");
-/**
- * Slack Gateway class
- *
- * Connects to Slack via Socket Mode and routes messages
- * to the MessageRouter for processing.
- */
+const telegram_message_ledger_js_1 = require("./telegram-message-ledger.js");
+const message_splitter_js_1 = require("./message-splitter.js");
+const file_delivery_js_1 = require("../api/file-delivery.js");
+const attachment_io_js_1 = require("../connectors/framework/attachment-io.js");
+const attachment_actions_js_1 = require("../api/attachment-actions.js");
+/** Owner-only Slack Socket Mode transport. */
 class SlackGateway extends base_gateway_js_1.BaseGateway {
+    options;
     source = 'slack';
-    principalResolver;
-    socketClient;
-    webClient;
-    config;
-    teamId;
-    ownerWarningLogged = false;
-    missingTeamIdWarningLogged = false;
-    // Multi-agent support
-    botToken;
-    // Dedup: prevent double processing from app_mention + message events
-    processedMessages = new Map();
-    static get DEDUP_TTL_MS() {
-        return (0, config_manager_js_1.getConfig)().gateway_tuning?.dedup_ttl_ms ?? 30_000;
-    }
-    // Safe logger instance
-    logger = (0, log_sanitizer_js_1.createSafeLogger)('SlackGateway');
-    get mentionPattern() {
-        return null; // Slack uses custom cleanMessageContent with multiple patterns
-    }
+    socket;
+    api;
+    ledger;
+    log;
+    activeInputs = new Set();
+    deliveryTails = new Map();
     constructor(options) {
-        super({ turnProcessor: options.turnProcessor });
-        this.botToken = options.botToken;
-        this.principalResolver = options.principalResolver;
-        this.config = {
-            enabled: true,
-            botToken: options.botToken,
-            appToken: options.appToken,
-            channels: options.config?.channels || {},
-            ownerUserId: options.ownerUserId,
-        };
-        // Create Socket Mode client for real-time events
-        this.socketClient = new socket_mode_1.SocketModeClient({
-            appToken: options.appToken,
-            serverPingTimeout: 30000,
-            clientPingTimeout: 30000,
-        });
-        // Create Web client for API calls
-        this.webClient = new web_api_1.WebClient(options.botToken);
-        // Multi-agent handler construction was here. Gated on `multi_agent.enabled`, false on
-        // this install, with zero handler traces in the entire log history.
-        this.setupEventListeners();
-    }
-    /**
-     * Set up Socket Mode event listeners
-     */
-    setupEventListeners() {
-        // Connection events
-        this.socketClient.on('connected', async () => {
-            this.logger.log('Gateway connected via Socket Mode');
+        super({ intake: options.intake });
+        this.options = options;
+        this.log = options.log ?? console.log;
+        this.socket = new socket_mode_1.SocketModeClient({ appToken: options.appToken });
+        this.api = new web_api_1.WebClient(options.token);
+        this.ledger =
+            options.messageLedger ?? new telegram_message_ledger_js_1.OwnerMessageLedger(options.messageLedgerPath, { log: this.log });
+        this.socket.on('connected', () => {
             this.connected = true;
-            this.emitEvent({
-                type: 'connected',
-                source: 'slack',
-                timestamp: new Date(),
-            });
+            this.emitEvent({ type: 'connected', source: this.source, timestamp: new Date() });
         });
-        this.socketClient.on('disconnected', () => {
+        this.socket.on('disconnected', () => {
             this.connected = false;
-            this.emitEvent({
-                type: 'disconnected',
-                source: 'slack',
-                timestamp: new Date(),
-            });
+            this.emitEvent({ type: 'disconnected', source: this.source, timestamp: new Date() });
         });
-        // Direct message events
-        this.socketClient.on('message', async ({ event, ack }) => {
+        this.socket.on('message', async ({ event, ack }) => {
             try {
+                await this.accept(event);
                 await ack();
-                // file_share subtype only arrives via 'message' event (not app_mention),
-                // so detect mention from text to avoid shouldRespond rejecting it
-                const slackEvent = event;
-                const hasMentionInText = !!slackEvent.text?.match(/<@[UW]\w+>/);
-                await this.handleMessage(slackEvent, hasMentionInText);
             }
             catch (error) {
-                const errMsg = error instanceof Error ? error.message : String(error);
-                this.logger.error('Error handling Slack message:', errMsg);
                 this.emitEvent({
                     type: 'error',
-                    source: 'slack',
+                    source: this.source,
                     timestamp: new Date(),
-                    error: error instanceof Error ? error : new Error(errMsg),
+                    error: error instanceof Error ? error : new Error(String(error)),
                 });
             }
         });
-        // App mention events (when @bot is mentioned in a channel)
-        this.socketClient.on('app_mention', async ({ event, ack }) => {
+        this.socket.on('app_mention', async ({ event, ack }) => {
             try {
+                await this.accept(event);
                 await ack();
-                await this.handleMessage(event, true);
             }
             catch (error) {
-                const errMsg = error instanceof Error ? error.message : String(error);
-                this.logger.error('Error handling Slack mention:', errMsg);
                 this.emitEvent({
                     type: 'error',
-                    source: 'slack',
+                    source: this.source,
                     timestamp: new Date(),
-                    error: error instanceof Error ? new Error(error.message) : new Error(String(error)),
+                    error: error instanceof Error ? error : new Error(String(error)),
                 });
             }
         });
     }
-    /**
-     * Handle incoming Slack message
-     */
-    async handleMessage(event, isMention) {
-        this.logger.log(`[Slack] handleMessage: subtype=${event.subtype || 'none'}, user=${event.user}, bot_id=${event.bot_id || 'none'}, files=${event.files?.length || 0}, text="${(event.text || '').substring(0, 50)}"`);
-        // Skip non-standard message subtypes (edits, deletes, unfurls, etc.)
-        // Allow file_share so uploaded files are processed
-        if (event.subtype && event.subtype !== 'file_share') {
-            this.logger.log(`[Slack] Skipping subtype: ${event.subtype}`);
-            return;
-        }
-        // Ignore bot messages before resolving an end-user principal.
-        if (event.bot_id)
-            return;
-        if (!this.teamId && !this.missingTeamIdWarningLogged) {
-            this.logger.warn('Slack team ID is unavailable; all senders will be diverted');
-            this.missingTeamIdWarningLogged = true;
-        }
-        const isDM = event.channel_type === 'im';
-        let principal = (0, principal_js_1.resolveConnectorPrincipal)({
-            connector: 'slack',
-            namespace: this.teamId ?? 'workspace',
-            userId: event.user,
-            ownerUserId: this.teamId ? this.config.ownerUserId : undefined,
-            isDirectMessage: isDM,
-        });
-        if (principal.class === 'external' && this.principalResolver && this.teamId) {
-            principal = (0, principal_js_1.overlayMemberPrincipal)(principal, this.principalResolver('slack', this.teamId, event.user));
-        }
-        if (principal.lane === 'divert') {
-            return;
-        }
-        // Dedup: Slack Socket Mode may redeliver events, and app_mention + message
-        // fire for the same @mention. Mark every processed event to prevent duplicates.
-        const dedupKey = event.ts;
-        if (this.processedMessages.has(dedupKey)) {
+    async start() {
+        if (this.connected)
             return;
-        }
-        // Only admitted owner messages become conversation context.
-        const channelHistory = (0, channel_history_js_1.getChannelHistory)();
-        channelHistory.record(event.channel, {
-            messageId: event.ts,
-            sender: 'User',
-            userId: event.user,
-            body: event.text || '',
-            timestamp: parseFloat(event.ts) * 1000,
-            isBot: false,
-        });
-        // Agent-bot message handling was here: shared-context recording and mention
-        // delegation between bots. Removed with the multi-bot handler, which never ran.
-        // Check if we should respond to this message
-        if (!this.shouldRespond(event, isDM, isMention)) {
+        if (!this.options.config.allowedChannels.length || !this.options.config.ownerUserIds.length)
+            throw new Error('slack owner allowlist is not configured');
+        if (!this.options.token.trim())
+            throw new Error('MAMA_SLACK_TOKEN is required');
+        if (!this.options.appToken.trim())
+            throw new Error('MAMA_SLACK_APP_TOKEN is required');
+        await this.socket.start();
+        this.connected = true;
+        await this.recoverPendingResponses();
+    }
+    async stop() {
+        if (!this.connected)
             return;
-        }
-        this.processedMessages.set(dedupKey, Date.now());
-        // Periodic cleanup
-        if (this.processedMessages.size > 100) {
-            const now = Date.now();
-            for (const [key, time] of this.processedMessages) {
-                if (now - time > SlackGateway.DEDUP_TTL_MS) {
-                    this.processedMessages.delete(key);
+        this.connected = false;
+        await this.socket.disconnect();
+        this.emitEvent({ type: 'disconnected', source: this.source, timestamp: new Date() });
+    }
+    recentDeliveredMessageRefs() {
+        return this.ledger.recentDeliveredMessageRefs();
+    }
+    async recoverPendingResponses() {
+        for (const entry of this.ledger.listUndelivered()) {
+            try {
+                const channel = entry.deliveryTarget?.startsWith('slack:')
+                    ? entry.deliveryTarget.slice('slack:'.length)
+                    : '';
+                const source = entry.key.startsWith('slack:');
+                const outbound = entry.key.startsWith('outbound:') || entry.key.startsWith('file:');
+                if ((!source && !outbound) ||
+                    !channel ||
+                    !this.options.config.allowedChannels.includes(channel))
+                    continue;
+                if (entry.deliveryUncertain) {
+                    this.log(`slack delivery requires reconciliation key=${entry.key}`);
+                    continue;
+                }
+                if (source && entry.state === 'processing' && !this.intake.isPending?.(entry.key)) {
+                    this.ledger.markReady(entry.key, INTERRUPTED_RESPONSE);
+                    await this.deliverResponse(entry.key, INTERRUPTED_RESPONSE);
+                }
+                else if (entry.state === 'ready' && entry.response !== undefined) {
+                    if (source)
+                        await this.deliverResponse(entry.key, entry.response);
+                    else
+                        await this.runInDestination(channel, () => this.sendChunks(channel, entry.key, entry.response));
                 }
             }
-        }
-        // Emit message received event
-        this.emitEvent({
-            type: 'message_received',
-            source: 'slack',
-            timestamp: new Date(),
-            data: {
-                channelId: event.channel,
-                userId: event.user,
-                isDM,
-                isMention,
-                hasThread: !!event.thread_ts,
-            },
-        });
-        // Remove mentions from message content
-        const cleanContent = this.cleanMessageContent(event.text);
-        // Process file attachments (images, documents, etc.)
-        const attachments = await this.downloadSlackFiles(event);
-        // Build content blocks from attachments
-        const contentBlocks = attachments.length > 0 ? await (0, attachment_utils_js_1.buildContentBlocks)(attachments) : [];
-        // Enrich content with file info for multi-agent (which only gets text)
-        let enrichedContent = cleanContent;
-        // Append file reference text blocks so agents know about uploaded files
-        const fileRefTexts = contentBlocks
-            .filter((b) => b.type === 'text' && b.text?.startsWith('[File:'))
-            .map((b) => b.text);
-        if (fileRefTexts.length > 0) {
-            enrichedContent = `${cleanContent}\n\n${fileRefTexts.join('\n')}`;
-        }
-        // Pre-analyze images for text enrichment (multi-agent gets text only)
-        const shouldPreAnalyzeImages = contentBlocks.some((b) => b.type === 'image')
-            ? (await import('./image-analyzer.js')).shouldUseClaudeImagePreanalysis()
-            : false;
-        if (shouldPreAnalyzeImages) {
-            const { getImageAnalyzer } = await import('./image-analyzer.js');
-            const analysisText = await getImageAnalyzer().processContentBlocks(contentBlocks);
-            if (analysisText) {
-                enrichedContent = `${enrichedContent}\n\n${analysisText}`;
+            catch (error) {
+                this.log(`slack recovery failed key=${entry.key} error=${error instanceof Error ? error.message : String(error)}`);
             }
         }
-        // Check if multi-agent mode should handle this message
-        // Normalize message for router
-        // Use enriched content (with image analysis) for text-only routing
-        const normalizedMessage = {
-            source: 'slack',
-            channelId: event.channel,
-            userId: event.user,
-            text: enrichedContent,
-            principal,
-            contentBlocks: contentBlocks.length > 0 ? contentBlocks : undefined,
-            metadata: {
-                threadTs: event.thread_ts || event.ts,
-                messageId: event.ts,
-                attachments: attachments.length > 0 ? attachments : undefined,
-            },
-        };
-        // Clear image contentBlocks after analysis to prevent double processing in message-router
-        if (shouldPreAnalyzeImages &&
-            normalizedMessage.contentBlocks?.some((b) => b.type === 'image')) {
-            normalizedMessage.contentBlocks = undefined;
-        }
-        // Create tool status tracker for real-time progress
-        const threadTs = event.thread_ts || event.ts;
-        const slackAdapter = {
-            postPlaceholder: async (content) => {
-                const res = await this.webClient.chat.postMessage({
-                    channel: event.channel,
-                    text: content,
-                    thread_ts: threadTs,
-                });
-                return res.ts ?? null;
-            },
-            editPlaceholder: async (handle, content) => {
-                await this.webClient.chat.update({
-                    channel: event.channel,
-                    ts: handle,
-                    text: content,
-                });
-            },
-            deletePlaceholder: async (handle) => {
-                await this.webClient.chat.delete({
-                    channel: event.channel,
-                    ts: handle,
-                });
-            },
-        };
-        const tracker = new tool_status_tracker_js_1.ToolStatusTracker(slackAdapter, {
-            throttleMs: 1500,
-            initialDelayMs: 3000,
+    }
+    async deliverResponse(sourceRef, response) {
+        const channel = sourceRefChannel(sourceRef);
+        this.requireAllowed(channel);
+        const entry = this.ledger.get(sourceRef);
+        if (!entry)
+            throw new Error(`Slack response has no accepted message ${sourceRef}`);
+        if (entry.deliveryTarget !== `slack:${channel}`)
+            throw new Error('Slack response destination conflicts with its accepted message');
+        if (entry.state === 'delivered')
+            return;
+        if (entry.state === 'processing')
+            this.ledger.markReady(sourceRef, response);
+        await this.runInDestination(channel, () => this.sendChunks(channel, sourceRef, response));
+    }
+    async sendMessage(channel, text, idempotencyKey) {
+        this.requireConnected();
+        this.requireAllowed(channel);
+        const key = `outbound:${(0, node_crypto_1.createHash)('sha256')
+            .update(`text\0${idempotencyKey ?? `${channel}:${text}`}`)
+            .digest('hex')}`;
+        const claim = this.ledger.claim(key, {
+            deliveryTarget: `slack:${channel}`,
+            payloadIdentity: (0, node_crypto_1.createHash)('sha256').update(text).digest('hex'),
+            keepDeliveredOnPayloadChange: true,
+            ...(idempotencyKey ? { idempotencyKey } : {}),
         });
-        const streamCallbacks = tracker.toStreamCallbacks();
-        // Process through message router
-        let result;
+        if (!claim.claimed) {
+            if (claim.entry.state === 'delivered')
+                return;
+            throw new Error('Slack message delivery is already in progress or uncertain');
+        }
+        this.ledger.markReady(key, text);
+        await this.runInDestination(channel, () => this.sendChunks(channel, key, text));
+    }
+    async sendToOwner(text, key) {
+        const channel = this.options.config.ownerChannelId;
+        if (!channel)
+            throw new Error('slack.owner_channel_id is required');
+        await this.sendMessage(channel, text, key);
+    }
+    async sendFile(path, caption, operationId) {
+        this.requireConnected();
+        if (!operationId.trim())
+            throw new Error('Slack file operation id is required');
+        const channel = this.options.config.ownerChannelId;
+        if (!channel)
+            throw new Error('slack.owner_channel_id is required');
+        this.requireAllowed(channel);
+        if (!this.options.filesRoot)
+            throw new Error('Slack workspace files root is not configured');
+        const file = (0, file_delivery_js_1.openWorkspaceFile)(this.options.filesRoot, path);
+        const key = `file:${operationId}`;
         try {
-            result = await this.turnProcessor.processTurn(normalizedMessage, {
-                onStream: streamCallbacks,
+            const identity = (0, file_delivery_js_1.workspaceFileIdentity)(file.fd, caption);
+            const claim = this.ledger.claim(key, {
+                deliveryTarget: `slack:${channel}`,
+                payloadIdentity: identity,
+                idempotencyKey: operationId,
             });
+            if (!claim.claimed) {
+                if (claim.entry.state === 'delivered')
+                    return { sentAs: file.sentAs, size: file.size, idempotent: true };
+                throw new Error('Slack file delivery is already in progress or uncertain');
+            }
+            const result = (await this.runInDestination(channel, () => this.api.files.uploadV2({
+                channel_id: channel,
+                file: (0, node_fs_1.readFileSync)(file.fd),
+                filename: (0, node_path_1.basename)(file.path),
+                ...(caption === undefined ? {} : { initial_comment: caption }),
+            })));
+            const id = result.files?.[0]?.id;
+            this.ledger.markDelivered(key);
+            return { ...(id ? { messageId: id } : {}), sentAs: file.sentAs, size: file.size };
+        }
+        catch (error) {
+            if (this.ledger.get(key)?.state === 'processing')
+                this.ledger.markFailed(key);
+            throw error;
         }
         finally {
-            await tracker.cleanup();
+            (0, node_fs_1.closeSync)(file.fd);
+        }
+    }
+    async accept(event) {
+        if (!event.channel ||
+            !event.ts ||
+            !event.user ||
+            event.bot_id ||
+            (event.subtype && event.subtype !== 'file_share'))
+            return;
+        const channel = event.channel;
+        const user = event.user;
+        if (!this.options.config.allowedChannels.includes(channel) ||
+            !this.options.config.ownerUserIds.includes(user)) {
+            this.log(`slack message dropped reason=non_owner channel_hash=${hash('channel', channel)} sender_hash=${hash('sender', user)}`);
+            return;
         }
-        if (result.outcome === 'external_divert') {
-            this.logger.log('[Slack] Turn externally diverted; no response sent');
+        const ref = `slack:${channel}:${event.ts}`;
+        if (this.activeInputs.has(ref))
+            return;
+        const existing = this.ledger.get(ref);
+        if (existing) {
+            if (existing.state === 'ready')
+                await this.deliverResponse(ref, existing.response ?? '');
             return;
         }
-        // Send response in thread
-        await this.sendResponse(event, result.response);
-        // Replace eyes with checkmark after response sent (only in multi-agent mode)
-        // Emit message sent event
-        this.emitEvent({
-            type: 'message_sent',
-            source: 'slack',
-            timestamp: new Date(),
-            data: {
-                channelId: event.channel,
-                responseLength: result.response.length,
-                duration: result.duration,
-                threadTs: event.thread_ts || event.ts,
-            },
-        });
-    }
-    /**
-     * Check if bot should respond to this message
-     */
-    shouldRespond(event, isDM, isMention) {
-        // Always respond to DMs
-        if (isDM)
-            return true;
-        // For channel messages, check if mention is required
-        const channelConfig = this.config.channels?.[event.channel];
-        if (channelConfig) {
-            // Channel-specific config
-            if (channelConfig.requireMention === false) {
-                return true; // No mention required for this channel
-            }
-            return isMention;
+        const files = event.files ?? [];
+        if (!event.text?.trim() && !files.length)
+            return;
+        const identity = (0, node_crypto_1.createHash)('sha256')
+            .update(`${event.text ?? ''}\0${files
+            .map((file) => file.id)
+            .sort()
+            .join(',')}`)
+            .digest('hex');
+        this.ledger.claim(ref, { deliveryTarget: `slack:${channel}`, payloadIdentity: identity });
+        this.activeInputs.add(ref);
+        try {
+            const attachments = await Promise.all(files.map(async (file) => {
+                let name = file.name || file.id;
+                try {
+                    name = (0, attachment_actions_js_1.safeFileName)(name);
+                    if (!this.options.downloadsDir)
+                        throw new Error('Attachment downloads directory is not configured');
+                    if (!file.url_private_download)
+                        throw new Error('Slack file has no download URL');
+                    const response = await fetch(file.url_private_download, {
+                        headers: { Authorization: `Bearer ${this.options.token}` },
+                        signal: AbortSignal.timeout(60_000),
+                    });
+                    if (!response.ok)
+                        throw new Error(`Slack attachment download failed (HTTP ${response.status})`);
+                    const path = (0, node_path_1.join)(this.options.downloadsDir, 'slack', `${(0, attachment_actions_js_1.safeFileName)(event.ts)}_${(0, attachment_actions_js_1.safeFileName)(file.id)}_${name}`);
+                    const size = await (0, attachment_io_js_1.saveResponseBody)(response, path);
+                    return { name, path, size, ...(file.mimetype ? { mimeType: file.mimetype } : {}) };
+                }
+                catch (error) {
+                    return { name, error: error instanceof Error ? error.message : String(error) };
+                }
+            }));
+            const input = {
+                id: ref,
+                channelKey: channel,
+                occurredAt: Math.floor(Number(event.ts) * 1000),
+                text: event.text?.trim() || attachments.map((file) => `[file: ${file.name}]`).join('\n'),
+                ...(event.thread_ts ? { replyTo: `slack:${channel}:${event.thread_ts}` } : {}),
+                ...(attachments.length ? { payload: { attachments } } : {}),
+            };
+            this.intake.acceptOwnerMessage(input);
+            this.emitEvent({
+                type: 'message_received',
+                source: this.source,
+                timestamp: new Date(input.occurredAt),
+                data: { sourceMessageRef: ref },
+            });
         }
-        // Default: require mention for channel messages
-        return isMention;
-    }
-    cleanMessageContent(content) {
-        if (!content) {
-            return '';
+        finally {
+            this.activeInputs.delete(ref);
         }
-        return content
-            .replace(/<@[UW]\w+>/g, '')
-            .replace(/<@[UW]\w+\|[^>]+>/g, '')
-            .trim();
     }
-    /**
-     * Download files attached to a Slack message.
-     * Slack requires Authorization header with bot token for url_private_download.
-     */
-    async downloadSlackFiles(event) {
-        if (!event.files || event.files.length === 0)
-            return [];
-        const attachments = [];
-        const authHeaders = { Authorization: `Bearer ${this.botToken}` };
-        for (const file of event.files) {
-            const downloadUrl = file.url_private_download || file.url_private;
-            if (!downloadUrl) {
-                this.logger.warn(`[Slack] No download URL for file: ${file.name}`);
-                continue;
-            }
+    async sendChunks(channel, key, text) {
+        const entry = this.ledger.get(key);
+        if (entry.deliveryUncertain)
+            throw new Error('Slack response delivery is uncertain');
+        const chunks = (0, message_splitter_js_1.splitForSlack)(text);
+        for (let i = entry.nextChunkIndex ?? 0; i < chunks.length; i++) {
+            this.ledger.markDeliveryProgress(key, i, true);
             try {
-                const localPath = await (0, attachment_utils_js_1.downloadFile)(downloadUrl, file.name, authHeaders);
-                const isImage = file.mimetype?.startsWith('image/');
-                attachments.push({
-                    type: isImage ? 'image' : 'file',
-                    url: downloadUrl,
-                    localPath,
-                    filename: file.name,
-                    contentType: file.mimetype || 'application/octet-stream',
-                    size: file.size,
-                });
-                this.logger.log(`[Slack] Downloaded ${isImage ? 'image' : 'file'}: ${file.name} -> ${localPath}`);
+                const sent = await this.api.chat.postMessage({ channel, text: chunks[i] });
+                this.ledger.markDeliveryProgress(key, i + 1, false, sent.ts);
             }
-            catch (err) {
-                const errMsg = err instanceof Error ? err.message : String(err);
-                this.logger.error(`[Slack] Failed to download file ${file.name}: ${errMsg}`);
+            catch (error) {
+                this.ledger.markDeliveryProgress(key, i, true);
+                throw error;
             }
         }
-        return attachments;
-    }
-    /**
-     * Send response to Slack (handling length limits and threading)
-     */
-    async sendResponse(originalEvent, response) {
-        const threadTs = originalEvent.thread_ts || originalEvent.ts;
-        const chunks = (0, message_splitter_js_1.splitForSlack)(response);
-        for (const chunk of chunks) {
-            await this.webClient.chat.postMessage({
-                channel: originalEvent.channel,
-                text: chunk,
-                thread_ts: threadTs,
-                reply_broadcast: true, // Also show in channel
-            });
-        }
-    }
-    // ============================================================================
-    // Gateway Interface Implementation
-    // ============================================================================
-    /**
-     * Start the Slack gateway
-     */
-    async start() {
-        if (!this.config.ownerUserId && !this.ownerWarningLogged) {
-            this.logger.warn('Slack owner user ID is not configured; all senders will be diverted');
-            this.ownerWarningLogged = true;
-        }
-        if (this.connected) {
-            this.logger.log('Slack gateway already connected');
-            return;
-        }
-        const authResult = await this.webClient.auth.test();
-        this.teamId = authResult.team_id ?? this.teamId;
-        await this.socketClient.start();
-    }
-    /**
-     * Stop the Slack gateway
-     */
-    async stop() {
-        // Stop multi-agent processes (don't block disconnect on failure)
-        if (!this.connected) {
-            return;
-        }
-        await this.socketClient.disconnect();
-        this.connected = false;
+        this.ledger.markDelivered(key);
         this.emitEvent({
-            type: 'disconnected',
-            source: 'slack',
+            type: 'message_sent',
+            source: this.source,
             timestamp: new Date(),
+            data: { sourceMessageRef: key },
         });
     }
-    // ============================================================================
-    // Configuration
-    // ============================================================================
-    /**
-     * Update gateway configuration
-     */
-    setConfig(config) {
-        if (config.channels) {
-            this.config.channels = { ...this.config.channels, ...config.channels };
-        }
-        if (config.enabled !== undefined) {
-            this.config.enabled = config.enabled;
+    async runInDestination(destination, work) {
+        const previous = this.deliveryTails.get(destination) ?? Promise.resolve();
+        let release;
+        const gate = new Promise((resolve) => {
+            release = resolve;
+        });
+        const tail = previous.then(() => gate);
+        this.deliveryTails.set(destination, tail);
+        await previous;
+        try {
+            return await work();
         }
-    }
-    /**
-     * Get current configuration
-     */
-    getConfig() {
-        return { ...this.config };
-    }
-    /**
-     * Add channel configuration
-     */
-    addChannelConfig(channelId, config) {
-        this.config.channels = this.config.channels || {};
-        this.config.channels[channelId] = config;
-    }
-    // ============================================================================
-    // Message Sending API (for discord_send tool compatibility)
-    // ============================================================================
-    /**
-     * Send message to a channel
-     */
-    async sendMessage(channelId, text) {
-        const chunks = (0, message_splitter_js_1.splitForSlack)(text);
-        for (const chunk of chunks) {
-            await this.webClient.chat.postMessage({
-                channel: channelId,
-                text: chunk,
-            });
+        finally {
+            release();
+            if (this.deliveryTails.get(destination) === tail)
+                this.deliveryTails.delete(destination);
         }
     }
-    /**
-     * Send file/document to a channel
-     * Supports any file type (documents, images, PDFs, etc.)
-     */
-    async sendFile(channelId, filePath, caption) {
-        const { createReadStream } = await import('fs');
-        const { basename } = await import('path');
-        const filename = basename(filePath);
-        await this.webClient.filesUploadV2({
-            channel_id: channelId,
-            file: createReadStream(filePath),
-            filename,
-            initial_comment: caption,
-        });
-    }
-    /**
-     * Send image to a channel (alias for sendFile)
-     */
-    async sendImage(channelId, imagePath, caption) {
-        return this.sendFile(channelId, imagePath, caption);
+    requireAllowed(channel) {
+        if (!this.options.config.allowedChannels.includes(channel))
+            throw new Error('Slack destination is not allowlisted');
     }
-    // ============================================================================
-    // Multi-Agent Support
-    // ============================================================================
-    /**
-     * Update multi-agent configuration
-     */
-    async setMultiAgentConfig(config) {
-        if (config.enabled) {
-            this.logger.log('[Slack] Multi-agent mode enabled/updated');
-        }
-        else {
-            this.logger.log('[Slack] Multi-agent mode disabled');
-        }
+    requireConnected() {
+        if (!this.connected)
+            throw new Error('Slack gateway not connected');
     }
 }
 exports.SlackGateway = SlackGateway;
+const INTERRUPTED_RESPONSE = 'The previous processing attempt was interrupted. It was not rerun because its external side effects could not be proven safe to repeat. Please send a new message if you want to retry it.';
+function sourceRefChannel(value) {
+    if (!value.startsWith('slack:'))
+        throw new Error('Slack source message reference is invalid');
+    const parts = value.split(':');
+    if (parts.length !== 3)
+        throw new Error('Slack source message reference is invalid');
+    return parts[1];
+}
+function hash(kind, value) {
+    return (0, node_crypto_1.createHash)('sha256').update(`${kind}\0${value}`).digest('hex');
+}
 //# sourceMappingURL=slack.js.map