@stratusagent/channel-slack 0.14.1 → 0.14.2

package/dist/index.js

@@ -5,6 +5,7 @@ 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_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.
@@ -116,6 +117,66 @@ const DEFAULT_FILE_DOWNLOAD_TIMEOUT_MS = 30_000;
  * 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)';
 /**
@@ -447,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;
@@ -513,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.
@@ -545,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
@@ -567,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
@@ -662,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);
@@ -669,6 +782,7 @@ class ReplyRenderer {
         }
         this.buffer = '';
         this.interim = '';
+        this.activeTools.clear();
         this.toolLine = undefined;
         this.runningTool = undefined;
         this.turnBreakPending = false;
@@ -745,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;
         }
@@ -756,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.
@@ -861,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 = '';
@@ -877,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,
@@ -894,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();
@@ -908,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:
@@ -942,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;
@@ -1051,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;
@@ -1079,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('');
@@ -1091,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;
@@ -1121,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());
@@ -1142,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;
@@ -1197,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.
@@ -1232,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}>.`);
     }
     /**
@@ -1257,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}`);
     }
     /**
@@ -1493,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',
@@ -2442,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.' },
         },
     ],
 });
@@ -2545,6 +2945,8 @@ export const createSlackChannelAdapter = (options) => {
     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
@@ -2775,6 +3177,12 @@ 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
@@ -4990,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 () => {
@@ -6958,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 } : {}),
@@ -7530,18 +7940,14 @@ export const createSlackChannelAdapter = (options) => {
             // 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()));
@@ -7594,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) {