@stratusagent/channel-slack 0.14.0 → 0.14.1

package/dist/index.js

@@ -3,7 +3,7 @@ import { constants } from 'node:fs';
 import { lstat, mkdir, open, readdir, readFile, realpath, rename, rm, writeFile } from 'node:fs/promises';
 import { createRequire } from 'node:module';
 import path from 'node:path';
-import { filePathsOf, isLatestTurn, latestTurnReply, MAX_IDEMPOTENCY_KEY_LENGTH, turnFailureFor, turnFilesFor, turnReplyFor, CONVERSATION_METADATA_KEY, SENDER_TRUST_METADATA_KEY, sessionWriteTrust, imageDimensions, isImageAttachmentMediaType, IMAGE_ATTACHMENT_MAX_BYTES, IMAGE_ATTACHMENT_MAX_DIMENSION, IMAGE_ATTACHMENTS_MAX_TOTAL_BYTES, escapeControlCharacters, HostRefusalError, RunAbortedError, leastTrusted, sessionTrustOf, SESSION_TRUST_METADATA_KEY, admitsSender, channelSessionKey, senderTrustFor, } from '@stratusagent/core';
+import { filePathsOf, isLatestTurn, latestTurnReply, MAX_IDEMPOTENCY_KEY_LENGTH, turnFailureFor, turnFilesFor, turnReplyFor, CONVERSATION_METADATA_KEY, SENDER_TRUST_METADATA_KEY, sessionWriteTrust, imageDimensions, isImageAttachmentMediaType, IMAGE_ATTACHMENT_MAX_BYTES, IMAGE_ATTACHMENT_MAX_DIMENSION, IMAGE_ATTACHMENTS_MAX_REPLAY_COUNT, IMAGE_ATTACHMENTS_MAX_TOTAL_BYTES, escapeControlCharacters, HostRefusalError, RunAbortedError, leastTrusted, sessionTrustOf, SESSION_TRUST_METADATA_KEY, admitsSender, channelSessionKey, senderTrustFor, } from '@stratusagent/core';
 import { codeRunsOf, toSlackMrkdwn } from "./mrkdwn.js";
 /**
  * The longest display name the model is shown. Slack caps profile names
@@ -110,6 +110,12 @@ const STATUS_REFRESH_MS = 60_000;
  * long.
  */
 const DEFAULT_FILE_DOWNLOAD_TIMEOUT_MS = 30_000;
+/**
+ * How long `stop()` waits on a socket that is still starting (card 935).
+ * Well inside the gateway's shutdown window, so a socket stuck connecting
+ * is reported by name rather than as the whole window running out.
+ */
+const DEFAULT_STOP_WAIT_MS = 10_000;
 /** What a turn that produced no text puts in its message, wherever it is posted from. */
 const NO_REPLY_TEXT = '(no reply)';
 /**
@@ -266,6 +272,40 @@ export const createSlackFileFetcher = (fetchImpl) => async (url, botToken, signa
     return { status: response.status, ...typed, body: Buffer.concat(chunks) };
 };
 const defaultFetchFile = (url, botToken, signal, maxBytes) => createSlackFileFetcher(fetch)(url, botToken, signal, maxBytes);
+/**
+ * The one origin a file URL may name for the bot token to go with it.
+ * `url_private` does not by itself mean Slack hosts the file: for a remote
+ * file (an app's pointer to a file it hosts), Slack returns the app's own
+ * URL there, on whatever host the app chose, so any app with
+ * `remote_files:write` could collect the token of every agent that opened
+ * its file. Slack's rule is never to send Slack credentials to such a URL,
+ * and to compare the parsed host exactly rather than a prefix
+ * (docs.slack.dev, Working with files: Downloading files). Previews and
+ * downloads both live here. A redirect elsewhere is not a leak either:
+ * fetch drops `authorization` on a cross-origin redirect.
+ */
+const SLACK_FILE_ORIGIN = 'https://files.slack.com';
+/**
+ * A fetcher that is only ever handed URLs on Slack's file host. Anything
+ * else is refused before a request is made, with a reason that names the
+ * origin, and the callers' own handling turns that into a name-only file
+ * and an operator warning, as for any download that failed.
+ */
+const onlySlackFileHost = (fetchFile) => (url, botToken, signal, maxBytes) => {
+    let origin;
+    try {
+        const parsed = new URL(url);
+        // Credentials in the URL would be sent with the token: not Slack's.
+        origin = parsed.username === '' && parsed.password === '' ? parsed.origin : `${parsed.protocol}//(credentials)@${parsed.host}`;
+    }
+    catch {
+        origin = undefined;
+    }
+    if (origin !== SLACK_FILE_ORIGIN) {
+        return Promise.reject(new Error(`${origin ?? 'its link'} is not Slack's file host (${SLACK_FILE_ORIGIN}), so the bot token is not sent there`));
+    }
+    return fetchFile(url, botToken, signal, maxBytes);
+};
 /**
  * The dispatch's idempotency key for a message's dedupe key: the key itself
  * when it fits the gateway's bound, and a digest of it when it does not —
@@ -1629,7 +1669,9 @@ const MIB = 1024 * 1024;
  * a 1024-pixel preview of a 14 MB screenshot as the screenshot, and states
  * what the small text says when it could only guess at it.
  */
