@jitsusama/agentic-harness.core 0.1.0

package/dist/slack/api/messages.d.ts

@@ -0,0 +1,98 @@
+/**
+ * Slack conversations API: history, replies, and posting.
+ *
+ * Handles reading messages from channels, fetching threads,
+ * and sending messages/replies.
+ */
+import type { Conversation, MessageTarget, SlackMessage } from "../types.js";
+import type { SlackClient } from "./client.js";
+/** Options for fetching a single message. */
+export interface GetMessageOptions {
+    signal?: AbortSignal;
+}
+/**
+ * Fetch a single message by target.
+ *
+ * For top-level messages, pass a target with `ts`.
+ * For thread replies, include `threadTs` in the target.
+ * Uses conversations.history for top-level messages and
+ * conversations.replies for thread replies.
+ */
+export declare function getMessage(client: SlackClient, target: MessageTarget, opts?: GetMessageOptions): Promise<SlackMessage>;
+/** Options for listing channel history. */
+export interface ListMessagesOptions {
+    limit?: number;
+    oldest?: string;
+    latest?: string;
+    signal?: AbortSignal;
+}
+/**
+ * List recent messages in a channel with automatic pagination.
+ *
+ * Uses conversations.history with cursor-based pagination.
+ * Pass `limit: 0` for unlimited. Returns messages in reverse
+ * chronological order (newest first).
+ */
+export declare function listMessages(client: SlackClient, conversation: Conversation, opts?: ListMessagesOptions): Promise<SlackMessage[]>;
+/** Options for fetching a thread. */
+export interface GetThreadOptions {
+    limit?: number;
+    signal?: AbortSignal;
+}
+/**
+ * Fetch all replies in a thread.
+ *
+ * The target's `ts` identifies the thread parent message.
+ * Auto-paginates using cursor until all messages are
+ * collected or the limit is reached.
+ */
+export declare function getThread(client: SlackClient, target: MessageTarget, opts?: GetThreadOptions): Promise<SlackMessage[]>;
+/** Result from sending a message. */
+export interface SendResult {
+    ok: boolean;
+    /** The conversation ID the message was posted to. */
+    channel: string;
+    ts: string;
+}
+/**
+ * Convert @mentions in outgoing text to Slack's native syntax.
+ *
+ * Handles two kinds of mentions:
+ * - Broadcast keywords (@here, @channel, @everyone) → `<!keyword>`
+ * - User handles (@franck.delache) → `<@USER_ID>`
+ *
+ * User resolution strategy:
+ * 1. Try the local user cache for every match (fast, no API)
+ * 2. For multi-segment handles (contain a dot, like first.last),
+ *    also try API resolution on cache miss
+ * 3. Leave unresolved handles as plain text
+ */
+export declare function formatMentions(client: SlackClient, text: string, signal?: AbortSignal): Promise<string>;
+/**
+ * Send a message to a channel.
+ *
+ * When `blocks` is provided, it's JSON-stringified and sent
+ * as the `blocks` parameter to `chat.postMessage`. The `text`
+ * field serves as the notification fallback.
+ */
+export declare function sendMessage(client: SlackClient, conversationId: string, text: string, blocks?: unknown[], signal?: AbortSignal): Promise<SendResult>;
+/**
+ * Edit an existing message.
+ *
+ * Calls `chat.update`. Slack only allows editing messages
+ * the authenticated user authored, and it cannot change
+ * file attachments, only the message's text and blocks.
+ *
+ * When `blocks` is provided, the previous blocks payload
+ * is replaced wholesale. Pass `blocks: []` to clear blocks
+ * and revert the message to plain text.
+ */
+export declare function editMessage(client: SlackClient, conversationId: string, ts: string, text: string, blocks?: unknown[], signal?: AbortSignal): Promise<SendResult>;
+/**
+ * Reply to a thread.
+ *
+ * When `blocks` is provided, it's JSON-stringified and sent
+ * as the `blocks` parameter to `chat.postMessage`. The `text`
+ * field serves as the notification fallback.
+ */
+export declare function replyToThread(client: SlackClient, conversationId: string, threadTs: string, text: string, blocks?: unknown[], signal?: AbortSignal): Promise<SendResult>;

package/dist/slack/api/messages.js

