allaboard 0.0.0-stage → 0.4.0

package/dist/chat/slack/reply/sinks.js

@@ -0,0 +1,2403 @@
+/**
+ * Write a rendered reply to Slack as a native stream: `chat.startStream` with the reply's first
+ * content, `chat.appendStream` as it grows, `chat.stopStream` at its end, in the session's thread.
+ * A stream in a thread the owner started notifies once, when it stops, with its first text as the
+ * banner, and never at its start (measured 2026-09-29). Slack closes a stream 5 minutes after it
+ * started (measured), so a reply that runs longer stops its stream at STREAM_SECONDS and goes on in
+ * the same message with `chat.update`, which never notifies; its end then posts a closing message.
+ * Every `chat.appendStream` and `chat.update` also waits its turn on an `UpdateLimiter` shared by
+ * every reply in the process: a token bucket that paces writes evenly under the app's own budget,
+ * rather than letting several busy threads exhaust it together and then freeze until it resets.
+ *
+ * The client is the replies client of `clients.ts` (`repliesClient`), and the sink relies on its
+ * policy: a rate limited call is sent again by the client, a call that failed on the connection
+ * is sent again once EXCEPT the four that create or grow a message (start, append, stop, post),
+ * which are never sent twice, since Slack may have applied them. The sink reads the thread back
+ * for those and adopts what landed. Constructed with another client, the sink would post or
+ * append twice after a reset.
+ *
+ * How a sink is stopped. Whoever stops a sink (`!stop`, a close, a restart)
+ * follows the same rule:
+ *
+ * 1. A pass is never cancelled. A pass is `flush`: it takes the lock, brings every message to
+ *    the model and ends the reply if it has ended. Once asked for it runs to its end, whoever
+ *    stops waiting for it, and the next pass queues behind it on the lock. `@slack/web-api` cannot
+ *    abort a call in flight (the only signal `WebClient.makeRequest` gives `fetch` is the client's
+ *    own timeout), and a call given up after Slack took it loses a message's ts or posts an
+ *    ending twice. For that reason no wait inside a pass (the lock, the limiter, a Slack call, a
+ *    read-back) takes a signal. One pause inside a Slack call does end early, at the daemon's
+ *    stop: the one the client makes after Slack rate limited the call (`ClientOptions.stopped`
+ *    in `clients.ts`). Nothing is in flight then, and Slack did not apply the call it answered
+ *    `ratelimited`: the pass gets that failure, as it does when the retries run out.
+ * 2. What can be cancelled is a wait outside a pass, and it is cancelled with an `AbortSignal`:
+ *    the debounce before a write, the pause before the end's one retry, the stream's 280 seconds
+ *    (each a `Task` with its own signal, aborted by `Task.cancel`), and a caller's own wait for a
+ *    pass. `finish`, `closeOut`, `waitLanded` and `settle` take an optional signal: aborting it
+ *    rejects that call with the signal's reason and leaves the pass running. To stop a sink,
+ *    abort the signal you gave it, then `settle()` to wait for what is in flight.
+ * 3. A cancelled wait rejects with the signal's reason; a `Task` aborts with `Cancelled`. A task
+ *    that was cancelled while its shielded pass ran sees `signal.aborted` when the pass returns
+ *    and does nothing more.
+ * 4. The lock is `Mutex`: first come, first served.
+ * 5. State is explicit, never carried by a task being alive: `pending` is null whenever no
+ *    debounce waits (cleared by the task itself as it returns, and by whoever cancels it), and
+ *    `landedValue` says whether and how the end resolved.
+ */
+import { isDeepStrictEqual } from "node:util";
+import { systemClock } from "../../../clock.js";
+import { cancellable, Fold, formatDuration, Mutex, shownPreview } from "../../../core/port.js";
+import { blank, strip } from "../../../text.js";
+import { formatFooter } from "../footer.js";
+import { asideBlock, BANNER_LIMIT, BLOCKS_LIMIT, blocksCount, blocksSizes, blockText, CARD_TEXT_FIELDS, cardAddition, cardBlock, cardChunk, cardFields, contextBlock, isRunningList, MESSAGE_LIMIT, PREVIEW_CUT, plainLines, plainText, previewBlocks, previewContainers, runningListBlock, split, TERMINAL, ZERO_WIDTH_SPACE, } from "./blocks.js";
+import { at, lastNewline, len, lstripNewlines, rstripNewlines, stripNewlines, take, } from "./chars.js";
+import { logger as defaultLogger, describe, describeRefusal, NOT_STREAMING, REFUSED_CONTENT, STILL_STREAMING, TOO_LONG, tooManyBlocks, unknownOutcome, } from "./errors.js";
+import { mrkdwnEscape } from "./escape.js";
+import { bannerText, markdownBlocks, markdownCut, plainWords } from "./markdown.js";
+import { positionOf, ThreadPlaces } from "./places.js";
+import { Task } from "./tasks.js";
+/** What `chat.delete` answers for a message that is not there: it counts as deleted. */
+const MESSAGE_NOT_FOUND = "message_not_found";
+export const DEBOUNCE_SECONDS = 1.0;
+// The final write has no next rewrite to fix it: one that fails for any reason but its content
+// is tried once more after this pause.
+export const FINAL_RETRY_SECONDS = 10.0;
+// A stream is closed by Slack 5 minutes after `chat.startStream` (measured 2026-09-28: refused at
+// 300.3 s and 305 s); stopped by the daemon at this age, it leaves a margin for the round trip.
+export const STREAM_SECONDS = 280.0;
+// A stream past this age is over, whatever the daemon did (refused at 300.3 s).
+export const STREAM_LIFE = 300.0;
+// A running command's card shows how long it has run from this age (the terminal shows seconds
+// from the first; a card is rewritten, so the first number waits for the first refresh) and is
+// refreshed at this interval while the stream lives. After the stream has stopped nothing
+// refreshes it: the seconds are read again whenever the message is rewritten.
+export const RUNNING_REFRESH_SECONDS = 30.0;
+// How far back a create of unknown outcome is looked for: the attempt's own clock, less this.
+export const ADOPT_SKEW_SECONDS = 2.0;
+// How much of a message's first words is compared to know it is the one that was lost.
+export const ADOPT_WORDS = 40;
+/** `a <= b`: by part, then by offset. */
+function upTo(a, b) {
+    return a[0] < b[0] || (a[0] === b[0] && a[1] <= b[1]);
+}
+function sameCursor(a, b) {
+    if (a === null || b === null)
+        return a === b;
+    return a[0] === b[0] && a[1] === b[1];
+}
+/** A preview piece of a tool, as a key: (part, piece). */
+function pieceKey(index, piece) {
+    return `${index}:${piece}`;
+}
+class Text {
+    text;
+    /** A line of the daemon's own: never the banner while Claude has words. */
+    notice;
+    /** A notice that says how a reply was cut short (`endingCursor`). */
+    ending;
+    /** A line about the work (a task's end): grey once the message is written by an update. */
+    aside;
+    /** Bumped when it changes: a message whose parts kept theirs is not rendered again. */
+    rev;
+    constructor(text, notice, ending, aside, rev) {
+        this.text = text;
+        this.notice = notice;
+        this.ending = ending;
+        this.aside = aside;
+        this.rev = rev;
+    }
+}
+/**
+ * The call as its card shows it: a call the terminal times (a shell command) that has run
+ * RUNNING_REFRESH_SECONDS reads `<title> · <duration>`.
+ */
+function timedUpdate(update, now) {
+    if (update.startedAt === null || update.status !== "in_progress")
+        return update;
+    const ran = now - update.startedAt;
+    if (ran < RUNNING_REFRESH_SECONDS)
+        return update;
+    return { ...update, title: `${update.title} · ${formatDuration(ran)}` };
+}
+export class Tool {
+    /** The call as the card shows it: the title carries the seconds read at the last `stamp`. */
+    update;
+    /** The call as the core gave it. */
+    base;
+    rev = 0;
+    shownPieces = [];
+    sizes = [];
+    carded = false;
+    constructor(update, now) {
+        this.set(update, now);
+    }
+    /** The seconds of a timed call read at `now`; true when the card's title changed. */
+    stamp(now) {
+        const shown = timedUpdate(this.base, now);
+        if (shown.title === this.update.title)
+            return false;
+        this.update = shown;
+        return true;
+    }
+    /** Whether the call is one whose card shows seconds and it still runs. */
+    get timed() {
+        return this.base.startedAt !== null && this.base.status === "in_progress";
+    }
+    /** A new state of the call, its seconds read at `now`. What follows its card is worked out once, here. */
+    set(update, now) {
+        this.base = update;
+        this.update = timedUpdate(update, now);
+        const view = shownPreview(update);
+        if (view === null || !view.body) {
+            this.shownPieces = [];
+        }
+        else if (view.plain) {
+            // One context block, as it is drawn: a piece counts for what the message holds.
+            this.shownPieces = [plainLines(view.body, view.record ? view.title : null)];
+        }
+        else {
+            this.shownPieces = split(view.body).filter((chunk) => chunk !== "");
+        }
+        this.sizes = this.shownPieces.map(len);
+        if (view === null || (view.plain && !view.record) || this.shownPieces.length === 0) {
+            this.carded = true;
+        }
+    }
+    /**
+     * Whether the tool is its preview alone: an Edit or a Write that reached the reply already
+     * ended well. A state that needs a card (running, failed, stopped, a preview with no body)
+     * gives it one for good, since a stream cannot take a card back.
+     */
+    get cardless() {
+        return !this.carded;
+    }
+    /** Piece `piece` (1 is the first). */
+    piece(piece) {
+        return this.shownPieces[piece - 1] ?? "";
+    }
+    /** The characters of piece `piece`, counted in code points (`len` of `chars.ts`). */
+    pieceSize(piece) {
+        return this.sizes[piece - 1] ?? 0;
+    }
+    /**
+     * The elements of the tool: its card (counted even when `cardless` draws none, so a cursor
+     * reads the same either way), then its preview pieces.
+     */
+    get extent() {
+        return 1 + this.shownPieces.length;
+    }
+}
+/**
+ * Piece `index` (1 is the first) of a tool's preview as blocks. With no card: a collapsed
+ * container titled with the call's line. Under a card: a collapsed container for a diff, code
+ * blocks for a new file's first lines, a context block for lines of words (a question's
+ * answers), each indented under its card and shown as written.
+ */
+export function pieceBlocks(tool, index) {
+    const view = shownPreview(tool.update);
+    if (view === null)
+        throw new Error("a piece of a tool with no preview");
+    const body = tool.piece(index);
+    if (view.plain)
+        return [contextBlock(body)];
+    if (!pieceCollapsed(tool))
+        return previewBlocks(body);
+    if (tool.cardless) {
+        return previewContainers(view.title, body, {
+            subtitle: view.summary,
+            language: view.language,
+            asCode: true,
+        });
+    }
+    return previewContainers(view.summary, body);
+}
+/**
+ * Whether `pieceBlocks` draws the tool's preview as collapsed containers, whose text a
+ * `chat.update` does not count toward MESSAGE_LIMIT. A context block and code blocks (markdown)
+ * always count.
+ */
+export function pieceCollapsed(tool) {
+    const view = shownPreview(tool.update);
+    if (view === null)
+        throw new Error("a piece of a tool with no preview");
+    return !view.plain && (tool.cardless || view.language === "diff");
+}
+/**
+ * The same piece for a stream: a `blocks` chunk (measured 2026-09-28 for a diff's container and
+ * 2026-09-29 for a markdown block, which reads back as rich text; a context block in one was
+ * seen drawn on the daemon on 2026-10-03).
+ */
+export function pieceChunk(tool, index) {
+    return { type: "blocks", blocks: pieceBlocks(tool, index) };
+}
+/** What a stream still has to be told, and where the reply goes on if it does not all fit. */
+class Plan {
+    /** Characters the message holds once these chunks are in. */
+    size;
+    /** Elements it holds. */
+    count;
+    /** What its cards count toward MESSAGE_LIMIT beside `size`. */
+    cardCost;
+    chunks = [];
+    /** Where the next message starts, if the rest does not fit. */
+    overflow = null;
+    /** Part to the offset sent up to. */
+    text = new Map();
+    pieces = new Set();
+    cards = new Map();
+    cardHeld = new Map();
+    /** Part to the blocks its text makes. */
+    textBlocks = new Map();
+    constructor(size, count, cardCost) {
+        this.size = size;
+        this.count = count;
+        this.cardCost = cardCost;
+    }
+}
+/**
+ * What the reply's last message showed when its end was written: nothing of it is removed by a
+ * late update.
+ */
+class Held {
+    /** Part to the offset its text was shown up to. */
+    text = new Map();
+    cards = new Set();
+    pieces = new Set();
+    /** The blocks they take, a card or a piece counting one. */
+    blocks() {
+        return this.text.size + this.cards.size + this.pieces.size;
+    }
+}
+/** The characters of card text a plan's chunks carry. */
+function planCardText(plan) {
+    let total = 0;
+    for (const chunk of plan.chunks) {
+        if (chunk.type !== "task_update")
+            continue;
+        for (const key of CARD_TEXT_FIELDS)
+            total += len(chunk[key] ?? "");
+    }
+    return total;
+}
+/**
+ * One Slack message of a reply: the span of the reply's model from `start` to the next message's
+ * start, first written as a stream (a reply's first message, and one that continues a stream
+ * that is still open) or as a post (one that continues a stopped message). While it streams,
+ * what it has been sent is remembered here, since a stream only grows.
+ */
+class Message {
+    start;
+    mode;
+    ts = null;
+    streaming = false;
+    textSent = new Map();
+    piecesSent = new Set();
+    /** What each card was told. */
+    cards = new Map();
+    /** The details and the output Slack holds per card: those of every chunk sent, joined. */
+    cardHeld = new Map();
+    // Characters of card text (title, details, output) in every chunk sent, for the log, and
+    // what the cards count toward MESSAGE_LIMIT (`cardAddition`); `size` counts none of it.
+    cardText = 0;
+    cardCost = 0;
+    size = 0;
+    count = 0;
+    /** Part to the blocks its text makes. */
+    textBlocks = new Map();
+    // The blocks the message may hold: BLOCKS_LIMIT, until Slack refuses a write of it for
+    // counting more of them than the daemon did.
+    blocksRoom = BLOCKS_LIMIT;
+    // Stopped: whether what it shows is its stream as sent, which needs no write while the
+    // model still says the same; else `shown` is the blocks of its last post or update.
+    exact = false;
+    shown = null;
+    /** The footer it shows. */
+    footer = [];
+    deadline = null;
+    /** The refresh of a running command's seconds, while the stream lives (`refreshTimed`). */
+    refresh = null;
+    // An append whose outcome is unknown: the stream is no longer told anything, it is stopped
+    // and the message goes on by update, from the model.
+    blind = false;
+    // An update refused in turn left it showing less than the model (`short`), until an update
+    // passes: while a message is short the reply's end has not landed.
+    short = false;
+    /** When its stream started, by the clock: a stream is over at 5 minutes. */
+    started = 0;
+    // (span revision, end) of the last write of a stopped message that has a successor: while it
+    // holds, nothing in the message changed and it is not rendered again.
+    checked = null;
+    // What a stop of unknown outcome carried, when it was the end's own stop or carried blocks of
+    // ours (the list); the stream's own stop at STREAM_SECONDS records nothing. If the next stop
+    // finds the stream over, that stop is the one that landed.
+    stopUnknown = null;
+    // Slack refused an update of this message whose containers were not counted: from then on
+    // they count toward MESSAGE_LIMIT, as in a post.
+    containersCounted = false;
+    constructor(start, mode) {
+        this.start = start;
+        this.mode = mode;
+    }
+}
+/**
+ * One reply in a Slack thread, as a native stream: Claude's text as it is written, and task
+ * cards for its tools, updated in place, in the order things happen: one per run of calls
+ * (`core/reply/fold`), which a silent update folds into a line of counts once the stream has
+ * stopped at the reply's end. The stream starts with the first content (never a placeholder) and
+ * stops with the reply's end, the footer at the bottom.
+ * It stops on its own at STREAM_SECONDS, since Slack closes a stream at 5 minutes, and when
+ * Slack refuses an append as too long, which it would refuse again: from then on the same
+ * message grows by `chat.update`, and the end posts the reply's ending (the text after its last
+ * call) with the footer as a new message.
+ * A reply past MESSAGE_LIMIT or BLOCKS_LIMIT continues in a new message (a new stream while the
+ * message still streams, else a post). `finish` ends the body only: a task that outlives the turn
+ * keeps updating its own card after that, in place. Never throws for a write that fails: it is
+ * sent again with the next one, the final one once more after FINAL_RETRY_SECONDS.
+ */
+export class ReplySink {
+    slack;
+    channel;
+    threadTs;
+    teamId;
+    userId;
+    botUserId;
+    limiter;
+    clock;
+    steady;
+    onOpenReply;
+    onWrite;
+    places;
+    logger;
+    debounceSeconds;
+    finalRetrySeconds;
+    /** A Slack write was attempted since `onWrite` was last called. */
+    wrote = false;
+    /** This sink's own entries in the open-replies list: the messages a crash would leave unfinished. */
+    tracked = new Set();
+    /** The end landed: nothing is left for a repair to close. */
+    ended = false;
+    /** The last message's body is whole, and only the closing message is owed. */
+    bodyLanded = false;
+    parts = [];
+    /** By the id of the card that shows them. */
+    tools = new Map();
+    /** Which cards show the calls: one per run of calls. */
+    fold = new Fold();
+    messages = [];
+    pending = null;
+    retry = null;
+    ending = null;
+    lock = new Mutex();
+    finished = false;
+    /** `rest` was called: the reply's messages are no longer streams. */
+    restRequested = false;
+    /** The agent's own words were written after the reply rested: a report turn's text. */
+    reportedSinceRest = false;
+    /**
+     * The session's footer, formatted, once it is drawn under this reply (`showFooter`), after its
+     * end. It stays on this reply for good.
+     */
+    footer = null;
+    /** The list of what still runs the thread's places last handed this reply; read once it rests. */
+    assigned = null;
+    /** Whether closeOut has run; a second call is a no-op. */
+    closedOut = false;
+    // How the reply ended, which says where its footer goes once one is drawn: "inline", on the
+    // stream's own stop (and on the message's updates after it); "moved", under the reply's ending
+    // in its last message (posted for it, or the continuation that opened on the line on how the
+    // reply ended); or "post", in a closing message that holds nothing else.
+    endMode = null;
+    // Set once the end has landed on Slack (`endLanded`): the reply's messages are then a fixed
+    // set, and a late update only edits them, keeping what its last message showed (`blocks`).
+    // Not `closedOut`, nor `endMode` alone: a close whose write failed still owes messages, and
+    // its retry must open them.
+    held = null;
+    /** The ts of the closing message, once posted. */
+    closing = null;
+    closingShown = [];
+    /** A write of the closing message failed: it may have landed, so what it shows is not known. */
+    closingUnsure = false;
+    /** The closing message was deleted: the footer, if one is drawn later, goes under the body. */
+    closingGone = false;
+    /**
+     * The closing message had nothing to show at the end: it is posted with the session's footer
+     * (`showFooter`), and that post is the push that says the session has ended.
+     */
+    closingDeferred = false;
+    /** The newest message of the thread when the closing message was put off (`newestAt`). */
+    deferredAt = null;
+    /** One more try of a write after the end, when a pass failed (the final write's retry). */
+    tailRetry = null;
+    /** `settle`'s own flush is running: no retry may outlive it. */
+    settling = false;
+    /** The retry of a write after the end is running its pass. */
+    retrying = false;
+    /** The retry in flight already logged that it gave up. */
+    gaveUpLogged = false;
+    /** The cut of an overtaken reply was logged: once is enough. */
+    cutWarned = false;
+    // Resolves once the reply is known to have ended on Slack (true) or its one retry failed too
+    // (false): what the session waits on before it shows a checkmark.
+    landed;
+    landedValue = null;
+    landedResolve = () => { };
+    // Bumped by `changed`: `later` compares it before and after a pass to notice a change that
+    // arrived while the pass wrote or waited its turn, and runs another pass for it.
+    version = 0;
+    rev = 0;
+    /** When the seconds of the running commands were last read while a stream lived. */
+    stampedAt = 0;
+    /** `slack` is the replies client (`repliesClient`), whatever the sink calls goes through it. */
+    constructor(slack, options) {
+        this.slack = slack;
+        this.channel = options.channel;
+        this.threadTs = options.threadTs;
+        this.teamId = options.teamId;
+        this.userId = options.userId;
+        this.botUserId = options.botUserId;
+        this.limiter = options.limiter;
+        this.clock = options.clock ?? systemClock;
+        this.steady = options.steady ?? this.clock;
+        this.onOpenReply = options.onOpenReply ?? null;
+        this.places = options.places ?? new ThreadPlaces();
+        this.places.join(this);
+        this.onWrite = options.onWrite ?? null;
+        this.logger = options.logger ?? defaultLogger;
+        this.debounceSeconds = options.debounceSeconds ?? DEBOUNCE_SECONDS;
+        this.finalRetrySeconds = options.finalRetrySeconds ?? FINAL_RETRY_SECONDS;
+        this.landed = new Promise((resolve) => {
+            this.landedResolve = resolve;
+        });
+    }
+    /**
+     * One transition of this sink's own entries in the thread's open-replies list: add `fresh`,
+     * or drop `old`; every other sink's entry is left alone. Best-effort: a failed state write is
+     * logged (ids only) and swallowed, since the reply itself must never fail over crash-repair
+     * bookkeeping. False then: the caller keeps its set as it was, or it would believe a ts no
+     * longer needs removing and orphan it in state.json forever, since nothing else ever asks to
+     * remove a ts this sink no longer remembers.
+     */
+    track(old, fresh) {
+        if (this.onOpenReply === null)
+            return true;
+        try {
+            this.onOpenReply(old, fresh);
+        }
+        catch (error) {
+            this.logger.warning(`could not update the open-reply tracking for ${this.channel}/${this.threadTs}: ` +
+                describe(error));
+            return false;
+        }
+        return true;
+    }
+    /**
+     * Whether a crash would leave the message unfinished: its stream still open, or a card of it
+     * still running (a stopped message stores such a card as an error until it is updated), or,
+     * for the reply's last message, the end not yet landed. Once the body is whole and only the
+     * closing message is owed, there is nothing of the answer left to fix.
+     */
+    keepsOpen(message, end) {
+        if (message.ts === null)
+            return false;
+        if (message.streaming)
+            return true;
+        // The list of what still runs is no more than a card a crash would leave running.
+        if (message.footer.some(isRunningList))
+            return true;
+        for (const { part, floor, ceil } of this.span(message.start, end)) {
+            if (!(part instanceof Tool))
+                continue;
+            const [hasCard] = ReplySink.toolElements(part, floor, ceil);
+            if (hasCard && !TERMINAL.includes(part.update.status))
+                return true;
+        }
+        return message === this.messages.at(-1) && !this.ended && !this.bodyLanded;
+    }
+    /**
+     * Bring this sink's open-reply entries to the messages that are unfinished now: one is added
+     * the moment it is written, and dropped once nothing is left for a repair to close.
+     */
+    retrack() {
+        const wanted = new Set();
+        for (const [index, message] of this.messages.entries()) {
+            const following = this.messages[index + 1];
+            const end = following === undefined ? null : following.start;
+            if (message.ts !== null && this.keepsOpen(message, end))
+                wanted.add(message.ts);
+        }
+        if (this.closing !== null && this.closingShown.some(isRunningList))
+            wanted.add(this.closing);
+        for (const ts of [...wanted].filter((ts) => !this.tracked.has(ts)).sort()) {
+            if (this.track(null, ts))
+                this.tracked.add(ts);
+        }
+        for (const ts of [...this.tracked].filter((ts) => !wanted.has(ts)).sort()) {
+            if (this.track(ts, null))
+                this.tracked.delete(ts);
+        }
+    }
+    /**
+     * The reply's end landed: from then on nothing is left open for a repair to close, but a card
+     * still running.
+     */
+    settleOpenReply() {
+        this.ended = true;
+        this.places.ended(this);
+        this.retrack();
+    }
+    /**
+     * Claude's words, or with `notice` a line of the daemon's own (never a banner while Claude
+     * has words). With `ending` that line says how the reply was cut short: a part of its own,
+     * never joined to an earlier notice, so it can move whole (`endingCursor`).
+     */
+    async text(markdown, options = {}) {
+        const ending = options.ending ?? false;
+        const notice = (options.notice ?? false) || ending;
+        const aside = options.aside ?? false;
+        if (!blank(markdown))
+            this.fold.text();
+        // The line a lost process writes (a notice that is an ending) is new text, and the last.
+        if (this.restRequested && (!notice || ending) && !blank(markdown))
+            this.reportedSinceRest = true;
+        const last = this.parts.at(-1);
+        if (last instanceof Text &&
+            last.notice === notice &&
+            last.ending === ending &&
+            last.aside === aside) {
+            last.text += markdown;
+            last.rev = this.nextRev();
+        }
+        else {
+            this.parts.push(new Text(markdown, notice, ending, aside, this.nextRev()));
+        }
+        this.changed();
+    }
+    /**
+     * A call's new state, on the cards that show it: a run of calls shares one card
+     * (`core/reply/fold`), a call with a view of its own has one.
+     */
+    async task(update) {
+        const cards = this.fold.task(update);
+        for (const card of cards) {
+            let tool = this.tools.get(card.id);
+            const now = this.reading();
+            if (tool === undefined) {
+                tool = new Tool(card, now);
+                this.tools.set(card.id, tool);
+                this.parts.push(tool);
+            }
+            else {
+                tool.set(card, now);
+            }
+            tool.rev = this.nextRev();
+        }
+        if (cards.length > 0) {
+            this.changed();
+            const last = this.messages.at(-1);
+            if (last !== undefined)
+                this.armRefresh(last);
+        }
+    }
+    /** Whether the reply's last message is a stream that is open. */
+    get live() {
+        return this.messages.at(-1)?.streaming === true;
+    }
+    /**
+     * The time a running command's seconds are read at. While the stream lives they move at the
+     * refresh alone, so that a card's title does not change with every piece of text; otherwise
+     * they are as of now.
+     */
+    reading() {
+        return this.live ? this.stampedAt : this.steady.time();
+    }
+    /** The tools whose card sits in `message`: the span a stream is told about. */
+    toolsOf(message) {
+        return this.span(message.start, null).flatMap(({ part }) => part instanceof Tool ? [part] : []);
+    }
+    /**
+     * Read the seconds of the running commands at `now`, those of `message`'s cards alone when it
+     * is given, else of every card; true when a card's title changed.
+     */
+    restamp(now, message) {
+        let moved = false;
+        const tools = message === undefined ? this.tools.values() : this.toolsOf(message);
+        for (const tool of tools) {
+            if (!tool.stamp(now))
+                continue;
+            tool.rev = this.nextRev();
+            moved = true;
+        }
+        return moved;
+    }
+    /** Start the refresh of the seconds on `message`, a stream that is open, if a command runs. */
+    armRefresh(message) {
+        if (!message.streaming || message.refresh !== null)
+            return;
+        if (!this.toolsOf(message).some((tool) => tool.timed))
+            return;
+        this.stampedAt = this.steady.time();
+        message.refresh = new Task((signal) => this.refreshTimed(message, signal));
+    }
+    /**
+     * Every RUNNING_REFRESH_SECONDS, while `message` streams and a timed command runs: read the
+     * seconds again and, when a title changed, send it. A wait outside a pass, cancelled with the
+     * stream (`gone`); the write is the debounced one every change makes.
+     */
+    async refreshTimed(message, signal) {
+        try {
+            while (message.streaming && this.toolsOf(message).some((tool) => tool.timed)) {
+                await this.clock.sleep(RUNNING_REFRESH_SECONDS, signal);
+                if (!message.streaming)
+                    return;
+                this.stampedAt = this.steady.time();
+                if (this.restamp(this.stampedAt, message))
+                    this.changed();
+            }
+        }
+        finally {
+            if (message.refresh?.signal === signal)
+                message.refresh = null;
+        }
+    }
+    nextRev() {
+        this.rev += 1;
+        return this.rev;
+    }
+    /** The position of the reply's last message in its thread, null while it has none. */
+    get lastAt() {
+        // A closing message that was deleted still marks where the reply sat: a reply never moves up.
+        const ts = this.closing ?? this.messages.findLast((message) => message.ts !== null)?.ts ?? null;
+        return ts === null ? null : positionOf(ts);
+    }
+    /** Whether nothing of the owner's and no other reply sits below this reply's last message. */
+    get last() {
+        return this.places.last(this);
+    }
+    /** Whether another reply has a message below this one. */
+    get overtaken() {
+        return this.places.overtaken(this);
+    }
+    /**
+     * Its turn's part has ended, it waits (`rest`) or its end has landed, and its last message is
+     * no stream: the message can be rewritten, and the footer shows under it. A reply that only
+     * finished is not at rest, whose end may still fail: it must not take the footer from a reply
+     * above it before it can draw one.
+     */
+    get resting() {
+        if (this.ended)
+            return true;
+        if (!this.finished || !this.restRequested)
+            return false;
+        const last = this.messages.at(-1);
+        // A stream not yet started is a stream: the first write opens it.
+        return !(last?.streaming === true || (last?.ts === null && last.mode === "stream"));
+    }
+    /**
+     * The list of what still runs this reply shows under its last message from now on, as the
+     * thread's places worked it out. A change is written unless the last message is a stream, which
+     * a stop ends (the reply's rest or its end).
+     */
+    assign(list) {
+        const moved = !isDeepStrictEqual(list, this.assigned);
+        this.assigned = list;
+        if (moved && this.messages.at(-1)?.streaming !== true)
+            this.changed();
+    }
+    /**
+     * The list taken off this reply's message now, not after the debounce: a reply below is about
+     * to create its first message (`ThreadPlaces.opens`). Through the lock, whatever the message
+     * shows now: a pass in flight may be drawing the list. A write that failed is tried again, as a
+     * debounced one would have been.
+     */
+    async unlist() {
+        if (this.assigned !== null)
+            return true;
+        this.pending?.cancel();
+        this.pending = null;
+        const ok = await this.flush();
+        if (!ok)
+            this.retryLater();
+        return ok;
+    }
+    /** `showFooterFormatted` with the footer as one line of mrkdwn. */
+    showFooter(footer, signal) {
+        return this.showFooterFormatted(formatFooter(footer, this.clock.time() * 1000), signal);
+    }
+    /**
+     * The session's footer under this reply's last message, by an edit, written now: the session
+     * has ended everything, and this reply holds its latest work. It stays on the reply, whatever
+     * is posted below it later. False when the write failed (one more try follows, as for any
+     * write after the end) or when the reply's end never landed: no message is known to hold it.
+     */
+    async showFooterFormatted(line, signal) {
+        if (this.landedValue !== true)
+            return false;
+        if (!line)
+            return true; // a footer that says nothing: nothing to draw
+        // The first footer drawn stays: a later draw of the same end (a forced end's, after a write
+        // the core saw fail) knows no more than it did.
+        this.footer ??= line;
+        this.pending?.cancel();
+        this.pending = null;
+        const ok = await cancellable(this.flush(), signal);
+        if (!ok)
+            this.retryLater();
+        return ok;
+    }
+    /**
+     * End the turn's part of the reply: what was written is sent now, not at the next debounce.
+     * A card still in progress is a task that outlives the turn: `task` keeps updating it after
+     * this. The stream stays open: it ends with `closeOut`, once the caller knows nothing more is
+     * coming, or stops with `rest`. A report that renders into the reply later is followed by
+     * another `finish`.
+     */
+    async finish(closing, signal) {
+        for (const update of closing)
+            await this.task(update);
+        this.finished = true;
+        // Before the pending write is cancelled: the flush below carries the change it schedules.
+        this.places.place();
+        this.pending?.cancel();
+        this.pending = null;
+        // What a card of a run of calls shows changes here, to its folded line: its message is
+        // rendered again even when nothing else in it changed.
+        for (const tool of this.tools.values()) {
+            if (tool.update.folded !== null)
+                tool.rev = this.nextRev();
+        }
+        await cancellable(this.flush(), signal);
+    }
+    /**
+     * The reply waits for work its turn started (see `Reply.rest`). The next pass stops a stream
+     * with no footer, then rewrites the message: one push, the stop's. Idempotent.
+     */
+    rest() {
+        const first = !this.restRequested;
+        this.restRequested = true;
+        // "Since it rested" is measured from the latest rest: an earlier report is old text.
+        this.reportedSinceRest = false;
+        // The reply may already be at rest (its stream gone): the placement says what it shows.
+        this.places.place();
+        // Called again while the stream is still open, the stop is tried again: it failed before.
+        if (first || this.messages.at(-1)?.streaming === true)
+            this.changed();
+    }
+    /**
+     * End the reply, once: stop its stream (one push), or, when the stream already stopped (at
+     * STREAM_SECONDS, or by `rest`), post its ending as a new message (the second push). The
+     * session's footer is not part of the end: `showFooter` adds it by an edit, once the session
+     * has ended everything. True when the reply ended on Slack (or nothing was owed); false when a
+     * write failed and one retry is scheduled: `waitLanded` then says how it ended. A second call
+     * is a no-op: the reply has already ended.
+     */
+    async closeOut(signal) {
+        if (this.closedOut)
+            return this.landedValue === true;
+        this.closedOut = true;
+        this.places.place();
+        // The end is its own task, shielded from the caller: a caller that stops waiting while Slack
+        // takes the write (a timer, a turn starting, a shutdown) must not leave `landed` unresolved
+        // with no retry, which no later `closeOut` could repair.
+        this.ending = new Task(() => this.endOut());
+        return cancellable(this.ending.result(), signal);
+    }
+    /**
+     * The end's first flush: whatever happens, `landed` resolves (an end that began always does),
+     * with the retry when Slack refused the write.
+     */
+    async endOut() {
+        let ok;
+        try {
+            ok = await this.flush();
+        }
+        catch (error) {
+            this.resolve(false);
+            throw error;
+        }
+        if (ok) {
+            this.resolve(true);
+            return true;
+        }
+        if (this.landedValue === null) {
+            // `settle` may have decided it already
+            this.retry = new Task((retry) => this.retryFinal(retry));
+        }
+        return false;
+    }
+    resolve(landed) {
+        if (landed)
+            this.settleOpenReply();
+        if (this.landedValue === null) {
+            this.landedValue = landed;
+            this.landedResolve(landed);
+        }
+    }
+    /** Whether the reply ends up on Slack: waits for the retry a failed end schedules. */
+    waitLanded(signal) {
+        return cancellable(this.landed, signal);
+    }
+    async retryFinal(signal) {
+        await this.clock.sleep(this.finalRetrySeconds, signal);
+        // Shielded: a shutdown's `settle` cancels this task, and a write given up after Slack took
+        // it would lose what it did.
+        const ok = await this.flush();
+        if (signal.aborted)
+            return;
+        this.resolve(ok);
+    }
+    /**
+     * Force this reply to its current, true form right now, cancelling any debounce still
+     * pending: a shutdown's very last chance. Cheap when nothing changed since the last write. A
+     * retry still waiting is tried now. True when the reply is on Slack (or nothing was owed): a
+     * shutdown that gets false has lost it.
+     */
+    async settle(signal) {
+        this.pending?.cancel();
+        this.pending = null;
+        if (this.ending !== null && !this.ending.done) {
+            // The end in flight may still schedule its retry: let it, so the cancel below sees it.
+            // `settled` hands back neither its error nor its cancellation: only this call's own
+            // signal ends the wait early.
+            await cancellable(this.ending.settled(), signal);
+        }
+        this.retry?.cancel();
+        this.tailRetry?.cancel();
+        // The flush below may fail a write that would start a retry; later changes retry as usual.
+        this.settling = true;
+        let ok;
+        try {
+            ok = await cancellable(this.flush(), signal);
+        }
+        finally {
+            this.settling = false;
+        }
+        if (this.closedOut && this.landedValue === null)
+            this.resolve(ok);
+        return ok || this.landedValue === true;
+    }
+    /**
+     * A background task or subagent can still update its own card after the reply itself ended
+     * (rare, and possibly during shutdown): debounced through `later`, like any other change,
+     * rather than flushed here and now, which would spend a limiter wait (real time, under a busy
+     * process's shared budget) inline on the caller, the SDK reader loop among them.
+     */
+    changed() {
+        // A message that is no stream is rewritten whole: the seconds of a running command are
+        // read again with it. A stream's wait for the refresh.
+        if (!this.live)
+            this.restamp(this.steady.time());
+        this.version += 1;
+        this.schedule();
+    }
+    schedule() {
+        if (this.pending === null)
+            this.pending = new Task((signal) => this.later(signal));
+    }
+    async later(signal) {
+        try {
+            for (;;) {
+                await this.clock.sleep(this.debounceSeconds, signal);
+                const version = this.version;
+                // Shielded: `finish` cancels a pending write, and a write given up after Slack took it
+                // would lose the message's ts. `finish` waits for the lock instead.
+                const ok = await this.flush();
+                if (signal.aborted)
+                    return;
+                if (!ok) {
+                    // A write after the end, or on a reply at rest, that failed is tried once more: with
+                    // one long task no later change may come.
+                    if (this.landedValue === true || this.resting)
+                        this.retryLater();
+                    return;
+                }
+                if (this.version === version)
+                    return;
+                // The reply changed again while that call wrote or waited its turn, in a way it never
+                // saw: another debounce, then flush again, so it still catches up rather than waiting
+                // for the next unrelated event to notice. The debounce stays inside the loop: while
+                // text keeps streaming, the version moves during every round trip, and without it here
+                // a reply would be written after every round trip instead of at most once per
+                // DEBOUNCE_SECONDS.
+            }
+        }
+        finally {
+            // In the same step as the decision to return: a change that arrives next starts a
+            // debounce of its own.
+            if (this.pending?.signal === signal)
+                this.pending = null;
+        }
+    }
+    // The reply's model: the parts in order, cut into messages at cursors.
+    spanRev(message, end) {
+        return this.span(message.start, end).reduce((rev, { part }) => Math.max(rev, part.rev), 0);
+    }
+    hasContent() {
+        return this.parts.some((part) => part instanceof Tool || !blank(part.text));
+    }
+    /**
+     * The parts from `start` to `end` (the model's end when null), each with the first and last
+     * element the span takes of it.
+     */
+    span(start, end) {
+        const last = end === null ? this.parts.length : Math.min(this.parts.length, end[0] + 1);
+        const spanned = [];
+        for (let index = start[0]; index < last; index += 1) {
+            const part = this.parts[index];
+            if (part === undefined)
+                continue;
+            spanned.push({
+                index,
+                part,
+                floor: index === start[0] ? start[1] : 0,
+                ceil: end !== null && index === end[0] ? end[1] : null,
+            });
+        }
+        return spanned;
+    }
+    /** Whether a span takes a tool's card, if it has one, and which of its preview pieces. */
+    static toolElements(tool, floor, ceil) {
+        const extent = tool.extent;
+        const top = ceil === null ? extent : Math.min(extent, ceil);
+        const pieces = [];
+        for (let piece = Math.max(floor, 1); piece < top; piece += 1)
+            pieces.push(piece);
+        return [floor === 0 && top > 0 && !tool.cardless, pieces];
+    }
+    /** The footer below a divider; empty when there is none. A stream's stop carries only this. */
+    footerBlocks() {
+        return this.footer ? [{ type: "divider" }, contextBlock(this.footer)] : [];
+    }
+    /**
+     * What the reply shows under its last message: the list of what still runs, when this reply
+     * holds it, above the footer's divider. Not on a stream's stop, which Slack may take the cards
+     * of no more than the footer's blocks of (not measured): the edit that follows the stop adds it.
+     */
+    closingBlocks() {
+        // The list only from what the places handed this reply once it rests: a reply whose end is on
+        // its way would draw a second card beside the one its holder still shows.
+        const list = this.resting ? this.assigned : null;
+        return list === null ? this.footerBlocks() : [runningListBlock(list), ...this.footerBlocks()];
+    }
+    /**
+     * What a message shows under its body: only the reply's last, when the footer rode on its
+     * stream's stop or when it is the reply's ending, in a message of its own (`end`), or while the
+     * reply rests before its end (`rest`), where only the list of what still runs shows and the
+     * footer once it is drawn. A reply that only finished shows none: it is not at rest, and its
+     * end follows at once.
+     */
+    footerOf(message) {
+        if (message === this.messages.at(-1) &&
+            (this.endMode === "inline" ||
+                this.endMode === "moved" ||
+                this.closingGone ||
+                (this.endMode === null && this.resting))) {
+            return this.closingBlocks();
+        }
+        return [];
+    }
+    /**
+     * Where the reply's ending starts in its last message: the text Claude wrote after its last
+     * call, whole (a part of the model is never cut: half a list or a heading without its body is
+     * no ending), with whatever follows it. Null when the message holds no such text from its
+     * start, or would keep nothing of the answer before it (an answer that is text alone): the
+     * ending is then the footer alone, unless the turn was cut short. The ending is then the
+     * daemon's line on how the reply ended (`Text.ending`), with whatever follows it: the message
+     * that notifies says so, where it would show empty or hold a footer alone. That line moves
+     * from under a line of the daemon's too, which stays.
+     */
+    endingCursor(message) {
+        const cursor = this.cutBefore(message, this.lastText(message, false));
+        if (cursor !== null)
+            return cursor;
+        return this.cutBefore(message, this.lastText(message, true), true);
+    }
+    /**
+     * The last part, from where `message` starts, that holds words of Claude's, or with `ending`
+     * the daemon's line on how the reply was cut short; null when there is none.
+     */
+    lastText(message, ending) {
+        for (let i = this.parts.length - 1; i >= message.start[0]; i -= 1) {
+            const part = this.parts[i];
+            if (part instanceof Text && (ending ? part.ending : !part.notice) && !blank(part.text)) {
+                return i;
+            }
+        }
+        return null;
+    }
+    /**
+     * The cursor at the start of part `index`, when cutting `message` there leaves it something of
+     * the answer, or with `notices` any line at all; null when the part opens the message or
+     * nothing would stay.
+     */
+    cutBefore(message, index, notices = false) {
+        if (index === null || upTo([index, 0], message.start))
+            return null;
+        const cursor = [index, 0];
+        // Something of the answer must stay before it, and show: a card that draws, a preview, or
+        // words of Claude's. A message left with a line
+        // of the daemon's alone, or with nothing, is no answer: cutting Claude's text there would
+        // move the whole answer out. The line on how the reply ended is no part of the answer, so
+        // a line of the daemon's is enough to stay above it.
+        for (const { part, floor, ceil } of this.span(message.start, cursor)) {
+            if (part instanceof Tool) {
+                const [hasCard, pieces] = ReplySink.toolElements(part, floor, ceil);
+                if ((hasCard && this.cardBlocks(part.update).length > 0) || pieces.length > 0) {
+                    return cursor;
+                }
+            }
+            else if ((notices || !part.notice) && !blank(part.text.slice(floor, ceil ?? undefined))) {
+                return cursor;
+            }
+        }
+        return null;
+    }
+    /**
+     * Whether `message`, posted as a continuation, starts at the daemon's line on how the reply
+     * ended, inside it or in what follows it: it rang when it was posted, and is the reply's
+     * ending as it stands.
+     */
+    opensOnEnding(message) {
+        let said = null;
+        for (let i = this.parts.length - 1; i >= 0; i -= 1) {
+            const part = this.parts[i];
+            if (part instanceof Text && part.ending && !blank(part.text)) {
+                said = i;
+                break;
+            }
+        }
+        return message.mode === "post" && said !== null && upTo([said, 0], message.start);
+    }
+    /**
+     * The notification's text, plain: the first paragraph of Claude's own words in the span; else
+     * the daemon's line on how the reply was cut short; else the first tool's title; else any
+     * line of the daemon's. Never a daemon line while there are words of Claude's to show. Cut to
+     * BANNER_LIMIT.
+     */
+    banner(span = null) {
+        const parts = span ?? this.span([0, 0], null);
+        const first = (words) => {
+            const end = words.indexOf("\n\n");
+            const paragraph = end === -1 ? words : words.slice(0, end);
+            return bannerText(paragraph, { limit: BANNER_LIMIT }) || "…";
+        };
+        let notice = "";
+        let said = "";
+        for (const { part, floor, ceil } of parts) {
+            if (!(part instanceof Text))
+                continue;
+            const words = strip(part.text.slice(floor, ceil ?? undefined));
+            if (words && !part.notice)
+                return first(words);
+            notice = notice || words;
+            said = said || (part.ending ? words : "");
+        }
+        if (said)
+            return first(said);
+        for (const { part } of parts) {
+            if (part instanceof Tool) {
+                return bannerText(cardFields(part.update).title, { limit: BANNER_LIMIT }) || "…";
+            }
+        }
+        return first(notice);
+    }
+    // What a stream is told.
+    /**
+     * What the message's stream lacks: the cards that changed since they were sent, then what the
+     * model has past what it was sent, in order, as far as the message holds.
+     */
+    plan(message) {
+        const plan = new Plan(message.size, message.count, message.cardCost);
+        for (const [toolId, sent] of message.cards) {
+            const tool = this.tools.get(toolId);
+            if (tool === undefined)
+                continue;
+            const chunk = cardChunk(tool.update);
+            if (!isDeepStrictEqual(chunk, sent))
+                ReplySink.planCard(message, plan, chunk);
+        }
+        for (const { index, part, floor } of this.span(message.start, null)) {
+            const more = part instanceof Text
+                ? this.planText(message, plan, index, part, floor)
+                : this.planTool(message, plan, index, part, floor);
+            if (!more)
+                break;
+        }
+        return plan;
+    }
+    /**
+     * Add a card's chunk to the plan as a stream takes it; false when the card is new and the
+     * message has no room for it. A message that holds nothing yet takes any card.
+     */
+    static planCard(message, plan, chunk) {
+        const toolId = chunk.id;
+        const room = MESSAGE_LIMIT - plan.size - plan.cardCost;
+        const [told, held, cost] = cardAddition(chunk, message.cards.get(toolId), message.cardHeld.get(toolId) ?? {}, room);
+        if (!message.cards.has(toolId) && cost > room && plan.size + plan.cardCost > 0)
+            return false;
+        plan.chunks.push(told);
+        plan.cards.set(toolId, chunk);
+        plan.cardHeld.set(toolId, held);
+        plan.cardCost += cost;
+        return true;
+    }
+    /** Add the unsent tail of a text part to the plan; false when the plan is complete. */
+    planText(message, plan, index, part, floor) {
+        const sent = Math.max(message.textSent.get(index) ?? 0, floor);
+        let tail = part.text.slice(sent);
+        let lead = 0;
+        if (plan.size === 0) {
+            // a message opens on its words, not on the blank lines before them
+            lead = tail.length - lstripNewlines(tail).length;
+            tail = tail.slice(lead);
+        }
+        if (blank(tail)) {
+            if (index === this.parts.length - 1 && !this.finished) {
+                return false; // more of it may come: the blanks go with it
+            }
+            plan.text.set(index, part.text.length);
+            return true;
+        }
+        const had = message.textBlocks.get(index) ?? 0;
+        const others = plan.count - had; // the blocks of everything else in the message
+        if (!had && others >= message.blocksRoom) {
+            plan.overflow = [index, sent];
+            return false;
+        }
+        // Characters, held against the limit; `fits` is where that many of them end in the tail.
+        const room = Math.max(0, MESSAGE_LIMIT - plan.size - plan.cardCost);
+        const fits = at(tail, room);
+        let piece;
+        let upto;
+        if (fits >= tail.length || blank(tail.slice(fits))) {
+            // All of it, or all but blanks, which go with what follows if anything does.
+            piece = tail.slice(0, fits);
+            upto = sent + lead + piece.length;
+        }
+        else {
+            const cut = room > 0 ? lastNewline(tail, fits) : -1;
+            const end = cut <= 0 ? fits : cut;
+            piece = tail.slice(0, end);
+            upto = sent + lead + end + (cut > 0 ? 1 : 0);
+            plan.overflow = [index, upto];
+        }
+        // The part's text in this message, as the update that follows the stream will write it:
+        // cut where the blocks Slack makes of it would pass the message's room.
+        const whole = part.text.slice(floor, sent + lead + piece.length);
+        const opening = floor + whole.length - lstripNewlines(whole).length;
+        let words = stripNewlines(whole);
+        // Text already sent can gain a block when its next line arrives (a line that turns out to
+        // head a table): the cut is then the next block's start, never inside a line.
+        const over = markdownCut(words, Math.max(1, message.blocksRoom - others), Math.max(0, sent + lead - opening));
+        if (over !== null) {
+            const stop = opening + over;
+            piece = part.text.slice(sent + lead, stop);
+            upto = stop;
+            plan.overflow = [index, stop];
+            words = stripNewlines(part.text.slice(opening, stop));
+        }
+        plan.text.set(index, upto);
+        if (!blank(piece)) {
+            // A line about the work is drawn small from its first chunk, as the update that follows
+            // the stream writes it: drawn as text first, it would shrink once the stream stops. A
+            // context block in a `blocks` chunk is drawn by Slack (seen 2026-10-03, `pieceChunk`).
+            // A later piece of the same part gets an id of its own: no two blocks of a message share
+            // one.
+            plan.chunks.push(part.aside
+                ? {
+                    type: "blocks",
+                    blocks: [
+                        asideBlock(mrkdwnEscape(stripNewlines(piece)), sent > floor ? `${index}-${sent}` : index),
+                    ],
+                }
+                : { type: "markdown_text", text: piece });
+            plan.size += len(piece);
+            const made = markdownBlocks(words);
+            plan.textBlocks.set(index, made);
+            plan.count = others + made;
+        }
+        return plan.overflow === null;
+    }
+    /**
+     * Add a tool's card, if this message holds it and has not sent it, and the pieces of its
+     * preview it has not sent; false when the plan is complete.
+     */
+    planTool(message, plan, index, tool, floor) {
+        const update = tool.update;
+        const [hasCard, pieces] = ReplySink.toolElements(tool, floor, null);
+        if (hasCard && !message.cards.has(update.id) && !plan.cards.has(update.id)) {
+            if (plan.count >= message.blocksRoom ||
+                !ReplySink.planCard(message, plan, cardChunk(update))) {
+                plan.overflow = [index, 0];
+                return false;
+            }
+            plan.count += 1;
+        }
+        for (const piece of pieces) {
+            if (message.piecesSent.has(pieceKey(index, piece)))
+                continue;
+            const size = tool.pieceSize(piece);
+            if (plan.count >= message.blocksRoom || plan.size + plan.cardCost + size > MESSAGE_LIMIT) {
+                plan.overflow = [index, piece];
+                return false;
+            }
+            plan.chunks.push(pieceChunk(tool, piece));
+            plan.pieces.add(pieceKey(index, piece));
+            plan.size += size;
+            plan.count += 1;
+        }
+        return true;
+    }
+    static sent(message, plan) {
+        for (const [index, upto] of plan.text)
+            message.textSent.set(index, upto);
+        for (const piece of plan.pieces)
+            message.piecesSent.add(piece);
+        for (const [id, chunk] of plan.cards)
+            message.cards.set(id, chunk);
+        for (const [id, held] of plan.cardHeld)
+            message.cardHeld.set(id, held);
+        message.cardText += planCardText(plan);
+        message.size = plan.size;
+        message.count = plan.count;
+        message.cardCost = plan.cardCost;
+        for (const [index, made] of plan.textBlocks)
+            message.textBlocks.set(index, made);
+    }
+    /**
+     * Whether the message's stream, as sent, shows what the model says for its span: every card
+     * as it is now, and ended (a card left in progress in a stopped stream is stored as an error
+     * until it is updated: measured 2026-09-28), every preview piece, all the text. Never once
+     * the body has ended, for a message with cards of a run of calls: the model then says the
+     * folded line, which a stream cannot show; without `folding` that is let pass, and the answer
+     * is whether the stream holds everything the span says.
+     */
+    streamShows(message, end, folding = true) {
+        for (const [toolId, sent] of message.cards) {
+            const update = this.tools.get(toolId)?.update;
+            if (update === undefined)
+                return false;
+            if (folding && this.finished && update.folded !== null)
+                return false;
+            if (!TERMINAL.includes(update.status) || !isDeepStrictEqual(cardChunk(update), sent)) {
+                return false;
+            }
+        }
+        for (const { index, part, floor, ceil } of this.span(message.start, end)) {
+            if (part instanceof Text) {
+                // A line about the work reads grey once the body has ended, which a stream cannot
+                // show: like a run's folded line.
+                if (folding && this.finished && part.aside && !blank(part.text))
+                    return false;
+                const sentTo = Math.max(message.textSent.get(index) ?? 0, floor);
+                if (!blank(part.text.slice(sentTo, ceil ?? undefined)))
+                    return false;
+            }
+            else {
+                const [hasCard, pieces] = ReplySink.toolElements(part, floor, ceil);
+                if (hasCard && !message.cards.has(part.update.id))
+                    return false;
+                if (pieces.some((piece) => !message.piecesSent.has(pieceKey(index, piece))))
+                    return false;
+            }
+        }
+        return true;
+    }
+    // What a message shows once it is no longer a stream: blocks.
+    /**
+     * The blocks of the message's span: Claude's text as markdown, the tools' task cards
+     * (`cardBlocks`), the preview blocks after a card. With no `end` (the reply's last message)
+     * only as many as fit MESSAGE_LIMIT and BLOCKS_LIMIT, and where the reply goes on if it does
+     * not all fit. Once the reply's end has landed nothing opens a message after it: what arrives
+     * late is shown when it all fits, and else not at all, the last message keeping what it showed
+     * (`Held`) and no cursor being returned. The blocks are counted for a `chat.update`, which
+     * takes a collapsed container's text without counting it; `posting` counts it, as a
+     * `chat.postMessage` does.
+     */
+    blocks(message, end, posting = false) {
+        const [blocks, overflow] = this.render(message, end, null, posting);
+        if (overflow === null || end !== null || this.held === null)
+            return [blocks, overflow];
+        return [this.render(message, null, this.held)[0], null];
+    }
+    /**
+     * `blocks` for one reading of the span: with `held`, only what the message showed when the
+     * reply's end landed, as the span is now, and the note for a preview of a card of it that was
+     * left out, if a block is free for it.
+     */
+    render(message, end, held, posting = false) {
+        const blocks = [];
+        let size = 0;
+        let count = 0; // the blocks as Slack counts them, `markdownBlocks` a text
+        const limit = message.blocksRoom;
+        const fixed = end !== null || held !== null;
+        // A message whose span is fixed: what its cards and text take, and what previews took.
+        const [baseBlocks, baseSize] = end !== null ? this.base(message, end) : [0, 0];
+        const leftOut = end !== null ? this.cutPieces(message, end, baseBlocks, baseSize) : new Set();
+        const noteRoom = held !== null && held.blocks() < BLOCKS_LIMIT;
+        let noted = false;
+        for (const { index, part, floor, ceil: spanCeil } of this.span(message.start, end)) {
+            if (part instanceof Text) {
+                const ceil = held !== null ? (held.text.get(index) ?? floor) : spanCeil;
+                const raw = part.text.slice(floor, ceil ?? undefined);
+                const lead = raw.length - lstripNewlines(raw).length;
+                const words = stripNewlines(raw.slice(lead));
+                if (!words)
+                    continue;
+                if (!fixed && count >= limit)
+                    return [blocks, [index, floor + lead]];
+                if (!fixed) {
+                    let stop = null;
+                    let skip = 0;
+                    // Where the characters the message still has room for end in the words.
+                    const fits = at(words, MESSAGE_LIMIT - size);
+                    if (fits < words.length) {
+                        const cut = fits > 0 ? lastNewline(words, fits) : -1;
+                        [stop, skip] = cut <= 0 ? [fits, 0] : [cut, 1];
+                    }
+                    const over = markdownCut(words, limit - count);
+                    if (over !== null && (stop === null || over < stop)) {
+                        // a line's start: the next message opens on it
+                        stop = over;
+                        skip = 0;
+                    }
+                    if (stop !== null) {
+                        const shown = words.slice(0, stop);
+                        if (stripNewlines(shown)) {
+                            blocks.push({ type: "markdown", text: rstripNewlines(shown) });
+                        }
+                        return [blocks, [index, floor + lead + stop + skip]];
+                    }
+                }
+                // A line about the work is small and grey, as the count of a run of calls is.
+                blocks.push(part.aside ? asideBlock(mrkdwnEscape(words), index) : { type: "markdown", text: words });
+                size += len(words);
+                count += markdownBlocks(words);
+            }
+            else {
+                const [hasCard, pieces] = ReplySink.toolElements(part, floor, spanCeil);
+                if (hasCard && (held === null || held.cards.has(part.update.id))) {
+                    if (!fixed && count >= limit)
+                        return [blocks, [index, 0]];
+                    const card = this.cardBlocks(part.update);
+                    blocks.push(...card);
+                    count += card.length;
+                }
+                for (const piece of pieces) {
+                    const length = ReplySink.weight(message, part, piece, posting);
+                    if (held !== null && !held.pieces.has(pieceKey(index, piece))) {
+                        // Late: left out, with the note when its card was shown, once.
+                        if (noteRoom && !noted && held.cards.has(part.update.id)) {
+                            blocks.push(contextBlock(PREVIEW_CUT));
+                            noted = true;
+                            count += 1;
+                        }
+                        continue;
+                    }
+                    if (!fixed) {
+                        if (count + 1 > limit || size + length > MESSAGE_LIMIT) {
+                            return [blocks, [index, piece]];
+                        }
+                    }
+                    else if (leftOut.has(pieceKey(index, piece))) {
+                        // A preview that arrives after its card, in a message whose span is fixed and
+                        // full: it is cut, and says so once, rather than pass the limit (Slack would
+                        // refuse the whole update, the card with it).
+                        if (!noted) {
+                            blocks.push(contextBlock(PREVIEW_CUT));
+                            noted = true;
+                            count += 1;
+                        }
+                        continue;
+                    }
+                    const shown = pieceBlocks(part, piece);
+                    if (!fixed && count + blocksCount(shown) > limit)
+                        return [blocks, [index, piece]];
+                    blocks.push(...shown);
+                    size += length;
+                    count += blocksCount(shown);
+                }
+            }
+        }
+        return [blocks, null];
+    }
+    /**
+     * A tool's card, or once the reply's body has ended what a card of a run of calls folds to: a
+     * line of counts, as the channel model drew it, or nothing.
+     */
+    cardBlocks(update) {
+        if (!this.finished || update.folded === null)
+            return [cardBlock(update)];
+        return update.folded ? [contextBlock(mrkdwnEscape(update.folded))] : [];
+    }
+    /**
+     * What the message shows of the model as it is now: as much of it as fits. Words can reach
+     * the model while the end is being written; past the limits they were never shown, and
+     * holding them would have every later edit of the message refused.
+     */
+    hold(message) {
+        const held = new Held();
+        const fits = this.render(message, null, null)[1];
+        for (const { index, part, floor, ceil } of this.span(message.start, fits)) {
+            if (part instanceof Text) {
+                if (stripNewlines(part.text.slice(floor, ceil ?? undefined))) {
+                    held.text.set(index, ceil === null ? part.text.length : ceil);
+                }
+            }
+            else {
+                const [hasCard, pieces] = ReplySink.toolElements(part, floor, ceil);
+                if (hasCard)
+                    held.cards.add(part.update.id);
+                for (const piece of pieces)
+                    held.pieces.add(pieceKey(index, piece));
+            }
+        }
+        return held;
+    }
+    /**
+     * The characters a preview piece counts toward MESSAGE_LIMIT in a message: its text, unless
+     * it is drawn as collapsed containers, the message is written by `chat.update` and Slack has
+     * not refused an update of it for them.
+     */
+    static weight(message, tool, piece, posting) {
+        if (!posting && !message.containersCounted && pieceCollapsed(tool))
+            return 0;
+        return tool.pieceSize(piece);
+    }
+    /**
+     * The preview pieces a fixed span has no room for, once the text and the cards, and the one
+     * note that says pieces were left out, have theirs. Pieces are taken in order.
+     */
+    cutPieces(message, end, baseBlocks, baseSize) {
+        let cut = new Set();
+        // a note is owed as soon as one piece is cut
+        for (const reserved of [0, 1]) {
+            cut = new Set();
+            let usedBlocks = 0;
+            let usedSize = 0;
+            for (const { index, part, floor, ceil } of this.span(message.start, end)) {
+                if (!(part instanceof Tool))
+                    continue;
+                for (const piece of ReplySink.toolElements(part, floor, ceil)[1]) {
+                    const length = ReplySink.weight(message, part, piece, false);
+                    if (baseBlocks + usedBlocks + 1 + reserved > message.blocksRoom ||
+                        baseSize + usedSize + length > MESSAGE_LIMIT) {
+                        cut.add(pieceKey(index, piece));
+                    }
+                    else {
+                        usedBlocks += 1;
+                        usedSize += length;
+                    }
+                }
+            }
+            if (cut.size === 0)
+                break;
+        }
+        return cut;
+    }
+    /**
+     * The blocks and characters the text and the cards of a fixed span take: what is left of the
+     * limits is what its previews may.
+     */
+    base(message, end) {
+        let blocks = 0;
+        let size = 0;
+        for (const { part, floor, ceil } of this.span(message.start, end)) {
+            if (part instanceof Text) {
+                const words = stripNewlines(part.text.slice(floor, ceil ?? undefined));
+                if (words) {
+                    blocks += markdownBlocks(words);
+                    size += len(words);
+                }
+            }
+            else if (ReplySink.toolElements(part, floor, ceil)[0]) {
+                blocks += 1;
+            }
+        }
+        return [blocks, size];
+    }
+    /**
+     * Bring a stopped message to what the model says, with a `chat.update` when it shows something
+     * else: (written, where the reply goes on past the message). An update never notifies
+     * (measured 2026-09-29). Nothing is written for a message whose stream already shows the
+     * model. An update refused for content that held a container, which counted for nothing, is
+     * tried once more with the containers counted, as a post counts them. With `split`, for a
+     * caller that opens the next message at the cursor returned: an update Slack refuses for too
+     * many blocks is tried again with less of the span (`tighten`); `room` is the room the message
+     * had before the first of those tries.
+     */
+    async updateStep(message, end, split = false, room = 0) {
+        const ts = message.ts;
+        if (ts === null)
+            throw new Error("an update of a message that was never written");
+        let [blocks, overflow] = this.blocks(message, end);
+        let footer = this.footerOf(message);
+        blocks = [...blocks, ...footer];
+        if (blocks.length === 0 || this.current(message, blocks, footer, end))
+            return [true, overflow];
+        try {
+            await this.limiter.acquire();
+            // A change can arrive while this write waits its turn: send what the reply looks like
+            // right now rather than the snapshot taken before the wait.
+            let fresh;
+            [fresh, overflow] = this.blocks(message, end);
+            footer = this.footerOf(message);
+            fresh = [...fresh, ...footer];
+            if (fresh.length === 0 || this.current(message, fresh, footer, end)) {
+                await this.limiter.refund(); // caught up: no write follows
+                return [true, overflow];
+            }
+            blocks = fresh;
+            this.wrote = true;
+            await this.slack.chat.update({
+                channel: this.channel,
+                ts,
+                text: this.banner(this.span(message.start, end)),
+                blocks,
+            });
+        }
+        catch (error) {
+            const code = describe(error);
+            const [text, elements, cards] = blocksSizes(blocks);
+            this.logger.warning(`chat.update failed (${describeRefusal(error)}) with text ${text}, ` +
+                `elements ${elements}, cards ${cards}`);
+            if (code === STILL_STREAMING) {
+                // The daemon's stop never reached Slack: stopped now, the next write passes.
+                await this.stop(message, null, end);
+            }
+            else if (REFUSED_CONTENT.has(code)) {
+                if (!message.containersCounted && blocks.some((block) => block.type === "container")) {
+                    message.containersCounted = true;
+                    return this.updateStep(message, end, split, room);
+                }
+                if (split && end === null && this.held === null && tooManyBlocks(error)) {
+                    const before = room || message.blocksRoom;
+                    if (ReplySink.tighten(message, blocks)) {
+                        return this.updateStep(message, end, true, before);
+                    }
+                    // Refused down to one block: nothing was written, so nothing is cut.
+                    message.blocksRoom = before;
+                    [blocks, overflow] = this.blocks(message, end);
+                    blocks = [...blocks, ...footer];
+                }
+                // The message already shows what it showed: never replaced by a plainer one. The
+                // change is dropped; the next one is tried. Nothing else would say the message is
+                // short of the model, so that is kept until an update passes. A stream never
+                // rewritten (`shown` is null) that was sent all of its span lacks only how the update
+                // would have drawn it, its cards folded: it is not short.
+                const whole = message.shown === null && this.streamShows(message, end, false);
+                message.shown = blocks;
+                message.exact = false;
+                message.footer = footer;
+                message.short = message.short || !whole;
+                return [true, overflow];
+            }
+            // The write may have landed with its answer lost: what the message shows is not known any
+            // more, and the next pass writes it again rather than find it equal to what it believes.
+            message.shown = null;
+            message.exact = false;
+            return [false, null];
+        }
+        message.shown = blocks;
+        message.exact = false;
+        message.footer = footer;
+        message.short = false;
+        return [true, overflow];
+    }
+    /**
+     * Slack counted more blocks in a write of the message than the daemon did: halve the room the
+     * message has, so that its next write holds less and the reply goes on in a new message.
+     * False, with the room as it was, when one block was already too many.
+     */
+    static tighten(message, blocks) {
+        if (message.blocksRoom <= 1)
+            return false;
+        message.blocksRoom = Math.max(1, Math.floor(Math.min(message.blocksRoom, blocksCount(blocks)) / 2));
+        return true;
+    }
+    /** Whether the message already shows `blocks`. */
+    current(message, blocks, footer, end) {
+        if (message.exact) {
+            return isDeepStrictEqual(message.footer, footer) && this.streamShows(message, end);
+        }
+        return message.shown !== null && isDeepStrictEqual(message.shown, blocks);
+    }
+    /**
+     * Slack refused the blocks of a message not yet posted: without this one retry it would never
+     * show, so it is posted as text alone. Never used on a message that shows something already,
+     * which a plainer form would replace.
+     */
+    async writePlain(message, blocks) {
+        let posted;
+        try {
+            this.wrote = true;
+            posted = await this.slack.chat.postMessage({
+                channel: this.channel,
+                thread_ts: this.threadTs,
+                text: plainText(blocks),
+                unfurl_links: false,
+                unfurl_media: false,
+            });
+        }
+        catch (error) {
+            this.logger.warning(`could not write a reply to Slack as plain text: ${describe(error)}`);
+            return false;
+        }
+        message.ts = String(posted.ts);
+        this.places.moved();
+        message.shown = [];
+        message.exact = false;
+        message.footer = [];
+        this.retrack();
+        return true;
+    }
+    /**
+     * Post the message that continues a stopped one, with the blocks of its span as a post takes
+     * them, then bring it to what an update takes: a container's text counts toward a post's limit
+     * and not toward an update's, so what the post left out of its span reaches the same message
+     * and no further one is opened for it.
+     */
+    async postStep(message, split = false, created) {
+        let [blocks, overflow] = this.blocks(message, null, true);
+        const footer = this.footerOf(message);
+        blocks = [...blocks, ...footer];
+        if (blocks.length === 0)
+            return [true, overflow];
+        const attempted = this.clock.time();
+        const banner = this.banner(this.span(message.start, null));
+        let posted;
+        try {
+            // Claude's text can carry a link built to leak data when Slack fetches it for a preview:
+            // no previews for anything the daemon posts.
+            this.wrote = true;
+            posted = await this.slack.chat.postMessage({
+                channel: this.channel,
+                thread_ts: this.threadTs,
+                text: banner,
+                blocks,
+                unfurl_links: false,
+                unfurl_media: false,
+            });
+        }
+        catch (error) {
+            const [text, elements, cards] = blocksSizes(blocks);
+            this.logger.warning(`chat.postMessage failed (${describeRefusal(error)}) with text ${text}, ` +
+                `elements ${elements}, cards ${cards}`);
+            if (split && tooManyBlocks(error) && ReplySink.tighten(message, blocks)) {
+                return this.postStep(message, true, created);
+            }
+            if (unknownOutcome(error)) {
+                const ts = await this.adopt(attempted, false, take(plainWords(banner), ADOPT_WORDS));
+                if (ts !== null) {
+                    message.ts = ts;
+                    this.places.moved();
+                    created?.();
+                    message.shown = blocks;
+                    message.footer = footer;
+                    this.retrack();
+                    return [true, overflow];
+                }
+            }
+            if (this.closedOut &&
+                REFUSED_CONTENT.has(describe(error)) &&
+                (await this.writePlain(message, blocks))) {
+                return [true, overflow];
+            }
+            return [false, null];
+        }
+        message.ts = String(posted.ts);
+        this.places.moved();
+        // The message sits where it sits: the edit that follows waits for the budget without
+        // holding the thread's other replies back.
+        created?.();
+        message.shown = blocks;
+        message.footer = footer;
+        this.retrack();
+        return this.updateStep(message, null, split);
+    }
+    /**
+     * The start of what a stream's first chunks say, as plain words: empty when there are none to
+     * compare (then nothing is adopted). A stream's `text` reads back with a card's title and with
+     * a container's title in it (recorded 2026-09-28, slack-sdk 3.44.1).
+     */
+    static firstWords(plan) {
+        const first = plan.chunks[0];
+        let words = "";
+        if (first === undefined) {
+            words = "";
+        }
+        else if (first.type === "blocks") {
+            const block = first.blocks[0];
+            if (block !== undefined) {
+                words = (block.type === "container" ? block.title.text : "") || blockText(block);
+            }
+        }
+        else if (first.type === "markdown_text") {
+            words = first.text;
+        }
+        else {
+            words = first.title;
+        }
+        return take(plainWords(words), ADOPT_WORDS);
+    }
+    /**
+     * A create that failed on the connection may have landed. Read the thread back, and return
+     * the ts of the daemon's own message newer than the attempt that carries `probe` (a stream:
+     * `streaming_state`, and the start of its text), or null. Writing again first would make it
+     * twice.
+     */
+    async adopt(attempted, stream, probe) {
+        let found;
+        try {
+            const read = await this.slack.conversations.replies({
+                channel: this.channel,
+                ts: this.threadTs,
+                oldest: (attempted - ADOPT_SKEW_SECONDS).toFixed(6),
+                limit: 200,
+            });
+            found = read.messages;
+        }
+        catch (error) {
+            this.logger.warning(`could not read the thread back for a lost write: ${describe(error)}`);
+            return null;
+        }
+        const known = new Set(this.messages.map((message) => message.ts));
+        known.add(this.closing);
+        for (const item of Array.isArray(found) ? found : []) {
+            if (typeof item !== "object" || item === null)
+                continue;
+            const message = item;
+            const ts = String(message.ts);
+            if (ts === this.threadTs || known.has(ts) || message.user !== this.botUserId)
+                continue;
+            if (stream && !("streaming_state" in message))
+                continue;
+            if (probe && plainWords(String(message.text ?? "")).includes(probe))
+                return ts;
+        }
+        return null;
+    }
+    /**
+     * Tell the message's stream what it lacks, starting it with the first content: (written,
+     * where the reply goes on past the message).
+     */
+    async streamStep(message) {
+        let plan = this.plan(message);
+        if (plan.chunks.length === 0)
+            return [true, plan.overflow];
+        if (message.ts === null) {
+            const attempted = this.clock.time();
+            let streamTs;
+            try {
+                this.wrote = true;
+                const started = await this.slack.chat.startStream({
+                    channel: this.channel,
+                    thread_ts: this.threadTs,
+                    recipient_team_id: this.teamId,
+                    recipient_user_id: this.userId,
+                    chunks: plan.chunks,
+                    task_display_mode: "timeline",
+                });
+                streamTs = String(started.ts);
+            }
+            catch (error) {
+                const unknown = unknownOutcome(error);
+                this.logger.warning(`could not start a reply's stream: ${describe(error)}` +
+                    (unknown
+                        ? " (outcome unknown: the thread is read back for a stream it may have made)"
+                        : ""));
+                const ts = unknown ? await this.adopt(attempted, true, ReplySink.firstWords(plan)) : null;
+                if (ts === null)
+                    return [false, null];
+                streamTs = ts; // it landed: this is that stream
+            }
+            message.ts = streamTs;
+            this.places.moved();
+            message.streaming = true;
+            message.started = attempted;
+            ReplySink.sent(message, plan);
+            this.retrack();
+            message.deadline = new Task((signal) => this.expire(message, signal));
+            this.armRefresh(message);
+            return [true, plan.overflow];
+        }
+        try {
+            await this.limiter.acquire();
+            // A change can arrive while this write waits its turn: tell the stream what it lacks
+            // right now, not the snapshot taken before the wait.
+            plan = this.plan(message);
+            if (plan.chunks.length === 0) {
+                await this.limiter.refund(); // caught up: no write follows
+                return [true, plan.overflow];
+            }
+            this.wrote = true;
+            await this.slack.chat.appendStream({
+                channel: this.channel,
+                ts: message.ts,
+                chunks: plan.chunks,
+            });
+        }
+        catch (error) {
+            const code = describe(error);
+            if (code === TOO_LONG) {
+                // Slack's cap follows what it stores, which the plan only estimates, and it would
+                // refuse the same append again. The stream is stopped bare, as at STREAM_SECONDS, and
+                // the message goes on by update, from the model; the end then posts the closing
+                // message. Only this code: any other refusal stays a failed write, which the session
+                // shows.
+                const cards = new Set([...message.cards.keys(), ...plan.cards.keys()]).size;
+                this.logger.warning(`chat.appendStream refused (${code}) with text ${plan.size}, elements ${plan.count}, ` +
+                    `cards ${cards}, card text sent ${message.cardText} and ${planCardText(plan)} more ` +
+                    "in this append: the stream is stopped and the message goes on by update");
+                if ((await this.stop(message, null, null)) === "failed")
+                    return [false, null];
+                return this.updateStep(message, null, true);
+            }
+            this.logger.warning(`could not write a reply to Slack: ${code}`);
+            if (code === NOT_STREAMING) {
+                // Slack ended the stream first: the message goes on by update.
+                this.gone(message);
+                // A rest stop that landed with its answer lost: the reply is at rest from here on.
+                if (this.restRequested)
+                    this.places.place();
+                return this.updateStep(message, null, true);
+            }
+            if (unknownOutcome(error)) {
+                // An append is not idempotent: sent again it may show twice. The stream is told
+                // nothing more; the message is stopped and goes on by update, from the model.
+                this.logger.warning("a stream append's outcome is unknown: the message goes on by update");
+                message.blind = true;
+            }
+            return [false, null];
+        }
+        ReplySink.sent(message, plan);
+        return [true, plan.overflow];
+    }
+    /** The message's stream is over, however it ended. */
+    gone(message) {
+        message.streaming = false;
+        // Its own deadline may be what stopped it: past its waits, a cancel changes nothing there.
+        message.deadline?.cancel();
+        message.deadline = null;
+        message.refresh?.cancel();
+        message.refresh = null;
+    }
+    /**
+     * Stop the message's stream, with `blocks` at its bottom: "stopped", "gone" (Slack had ended
+     * it already) or "failed". A stop notifies; what the stream still lacks is left for the
+     * update that follows.
+     */
+    async stop(message, blocks, end) {
+        const ts = message.ts;
+        if (ts === null)
+            throw new Error("a stop of a stream that never started");
+        let footer = blocks !== null && blocks.length > 0 ? blocks : null;
+        let result = "stopped";
+        try {
+            this.wrote = true;
+            await this.slack.chat.stopStream({
+                channel: this.channel,
+                ts,
+                ...(footer === null ? {} : { blocks: footer }),
+            });
+        }
+        catch (error) {
+            if (describe(error) !== NOT_STREAMING) {
+                this.logger.warning(`could not stop a reply's stream: ${describe(error)}`);
+                // The end's stop carries no footer (the session draws it later): it is ours all the same.
+                const ours = footer !== null || this.closedOut;
+                if (unknownOutcome(error) && ours && message.stopUnknown === null) {
+                    message.stopUnknown = [...(footer ?? [])];
+                }
+                return "failed";
+            }
+            if (message.stopUnknown !== null && !this.pastLife(message)) {
+                // The stop that failed on the connection is the one that landed, with what it carried.
+                footer = message.stopUnknown;
+                result = "stopped";
+            }
+            else {
+                // Over with no stop of ours behind it, or past the stream's life, when Slack's own end
+                // cannot be told from our stop landing: the end posts a closing message of its own.
+                result = "gone";
+            }
+            message.stopUnknown = null;
+        }
+        this.gone(message);
+        message.stopUnknown = null;
+        message.exact = this.streamShows(message, end);
+        message.footer = result === "stopped" ? [...(footer ?? [])] : [];
+        if (end === null && this.restRequested)
+            this.places.place();
+        return result;
+    }
+    pastLife(message) {
+        return this.clock.time() - message.started >= STREAM_LIFE;
+    }
+    /**
+     * STREAM_SECONDS after the stream started: stop it before Slack does, and go on by update.
+     * The stop notifies (accepted); the updates after it never do.
+     */
+    async expire(message, signal) {
+        await this.clock.sleep(STREAM_SECONDS, signal);
+        const release = await this.lock.acquire(signal);
+        try {
+            if (!message.streaming)
+                return;
+            if ((await this.stop(message, null, null)) === "failed") {
+                return; // Slack ends it at 5 minutes: the next append finds it over
+            }
+            // The message is rewritten from the model now, with no stream to wait for.
+            this.restamp(this.steady.time());
+            await this.sync();
+        }
+        finally {
+            release();
+        }
+    }
+    // The one place a reply is written.
+    /**
+     * Write what changed; false when a write failed and the reply is not as it should be. A write
+     * can take real time (the limiter, a round trip), during which the reply can change again:
+     * what is written is what the reply looks like right now, never the snapshot taken before the
+     * wait, so a wait never drops a change. `later` runs this again when `version` moved during
+     * it. A pass: never cancelled (see the top of this file).
+     */
+    /** Whether a message of the reply, or its closing message, still shows the list. */
+    showsList() {
+        return (this.messages.some((message) => message.footer.some(isRunningList)) ||
+            this.closingShown.some(isRunningList));
+    }
+    async flush() {
+        const release = await this.lock.acquire();
+        try {
+            const ok = await this.sync();
+            if (ok && this.closedOut)
+                this.settleOpenReply();
+            if (ok && this.assigned === null && !this.showsList())
+                this.places.unlisted(this);
+            return ok;
+        }
+        finally {
+            release();
+        }
+    }
+    /**
+     * Bring every message of the reply to the model, then, once the reply has ended, end it, and
+     * follow which messages a crash would leave unfinished. The lock is held.
+     */
+    async sync() {
+        try {
+            return await this.syncMessages();
+        }
+        finally {
+            this.retrack();
+            if (this.wrote) {
+                this.wrote = false;
+                this.onWrite?.();
+            }
+        }
+    }
+    async syncMessages() {
+        if (this.messages.length === 0) {
+            if (!this.hasContent())
+                return this.closedOut ? this.end() : true;
+            this.messages.push(new Message([0, 0], this.restRequested ? "post" : "stream"));
+        }
+        for (let i = 0; i + 1 < this.messages.length; i += 1) {
+            const message = this.messages[i];
+            const following = this.messages[i + 1];
+            if (message === undefined || following === undefined || message.ts === null)
+                continue;
+            const rev = this.spanRev(message, following.start);
+            if (message.checked !== null &&
+                message.checked.rev === rev &&
+                sameCursor(message.checked.end, following.start)) {
+                continue; // nothing in it changed since it was last brought to the model
+            }
+            if (!(await this.updateStep(message, following.start))[0])
+                return false;
+            message.checked = { rev, end: following.start };
+        }
+        for (;;) {
+            const message = this.messages.at(-1);
+            if (message === undefined)
+                return false;
+            if (message.streaming && (message.blind || this.restRequested)) {
+                // Told nothing more, or the reply rests: stopped now (with the footer, if the reply has
+                // ended or rests), and the update below writes the whole message from the model.
+                const footer = this.closedOut || this.restRequested ? this.footerBlocks() : null;
+                const result = await this.stop(message, footer, null);
+                if (result === "failed") {
+                    // A refused rest keeps appending to the stream, which the next pass or the 280 seconds
+                    // stop again; a stream told nothing more, or one the end stops, is not appended to.
+                    if (message.blind || this.closedOut)
+                        return false;
+                    // No change may come before then: one more try after the pause, as for a write on a
+                    // reply at rest.
+                    if (this.retrying)
+                        this.warnGaveUp();
+                    else
+                        this.retryLater();
+                }
+                else {
+                    if (this.closedOut && result === "stopped")
+                        this.endMode = "inline";
+                    if (message.blind)
+                        message.exact = false;
+                }
+            }
+            let step;
+            const fresh = message.ts === null;
+            if (message.ts === null) {
+                // The reply's first message: the list leaves the reply above it before it is created.
+                const opened = this.messages.length === 1 ? await this.places.opens(this) : null;
+                // A message is created with the thread's places held, after the decision that it may be.
+                const free = await this.creating();
+                try {
+                    if (this.messages.length > 1 && this.places.overtaken(this)) {
+                        // A continuation planned before another reply wrote below, not yet posted: it
+                        // would land under that reply. The message before it is the reply's last again.
+                        this.messages.pop();
+                        this.warnCut();
+                        continue;
+                    }
+                    step =
+                        message.mode === "stream"
+                            ? await this.streamStep(message)
+                            : await this.postStep(message, true, free);
+                }
+                finally {
+                    free();
+                    opened?.();
+                }
+            }
+            else if (message.streaming) {
+                step = await this.streamStep(message);
+            }
+            else {
+                step = await this.updateStep(message, null, true);
+            }
+            const [ok, overflow] = step;
+            if (!ok)
+                return false;
+            const previous = this.messages.at(-2);
+            if (fresh &&
+                previous !== undefined &&
+                previous.ts !== null &&
+                previous.footer.length > 0 &&
+                message.ts !== null) {
+                // The continuation is written: the message before it is no longer the reply's last, and
+                // was written as if it were, with the footer and the list. Neither is in two messages of
+                // a reply at rest.
+                if (!(await this.updateStep(previous, message.start))[0])
+                    return false;
+            }
+            if (overflow === null)
+                break;
+            if (this.places.overtaken(this)) {
+                // Another reply is below: a message opened now would sit below it. What does not fit
+                // is cut, as a card's text is.
+                this.warnCut();
+                break;
+            }
+            if (sameCursor(overflow, message.start)) {
+                this.logger.error("a reply's message cannot hold its first element");
+                return false;
+            }
+            const mode = message.streaming ? "stream" : "post";
+            if (message.streaming && (await this.stop(message, null, overflow)) === "failed") {
+                return false;
+            }
+            this.messages.push(new Message(overflow, mode));
+        }
+        if (!this.closedOut)
+            return true;
+        // The end is written either way; a message left short of the model makes it one that did
+        // not land, which the session shows.
+        const ended = await this.end();
+        const last = this.messages.at(-1);
+        if (this.held === null && last !== undefined && this.endLanded())
+            this.held = this.hold(last);
+        return ended && !this.messages.some((message) => message.short);
+    }
+    /**
+     * The reply's end, on Slack: the footer on the last stream's stop; once the stream is over,
+     * under the reply's ending, posted as a new message, or in a closing message of its own when
+     * there is no ending to move (`endingCursor`). A continuation that opened on the line on how
+     * the reply ended is the ending as it stands (`opensOnEnding`): nothing is posted, and the
+     * footer goes under it by edit.
+     */
+    async end() {
+        const message = this.messages.at(-1);
+        if (message === undefined)
+            return true; // nothing was ever shown: nothing to end
+        if (this.endMode === "inline" || this.endMode === "moved") {
+            // The stream's stop carried the footer, or the ending posted as the reply's last message
+            // does: a later change edits that message (`syncMessages`).
+            return true;
+        }
+        if (message.streaming) {
+            const result = await this.stop(message, this.footerBlocks(), null);
+            if (result === "failed")
+                return false;
+            if (result === "stopped")
+                this.endMode = "inline";
+            // A stream cannot fold its cards: the update that follows its stop does, silently. The
+            // reply has ended whatever becomes of that write: one that fails is tried once more with
+            // the next pass, and the cards stay if that fails too.
+            if (!(await this.updateStep(message, null))[0]) {
+                this.version += 1;
+                this.schedule();
+            }
+            if (result === "stopped")
+                return true;
+        }
+        // Everything below may create a message, and is decided with the thread's places held.
+        const free = await this.creating();
+        try {
+            return await this.endCreating(message, free);
+        }
+        finally {
+            free();
+        }
+    }
+    /**
+     * Takes the thread's places lock, for the decision to create a message and the call that
+     * creates it. Returns the release, which may be called more than once: the creator calls it as
+     * soon as the message's `ts` is set, and the caller's `finally` calls it again. Edits never
+     * hold it, since an edit does not change where a message sits.
+     */
+    async creating() {
+        const release = await this.places.lock.acquire();
+        let held = true;
+        return () => {
+            if (!held)
+                return;
+            held = false;
+            release();
+        };
+    }
+    /**
+     * A reply at rest that is no longer the last thing in the thread and was written no words of
+     * the agent's since it rested: its ending would only be its old text again.
+     */
+    leftBehind() {
+        return this.restRequested && !this.reportedSinceRest && !this.last;
+    }
+    /** The part of `end` that posts: the ending, or the closing message. */
+    async endCreating(message, free) {
+        const owed = this.endMode === null || (this.endMode === "post" && this.closing === null);
+        // A closing message put off is not posted below anything written in the thread since.
+        const passed = this.closingDeferred && (this.places.newestAt ?? 0) > (this.deferredAt ?? 0);
+        if (owed && (this.places.overtaken(this) || this.leftBehind() || passed)) {
+            // Another reply has a message below this one, or this one rested, was left behind by the
+            // owner's and has nothing to report, or its closing message was put off and something was
+            // written below since (the owner's message, a line of the daemon's): nothing is posted (it
+            // would land under that message, or repeat old text as the newest), and the footer, once
+            // drawn, goes under this message by a silent edit.
+            this.endMode = "inline";
+            this.closingDeferred = false;
+            free();
+            return (await this.updateStep(message, null))[0];
+        }
+        if (this.endMode === null) {
+            const cursor = this.endingCursor(message);
+            if (cursor !== null) {
+                // The reply's ending, with the footer, as a new message: the one that notifies, so the
+                // notification says how the work ended. Posted first, then taken out of the message it
+                // grew in: for a moment it shows twice, never nowhere.
+                const ending = new Message(cursor, "post");
+                this.messages.push(ending);
+                this.endMode = "moved"; // the footer goes under it, in the same post
+                try {
+                    await this.postStep(ending, false, free);
+                }
+                finally {
+                    if (ending.ts === null) {
+                        // Not posted: as if never tried, so the next pass posts it before it shortens
+                        // anything.
+                        this.messages.pop();
+                        this.endMode = null;
+                    }
+                }
+                free();
+                if (this.endMode === null)
+                    return false;
+                // its stream said more than its span
+                message.exact = false;
+                message.checked = null;
+                return (await this.updateStep(message, cursor))[0];
+            }
+            if (this.opensOnEnding(message)) {
+                // A full message pushed the line into this one, which notified with it: a closing
+                // message after it would ring again with nothing to show. The footer, if there is
+                // one, goes under it by a silent edit.
+                this.endMode = "moved";
+                free();
+                return (await this.updateStep(message, null))[0];
+            }
+        }
+        this.endMode = "post";
+        this.bodyLanded = true; // every message is written: only the closing message is owed
+        if (!(await this.writeClosing(free)))
+            return false;
+        // A message that rested showed the footer: the closing message holds it now.
+        return message.footer.length === 0 || (await this.updateStep(message, null))[0];
+    }
+    /**
+     * Delete the closing message that held the footer alone. The reply stays ended: a delete that
+     * fails leaves the footer where it is, is logged, and is tried once more after
+     * `finalRetrySeconds`. A message Slack no longer has counts as deleted.
+     */
+    async deleteClosing(ts, created) {
+        created?.(); // a delete creates nothing: another reply may create meanwhile
+        try {
+            await this.limiter.acquire();
+            this.wrote = true;
+            await this.slack.chat.delete({ channel: this.channel, ts });
+        }
+        catch (error) {
+            if (describe(error) !== MESSAGE_NOT_FOUND) {
+                this.logger.warning(`could not delete a reply's closing message: ${describe(error)}`);
+                if (this.retrying)
+                    this.warnGaveUp();
+                else
+                    this.retryLater();
+                return true;
+            }
+        }
+        this.closingGone = true;
+        this.closingShown = [];
+        this.places.moved();
+        return true;
+    }
+    /**
+     * One more try after `finalRetrySeconds` of a write that follows the end: the final write has
+     * no next rewrite to fix it. A try in flight is not followed by another.
+     */
+    retryLater() {
+        if (this.tailRetry !== null || this.settling)
+            return;
+        const task = new Task(async (signal) => {
+            try {
+                await this.clock.sleep(this.finalRetrySeconds, signal);
+                // Shielded like the final write: a pass given up after Slack took it would lose its result.
+                this.retrying = true;
+                this.gaveUpLogged = false;
+                if (!(await this.flush()))
+                    this.warnGaveUp();
+            }
+            finally {
+                this.retrying = false;
+                if (this.tailRetry === task)
+                    this.tailRetry = null;
+            }
+        });
+        this.tailRetry = task;
+    }
+    /** The retry of a write after the end failed too: the next change of the reply writes it. */
+    warnGaveUp() {
+        // Once per retry: its stop and its append may both fail.
+        if (this.gaveUpLogged)
+            return;
+        this.gaveUpLogged = true;
+        this.logger.warning("could not bring a reply's footer to the thread once it rested or ended, tried twice: " +
+            "the next change of the reply writes it");
+    }
+    /** Logs once that an overtaken reply shows less than it said. */
+    warnCut() {
+        if (this.cutWarned)
+            return;
+        this.cutWarned = true;
+        this.logger.warning("a reply that another reply sits below shows less than it said: a message opened now " +
+            "would land below that reply");
+    }
+    /**
+     * Whether the reply's end is on Slack: the footer rode on the last stream's stop ("inline",
+     * set after a stop that landed) or sits in the ending posted as the last message ("moved",
+     * reset when that post fails), or the closing message was posted. A continuation that is the
+     * ending as it stands is "moved" too, from before its footer is written: it rang when it was
+     * posted, and an edit that fails is written by the next pass. Not `endMode === "post"`, which
+     * `end` sets before the closing message is written.
+     */
+    endLanded() {
+        return (this.endMode === "inline" ||
+            this.endMode === "moved" ||
+            this.closing !== null ||
+            this.closingDeferred);
+    }
+    /**
+     * Post the closing message of a reply whose stream stopped early and that has no ending to
+     * move into a message of its own (`end`), or bring it to the list and the footer as they
+     * stand: it stays once posted, since it is what notified. Its text is Claude's own words, as a
+     * banner: never a line of the daemon's. With nothing to show it is not posted yet: the
+     * session's footer posts it (`closingDeferred`). One posted that is left with nothing else
+     * holds one zero-width space.
+     */
+    async writeClosing(created) {
+        // Deleted: the footer, if one is drawn later, goes under the body (`footerOf`).
+        if (this.closingGone)
+            return true;
+        let blocks = this.closingBlocks();
+        // A list that is no longer assigned leaves the message with nothing: it goes.
+        if (blocks.length === 0 && this.closing !== null && this.closingShown.some(isRunningList)) {
+            return this.deleteClosing(this.closing, created);
+        }
+        if (blocks.length === 0 && this.closing === null) {
+            // Nothing to show yet: posted with the session's footer, never empty.
+            if (!this.closingDeferred)
+                this.deferredAt = this.places.newestAt;
+            this.closingDeferred = true;
+            created?.();
+            return true;
+        }
+        this.closingDeferred = false;
+        if (blocks.length === 0)
+            blocks = [contextBlock(ZERO_WIDTH_SPACE)];
+        const attempted = this.clock.time();
+        try {
+            if (this.closing === null) {
+                this.wrote = true;
+                const posted = await this.slack.chat.postMessage({
+                    channel: this.channel,
+                    thread_ts: this.threadTs,
+                    text: this.banner(),
+                    blocks,
+                    unfurl_links: false,
+                    unfurl_media: false,
+                });
+                this.closing = String(posted.ts);
+                this.places.moved();
+                created?.();
+            }
+            else if (this.closingUnsure || !isDeepStrictEqual(blocks, this.closingShown)) {
+                // An edit never notifies (measured 2026-09-27): the text stays as posted.
+                created?.();
+                await this.limiter.acquire();
+                this.wrote = true;
+                await this.slack.chat.update({
+                    channel: this.channel,
+                    ts: this.closing,
+                    text: this.banner(),
+                    blocks,
+                });
+            }
+        }
+        catch (error) {
+            this.logger.warning(`could not write a reply's closing message: ${describe(error)}`);
+            if (this.closing !== null)
+                this.closingUnsure = true;
+            if (this.closing === null && unknownOutcome(error)) {
+                this.closing = await this.adopt(attempted, false, take(plainWords(this.banner()), ADOPT_WORDS));
+                if (this.closing !== null) {
+                    this.places.moved();
+                    this.closingShown = blocks;
+                    return true;
+                }
+            }
+            return false;
+        }
+        this.closingShown = blocks;
+        this.closingUnsure = false;
+        return true;
+    }
+}