-const previewNote = (previews) => previews.map(({ name, width, height, original }) => `\n[${name} is shown as Slack's ${width}×${height} preview, because the original ${original}. Small text in it may not be legible: ask for a crop rather than guessing at it.]`).join('');
+const previewNote = (previews) => previews.map((preview) => `\n[${previewSentence(preview)}]`).join('');
+/** One preview, said the same way to a turn and to a read of history. */
+const previewSentence = ({ name, width, height, original }) => `${name} is shown as Slack's ${width}×${height} preview, because the original ${original}. Small text in it may not be legible: ask for a crop rather than guessing at it.`;
 /**
  * A message's attachments, sorted into the images the model will be shown
  * and everything else. An image is fetched only when Slack's own metadata
@@ -1820,6 +1862,102 @@ const readImageAttachments = async (files, botToken, fetchFile, timeoutMs, warn,
     });
     return { images, unread, previews };
 };
+/** A read's byte cap, said in the unit it was most likely set in. */
+const readCapLabel = (bytes) => (bytes % MIB === 0 ? `${bytes / MIB} MB` : `${bytes} bytes`);
+/**
+ * The image cap a read asked for, held to what one request can carry, or
+ * undefined when it asked for none: then files come back by name only.
+ */
+const historyImageCap = (images) => {
+    if (images === undefined || !Number.isInteger(images.count) || images.count <= 0 || !Number.isFinite(images.bytes) || images.bytes < 1) {
+        return undefined;
+    }
+    return {
+        count: Math.min(images.count, IMAGE_ATTACHMENTS_MAX_REPLAY_COUNT),
+        bytes: Math.min(Math.floor(images.bytes), IMAGE_ATTACHMENTS_MAX_TOTAL_BYTES),
+    };
+};
+/** What a read is told about an image it tried to fetch and could not show. */
+const unshownImageNote = (label, reason) => {
+    switch (reason) {
+        case 'too-large':
+            return `${label} is not shown: it is over the ${IMAGE_ATTACHMENT_MAX_BYTES / MIB} MB or ${IMAGE_ATTACHMENT_MAX_DIMENSION} pixels a side a model can be sent, and Slack had no smaller preview of it that could be.`;
+        case 'timed-out':
+            return `${label} is not shown: it was not downloaded in time.`;
+        case 'unreadable':
+            return `${label} is not shown: its bytes are not a complete image.`;
+        default:
+            return `${label} is not shown: it could not be downloaded.`;
+    }
+};
+/**
+ * The images on the messages a read returns, fetched for a read that asks
+ * (`ConversationReadRequest.images`) and set on each message with a note
+ * for every image file it does not show. Each image goes through the same
+ * reader a turn's attachments do — Slack's metadata first, the bytes
+ * checked, Slack's preview for one over the per-image limits, and only
+ * from Slack's own file host — one file at a time, in the order the
+ * messages are returned. The read's cap is spent in that order, and once
+ * an image does not fit, none after it is taken, so what is shown is one
+ * unbroken stretch of the read rather than whichever small ones squeezed
+ * in. One deadline covers every download in the read.
+ */
+const readHistoryImages = async (sources, cap, botToken, fetchFile, timeoutMs, warn) => {
+    const deadline = AbortSignal.timeout(timeoutMs);
+    const pastBytes = `past this read's cap of ${readCapLabel(cap.bytes)} of images`;
+    let count = 0;
+    let remaining = cap.bytes;
+    let full;
+    for (const { message, files } of sources) {
+        const images = [];
+        const notes = [];
+        for (const file of files) {
+            const label = fileLabel(file);
+            if (!isImageAttachmentMediaType(file.mimetype)) {
+                if (file.mimetype?.startsWith('image/') === true) {
+                    notes.push(`${label} is not shown: it is ${file.mimetype}, a kind of image a model cannot be shown.`);
+                }
+                continue;
+            }
+            if (full === undefined && count >= cap.count) {
+                full = `past this read's cap of ${cap.count} images`;
+            }
+            // Slack's own size, trusted before any bytes move. An original over
+            // the per-image limit may still go as its preview, whose size only
+            // its bytes can say.
+            if (full === undefined && file.size !== undefined && file.size <= IMAGE_ATTACHMENT_MAX_BYTES && file.size > remaining) {
+                full = pastBytes;
+            }
+            if (full !== undefined) {
+                notes.push(`${label} is not shown: ${full}.`);
+                continue;
+            }
+            const reasons = new Map();
+            const read = await readImageAttachments([file], botToken, fetchFile, timeoutMs, warn, reasons, deadline);
+            const image = read.images[0];
+            if (image === undefined) {
+                notes.push(unshownImageNote(label, reasons.get(file)));
+                continue;
+            }
+            const size = Buffer.byteLength(image.data, 'base64');
+            if (size > remaining) {
+                full = pastBytes;
+                notes.push(`${label} is not shown: ${full}.`);
+                continue;
+            }
+            remaining -= size;
+            count += 1;
+            images.push(image);
+            notes.push(...read.previews.map(previewSentence));
+        }
+        if (images.length > 0) {
+            message.images = images;
+        }
+        if (notes.length > 0) {
+            message.imageNotes = notes;
+        }
+    }
+};
 /** The most one text attachment may weigh to be read into the message. */
 const TEXT_ATTACHMENT_MAX_BYTES = 100 * 1024;
 /**
@@ -2351,6 +2489,33 @@ const slackErrorCode = (error) => {
     const code = error?.data?.error;
     return typeof code === 'string' && code.length > 0 ? code : undefined;
 };
+/** Slack's code for a failed call, or the SDK's message when Slack never answered. */
+const describeSlackError = (error) => slackErrorCode(error) ?? (error instanceof Error ? error.message : String(error));
+/** Codes Slack answers when the token itself is refused. */
+const SLACK_AUTH_ERRORS = new Set(['not_authed', 'invalid_auth', 'account_inactive', 'token_revoked', 'token_expired']);
+/**
+ * Codes with which Slack refuses a whole `conversations.invite` without
+ * inviting anyone, so `inviteToConversation` can reject and the members
+ * are known unchanged. Everything else, per-person codes and failures that
+ * may have partly worked included, is settled per entry instead.
+ */
+const SLACK_INVITE_REFUSALS = new Set([
+    'not_in_channel',
+    'missing_scope',
+    'is_archived',
+    'channel_not_found',
+    'method_not_supported_for_channel_type',
+    'no_user',
+    'ratelimited',
+    ...SLACK_AUTH_ERRORS,
+]);
+/**
+ * What `channel_not_found` means to an app: Slack says the same for a
+ * wrong id and for a private channel it can't see, and so does
+ * `conversations.info`, so the sentence names both.
+ */
+const channelNotFoundSentence = (agentId, conversation) => `Slack found no channel ${conversation} that ${agentId}'s app can see. Check the id (copy it from the channel's link; a name won't work). `
+    + 'If the id is right, the channel is private, and a member has to invite the app.';
 /**
  * Orders two Slack message timestamps ("seconds.micros"). Compared as
  * integers, not floats: a current ts has more digits than a double holds.
@@ -2377,13 +2542,17 @@ export const createSlackChannelAdapter = (options) => {
     const editIntervalMs = options.editIntervalMs ?? DEFAULT_EDIT_INTERVAL_MS;
     const createSocket = options.createSocketClient ?? defaultSocketClient;
     const createWeb = options.createWebClient ?? defaultWebClient;
-    const fetchFile = options.fetchFile ?? defaultFetchFile;
+    const fetchFile = onlySlackFileHost(options.fetchFile ?? defaultFetchFile);
     const fileDownloadTimeoutMs = options.fileDownloadTimeoutMs ?? DEFAULT_FILE_DOWNLOAD_TIMEOUT_MS;
+    const stopWaitMs = options.stopWaitMs ?? DEFAULT_STOP_WAIT_MS;
     const now = options.now ?? Date.now;
     const connections = [];
+    // The agents this adapter carries: `options.agents` until a reload reads
+    // another list (`options.loadAgents`).
+    let carried = options.agents;
     // Every agent this adapter was asked to carry, connected or not — the
     // difference between "mine and broken" and "not mine".
-    const configuredAgents = new Set(options.agents.map((agent) => agent.agentId));
+    const configuredAgents = new Set(carried.map((agent) => agent.agentId));
     // Renderers queue per session: two messages in one thread share a
     // session id, and the gateway serializes their turns — so events route
     // to the FIRST registered renderer (the running turn), never a later
@@ -2577,8 +2746,9 @@ export const createSlackChannelAdapter = (options) => {
      * is the correct outcome there, and it is also the visible one — the same
      * thing a mention has always done when an app is down.
      *
-     * Insertion order is `options.agents` order, which is what makes
-     * `agentNamedIn` deterministic across every connection.
+     * Insertion order is the carried agents' order (`options.agents`, or the
+     * list a reload read), which is what makes `agentNamedIn` deterministic
+     * across every connection.
      */
     const botIdentities = new Map();
     // Rendered approval requests, keyed by the gateway's request id — the