@@ -0,0 +1,292 @@
+/**
+ * Slack conversations API: history, replies, and posting.
+ *
+ * Handles reading messages from channels, fetching threads,
+ * and sending messages/replies.
+ */
+import { extractTables } from "../blocks.js";
+import { lookupId } from "../resolvers/cache.js";
+import { cacheUser, resolveUser } from "../resolvers/user.js";
+/** Cache filename used by the user resolver. */
+const USER_CACHE_FILE = "users.json";
+/** Convert a raw API message to our domain type. */
+function toSlackMessage(msg, conversation) {
+    if (msg.user && msg.username) {
+        cacheUser(msg.username, msg.user);
+    }
+    const attachments = msg.attachments?.length
+        ? msg.attachments.map((a) => ({
+            title: a.title,
+            text: a.text,
+            fallback: a.fallback,
+            fromUrl: a.from_url,
+            imageUrl: a.image_url,
+        }))
+        : undefined;
+    const files = msg.files?.length
+        ? msg.files.map((f) => ({
+            name: f.name,
+            mimetype: f.mimetype,
+            url: f.url_private || f.permalink,
+        }))
+        : undefined;
+    // A message is a thread parent when its threadTs equals its own ts.
+    // Messages without threadTs are top-level posts (not in any thread).
+    const isThreadParent = msg.thread_ts !== undefined && msg.thread_ts === msg.ts;
+    // Extract tables from Block Kit blocks. Tables can live
+    // in top-level blocks (sent via chat.postMessage) or inside
+    // attachments[].blocks (created in Slack's WYSIWYG editor).
+    const allBlocks = [];
+    if (msg.blocks?.length) {
+        allBlocks.push(...msg.blocks);
+    }
+    if (msg.attachments?.length) {
+        for (const att of msg.attachments) {
+            if (att.blocks?.length) {
+                allBlocks.push(...att.blocks);
+            }
+        }
+    }
+    const tables = allBlocks.length ? extractTables(allBlocks) : undefined;
+    return {
+        ts: msg.ts,
+        text: msg.text ?? "",
+        user: msg.user,
+        conversation,
+        threadTs: msg.thread_ts,
+        replyCount: msg.reply_count,
+        isThreadParent,
+        reactions: msg.reactions,
+        attachments,
+        files,
+        tables: tables?.length ? tables : undefined,
+        permalink: msg.permalink,
+    };
+}
+/**
+ * Fetch a single message by target.
+ *
+ * For top-level messages, pass a target with `ts`.
+ * For thread replies, include `threadTs` in the target.
+ * Uses conversations.history for top-level messages and
+ * conversations.replies for thread replies.
+ */
+export async function getMessage(client, target, opts) {
+    const { conversation, ts, threadTs } = target;
+    let msg;
+    if (threadTs) {
+        // Fetch a specific thread reply: threadTs is the parent,
+        // ts is the reply we want.
+        const response = await client.call("conversations.replies", {
+            channel: conversation.id,
+            ts: threadTs,
+            latest: ts,
+            oldest: ts,
+            limit: 1,
+            inclusive: true,
+        }, opts?.signal);
+        // Slack may include the thread parent alongside the
+        // targeted reply; find the exact message we asked for.
+        msg = response.messages?.find((m) => m.ts === ts);
+    }
+    else {
+        // Fetch a top-level channel message.
+        const response = await client.call("conversations.history", {
+            channel: conversation.id,
+            latest: ts,
+            oldest: ts,
+            limit: 1,
+            inclusive: true,
+        }, opts?.signal);
+        msg = response.messages?.[0];
+    }
+    if (!msg) {
+        throw new Error("Message not found.");
+    }
+    // Best-effort permalink fetch.
+    try {
+        const linkResponse = await client.call("chat.getPermalink", { channel: conversation.id, message_ts: ts }, opts?.signal);
+        msg.permalink = linkResponse.permalink;
+    }
+    catch {
+        // Permalink is non-critical.
+    }
+    return toSlackMessage(msg, conversation);
+}
+/** Maximum results per page for conversations.history. */
+const MAX_HISTORY_PER_PAGE = 200;
+/** Default number of messages when no limit is specified. */
+const DEFAULT_HISTORY_LIMIT = 20;
+/**
+ * List recent messages in a channel with automatic pagination.
+ *
+ * Uses conversations.history with cursor-based pagination.
+ * Pass `limit: 0` for unlimited. Returns messages in reverse
+ * chronological order (newest first).
+ */
+export async function listMessages(client, conversation, opts = {}) {
+    const targetLimit = opts.limit === 0 ? undefined : opts.limit || DEFAULT_HISTORY_LIMIT;
+    const perPage = targetLimit
+        ? Math.min(targetLimit, MAX_HISTORY_PER_PAGE)
+        : MAX_HISTORY_PER_PAGE;
+    const raw = await client.paginate("conversations.history", {
+        channel: conversation.id,
+        limit: perPage,
+        oldest: opts.oldest,
+        latest: opts.latest,
+    }, (r) => (r.messages ?? []), targetLimit, opts.signal);
+    return raw.map((m) => toSlackMessage(m, conversation));
+}
+/**
+ * Fetch all replies in a thread.
+ *
+ * The target's `ts` identifies the thread parent message.
+ * Auto-paginates using cursor until all messages are
+ * collected or the limit is reached.
+ */
+export async function getThread(client, target, opts) {
+    const { conversation, ts } = target;
+    const maxResults = opts?.limit || 100;
+    const messages = await client.paginate("conversations.replies", {
+        channel: conversation.id,
+        ts,
+        limit: Math.min(maxResults, 200),
+    }, (r) => (r.messages ?? []), maxResults, opts?.signal);
+    return messages.map((m) => toSlackMessage(m, conversation));
+}
+/**
+ * Pattern matching @handle mentions in outgoing message text.
+ *
+ * Matches any @word pattern that isn't already inside Slack's
+ * `<@U...>` syntax. Handles may contain dots, hyphens and
+ * underscores.
+ */
+const OUTGOING_MENTION_PATTERN = /(?<![<@\w])@([\w][\w.-]*[\w])/g;
+/**
+ * Slack broadcast keywords that use `<!keyword>` syntax
+ * instead of `<@USER_ID>`.
+ */
+const SLACK_BROADCASTS = new Set(["here", "channel", "everyone"]);
+/**
+ * Convert @mentions in outgoing text to Slack's native syntax.
+ *
+ * Handles two kinds of mentions:
+ * - Broadcast keywords (@here, @channel, @everyone) → `<!keyword>`
+ * - User handles (@franck.delache) → `<@USER_ID>`
+ *
+ * User resolution strategy:
+ * 1. Try the local user cache for every match (fast, no API)
+ * 2. For multi-segment handles (contain a dot, like first.last),
+ *    also try API resolution on cache miss
+ * 3. Leave unresolved handles as plain text
+ */
+export async function formatMentions(client, text, signal) {
+    const matches = [...text.matchAll(OUTGOING_MENTION_PATTERN)];
+    if (matches.length === 0)
+        return text;
+    // Deduplicate handles to avoid resolving the same one twice.
+    const uniqueHandles = [
+        ...new Set(matches.map((m) => m[1]).filter((h) => !SLACK_BROADCASTS.has(h))),
+    ];
+    const resolved = new Map();
+    for (const handle of uniqueHandles) {
+        // Fast path: check the local cache (no API call).
+        const cached = lookupId(USER_CACHE_FILE, handle);
+        if (cached) {
+            resolved.set(handle, cached);
+            continue;
+        }
+        // API fallback: only for multi-segment handles (first.last)
+        // to avoid spurious lookups for random @words in text.
+        if (handle.includes(".")) {
+            try {
+                const userId = await resolveUser(client, handle, signal);
+                resolved.set(handle, userId);
+            }
+            catch {
+                // Handle couldn't be resolved. Leave as plain text.
+            }
+        }
+    }
+    return text.replace(OUTGOING_MENTION_PATTERN, (_match, handle) => {
+        if (SLACK_BROADCASTS.has(handle))
+            return `<!${handle}>`;
+        const userId = resolved.get(handle);
+        return userId ? `<@${userId}>` : `@${handle}`;
+    });
+}
+/**
+ * Send a message to a channel.
+ *
+ * When `blocks` is provided, it's JSON-stringified and sent
+ * as the `blocks` parameter to `chat.postMessage`. The `text`
+ * field serves as the notification fallback.
+ */
+export async function sendMessage(client, conversationId, text, blocks, signal) {
+    const formatted = await formatMentions(client, text, signal);
+    const params = {
+        channel: conversationId,
+        text: formatted,
+    };
+    if (blocks) {
+        params.blocks = JSON.stringify(blocks);
+    }
+    const response = await client.call("chat.postMessage", params, signal);
+    return {
+        ok: true,
+        channel: response.channel,
+        ts: response.ts,
+    };
+}
+/**
+ * Edit an existing message.
+ *
+ * Calls `chat.update`. Slack only allows editing messages
+ * the authenticated user authored, and it cannot change
+ * file attachments, only the message's text and blocks.
+ *
+ * When `blocks` is provided, the previous blocks payload
+ * is replaced wholesale. Pass `blocks: []` to clear blocks
+ * and revert the message to plain text.
+ */
+export async function editMessage(client, conversationId, ts, text, blocks, signal) {
+    const formatted = await formatMentions(client, text, signal);
+    const params = {
+        channel: conversationId,
+        ts,
+        text: formatted,
+    };
+    if (blocks) {
+        params.blocks = JSON.stringify(blocks);
+    }
+    const response = await client.call("chat.update", params, signal);
+    return {
+        ok: true,
+        channel: response.channel,
+        ts: response.ts,
+    };
+}
+/**
+ * Reply to a thread.
+ *
+ * When `blocks` is provided, it's JSON-stringified and sent
+ * as the `blocks` parameter to `chat.postMessage`. The `text`
+ * field serves as the notification fallback.
+ */
+export async function replyToThread(client, conversationId, threadTs, text, blocks, signal) {
+    const formatted = await formatMentions(client, text, signal);
+    const params = {
+        channel: conversationId,
+        text: formatted,
+        thread_ts: threadTs,
+    };
+    if (blocks) {
+        params.blocks = JSON.stringify(blocks);
+    }
+    const response = await client.call("chat.postMessage", params, signal);
+    return {
+        ok: true,
+        channel: response.channel,
+        ts: response.ts,
+    };
+}

