@stratusagent/channel-slack 0.14.0 → 0.14.2

package/dist/index.js

@@ -3,8 +3,9 @@ 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";
+import { textingParts } from "./texts.js";
 /**
  * The longest display name the model is shown. Slack caps profile names
  * well under this; the bound is for a profile that is not a name.
@@ -110,6 +111,72 @@ 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;
+/**
+ * How long an approval prompt waits for the words its turn wrote before the
+ * call to land first (card 950). Long enough for an ordinary post, short
+ * enough that a slow or refusing Slack never keeps the question from an
+ * approver: the turn is parked on that answer.
+ */
+const DEFAULT_APPROVAL_PROMPT_WAIT_MS = 5_000;
+/**
+ * How long a task works before its progress message opens (card 949): long
+ * enough that a quick answer, a lookup or two, is just its reply; short
+ * enough that a task taking minutes shows what it is doing while it does.
+ */
+const DEFAULT_PROGRESS_AFTER_MS = 10_000;
+/** Room kept for a progress message's first line and its `…` when its notes are trimmed. */
+const PROGRESS_HEADER_ROOM = 200;
+/**
+ * The most a progress message holds under its first line. Words longer than
+ * this are content, not a step — an analysis written before a tool call —
+ * and are posted whole as messages of their own, as before card 949, rather
+ * than cut to fit and lost.
+ */
+const PROGRESS_NOTE_ROOM = SLACK_MAX_MESSAGE_CHARS - PROGRESS_HEADER_ROOM;
+const stepCount = (steps) => `${steps} ${steps === 1 ? 'step' : 'steps'}`;
+/** A tool's name as code, which no backtick of its own can close early. */
+const toolCode = (toolName) => `\`${escapeSlackText(toolName.replace(/`/g, ''))}\``;
+/**
+ * The first line of a progress message: what the turn is doing, from the
+ * tool calls it made and is making. Words the model wrote are under it, as
+ * notes; this line is the part that cannot claim more than happened.
+ */
+const progressHeader = (state) => {
+    switch (state.end) {
+        case 'done':
+            return `✓ Done · ${stepCount(state.steps)}`;
+        case 'stopped':
+            return `■ Stopped after ${stepCount(state.steps)}`;
+        case 'failed':
+            return `✗ Failed after ${stepCount(state.steps)}`;
+        default:
+            break;
+    }
+    if (state.waitingOn !== undefined) {
+        return `⏸ Waiting for approval to run ${toolCode(state.waitingOn)}`;
+    }
+    const latest = [...state.running.values()].at(-1);
+    if (latest !== undefined) {
+        return `⚙ Working · step ${state.steps}: ${toolCode(latest)}`;
+    }
+    return `⚙ Working · ${stepCount(state.steps)} done`;
+};
+/** Resolves when `work` settles or after `ms`, whichever is first; never rejects. */
+const settledWithin = (work, ms) => new Promise((resolve) => {
+    const timer = setTimeout(resolve, ms);
+    timer.unref?.();
+    const done = () => {
+        clearTimeout(timer);
+        resolve();
+    };
+    work.then(done, done);
+});
 /** What a turn that produced no text puts in its message, wherever it is posted from. */
 const NO_REPLY_TEXT = '(no reply)';
 /**
@@ -266,6 +333,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 —
@@ -407,6 +508,40 @@ class ReplyRenderer {
      * once that is known, so the thread's other agents hear it in its place.
      */
     onInterim;