@@ -2607,6 +2777,16 @@ export const createSlackChannelAdapter = (options) => {
     const resolvedWhileRendering = new Map();
     let unsubscribe;
     let gatewayRef;
+    // Set as `stop()` begins, so a reload still connecting an app leaves
+    // nothing up behind the stop.
+    let stopRequested = false;
+    // Sockets between `start()` and `connections`, by the agent they serve
+    // (card 935). A stop can't see them to close them: `connect` closes each
+    // once its start returns, and the stop waits for that, bounded.
+    const socketsStarting = new Map();
+    // Agents whose socket `connect` could not close for a stop: up still,
+    // which the stop has to report.
+    const leftUpAtStop = new Set();
     // Everything the adapter owes Slack goes through here, so stop() drains
     // it: an approval question or its retraction must reach the workspace
     // before the sockets close, or a message keeps offering buttons that
@@ -3361,7 +3541,7 @@ export const createSlackChannelAdapter = (options) => {
     };
     const connectionFor = (agentId) => connections.find((candidate) => candidate.config.agentId === agentId);
     /** An agent's configuration, whether or not its socket came up. */
-    const agentConfigFor = (agentId) => options.agents.find((candidate) => candidate.agentId === agentId);
+    const agentConfigFor = (agentId) => carried.find((candidate) => candidate.agentId === agentId);
     /**
      * Which agent each home channel belongs to, keyed `team:channel` because
      * a channel id is unique only within its workspace. Settled at start,
@@ -3377,7 +3557,7 @@ export const createSlackChannelAdapter = (options) => {
     const settleHomeOwners = () => {
         homeOwners.clear();
         const claims = new Map();
-        for (const agent of options.agents) {
+        for (const agent of carried) {
             const teamId = botIdentities.get(agent.agentId)?.teamId;
             if (teamId === undefined) {
                 continue;
@@ -3908,6 +4088,7 @@ export const createSlackChannelAdapter = (options) => {
             names.set(user, await name);
         }
         const messages = [];
+        const sources = [];
         for (const message of raw) {
             if (!message.ts) {
                 continue;
@@ -3920,7 +4101,7 @@ export const createSlackChannelAdapter = (options) => {
                 || (message.user ? names.get(message.user) : undefined);
             const at = Number.parseFloat(message.ts);
             const files = (message.files ?? []).map((file) => file.name ?? file.title ?? file.id ?? 'file');
-            messages.push({
+            const read = {
                 id: message.ts,
                 author,
                 text: plainSlackText(connection, message.text ?? '', names),
@@ -3929,7 +4110,15 @@ export const createSlackChannelAdapter = (options) => {
                 ...(message.thread_ts && message.thread_ts !== message.ts ? { thread: message.thread_ts } : {}),
                 ...(message.reply_count ? { replies: message.reply_count } : {}),
                 ...(files.length > 0 ? { files } : {}),
-            });
+            };
+            messages.push(read);
+            if (message.files !== undefined && message.files.length > 0) {
+                sources.push({ message: read, files: message.files });
+            }
+        }
+        const imageCap = historyImageCap(request.images);
+        if (imageCap !== undefined) {
+            await readHistoryImages(sources, imageCap, connection.config.botToken, fetchFile, fileDownloadTimeoutMs, warn);
         }
         return { messages, more, ...(listing ? await listing : {}) };
     };
@@ -3972,15 +4161,60 @@ export const createSlackChannelAdapter = (options) => {
         if (!create || !setTopic || !setPurpose || !inviteUsers) {
             throw new Error('slack: this Slack client cannot create channels.');
         }
-        // Who each entry is, before anything exists: agents on this host become
-        // the user their app posts as, in the same workspace only.
-        const invited = [];
+        // Who each entry is, before anything exists. The creating app is a
+        // member already, so naming it counts as invited.
+        const { own, notInvited, toInvite } = resolveInvitees(connection, request.agentId, invite);
+        const invited = [...own];
+        const kind = request.private === true ? 'private' : 'public';
+        let created;
+        try {
+            created = await create({ name, is_private: request.private === true });
+        }
+        catch (error) {
+            const code = slackErrorCode(error);
+            if (code === 'missing_scope') {
+                throw new Error(`slack: ${request.agentId}'s Slack app can't create ${kind} channels because it lacks the ${request.private === true ? 'groups:write' : 'channels:manage'} scope. Add it to the app's manifest and reinstall the app.`);
+            }
+            if (code === 'name_taken') {
+                throw new Error(`slack: there is already a channel named #${name} in this workspace, perhaps archived. Pick another name, or use that channel.`);
+            }
+            throw new Error(`slack: Slack could not create #${name} (${code ?? (error instanceof Error ? error.message : String(error))}).`);
+        }
+        const conversation = created.channel?.id;
+        if (!conversation) {
+            throw new Error(`slack: Slack answered the create of #${name} without a channel id, so whether it exists is unknown. Read the channel list before trying again.`);
+        }
+        const notSet = [];
+        if (request.topic) {
+            await setTopic({ channel: conversation, topic: request.topic })
+                .catch((error) => notSet.push({ field: 'topic', reason: `Slack did not set the topic (${describeSlackError(error)}).` }));
+        }
+        if (request.purpose) {
+            await setPurpose({ channel: conversation, purpose: request.purpose })
+                .catch((error) => notSet.push({ field: 'purpose', reason: `Slack did not set the purpose (${describeSlackError(error)}).` }));
+        }
+        // The channel exists now, so every code is settled per entry and none
+        // turns into a rejection the agent would retry into a second channel.
+        const settled = await inviteAtSlack(connection, inviteUsers, conversation, toInvite);
+        invited.push(...settled.invited);
+        notInvited.push(...settled.notInvited);
+        sortByRequest(invite, invited, notInvited);
+        return { conversation, name: created.channel?.name ?? name, invited, notInvited, notSet };
+    };
+    /**
+     * Who each invite entry is, before Slack is asked: agents on this host
+     * become the user their app posts as, in the same workspace only. `own`
+     * holds the entries that are the asking app itself (the agent, or one
+     * sharing its bot user), which no invitation can add.
+     */
+    const resolveInvitees = (connection, agentId, invite) => {
+        const own = [];
         const notInvited = [];
         const toInvite = new Map();
         for (const who of invite) {
             const identity = botIdentities.get(who);
-            if (who === request.agentId || identity?.botUserId === connection.botUserId) {
-                invited.push(who);
+            if (who === agentId || identity?.botUserId === connection.botUserId) {
+                own.push(who);
             }
             else if (configuredAgents.has(who) && !identity?.botUserId) {
                 notInvited.push({ who, reason: `Agent ${who}'s Slack app is not connected, so its Slack user is unknown.` });
@@ -4000,90 +4234,316 @@ export const createSlackChannelAdapter = (options) => {
                 notInvited.push({ who, reason: 'Not a Slack user id (U… or W…) or an agent with a Slack app on this host.' });
             }
         }
-        const kind = request.private === true ? 'private' : 'public';
-        let created;
+        return { own, notInvited, toInvite };
+    };
+    /**
+     * Sends one `conversations.invite`, force on so a bad id cannot stop the
+     * good ones, and settles each entry of `toInvite` (entry -> Slack user).
+     * Slack's per-id failures name who was refused, and `already_in_channel`
+     * counts as invited. A failed call that does not name everyone leaves
+     * the rest to the channel's members, and who cannot be checked is never
+     * claimed. A call Slack refused with a code `refusesWhole` accepts stops
+     * there, before any members check, with nobody settled and the code in
+     * `refusedWith` for the caller to reject on. Without `refusesWhole`
+     * every code is settled per entry.
+     */
+    const inviteAtSlack = async (connection, inviteUsers, conversation, toInvite, refusesWhole = () => false) => {
+        const invited = [];
+        const notInvited = [];
+        if (toInvite.size === 0) {
+            return { invited, notInvited };
+        }
+        // Slack's per-id failures, by user id: on the answer, or on the error
+        // the SDK throws for an ok: false answer.
+        const refusedOf = (errors) => new Map((Array.isArray(errors) ? errors : []).flatMap((entry) => typeof entry?.user === 'string' && typeof entry.error === 'string' ? [[entry.user, entry.error]] : []));
+        let refused;
+        let failure;
         try {
-            created = await create({ name, is_private: request.private === true });
+            refused = refusedOf((await inviteUsers({ channel: conversation, users: [...new Set(toInvite.values())].join(','), force: true })).errors);
         }
         catch (error) {
             const code = slackErrorCode(error);
-            if (code === 'missing_scope') {
-                throw new Error(`slack: ${request.agentId}'s Slack app can't create ${kind} channels because it lacks the ${request.private === true ? 'groups:write' : 'channels:manage'} scope. Add it to the app's manifest and reinstall the app.`);
-            }
-            if (code === 'name_taken') {
-                throw new Error(`slack: there is already a channel named #${name} in this workspace, perhaps archived. Pick another name, or use that channel.`);
+            if (code !== undefined && refusesWhole(code)) {
+                return { invited, notInvited, refusedWith: code };
             }
-            throw new Error(`slack: Slack could not create #${name} (${code ?? (error instanceof Error ? error.message : String(error))}).`);
-        }
-        const conversation = created.channel?.id;
-        if (!conversation) {
-            throw new Error(`slack: Slack answered the create of #${name} without a channel id, so whether it exists is unknown. Read the channel list before trying again.`);
-        }
-        const notSet = [];
-        const describe = (error) => slackErrorCode(error) ?? (error instanceof Error ? error.message : String(error));
-        if (request.topic) {
-            await setTopic({ channel: conversation, topic: request.topic })
-                .catch((error) => notSet.push({ field: 'topic', reason: `Slack did not set the topic (${describe(error)}).` }));
+            refused = refusedOf(error?.data?.errors);
+            failure = describeSlackError(error);
         }
-        if (request.purpose) {
-            await setPurpose({ channel: conversation, purpose: request.purpose })
-                .catch((error) => notSet.push({ field: 'purpose', reason: `Slack did not set the purpose (${describe(error)}).` }));
-        }
-        if (toInvite.size > 0) {
-            // Slack's per-id failures, by user id: on the answer, or on the error
-            // the SDK throws for an ok: false answer.
-            const refusedOf = (errors) => new Map((Array.isArray(errors) ? errors : []).flatMap((entry) => typeof entry?.user === 'string' && typeof entry.error === 'string' ? [[entry.user, entry.error]] : []));
-            let refused;
-            let failure;
+        // A failed call that does not name everyone leaves the rest unknown,
+        // so the channel's members decide; who cannot be checked is not claimed.
+        let members;
+        let membersFailure;
+        if (failure !== undefined && [...toInvite.values()].some((user) => !refused.has(user))) {
             try {
-                refused = refusedOf((await inviteUsers({ channel: conversation, users: [...new Set(toInvite.values())].join(','), force: true })).errors);
+                members = new Set();
+                let cursor;
+                do {
+                    const page = await connection.web.conversations.members({ channel: conversation, limit: 1000, ...(cursor ? { cursor } : {}) });
+                    for (const member of page.members ?? []) {
+                        members.add(member);
+                    }
+                    cursor = page.response_metadata?.next_cursor || undefined;
+                } while (cursor);
             }
             catch (error) {
-                refused = refusedOf(error?.data?.errors);
-                failure = describe(error);
-            }
-            // A failed call that does not name everyone leaves the rest unknown,
-            // so the channel's members decide; who cannot be checked is not claimed.
-            let members;
-            let membersFailure;
-            if (failure !== undefined && [...toInvite.values()].some((user) => !refused.has(user))) {
-                try {
-                    members = new Set();
-                    let cursor;
-                    do {
-                        const page = await connection.web.conversations.members({ channel: conversation, limit: 1000, ...(cursor ? { cursor } : {}) });
-                        for (const member of page.members ?? []) {
-                            members.add(member);
-                        }
-                        cursor = page.response_metadata?.next_cursor || undefined;
-                    } while (cursor);
-                }
-                catch (error) {
-                    members = undefined;
-                    membersFailure = describe(error);
-                }
+                members = undefined;
+                membersFailure = describeSlackError(error);
             }
-            for (const [who, user] of toInvite) {
-                const code = refused.get(user);
-                if (code === 'already_in_channel' || (code === undefined && (failure === undefined || members?.has(user)))) {
-                    invited.push(who);
-                }
-                else if (code !== undefined || members !== undefined) {
-                    notInvited.push({ who, reason: `Slack did not invite them (${code ?? failure}).` });
-                }
-                else {
-                    notInvited.push({
-                        who,
-                        reason: `The invitation failed (${failure}) and the channel's members could not be checked (${membersFailure}), so they may or may not have been added.`,
-                    });
-                }
+        }
+        for (const [who, user] of toInvite) {
+            const code = refused.get(user);
+            if (code === 'already_in_channel' || (code === undefined && (failure === undefined || members?.has(user)))) {
+                invited.push(who);
+            }
+            else if (code !== undefined || members !== undefined) {
+                notInvited.push({ who, reason: `Slack did not invite them (${code ?? failure}).` });
+            }
+            else {
+                notInvited.push({
+                    who,
+                    reason: `The invitation failed (${failure}) and the channel's members could not be checked (${membersFailure}), so they may or may not have been added.`,
+                });
             }
         }
+        return { invited, notInvited };
+    };
+    /** Puts both lists back in the order the caller named the entries. */
+    const sortByRequest = (invite, invited, notInvited) => {
         const order = new Map(invite.map((who, index) => [who, index]));
         const byRequest = (left, right) => (order.get(left) ?? 0) - (order.get(right) ?? 0);
         invited.sort(byRequest);
         notInvited.sort((left, right) => byRequest(left.who, right.who));
-        return { conversation, name: created.channel?.name ?? name, invited, notInvited, notSet };
+    };
+    /**
+     * Joins an existing public channel with the asking agent's own app —
+     * `channel.join`. Anything it did not join rejects with a sentence; an
+     * answer that leaves it unknown says so, and that a retry is safe,
+     * since Slack treats a second join as a no-op.
+     */
+    const joinConversation = async (request) => {
+        const conversation = request.conversation.trim();
+        if (!conversation) {
+            throw new Error('slack: joining needs a channel id (C…).');
+        }
+        const connection = connectionFor(request.agentId);
+        if (!connection) {
+            throw new Error(configuredAgents.has(request.agentId)
+                ? `slack: ${request.agentId}'s Slack app is not connected right now, so it cannot join ${conversation}.`
+                : `slack: agent ${request.agentId} has no Slack app, so it cannot join a Slack channel.`);
+        }
+        const { join } = connection.web.conversations;
+        if (!join) {
+            throw new Error('slack: this Slack client cannot join channels.');
+        }
+        const agent = request.agentId;
+        let joined;
+        try {
+            joined = await join({ channel: conversation });
+        }
+        catch (error) {
+            const code = slackErrorCode(error);
+            if (code === undefined || code === 'internal_error' || code === 'fatal_error') {
+                throw new Error(`slack: Slack's answer left it unknown whether ${agent}'s app joined ${conversation} (${describeSlackError(error)}). Trying again is safe: joining a channel twice changes nothing.`);
+            }
+            if (code === 'missing_scope') {
+                throw new Error(`slack: ${agent}'s Slack app can't join channels on its own because it lacks the channels:join scope. Add it to the app's manifest and reinstall the app.`);
+            }
+            if (code === 'method_not_supported_for_channel_type') {
+                throw new Error(`slack: ${conversation} isn't a public channel. Slack never lets an app join a private channel on its own: a member has to invite the app.`);
+            }
+            if (code === 'channel_not_found') {
+                throw new Error(`slack: ${channelNotFoundSentence(agent, conversation)}`);
+            }
+            if (code === 'is_archived') {
+                throw new Error(`slack: ${conversation} is archived, so it can't be joined.`);
+            }
+            if (code === 'too_many_members') {
+                throw new Error(`slack: ${conversation} is at Slack's member limit, so ${agent}'s app can't join it.`);
+            }
+            if (code === 'ratelimited') {
+                throw new Error(`slack: Slack is rate-limiting ${agent}'s app; try joining ${conversation} again later.`);
+            }
+            if (SLACK_AUTH_ERRORS.has(code)) {
+                throw new Error(`slack: Slack refused ${agent}'s app token (${code}). Reinstall the app or replace its bot token.`);
+            }
+            throw new Error(`slack: Slack did not let ${agent}'s app join ${conversation} (${code}).`);
+        }
+        const warnings = [joined.warning, ...(joined.response_metadata?.warnings ?? [])];
+        return { conversation: joined.channel?.id ?? conversation, alreadyMember: warnings.includes('already_in_channel') };
+    };
+    /**
+     * Invites people and agents to an existing channel with the asking
+     * agent's own app — `channel.invite`. It rejects only when nobody was
+     * invited: a request refused before Slack is asked, or a whole call Slack
+     * refused without acting. Everything else is settled per entry by the
+     * same code `createConversation` uses.
+     */
+    const inviteToConversation = async (request) => {
+        const conversation = request.conversation.trim();
+        if (!conversation) {
+            throw new Error('slack: an invitation needs a channel id (C…).');
+        }
+        const invite = request.invite;
+        if (invite.length === 0) {
+            throw new Error('slack: an invitation needs at least one person or agent to invite.');
+        }
+        if (invite.length > CHANNEL_INVITE_LIMIT) {
+            throw new Error(`slack: that invites ${invite.length.toLocaleString('en-US')} people; Slack invites at most ${CHANNEL_INVITE_LIMIT.toLocaleString('en-US')} at once. Nobody was invited.`);
+        }
+        const connection = connectionFor(request.agentId);
+        if (!connection) {
+            throw new Error(configuredAgents.has(request.agentId)
+                ? `slack: ${request.agentId}'s Slack app is not connected right now, so it cannot invite anyone to ${conversation}.`
+                : `slack: agent ${request.agentId} has no Slack app, so it cannot invite anyone to a Slack channel.`);
+        }
+        const inviteUsers = connection.web.conversations.invite;
+        if (!inviteUsers) {
+            throw new Error('slack: this Slack client cannot invite people to channels.');
+        }
+        const agent = request.agentId;
+        const { own, notInvited, toInvite } = resolveInvitees(connection, agent, invite);
+        for (const who of own) {
+            notInvited.push({ who, reason: 'That is your own app, which can\'t invite itself. To join a public channel, use channel.join.' });
+        }
+        const settled = await inviteAtSlack(connection, inviteUsers, conversation, toInvite, (code) => SLACK_INVITE_REFUSALS.has(code));
+        if (settled.refusedWith !== undefined) {
+            const code = settled.refusedWith;
+            const why = code === 'not_in_channel'
+                ? `${agent}'s app isn't in ${conversation}, so it can't invite anyone there. For a public channel, join it first with channel.join; for a private one, a member has to invite the app.`
+                : code === 'channel_not_found'
+                    ? channelNotFoundSentence(agent, conversation)
+                    : code === 'missing_scope'
+                        ? `${agent}'s Slack app lacks the scope to invite people: channels:write.invites for a public channel or groups:write.invites for a private one (channels:manage or groups:write also work). Add it to the app's manifest and reinstall the app.`
+                        : code === 'is_archived'
+                            ? `${conversation} is archived, so nobody can be invited to it.`
+                            : code === 'method_not_supported_for_channel_type'
+                                ? `${conversation} is a direct message or another conversation Slack doesn't allow invitations to.`
+                                : code === 'ratelimited'
+                                    ? `Slack is rate-limiting ${agent}'s app; try the invitation again later.`
+                                    : SLACK_AUTH_ERRORS.has(code)
+                                        ? `Slack refused ${agent}'s app token (${code}). Reinstall the app or replace its bot token.`
+                                        : `Slack did not invite anyone to ${conversation} (${code}).`;
+            throw new Error(`slack: ${why} Nobody was invited.`);
+        }
+        const invited = settled.invited;
+        notInvited.push(...settled.notInvited);
+        sortByRequest(invite, invited, notInvited);
+        return { invited, notInvited };
+    };
+    /**
+     * Other agents on this host whose Slack app is this agent's: the same
+     * bot token configured (connected or not), or the same bot user in the
+     * same workspace. Slack's `creator` names the app's bot user, so it
+     * can't tell those agents' channels apart. This sees only this process;
+     * one app per agent is the supported setup (see the README).
+     */
+    const agentsSharingAppWith = (connection) => {
+        const agentId = connection.config.agentId;
+        const sharing = new Set();
+        for (const other of carried) {
+            if (other.agentId !== agentId && other.botToken === connection.config.botToken) {
+                sharing.add(other.agentId);
+            }
+        }
+        for (const [other, identity] of botIdentities) {
+            if (other !== agentId && identity.botUserId !== '' && identity.botUserId === connection.botUserId && identity.teamId === connection.teamId) {
+                sharing.add(other);
+            }
+        }
+        return [...sharing];
+    };
+    /**
+     * Archives a channel the asking agent's own app created — what
+     * `channel.archive` runs on. Everything it refuses is refused before
+     * Slack is asked to archive: an id Slack can't show this app, a direct
+     * message, a channel another user or app created, an app other agents
+     * here share, a channel shared outside the workspace. Slack keeps who
+     * created a channel and whether it is archived, so nothing is stored
+     * here and the rule holds across restarts and hosts. Refusals name the
+     * channel by id only: its name is whatever its members typed.
+     */
+    const archiveConversation = async (request) => {
+        const conversation = request.conversation.trim();
+        if (!conversation) {
+            throw new Error('slack: archiving needs a channel id (C…).');
+        }
+        const connection = connectionFor(request.agentId);
+        if (!connection) {
+            throw new Error(configuredAgents.has(request.agentId)
+                ? `slack: ${request.agentId}'s Slack app is not connected right now, so it cannot archive ${conversation}.`
+                : `slack: agent ${request.agentId} has no Slack app, so it cannot archive a Slack channel.`);
+        }
+        const { archive } = connection.web.conversations;
+        if (!archive) {
+            throw new Error('slack: this Slack client cannot archive channels.');
+        }
+        const agent = request.agentId;
+        const nothing = 'Nothing was archived.';
+        const sharing = agentsSharingAppWith(connection);
+        if (sharing.length > 0) {
+            throw new Error(`slack: ${agent}'s Slack app is also ${sharing.map((other) => `${other}'s`).join(' and ')} here, so Stratus can't tell which agent created ${conversation}. `
+                + `Give each agent its own Slack app. A person can archive it in Slack. ${nothing}`);
+        }
+        let info;
+        try {
+            info = (await connection.web.conversations.info({ channel: conversation })).channel;
+        }
+        catch (error) {
+            const code = slackErrorCode(error);
+            if (code === 'channel_not_found') {
+                throw new Error(`slack: ${channelNotFoundSentence(agent, conversation)} Either way, ${agent} can only archive channels its own app created. ${nothing}`);
+            }
+            if (code === 'ratelimited') {
+                throw new Error(`slack: Slack is rate-limiting ${agent}'s app; try archiving ${conversation} again later. ${nothing}`);
+            }
+            if (code !== undefined && SLACK_AUTH_ERRORS.has(code)) {
+                throw new Error(`slack: Slack refused ${agent}'s app token (${code}). Reinstall the app or replace its bot token. ${nothing}`);
+            }
+            throw new Error(`slack: Slack could not tell ${agent}'s app who created ${conversation} (${describeSlackError(error)}). ${nothing}`);
+        }
+        if (info?.is_im === true || info?.is_mpim === true) {
+            throw new Error(`slack: ${conversation} is a direct message, and only channels can be archived. ${nothing}`);
+        }
+        const creator = info?.creator ?? '';
+        if (creator === '' || connection.botUserId === '' || creator !== connection.botUserId) {
+            throw new Error(`slack: ${agent}'s app didn't create ${conversation}: another user or app did, so ${agent} can't archive it. A person can archive it in Slack. ${nothing}`);
+        }
+        if (info?.is_shared === true || info?.is_ext_shared === true || info?.is_org_shared === true || info?.is_pending_ext_shared === true) {
+            throw new Error(`slack: ${conversation} is shared with another workspace or organization, so archiving it would reach people outside this one. A person can archive it in Slack. ${nothing}`);
+        }
+        if (info?.is_archived === true) {
+            return { conversation, alreadyArchived: true };
+        }
+        try {
+            await archive({ channel: conversation });
+        }
+        catch (error) {
+            const code = slackErrorCode(error);
+            if (code === 'already_archived') {
+                return { conversation, alreadyArchived: true };
+            }
+            warn(`slack: ${agent} could not archive ${conversation} (${describeSlackError(error)})`);
+            if (code === undefined || code === 'internal_error' || code === 'fatal_error') {
+                throw new Error(`slack: Slack's answer left it unknown whether ${agent}'s app archived ${conversation} (${describeSlackError(error)}). It may be archived. Trying again is safe: archiving a channel twice changes nothing.`);
+            }
+            const isPrivate = info?.is_private === true || info?.is_group === true;
+            const why = code === 'missing_scope'
+                ? `${agent}'s Slack app can't archive ${isPrivate ? 'private' : 'public'} channels because it lacks the ${isPrivate ? 'groups:write' : 'channels:manage'} scope. Add it to the app's manifest and reinstall the app.`
+                : code === 'not_in_channel'
+                    ? `${agent}'s app is no longer a member of ${conversation}, so it can't archive it. A member has to add the app back first.`
+                    : code === 'restricted_action'
+                        ? `This workspace limits who can archive channels, so ${agent}'s app can't archive ${conversation}. A person has to do it in Slack.`
+                        : code === 'ratelimited'
+                            ? `Slack is rate-limiting ${agent}'s app; try archiving ${conversation} again later.`
+                            : code === 'channel_not_found'
+                                ? channelNotFoundSentence(agent, conversation)
+                                : SLACK_AUTH_ERRORS.has(code)
+                                    ? `Slack refused ${agent}'s app token (${code}). Reinstall the app or replace its bot token.`
+                                    : `Slack did not let ${agent}'s app archive ${conversation} (${code}).`;
+            throw new Error(`slack: ${why} ${nothing}`);
+        }
+        log(`slack: ${agent} archived ${conversation}`);
+        return { conversation, alreadyArchived: false };
     };
     /**
      * Renders one parked call as buttons and remembers where it went.
@@ -6816,12 +7276,244 @@ export const createSlackChannelAdapter = (options) => {
             renderers.get(sessionId)?.[0]?.refreshLoading();
         }
     };
+    /**
+     * One agent's app, authenticated, with who its bot is recorded, and its
+     * socket built but not started: undefined, with a warning, when it would
+     * not authenticate. Recorded before the socket is even built: an app
+     * that never comes up must still be recognizable when somebody names it.
+     */
+    const authenticate = async (config) => {
+        try {
+            const created = createWeb(config.botToken);
+            const web = config.linkPreviews === false ? withoutLinkPreviews(created) : created;
+            const auth = await web.auth.test();
+            const botUserId = auth.user_id ?? '';
+            const teamId = auth.team_id ?? '';
+            checkBotScopes(config.agentId, auth.response_metadata?.scopes ?? [], warn);
+            botIdentities.set(config.agentId, { botUserId, teamId });
+            return {
+                config,
+                web,
+                socket: createSocket(config.appToken),
+                botUserId,
+                teamId,
+                statusWarned: { value: false },
+            };
+        }
+        catch (error) {
+            // One broken app must not take the rest of the fleet down.
+            warn(`slack: could not connect ${config.agentId}: ${error instanceof Error ? error.message : String(error)}`);
+            return undefined;
+        }
+    };
+    /**
+     * Starts an authenticated app's socket and serves it. Resolves with the
+     * listener a replay of kept messages delivers through, or undefined when
+     * the socket would not start: authenticated but not serving, it answers
+     * nothing, and stays recognizable so nobody answers in its place.
+     */
+    const connect = async (connection) => {
+        const { config, socket } = connection;
+        try {
+            // Returns the work it started: the SDK ignores it, and a test's fake
+            // socket waits on it rather than guessing how long it takes.
+            const handle = (inbound) => {
+                const handled = inbound.catch((error) => {
+                    warn(`slack event handling failed: ${error instanceof Error ? error.message : String(error)}`);
+                });
+                inflight.add(handled);
+                void handled.finally(() => inflight.delete(handled));
+                return handled;
+            };
+            // The replay's own deliveries never wait on the hold they release.
+            const onReplay = (args) => handle(handleInbound(connection, args));
+            const onEvent = (args) => {
+                const channel = args.event?.channel;
+                const hold = typeof channel === 'string' ? replayHolds.get(holdKey(config.agentId, channel))?.held : undefined;
+                if (hold === undefined) {
+                    return onReplay(args);
+                }
+                // Acked now, as any delivery is, so Slack does not redeliver a
+                // message that is only waiting its turn; admitted after the hold.
+                void Promise.resolve(args.ack()).catch((error) => {
+                    warn(`slack: could not ack an envelope: ${error instanceof Error ? error.message : String(error)}`);
+                });
+                return handle(hold.then(() => handleInbound(connection, { ...args, ack: async () => { } })));
+            };
+            socket.on('app_mention', onEvent);
+            socket.on('message', onEvent);
+            socket.on('interactive', (args) => {
+                const handled = handleInteractive(connection, args).catch((error) => {
+                    warn(`slack interaction handling failed: ${error instanceof Error ? error.message : String(error)}`);
+                });
+                track(handled);
+                return handled;
+            });
+            const up = (async () => {
+                await socket.start();
+                // A stop that began while this socket was starting has already
+                // disconnected what it could see; one left up here would answer
+                // beside the next daemon. Checked in the same step that adds it
+                // to `connections`, so a stop either sees it there or finds it
+                // here.
+                if (stopRequested) {
+                    if (!await disconnect(connection, 'the adapter is stopping')) {
+                        leftUpAtStop.add(config.agentId);
+                    }
+                    return false;
+                }
+                connections.push(connection);
+                return true;
+            })();
+            socketsStarting.set(up, config.agentId);
+            try {
+                if (!await up) {
+                    return undefined;
+                }
+            }
+            finally {
+                socketsStarting.delete(up);
+            }
+            log(`slack: ${config.agentId} connected (bot ${connection.botUserId} in team ${connection.teamId})`);
+            return onReplay;
+        }
+        catch (error) {
+            warn(`slack: could not connect ${config.agentId}: ${error instanceof Error ? error.message : String(error)}`);
+            return undefined;
+        }
+    };
+    /** Closes an app's socket; false, with a warning, when the close was refused. */
+    const disconnect = async (connection, reason) => {
+        try {
+            await connection.socket.disconnect();
+            return true;
+        }
+        catch (error) {
+            warn(`slack: could not disconnect ${connection.config.agentId} (${reason}): ${error instanceof Error ? error.message : String(error)}`);
+            return false;
+        }
+    };
+    const sameApp = (a, b) => a.appToken === b.appToken && a.botToken === b.botToken;
+    /**
+     * Brings the connected apps in line with the agents to carry now (card
+     * 894): connects an agent whose app is new, or that the roster has only
+     * now, or that did not come up before; reconnects one whose tokens
+     * changed; disconnects one whose tokens were removed or whose soul is
+     * gone. Every other socket is left alone, so a conversation on it never
+     * notices. Settings come with the list `options.loadAgents` reads, which
+     * for the daemon is the config it started with.
+     */
+    const reconcile = async () => {
+        const gateway = gatewayRef;
+        if (gateway === undefined || stopRequested || options.loadAgents === undefined) {
+            return;
+        }
+        const next = await options.loadAgents();
+        if (gatewayRef !== gateway || stopRequested) {
+            return;
+        }
+        const known = new Set(gateway.agents().map((agent) => agent.id));
+        const wanted = new Map(next.filter((config) => known.has(config.agentId)).map((config) => [config.agentId, config]));
+        const connected = new Map(connections.map((connection) => [connection.config.agentId, connection]));
+        const leaving = [...connected.values()].filter((connection) => {
+            const config = wanted.get(connection.config.agentId);
+            return config === undefined || !sameApp(config, connection.config);
+        });
+        // Closed first, and only a closed one is let go of. A socket whose close
+        // was refused may still deliver, so it stays this agent's connection,
+        // on the tokens it has, and nothing is started beside it: a second
+        // socket for the agent would answer every message twice, and a removed
+        // app would keep answering while reported gone. A restart clears it.
+        for (const connection of leaving) {
+            const agentId = connection.config.agentId;
+            const reason = !known.has(agentId)
+                ? 'its soul is gone'
+                : wanted.has(agentId) ? 'its tokens changed' : 'its tokens were removed';
+            if (!await disconnect(connection, reason)) {
+                warn(`slack: ${agentId} stays connected with the app it had until a restart, since its socket would not close`);
+                continue;
+            }
+            const index = connections.indexOf(connection);
+            if (index >= 0) {
+                connections.splice(index, 1);
+            }
+            log(`slack: ${agentId} disconnected (${reason})`);
+        }
+        // What is still connected now, stuck sockets included, serves on.
+        const serving = (agentId) => connections.find((connection) => connection.config.agentId === agentId);
+        const arriving = [...wanted.values()].filter((config) => serving(config.agentId) === undefined);
+        // A connected app keeps the configuration it is serving with.
+        carried = [
+            ...next.map((config) => serving(config.agentId)?.config ?? config),
+            ...connections.filter((connection) => !next.some((config) => config.agentId === connection.config.agentId)).map((connection) => connection.config),
+        ];
+        configuredAgents.clear();
+        for (const config of carried) {
+            configuredAgents.add(config.agentId);
+        }
+        // Who each remaining bot is, in the carried order: an app no longer
+        // carried is nobody's to recognize, and a new one is learned below.
+        const kept = new Map(botIdentities);
+        botIdentities.clear();
+        for (const config of carried) {
+            const identity = kept.get(config.agentId);
+            if (identity !== undefined && serving(config.agentId) !== undefined) {
+                botIdentities.set(config.agentId, identity);
+            }
+        }
+        for (const config of next) {
+            if (!known.has(config.agentId) && serving(config.agentId) === undefined) {
+                warn(`slack: no roster agent with id ${config.agentId}; skipping its Slack app`);
+            }
+        }
+        // Every new identity first, then the sockets, as `start` does: a
+        // mention of an agent not yet known would read as an untagged reply.
+        const authenticated = [];
+        for (const config of arriving) {
+            if (stopRequested) {
+                return;
+            }
+            const connection = await authenticate(config);
+            if (connection) {
+                authenticated.push(connection);
+            }
+        }
+        if (authenticated.length > 0) {
+            const learned = new Map(botIdentities);
+            botIdentities.clear();
+            for (const config of carried) {
+                const identity = learned.get(config.agentId);
+                if (identity !== undefined) {
+                    botIdentities.set(config.agentId, identity);
+                }
+            }
+        }
+        settleHomeOwners();
+        for (const connection of authenticated) {
+            if (stopRequested) {
+                return;
+            }
+            await connect(connection);
+        }
+    };
+    // One reload at a time: the gateway can call again before an earlier one
+    // settled, since it stops waiting after a bound.
+    let reloading = Promise.resolve();
+    const reload = () => {
+        const run = reloading.then(reconcile, reconcile);
+        reloading = run.catch(() => undefined);
+        return run;
+    };
     return {
         name: 'slack',
+        ...(options.loadAgents !== undefined ? { reload } : {}),
         resolveOutbound,
         readConversation,
         sessionConversation,
         createConversation,
+        joinConversation,
+        inviteToConversation,
+        archiveConversation,
         // A channel id is unique only within its workspace, so a standing
         // grant on one is bound to the team the agent's app authenticated in.
         accountFor: (agentId) => botIdentities.get(agentId)?.teamId || undefined,
@@ -6831,6 +7523,8 @@ export const createSlackChannelAdapter = (options) => {
         credentialEnvForms: true,
         async start(gateway) {
             gatewayRef = gateway;
+            stopRequested = false;
+            leftUpAtStop.clear();
             // Nothing counts as seen live until every socket is up (Codex
             // 4321128637): a message sent while the sockets are still coming up
             // reaches none of them, so a read stopping before it stops short.
@@ -6956,33 +7650,14 @@ export const createSlackChannelAdapter = (options) => {
             // agent not yet known reads as an untagged reply — which the agent
             // holding that thread would then answer.
             const authenticated = [];
-            for (const config of options.agents) {
+            for (const config of carried) {
                 if (!known.has(config.agentId)) {
                     warn(`slack: no roster agent with id ${config.agentId}; skipping its Slack app`);
                     continue;
                 }
-                try {
-                    const created = createWeb(config.botToken);
-                    const web = config.linkPreviews === false ? withoutLinkPreviews(created) : created;
-                    const auth = await web.auth.test();
-                    const botUserId = auth.user_id ?? '';
-                    const teamId = auth.team_id ?? '';
-                    checkBotScopes(config.agentId, auth.response_metadata?.scopes ?? [], warn);
-                    // Recorded before the socket is even built: an app that never
-                    // comes up must still be recognizable when somebody names it.
-                    botIdentities.set(config.agentId, { botUserId, teamId });
-                    authenticated.push({
-                        config,
-                        web,
-                        socket: createSocket(config.appToken),
-                        botUserId,
-                        teamId,
-                        statusWarned: { value: false },
-                    });
-                }
-                catch (error) {
-                    // One broken app must not take the rest of the fleet down.
-                    warn(`slack: could not connect ${config.agentId}: ${error instanceof Error ? error.message : String(error)}`);
+                const connection = await authenticate(config);
+                if (connection) {
+                    authenticated.push(connection);
                 }
             }
             settleHomeOwners();
@@ -7005,51 +7680,9 @@ export const createSlackChannelAdapter = (options) => {
                 }
             }
             for (const connection of authenticated) {
-                const { config, socket } = connection;
-                try {
-                    // Returns the work it started: the SDK ignores it, and a test's fake
-                    // socket waits on it rather than guessing how long it takes.
-                    const handle = (inbound) => {
-                        const handled = inbound.catch((error) => {
-                            warn(`slack event handling failed: ${error instanceof Error ? error.message : String(error)}`);
-                        });
-                        inflight.add(handled);
-                        void handled.finally(() => inflight.delete(handled));
-                        return handled;
-                    };
-                    // The replay's own deliveries never wait on the hold they release.
-                    const onReplay = (args) => handle(handleInbound(connection, args));
-                    const onEvent = (args) => {
-                        const channel = args.event?.channel;
-                        const hold = typeof channel === 'string' ? replayHolds.get(holdKey(config.agentId, channel))?.held : undefined;
-                        if (hold === undefined) {
-                            return onReplay(args);
-                        }
-                        // Acked now, as any delivery is, so Slack does not redeliver a
-                        // message that is only waiting its turn; admitted after the hold.
-                        void Promise.resolve(args.ack()).catch((error) => {
-                            warn(`slack: could not ack an envelope: ${error instanceof Error ? error.message : String(error)}`);
-                        });
-                        return handle(hold.then(() => handleInbound(connection, { ...args, ack: async () => { } })));
-                    };
-                    socket.on('app_mention', onEvent);
-                    socket.on('message', onEvent);
-                    listeners.set(config.agentId, onReplay);
-                    socket.on('interactive', (args) => {
-                        const handled = handleInteractive(connection, args).catch((error) => {
-                            warn(`slack interaction handling failed: ${error instanceof Error ? error.message : String(error)}`);
-                        });
-                        track(handled);
-                        return handled;
-                    });
-                    await socket.start();
-                    connections.push(connection);
-                    log(`slack: ${config.agentId} connected (bot ${connection.botUserId} in team ${connection.teamId})`);
-                }
-                catch (error) {
-                    // Authenticated but not serving: it answers nothing, and stays
-                    // recognizable so nobody answers in its place.
-                    warn(`slack: could not connect ${config.agentId}: ${error instanceof Error ? error.message : String(error)}`);
+                const onReplay = await connect(connection);
+                if (onReplay) {
+                    listeners.set(connection.config.agentId, onReplay);
                 }
             }
             const liveMs = now() + LIVE_FROM_MARGIN_MS;
@@ -7063,11 +7696,28 @@ export const createSlackChannelAdapter = (options) => {
             track(replayKept(kept, new Map([...listeners].filter(([agentId]) => connections.some((connection) => connection.config.agentId === agentId))), replayStopping.signal).finally(releaseAllConversations));
         },
         async stop() {
+            stopRequested = true;
             replayStopping?.abort();
             releaseAllConversations();
             // Stop intake first, so no new INBOUND event can slip into
-            // `inflight` while the drain below runs.
-            await Promise.allSettled(connections.map((connection) => connection.socket.disconnect()));
+            // `inflight` while the drain below runs. A close that is refused
+            // leaves a socket that may still deliver (card 935), and so does one
+            // still starting that does not come down in time: the stop rejects
+            // naming them, after the drain, and the gateway counts that as not
+            // drained, so a restart exits for the service manager rather than
+            // start a second daemon answering beside them.
+            const closing = Promise.all(connections.map(async (connection) => await disconnect(connection, 'the adapter is stopping') ? undefined : connection.config.agentId));
+            // Whatever is still in here once the wait ends never came up or down.
+            const starting = new Map(socketsStarting);
+            let waited;
+            await Promise.race([
+                Promise.allSettled([...starting.keys()].map((up) => up.finally(() => starting.delete(up)))),
+                new Promise((resolve) => { waited = setTimeout(resolve, stopWaitMs); }),
+            ]);
+            clearTimeout(waited);
+            const refused = [...new Set([...(await closing).filter((agentId) => agentId !== undefined), ...leftUpAtStop])];
+            const stillStarting = [...new Set(starting.values())];
+            leftUpAtStop.clear();
             // Until it stays empty, not once. The bus subscription is still live
             // here — it comes down after the drain, because a turn finishing
             // inside the drain still has an outcome to render — so a turn the
@@ -7101,6 +7751,13 @@ export const createSlackChannelAdapter = (options) => {
             rendering.clear();
             resolvedWhileRendering.clear();
             credentialsPosting.clear();
+            const left = [
+                ...(refused.length > 0 ? [`the socket for ${refused.join(', ')} would not close`] : []),
+                ...(stillStarting.length > 0 ? [`the socket for ${stillStarting.join(', ')} was still starting after ${stopWaitMs}ms`] : []),
+            ];
+            if (left.length > 0) {
+                throw new Error(`${left.join('; ')}, so it may still deliver messages`);
+            }
         },
     };
 };