package/dist/slack/api/reactions.d.ts

@@ -0,0 +1,47 @@
+/**
+ * Slack reactions API: add, remove, list and get.
+ */
+import type { SlackClient } from "./client.js";
+/**
+ * Add a reaction to a message.
+ */
+export declare function addReaction(client: SlackClient, channel: string, ts: string, emoji: string, signal?: AbortSignal): Promise<void>;
+/**
+ * Remove a reaction from a message.
+ */
+export declare function removeReaction(client: SlackClient, channel: string, ts: string, emoji: string, signal?: AbortSignal): Promise<void>;
+/** Reaction details on a message. */
+export interface MessageReactions {
+    ts: string;
+    channel: string;
+    user?: string;
+    text?: string;
+    reactions: Array<{
+        name: string;
+        count: number;
+        users: string[];
+    }>;
+}
+/**
+ * Get reactions on a specific message.
+ */
+export declare function getReactions(client: SlackClient, channel: string, ts: string, signal?: AbortSignal): Promise<MessageReactions>;
+/** A message the user reacted to. */
+export interface ReactedMessage {
+    ts: string;
+    channel?: string;
+    user?: string;
+    text?: string;
+    reactions: Array<{
+        name: string;
+        count: number;
+        users: string[];
+    }>;
+}
+/**
+ * List messages the authenticated user (or a specified user) has reacted to.
+ */
+export declare function listReactions(client: SlackClient, opts?: {
+    user?: string;
+    limit?: number;
+}, signal?: AbortSignal): Promise<ReactedMessage[]>;