+    /**
+     * Card 949, `final` mode: a task says what it is about to do in a
+     * message of its own (its first words before a tool), then keeps ONE
+     * progress message up to date — a first line built from its tool events,
+     * and under it whatever else it wrote between tools — and posts its reply
+     * as a message of its own. Narration that used to be a post per step is
+     * an edit, so a long task is three messages, not twenty.
+     *
+     * Whether this turn's first words have gone out, so later words are notes.
+     */
+    firstWordsSaid = false;
+    /** Whether the progress message has been asked for; it may not have landed yet. */
+    progressOpen = false;
+    /** The progress message, once Slack took it. */
+    progressRef;
+    /** What the first line says, from this turn's own tool events only. */
+    progress = { steps: 0, running: new Map(), waitingOn: undefined, end: undefined };
+    /**
+     * The notes under that line, as sent: converted, oldest dropped past one
+     * message's room. `shown` once a write that held the note has landed: a
+     * note trimmed while its write was still queued never reached anyone.
+     */
+    progressNotes = [];
+    /** Whether older notes were dropped for room, so the message says so. */
+    progressNotesCut = false;
+    /** Whether the last thing this turn said is a note rather than a message of its own. */
+    lastSaidWasNote = false;
+    progressTimer;
+    progressOpenTimer;
+    lastProgressAt = 0;
+    turnStartedAt = 0;
+    /** How the turn ended, for the progress message: a stop or a failure says so before it finalizes. */
+    ending = 'done';
+    progressAfterMs;
     /** The lowest trust this turn's session was lowered to while it ran (`session.tainted`). */
     taintedTo;
     turnBreakPending = false;