package/dist/slack/api/reactions.js

@@ -0,0 +1,50 @@
+/**
+ * Slack reactions API: add, remove, list and get.
+ */
+/**
+ * Add a reaction to a message.
+ */
+export async function addReaction(client, channel, ts, emoji, signal) {
+    const name = emoji.replace(/^:/, "").replace(/:$/, "");
+    await client.call("reactions.add", { channel, timestamp: ts, name }, signal);
+}
+/**
+ * Remove a reaction from a message.
+ */
+export async function removeReaction(client, channel, ts, emoji, signal) {
+    const name = emoji.replace(/^:/, "").replace(/:$/, "");
+    await client.call("reactions.remove", { channel, timestamp: ts, name }, signal);
+}
+/**
+ * Get reactions on a specific message.
+ */
+export async function getReactions(client, channel, ts, signal) {
+    const response = await client.call("reactions.get", { channel, timestamp: ts, full: true }, signal);
+    const msg = response.message ?? {};
+    return {
+        ts: msg.ts ?? ts,
+        channel,
+        user: msg.user,
+        text: msg.text,
+        reactions: msg.reactions ?? [],
+    };
+}
+/**
+ * List messages the authenticated user (or a specified user) has reacted to.
+ */
+export async function listReactions(client, opts = {}, signal) {
+    const limit = Math.min(opts.limit || 20, 100);
+    const response = await client.call("reactions.list", { user: opts.user, limit, full: true }, signal);
+    return (response.items ?? [])
+        .filter((item) => item.type === "message" && item.message)
+        .map((item) => {
+        const msg = item.message;
+        return {
+            ts: msg.ts,
+            channel: item.channel,
+            user: msg.user,
+            text: msg.text,
+            reactions: msg.reactions ?? [],
+        };
+    });
+}

package/dist/slack/api/resolve-conversations.d.ts

@@ -0,0 +1,43 @@
+/**
+ * Batch conversation resolution for messages.
+ *
+ * After fetching messages from any API, this module resolves
+ * conversation IDs to display names and determines the
+ * conversation kind (channel, DM, group DM). This means the
+ * renderers always show #channel-name, "@person", or
+ * "@a, @b, @c" instead of raw IDs like C0AJY0FLK8Q.
+ *
+ * Uses the shared conversation cache to avoid redundant
+ * conversations.info calls across the extension.
+ */
+import type { SlackMessage } from "../types.js";
+import type { SlackClient } from "./client.js";
+/**
+ * Resolve conversation metadata for all unique conversations
+ * in a list of messages. Creates or enriches the Conversation
+ * object on each message.
+ *
+ * Calls conversations.info for unknown conversations, caches
+ * the results, and resolves DM partner names. Silently skips
+ * conversations that fail to resolve.
+ */
+export declare function resolveConversationsInMessages(client: SlackClient, messages: SlackMessage[], signal?: AbortSignal): Promise<void>;
+/**
+ * Pre-populate the conversation cache from search results.
+ *
+ * Search results include channel name but not channel type.
+ * This avoids conversations.info calls for channels we've
+ * already seen names for, but those entries won't have
+ * accurate kind until conversations.info runs.
+ *
+ * Skips names that look like user IDs (DM channels), since those
+ * need conversations.info to resolve properly.
+ */
+export declare function cacheConversationFromSearch(channelId: string, name: string): void;
+/**
+ * Update DM conversation display names after user resolution.
+ *
+ * Call this after resolveUsersInMessages to refresh DM
+ * display names with resolved @handles instead of raw IDs.
+ */
+export declare function refreshDmNames(messages: SlackMessage[]): void;

package/dist/slack/api/resolve-conversations.js