@@ -473,6 +608,12 @@ class ReplyRenderer {
      * could not be opened.
      */
     streaming;
+    /**
+     * Whether the reply, and what the turn says before a tool, are posted a
+     * paragraph to a message (`texts` mode). Never with `streaming`: there
+     * is one placeholder to stream into.
+     */
+    texts;
     /**
      * The thread the loading status belongs to: the reply's thread, or the
      * message itself in a DM, whose reply has no thread to key one on.
@@ -505,6 +646,13 @@ class ReplyRenderer {
     statusTimer;
     /** The tool the turn is running, for the status line; the streamed `toolLine` is the other mode's. */
     runningTool;
+    /**
+     * Calls started and not yet settled, by call id, oldest first. Core runs
+     * a response's read-only calls together, so one can settle while another
+     * still runs: both lines name the newest call still running, and clear
+     * only once none is.
+     */
+    activeTools = new Map();
     web;
     /**
      * The one person in the conversation when this turn is a DM: whoever sent
@@ -527,11 +675,13 @@ class ReplyRenderer {
         this.lazy = options.lazy ?? false;
         this.now = options.now ?? Date.now;
         this.streaming = options.streaming ?? true;
+        this.texts = !this.streaming && options.texts === true;
         this.statusThread = options.statusThread ?? threadTs;
         this.statusWarned = options.statusWarned ?? { value: false };
         this.after = options.after ?? Promise.resolve();
         this.dmWith = options.dmWith;
         this.onInterim = options.onInterim;
+        this.progressAfterMs = options.progressAfterMs ?? DEFAULT_PROGRESS_AFTER_MS;
     }
     /**
      * Show Slack's loading status for this turn, and keep it up until the
@@ -622,6 +772,9 @@ class ReplyRenderer {
      * included, so this turn's placeholder starts empty.
      */
     beginTurn() {
+        if (!this.turnStarted) {
+            this.turnStartedAt = Date.now();
+        }
         this.turnStarted = true;
         if (this.pendingEdit) {
             clearTimeout(this.pendingEdit);
@@ -629,6 +782,7 @@ class ReplyRenderer {
         }
         this.buffer = '';
         this.interim = '';
+        this.activeTools.clear();
         this.toolLine = undefined;
         this.runningTool = undefined;
         this.turnBreakPending = false;
@@ -705,9 +859,16 @@ class ReplyRenderer {
             // all, so this is the only thing between the text before a tool and
             // the text after it — without it they fuse in the live message.
             this.turnBreakPending = true;
-            this.toolLine = `⚙ ${event.call.toolName}…`;
-            this.runningTool = event.call.toolName;
+            this.activeTools.set(event.call.id, event.call.toolName);
+            this.showActiveTool();
             this.flushInterim(ofThisTurn);
+            if (ofThisTurn && this.mayShowProgress()) {
+                this.progress.steps += 1;
+                this.progress.running.set(event.call.id, event.call.toolName);
+                this.progress.waitingOn = undefined;
+                this.openProgressInTime();
+                this.scheduleProgress();
+            }
             this.scheduleEdit();
             return;
         }
@@ -716,21 +877,27 @@ class ReplyRenderer {
             // else clears the status line or marks the boundary for it — the
             // message would keep claiming a refused tool is running, and the
             // model's follow-up would fuse with the text before the attempt.
-            this.toolLine = undefined;
-            this.runningTool = undefined;
+            this.activeTools.delete(event.call.id);
+            this.showActiveTool();
             this.turnBreakPending = true;
             // Words written before a call that was refused were still said
             // before a tool, and must not run into the next response's.
             this.flushInterim(ofThisTurn);
+            if (ofThisTurn) {
+                this.settleProgressStep(event.call.id);
+            }
             this.scheduleEdit();
             return;
         }
         if (event.type === 'tool.completed') {
-            this.toolLine = undefined;
-            this.runningTool = undefined;
+            this.activeTools.delete(event.result.callId);
+            this.showActiveTool();
             // Settled here too for a call rejected before it ran, which never
             // reached `tool.called`; after one that did, this is empty.
             this.flushInterim(ofThisTurn);
+            if (ofThisTurn) {
+                this.settleProgressStep(event.result.callId);
+            }
             // Also a boundary, and not only for symmetry: a call rejected before
             // execution settles as tool.completed without ever having emitted
             // tool.called, so this is the only mark that attempt leaves.
@@ -821,8 +988,18 @@ class ReplyRenderer {
         const text = this.interim.trim();
         this.interim = '';
         if (this.streaming || this.lazy || !this.turnStarted || !ofThisTurn || text.length === 0) {
-            return;
+            return undefined;
+        }
+        // Only words before the turn's first tool are a message of their own:
+        // after one, a step has run, and what follows is progress whether or
+        // not the turn opened with a line.
+        if (this.firstWordsSaid || this.progressOpen || this.progress.steps > 0) {
+            const note = toSlackMrkdwn(text);
+            if (note.length <= PROGRESS_NOTE_ROOM) {
+                return this.noteProgress(text, note);
+            }
         }
+        this.firstWordsSaid = true;
         const handover = this.handover;
         const after = this.after;
         let heard = '';
@@ -837,7 +1014,7 @@ class ReplyRenderer {
             .then(async () => {
             const landed = [];
             try {
-                for (const chunk of messageChunks(text)) {
+                for (const chunk of this.chunksOf(text)) {
                     const posted = await this.web.chat.postMessage({
                         channel: this.channel,
                         text: chunk,
@@ -854,12 +1031,13 @@ class ReplyRenderer {
                 // reply, where repeating a few lines beats losing the rest.
                 if (landed.length > 0) {
                     this.interimPosted = true;
-                    heard = landed.length === messageChunks(text).length ? text : landed.join('\n\n');
+                    heard = landed.length === this.chunksOf(text).length ? text : landed.join('\n\n');
                 }
                 settleLanded(landed.length > 0);
             }
             this.lastInterim = text;
             this.interimSaid.push(text);
+            this.lastSaidWasNote = false;
             // A post of the app's in this thread takes the status down while
             // the turn is still working; put it back.
             this.refreshLoading();
@@ -868,6 +1046,230 @@ class ReplyRenderer {
             // Settled whatever happened above, or the other agents' intake would
             // wait on it for good. A second settle is a no-op.
             .finally(() => settleLanded(false));
+        return landedNow;
+    }
+    /**
+     * Whether this turn keeps a progress message (card 949): `final` mode,
+     * a turn somebody asked for, and its own — the same turns that post
+     * their words before a tool. A streaming turn's placeholder already
+     * shows its tool lines, and a turn nobody asked for must not speak
+     * before it decides to.
+     */
+    mayShowProgress() {
+        return !this.streaming && !this.lazy && this.turnStarted && !this.finalized;
+    }
+    /**
+     * Words the turn wrote between tools after its first line: a note in the
+     * progress message, opening it if need be, rather than a post of their
+     * own. Heard by the thread's other agents and stripped from a reply that
+     * repeats them, as a message of their own would be. A note Slack refused
+     * is taken out again, so a later edit never shows words nobody heard.
+     */
+    noteProgress(text, converted) {
+        this.progressOpen = true;
+        this.clearProgressOpenTimer();
+        const note = { text: converted };
+        this.progressNotes.push(note);
+        this.trimProgressNotes();
+        let heard = '';
+        let settleLanded;
+        const landedNow = new Promise((resolve) => {
+            settleLanded = resolve;
+        });
+        this.onInterim?.(() => heard, landedNow);
+        // Said once a write that held it has landed, whichever write that was,
+        // and only then. Its own write can land after a slow Slack let later
+        // notes trim it out unseen, or be refused after an earlier write showed
+        // it. Unseen, it is not said: the others do not hear it, and a reply
+        // that repeats it keeps it.
+        const settle = () => {
+            if (!note.shown) {
+                this.progressNotes = this.progressNotes.filter((kept) => kept !== note);
+                settleLanded(false);
+                return;
+            }
+            this.interimPosted = true;
+            heard = text;
+            this.lastInterim = text;
+            this.interimSaid.push(text);
+            this.lastSaidWasNote = true;
+            settleLanded(true);
+        };
+        this.queueProgressWrite(settle, settle);
+        return landedNow;
+    }
+    /**
+     * Keep the notes to what one message holds with its first line: the
+     * newest, since the oldest are what a reader has already seen. Past
+     * that the message opens with `…`, and memory stays bounded however
+     * long the task runs.
+     */
+    trimProgressNotes() {
+        let size = this.progressNotes.reduce((total, note) => total + note.text.length + 2, 0);
+        while (size > PROGRESS_NOTE_ROOM && this.progressNotes.length > 1) {
+            size -= (this.progressNotes.shift()?.text.length ?? 0) + 2;
+            this.progressNotesCut = true;
+        }
+    }
+    progressText(omitLast = false) {
+        const notes = omitLast ? this.progressNotes.slice(0, -1) : this.progressNotes;
+        const parts = [progressHeader(this.progress), ...(this.progressNotesCut ? ['…'] : []), ...notes.map((note) => note.text)];
+        return truncateForSlack(parts.join('\n\n'));
+    }
+    /**
+     * Put the progress message as it stands now into the thread: posted the
+     * first time, edited after. On the upload chain, behind the turn ahead
+     * and any handover, so it lands below this turn's first line and above
+     * its files and reply, and reads its state when it runs, not when asked.
+     */
+    queueProgressWrite(landed, refused) {
+        const handover = this.handover;
+        const after = this.after;
+        this.uploadChain = this.uploadChain
+            .then(() => handover)
+            .then(() => after)
+            .then(async () => {
+            this.lastProgressAt = Date.now();
+            const held = [...this.progressNotes];
+            await this.writeProgress(this.progressText());
+            for (const note of held) {
+                note.shown = true;
+            }
+            landed?.();
+        })
+            .catch((error) => {
+            refused?.();
+            this.warn(`could not update the progress message: ${error instanceof Error ? error.message : String(error)}`);
+        });
+    }
+    async writeProgress(text) {
+        const ref = this.progressRef;
+        if (ref) {
+            await this.web.chat.update({ channel: ref.channel, ts: ref.ts, text });
+            return;
+        }
+        const posted = await this.web.chat.postMessage({
+            channel: this.channel,
+            text,
+            ...(this.threadTs ? { thread_ts: this.threadTs } : {}),
+        });
+        if (posted.ts) {
+            this.progressRef = { channel: posted.channel ?? this.channel, ts: posted.ts };
+        }
+        this.placeText(posted.ts);
+        // A post of the app's in this thread takes the status down while the
+        // turn is still working; put it back.
+        this.refreshLoading();
+    }
+    /** Edit the progress message for a step that started or settled, at most once per edit interval. */
+    scheduleProgress() {
+        if (!this.progressOpen || this.finalized || this.progressTimer) {
+            return;
+        }
+        const delay = Math.max(0, this.editIntervalMs - (Date.now() - this.lastProgressAt));
+        this.progressTimer = setTimeout(() => {
+            this.progressTimer = undefined;
+            if (!this.finalized) {
+                this.queueProgressWrite();
+            }
+        }, delay);
+        this.progressTimer.unref?.();
+    }
+    /**
+     * Open the progress message once the turn has worked `progressAfterMs`:
+     * now, if it has, or when it will have. Asked on a tool call, so there
+     * is always a step to show; a quick answer ends first and opens none.
+     */
+    openProgressInTime() {
+        if (this.progressOpen || this.progressOpenTimer) {
+            return;
+        }
+        const open = () => {
+            this.progressOpen = true;
+            this.queueProgressWrite();
+        };
+        const wait = this.progressAfterMs - (Date.now() - this.turnStartedAt);
+        if (wait <= 0) {
+            open();
+            return;
+        }
+        this.progressOpenTimer = setTimeout(() => {
+            this.progressOpenTimer = undefined;
+            if (!this.finalized && !this.progressOpen) {
+                open();
+            }
+        }, wait);
+        this.progressOpenTimer.unref?.();
+    }
+    /** A step of this turn's finished or was refused. */
+    settleProgressStep(callId) {
+        if (!this.mayShowProgress()) {
+            return;
+        }
+        this.progress.running.delete(callId);
+        this.progress.waitingOn = undefined;
+        this.scheduleProgress();
+    }
+    /**
+     * A call of this turn's is waiting on a person: the progress message says
+     * so until the call runs or is refused. The prompt itself is a message
+     * of its own, below it.
+     */
+    awaitingApproval(toolName, ofThisTurn) {
+        if (!ofThisTurn || !this.mayShowProgress()) {
+            return;
+        }
+        this.progress.waitingOn = toolName;
+        this.scheduleProgress();
+    }
+    clearProgressOpenTimer() {
+        if (this.progressOpenTimer) {
+            clearTimeout(this.progressOpenTimer);
+            this.progressOpenTimer = undefined;
+        }
+    }
+    clearProgressTimers() {
+        this.clearProgressOpenTimer();
+        if (this.progressTimer) {
+            clearTimeout(this.progressTimer);
+            this.progressTimer = undefined;
+        }
+    }
+    /**
+     * The progress message's last edit: how the task ended, and every note
+     * but one that became the reply. Resolves once Slack has answered; a
+     * refusal leaves the last state that landed, and is logged.
+     */
+    async closeProgress(omitLast) {
+        this.clearProgressTimers();
+        const ref = this.progressRef;
+        if (!ref) {
+            return;
+        }
+        this.progress.end = this.ending;
+        try {
+            await this.web.chat.update({ channel: ref.channel, ts: ref.ts, text: this.progressText(omitLast) });
+        }
+        catch (error) {
+            this.warn(`could not finish the progress message: ${error instanceof Error ? error.message : String(error)}`);
+        }
+    }
+    /**
+     * Post what the model said before a call that is about to ask for
+     * approval, and resolve once it has landed (or could not), or at once
+     * when there is nothing to post (card 950).
+     *
+     * The prompt is posted before the call starts, so waiting for
+     * `tool.called` put the question above the line saying what the agent
+     * set out to do, and the approver answered without it. The same flush
+     * `tool.called` would have done, only earlier: what it posts is stripped
+     * from the reply as before, and the flush at `tool.called` finds nothing.
+     */
+    sayBeforeAsking(ofThisTurn) {
+        if (this.finalized) {
+            return undefined;
+        }
+        return this.flushInterim(ofThisTurn);
     }
     /**
      * Everything this turn said in the thread, for its other agents to hear:
@@ -902,6 +1304,12 @@ class ReplyRenderer {
         }
         return rest === this.lastInterim ? '' : rest;
     }
+    /** Point both status lines at the newest call still running, or clear them. */
+    showActiveTool() {
+        const running = [...this.activeTools.values()].at(-1);
+        this.runningTool = running;
+        this.toolLine = running === undefined ? undefined : `⚙ ${running}…`;
+    }
     currentText() {
         const parts = [this.buffer.trim(), this.toolLine].filter((part) => Boolean(part && part.length > 0));
         return parts.length > 0 ? parts.join('\n\n') : PLACEHOLDER_TEXT;
@@ -1011,6 +1419,7 @@ class ReplyRenderer {
         const hadStatus = this.statusTimer !== undefined;
         this.stopLoading();
         this.finalized = true;
+        this.clearProgressTimers();
         if (!this.streaming) {
             await this.after;
             await this.statusChain;
@@ -1039,10 +1448,25 @@ class ReplyRenderer {
         // tool call) is not posted again, and a turn that said things along
         // the way is not followed by `(no reply)`.
         await this.uploadChain;
+        // Words the turn ended on, written before its last tool call, are its
+        // answer (card 949): a reply that only repeats them, or an empty one,
+        // posts them as the reply, and the progress message lets them go. Left
+        // as its last note, the answer would sit in the message that says how
+        // the work went, above where anyone looks for it.
+        let promoted = false;
         if (this.interimPosted && !this.ref) {
-            reply = this.unsaid(reply);
-        }
+            const rest = this.unsaid(reply);
+            promoted = rest.length === 0 && this.lastSaidWasNote && this.lastInterim !== undefined;
+            reply = promoted && this.lastInterim !== undefined ? this.lastInterim : rest;
+        }
+        // Alongside the reply rather than ahead of it: an edit keeps its place,
+        // and the answer should not wait on a round trip for a status line.
+        // Words promoted to the reply are the exception: they leave the
+        // progress message only once the reply holding them has landed, so a
+        // reply Slack refuses does not take the answer out of the thread.
+        const closed = promoted ? undefined : this.closeProgress(false);
         if (!this.ref && this.interimPosted && reply.trim().length === 0) {
+            await (closed ?? this.closeProgress(false));
             // Nothing posts after this to take the status down, so it is cleared.
             if (hadStatus) {
                 this.setStatus('');
@@ -1051,7 +1475,7 @@ class ReplyRenderer {
             return this.outcome(true, true);
         }
         const text = reply.trim().length > 0 ? reply : NO_REPLY_TEXT;
-        const chunks = messageChunks(text);
+        const chunks = this.chunksOf(text);
         // No placeholder — a handover could not open a fresh one — and the
         // reply is a message of its own rather than nothing at all.
         const rest = this.ref ? chunks.slice(1) : chunks;
@@ -1081,6 +1505,7 @@ class ReplyRenderer {
         // avoid, so it is taken back like an abandoned attempt's. One Slack
         // will not let go stands, and a message the thread can see is the
         // last thing said whatever it says.
+        await (closed ?? this.closeProgress(published));
         let stranded = false;
         if (this.lazy && this.ref !== undefined && !landed && !this.edited) {
             stranded = !(await this.retract());
@@ -1102,6 +1527,10 @@ class ReplyRenderer {
         }
         return this.outcome(published, landed || this.edited || this.uploaded || stranded, !published);
     }
+    /** This turn's text as the messages it is posted as, in this agent's reply mode. */
+    chunksOf(text) {
+        return messageChunks(text, this.texts ? 'texts' : undefined);
+    }
     placeText(ts) {
         if (ts !== undefined && (this.textAt === undefined || ts > this.textAt)) {
             this.textAt = ts;
@@ -1157,6 +1586,7 @@ class ReplyRenderer {
             const hadStatus = this.statusTimer !== undefined;
             this.stopLoading();
             this.finalized = true;
+            this.clearProgressTimers();
             // The barrier `finalizeInOrder` takes, for the same reason: the turn
             // queued behind this one waits on `posted`, and settling it before
             // the reply ahead has posted would let that turn's reply overtake it.
@@ -1192,6 +1622,7 @@ class ReplyRenderer {
         if (this.lazy && !this.ref && this.buffer.trim().length === 0) {
             return this.finalize('');
         }
+        this.ending = 'stopped';
         return this.finalize(`Stopped by <@${by}>.`);
     }
     /**
@@ -1217,6 +1648,8 @@ class ReplyRenderer {
             this.warn(`a turn nobody asked for failed before saying anything: ${message}`);
             return this.finalize('');
         }
+        // A spent budget is a limit working, not a fault: the task stopped.
+        this.ending = refused ? 'stopped' : 'failed';
         return this.finalize(refused ? message : `Something went wrong: ${message}`);
     }
     /**
@@ -1453,8 +1886,12 @@ const messageText = (text) => truncateForSlack(toSlackMrkdwn(text));
  * Agent text as however many Slack messages it takes. Converted before it
  * is split, so a chunk is measured at the length it will be sent at, and so
  * no rewrite is ever asked to span a boundary.
+ *
+ * In `texts` mode a reply is first cut into the few messages it is texted
+ * as, each then converted and sized on its own: the cuts never fall inside
+ * code, and nothing else in the conversion crosses a line.
  */
-const messageChunks = (text) => splitForSlack(toSlackMrkdwn(text));
+const messageChunks = (text, replies) => (replies === 'texts' ? textingParts(text) : [text]).flatMap((part) => splitForSlack(toSlackMrkdwn(part)));
 const APPROVAL_ACTIONS = {
     stratus_approve_once: 'once',
     stratus_approve_always: 'always',
@@ -1629,7 +2066,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 +2259,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;
 /**
@@ -2304,7 +2839,10 @@ const credentialModal = (post, requestId) => ({
             type: 'input',
             block_id: CREDENTIAL_BLOCK,
             label: { type: 'plain_text', text: `Value for ${post.name}` },
-            element: { type: 'plain_text_input', action_id: CREDENTIAL_INPUT },
+            // Several lines: a one-line field flattens the line breaks of a pasted
+            // key file, such as a PEM private key, and the key stops working.
+            element: { type: 'plain_text_input', action_id: CREDENTIAL_INPUT, multiline: true },
+            hint: { type: 'plain_text', text: 'Paste the whole value. A key file, such as a PEM private key, keeps its line breaks.' },
         },
     ],
 });
@@ -2351,6 +2889,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 +2942,19 @@ 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 approvalPromptWaitMs = options.approvalPromptWaitMs ?? DEFAULT_APPROVAL_PROMPT_WAIT_MS;
+    const progressAfterMs = options.progressAfterMs ?? DEFAULT_PROGRESS_AFTER_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 +3148,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
@@ -2605,8 +3177,24 @@ export const createSlackChannelAdapter = (options) => {
     // outstanding.
     const rendering = new Set();
     const resolvedWhileRendering = new Map();
+    // Requests whose prompt is waiting for its turn's line to land first
+    // (card 950), and those of them settled in that wait: a request answered
+    // or cancelled before anyone was asked has no prompt to post. Bounded the
+    // same way: an id is here only for one bounded wait.
+    const askingAfterLine = new Set();
+    const settledBeforeAsked = new Set();
     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 +3949,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 +3965,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 +4496,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 +4509,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 +4518,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 +4569,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 +4642,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))}).`);
+            refused = refusedOf(error?.data?.errors);
+            failure = describeSlackError(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)}).` }));
-        }
-        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.
@@ -4530,7 +5398,7 @@ export const createSlackChannelAdapter = (options) => {
         // last. `NO_REPLY_TEXT` is what a rendered turn with nothing to say
         // puts in its own message too. With nothing queued behind, there is no
         // order to keep and nothing to say, so the files go on their own.
-        const chunks = routing.reply ? messageChunks(routing.reply) : [];
+        const chunks = routing.reply ? messageChunks(routing.reply, connection.config.replies) : [];
         const posting = chunks.length > 0 ? chunks : (behind && files.length > 0 ? [NO_REPLY_TEXT] : []);
         let landed = [];
         const uploads = async () => {
@@ -6498,6 +7366,8 @@ export const createSlackChannelAdapter = (options) => {
                 lazy: judged,
                 now,
                 streaming,
+                progressAfterMs,
+                texts: connection.config.replies === 'texts',
                 statusThread: thread ?? event.ts,
                 statusWarned: connection.statusWarned,
                 ...(ahead ? { after: ahead } : {}),
@@ -6816,12 +7686,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,23 +7933,21 @@ 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.
             liveFrom = NOT_LIVE_YET;
             unsubscribe = gateway.bus.subscribe((event) => {
-                // Approval traffic is not part of a reply: it gets its own message
-                // with its own lifetime, and routing it through the running turn's
-                // renderer would fold a question into the answer being streamed.
-                if (event.type === 'tool.approval-requested') {
-                    track(renderApprovalRequest(event));
-                    return;
-                }
                 if (event.type === 'credential.provided') {
                     track(settleCredentialPost(event));
                     return;
                 }
                 if (event.type === 'tool.approval-resolved') {
+                    if (askingAfterLine.has(event.requestId)) {
+                        settledBeforeAsked.add(event.requestId);
+                    }
                     // The question was posted into the turn's thread, which took the
                     // loading status down with it; the turn works on once answered.
                     track(retractApprovalRequest(event).finally(() => renderers.get(event.sessionId)?.[0]?.refreshLoading()));
@@ -6900,6 +8000,30 @@ export const createSlackChannelAdapter = (options) => {
                 // turn from a renderer still waiting to start, and the renderer
                 // keeps what it is handed, as it always has.
                 const foreign = exact && !rendered;
+                // Approval traffic is not part of a reply: it gets its own message
+                // with its own lifetime, and routing it through the running turn's
+                // renderer would fold a question into the answer being streamed.
+                // What the turn wrote before the call goes out first, though, so
+                // the approver reads the line saying what the agent is doing above
+                // the question it leads to (card 950). The wait is bounded: a line
+                // Slack is slow to take must not keep the question from anyone.
+                if (event.type === 'tool.approval-requested') {
+                    head?.awaitingApproval(event.call.toolName, !foreign);
+                    const said = head?.sayBeforeAsking(!foreign);
+                    if (!said) {
+                        track(renderApprovalRequest(event));
+                        return;
+                    }
+                    askingAfterLine.add(event.requestId);
+                    track(settledWithin(said, approvalPromptWaitMs).then(async () => {
+                        askingAfterLine.delete(event.requestId);
+                        if (settledBeforeAsked.delete(event.requestId)) {
+                            return;
+                        }
+                        await renderApprovalRequest(event);
+                    }));
+                    return;
+                }
                 if (event.type === 'tool.completed' && event.result.ok && (foreign || !head)) {
                     const produced = collectFilePaths(event.result);
                     if (produced.length > 0) {
@@ -6956,33 +8080,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 +8110,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 +8126,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 +8181,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`);
+            }
         },
     };
 };