@@ -0,0 +1,130 @@
+/**
+ * Batch conversation resolution for messages.
+ *
+ * After fetching messages from any API, this module resolves
+ * conversation IDs to display names and determines the
+ * conversation kind (channel, DM, group DM). This means the
+ * renderers always show #channel-name, "@person", or
+ * "@a, @b, @c" instead of raw IDs like C0AJY0FLK8Q.
+ *
+ * Uses the shared conversation cache to avoid redundant
+ * conversations.info calls across the extension.
+ */
+import { cacheChannelName } from "../resolvers/conversation.js";
+import { cacheConversation, fetchConversation, getCachedConversation, refreshCachedDmNames, } from "../resolvers/conversation-cache.js";
+/**
+ * Resolve conversation metadata for all unique conversations
+ * in a list of messages. Creates or enriches the Conversation
+ * object on each message.
+ *
+ * Calls conversations.info for unknown conversations, caches
+ * the results, and resolves DM partner names. Silently skips
+ * conversations that fail to resolve.
+ */
+export async function resolveConversationsInMessages(client, messages, signal) {
+    const unknownIds = new Set();
+    for (const msg of messages) {
+        const id = msg.conversation?.id;
+        if (id && !getCachedConversation(id)) {
+            unknownIds.add(id);
+        }
+    }
+    // Resolve unknown conversations via conversations.info.
+    if (unknownIds.size > 0) {
+        const ids = [...unknownIds];
+        const BATCH_SIZE = 20;
+        for (let i = 0; i < ids.length; i += BATCH_SIZE) {
+            if (signal?.aborted)
+                return;
+            const batch = ids.slice(i, i + BATCH_SIZE);
+            await Promise.all(batch.map(async (id) => {
+                try {
+                    await fetchConversation(client, id, signal);
+                }
+                catch {
+                    // Conversation not found or inaccessible. Skip.
+                }
+            }));
+        }
+    }
+    // Apply resolved metadata to messages.
+    for (const msg of messages) {
+        const id = msg.conversation?.id;
+        if (!id)
+            continue;
+        const cached = getCachedConversation(id);
+        if (cached) {
+            msg.conversation = cached;
+            // Cache name → ID for cross-session persistence.
+            if (cached.kind === "channel" && cached.name) {
+                cacheChannelName(cached.name, cached.id);
+            }
+        }
+    }
+}
+/**
+ * Detect names that are actually user IDs.
+ *
+ * The search API returns user IDs as channel names for DM
+ * channels (e.g. "U098TB6UXGA" instead of a readable name).
+ * We must not cache these because they'd prevent proper
+ * conversations.info resolution.
+ */
+function looksLikeUserId(name) {
+    return /^[UW][A-Z0-9]{8,}$/.test(name);
+}
+/**
+ * Pre-populate the conversation cache from search results.
+ *
+ * Search results include channel name but not channel type.
+ * This avoids conversations.info calls for channels we've
+ * already seen names for, but those entries won't have
+ * accurate kind until conversations.info runs.
+ *
+ * Skips names that look like user IDs (DM channels), since those
+ * need conversations.info to resolve properly.
+ */
+export function cacheConversationFromSearch(channelId, name) {
+    if (getCachedConversation(channelId))
+        return;
+    // DM channels report user IDs as names in search results.
+    // Skip these so resolveConversationsInMessages can do a
+    // proper conversations.info lookup.
+    if (looksLikeUserId(name))
+        return;
+    const isGroupDm = name.startsWith("mpdm-");
+    const conversation = {
+        id: channelId,
+        name: isGroupDm ? undefined : name,
+        kind: isGroupDm ? "group_dm" : "channel",
+        displayName: isGroupDm ? formatGroupDmName(name) : `#${name}`,
+    };
+    cacheConversation(conversation);
+}
+/**
+ * Update DM conversation display names after user resolution.
+ *
+ * Call this after resolveUsersInMessages to refresh DM
+ * display names with resolved @handles instead of raw IDs.
+ */
+export function refreshDmNames(messages) {
+    refreshCachedDmNames();
+    for (const msg of messages) {
+        const id = msg.conversation?.id;
+        if (!id)
+            continue;
+        const cached = getCachedConversation(id);
+        if (cached) {
+            msg.conversation = cached;
+        }
+    }
+}
+/**
+ * Format a group DM name from the mpdm- format.
+ * Slack names group DMs like `mpdm-user1--user2--user3-1`.
+ */
+function formatGroupDmName(rawName) {
+    const stripped = rawName.replace(/^mpdm-/, "").replace(/-\d+$/, "");
+    const users = stripped.split("--").map((u) => `@${u}`);
+    return users.join(", ");
+}

package/dist/slack/api/resolve-messages.d.ts

@@ -0,0 +1,29 @@
+/**
+ * Unified message resolution: users, conversations and
+ * channel mentions in one call.
+ *
+ * Composes resolveUsersInMessages, resolveConversationsInMessages
+ * and refreshDmNames into a single entry point. Also resolves
+ * channel IDs that only appear as text mentions (<#C123>),
+ * which the per-message conversation resolver doesn't cover.
+ *
+ * Consumers call this after fetching messages and before
+ * rendering. API functions (getMessage, getThread, etc.) do
+ * free cache warming but no resolution, so this function is
+ * the explicit resolution step.
+ */
+import type { SlackMessage } from "../types.js";
+import type { SlackClient } from "./client.js";
+/**
+ * Resolve all unknown entities in a list of messages.
+ *
+ * Handles three concerns in order:
+ * 1. User IDs → display names (msg.user + <@U123> in text)
+ * 2. Conversation IDs → metadata (msg.conversation.id)
+ * 3. Channel mentions in text → cache warming (<#C123>)
+ * 4. DM display name refresh (after user names are known)
+ *
+ * Mutates messages in place. Silently skips entities that
+ * fail to resolve (deleted users, inaccessible channels).
+ */
+export declare function resolveMessages(client: SlackClient, messages: SlackMessage[], signal?: AbortSignal): Promise<void>;