allaboard 0.0.0-stage → 0.5.0

package/dist/agent/claude/usage.js

@@ -0,0 +1,110 @@
+/** Claude Code's `/usage` text read into the 5-hour and weekly limits. */
+import { strip } from "../../text.js";
+// `/usage` answers in seconds; past this the probe gives up, so the footer never stops refreshing.
+export const USAGE_TIMEOUT = 60_000;
+// Wording measured on Claude Code 2.1.280 (2026-09-23). A change hides the field, nothing more.
+const SESSION_LINE = /^Current session: (\d+)% used(?: · resets (.+))?$/m;
+const WEEK_LINE = /^Current week \(all models\): (\d+)% used(?: · resets (.+))?$/m;
+const RESET = /^(?<mon>[A-Z][a-z]{2}) (?<day>\d{1,2}) at (?<hour>\d{1,2})(?::(?<min>\d{2}))?(?<ampm>am|pm) \((?<tz>[^)]+)\)$/;
+const MONTHS = ["Jan", "Feb", "Mar", "Apr", "May", "Jun", "Jul", "Aug", "Sep", "Oct", "Nov", "Dec"];
+const DAY_MS = 86_400_000;
+const formatters = new Map();
+/** The zone's formatter, null for a zone the runtime does not know. */
+function formatterFor(zone) {
+    // `zoneinfo` knows no zone named by an offset; `Intl` reads "+02:00" as one.
+    if (/^[+-]/.test(zone)) {
+        return null;
+    }
+    let formatter = formatters.get(zone);
+    if (formatter === undefined) {
+        try {
+            formatter = new Intl.DateTimeFormat("en-US", {
+                timeZone: zone,
+                hourCycle: "h23",
+                year: "numeric",
+                month: "numeric",
+                day: "numeric",
+                hour: "numeric",
+                minute: "numeric",
+                second: "numeric",
+            });
+        }
+        catch (error) {
+            if (!(error instanceof RangeError)) {
+                throw error;
+            }
+            formatter = null;
+        }
+        formatters.set(zone, formatter);
+    }
+    return formatter;
+}
+function wallClock(at, formatter) {
+    const parts = {};
+    for (const part of formatter.formatToParts(at)) {
+        if (part.type !== "literal") {
+            parts[part.type] = Number(part.value);
+        }
+    }
+    return parts;
+}
+/** The zone's offset from UTC at an instant, in milliseconds. */
+function offsetAt(at, formatter) {
+    const w = wallClock(at, formatter);
+    const local = Date.UTC(w.year, w.month - 1, w.day, w.hour, w.minute, w.second);
+    return local - Math.floor(at / 1000) * 1000;
+}
+/**
+ * The instant a wall-clock time has in a zone, as `zoneinfo` reads it with `fold=0`: a time the
+ * zone repeats is its first occurrence, and one it skips takes the offset from before the jump.
+ */
+function instantOf(wall, formatter) {
+    const before = offsetAt(wall - DAY_MS, formatter);
+    const after = offsetAt(wall + DAY_MS, formatter);
+    const valid = [before, after]
+        .map((offset) => wall - offset)
+        .filter((instant) => offsetAt(instant, formatter) === wall - instant);
+    return valid.length > 0 ? Math.min(...valid) : wall - before;
+}
+/** The instant in `text` ("Sep 24 at 1:10am (Europe/Berlin)"), null when it cannot be read. */
+export function parseReset(text, now) {
+    const found = RESET.exec(strip(text))?.groups;
+    if (found === undefined) {
+        return null;
+    }
+    const month = MONTHS.indexOf(found.mon);
+    const formatter = formatterFor(found.tz);
+    if (month < 0 || formatter === null) {
+        return null;
+    }
+    const hour = (Number(found.hour) % 12) + (found.ampm === "pm" ? 12 : 0);
+    const day = Number(found.day);
+    const minute = Number(found.min ?? 0);
+    const at = (year) => {
+        const wall = new Date(Date.UTC(year, month, day, hour, minute));
+        // A day or a minute out of range is a date that does not exist, not the next month's.
+        if (minute > 59 || wall.getUTCMonth() !== month || wall.getUTCDate() !== day) {
+            return null;
+        }
+        return instantOf(wall.getTime(), formatter);
+    };
+    // The year is the one `now` has in the reset's own zone.
+    const year = wallClock(now, formatter).year;
+    const instant = at(year);
+    if (instant === null || instant >= now - DAY_MS) {
+        return instant;
+    }
+    return at(year + 1);
+}
+function parseLimit(pattern, text, now) {
+    const match = pattern.exec(text);
+    if (match === null) {
+        return null;
+    }
+    const reset = match[2];
+    return { percent: Number(match[1]), resetsAt: reset ? parseReset(reset, now) : null };
+}
+/** The 5-hour and weekly figures from `/usage`; a field it cannot read is null. */
+export function parseUsage(text, now) {
+    return { session: parseLimit(SESSION_LINE, text, now), week: parseLimit(WEEK_LINE, text, now) };
+}

package/dist/agent/claude/wire.js

@@ -0,0 +1,22 @@
+/**
+ * Reading what Claude Code sends as `unknown`. The SDK's types describe less than the wire
+ * carries (of 24 recorded kinds, 9 hold fields the types do not declare and one is absent from
+ * the union, measured 2026-10-10 on SDK 0.3.296), so nothing here trusts a declared shape: each
+ * value is narrowed where it is read.
+ */
+/** `value` when it is a string, else null. */
+export function string(value) {
+    return typeof value === "string" ? value : null;
+}
+/** `value` when it is a string that says something, else null. */
+export function words(value) {
+    return typeof value === "string" && value !== "" ? value : null;
+}
+/** `value` when it is a whole number, else null. */
+export function integer(value) {
+    return typeof value === "number" && Number.isInteger(value) ? value : null;
+}
+/** `value` when it is a number, else null. */
+export function number(value) {
+    return typeof value === "number" && Number.isFinite(value) ? value : null;
+}

package/dist/agent/seam.js

@@ -0,0 +1,21 @@
+/**
+ * The agent refused to resume the session a start named (its transcript is gone): the thread
+ * that held it cannot go on. Any other failure of a start rejects with the failure itself, and
+ * the thread's next message tries again.
+ */
+export class ResumeRefused extends Error {
+    constructor(options) {
+        super("the agent could not resume the session", options);
+        this.name = "ResumeRefused";
+    }
+}
+/**
+ * A setting the owner gave the agent in the daemon's file cannot be used; the message names the
+ * variable and says what to fix. The daemon logs it as it does its own configuration errors.
+ */
+export class AgentConfigError extends Error {
+    constructor(message) {
+        super(message);
+        this.name = "AgentConfigError";
+    }
+}

package/dist/chat/seam.js

@@ -0,0 +1,10 @@
+/**
+ * A call the chat refused or could not take. `name` is the provider's code for the failure
+ * (`channel_not_found`), or the error's own name: all a log line may say of it, never content.
+ */
+export class ChatError extends Error {
+    constructor(code, options) {
+        super(code, options);
+        this.name = code;
+    }
+}

package/dist/chat/slack/app/answers.js

@@ -0,0 +1,209 @@
+/**
+ * What every listener shares: the checks each one runs on its own, where the daemon's own answers
+ * go, and how a failure after the checks reaches the owner.
+ *
+ * The work handed to `replyOnFailure` is a function, called inside its guard.
+ */
+import { Cancelled, DirectoryUnavailable, fill, named, SessionClosed, SessionGone, texts, } from "../../../core/port.js";
+import { getLogger } from "../../../log.js";
+import { deliver } from "../notice.js";
+import { contextBlock, noticeText } from "../reply/blocks.js";
+import { describe } from "../reply/errors.js";
+import * as slackTexts from "../texts.js";
+import { isOwner } from "./guards.js";
+export const logger = getLogger("allaboard.chat.slack.app");
+/** Whether a wait was cancelled: a task's signal aborted. */
+export function isCancelled(error) {
+    return error instanceof Cancelled;
+}
+export class Answers {
+    parts;
+    constructor(parts) {
+        this.parts = parts;
+    }
+    /**
+     * Whether the daemon has stopped. A listener that finds it so ends silently: Node's listeners
+     * go on at their next await after the stop.
+     */
+    get stopped() {
+        return this.parts.stopped.aborted;
+    }
+    /**
+     * One message to the channel: a normal post (in `threadTs`'s thread, or top-level when it is
+     * null) or, with `ephemeral`, one only the owner sees, under `threadTs`. A normal post pushes
+     * only inside a thread the owner started; an ephemeral message never does. Returns the `ts`
+     * of a normal post, null for an ephemeral message and once the daemon has stopped.
+     */
+    async deliver(channel, threadTs, text, blocks, options) {
+        const { slack, identity, sessions } = this.parts;
+        if (this.stopped)
+            return null;
+        const posted = await deliver(slack, identity.ownerUserId, { channel, threadTs }, text, blocks, options);
+        if (threadTs !== null) {
+            // Slack clears a thread's status line when the app replies: the session's is set
+            // again, so `Working…` does not go for a minute after the answer to a word.
+            sessions.wrote(channel, threadTs);
+        }
+        return posted;
+    }
+    /**
+     * One of the daemon's own notices (a bind, a resume, a restart), small and grey as the footer,
+     * so it reads apart from Claude's replies. `text` is mrkdwn.
+     */
+    async notice(channel, threadTs, text, options = {}) {
+        await this.deliver(channel, threadTs, text, [contextBlock(noticeText(text))], {
+            ephemeral: options.ephemeral ?? false,
+        });
+    }
+    /**
+     * A line for the owner alone, under their message in `threadTs`'s thread: a refusal that
+     * answers what they just did. With `stays` it is a post in the thread instead, which a reload
+     * keeps and which can notify. Never throws: nobody is left to tell about a failure.
+     */
+    async tellOwner(channel, threadTs, text, options = {}) {
+        await this.thread(channel, threadTs).tell(text, options);
+    }
+    /**
+     * `tellOwner` about the message `ts`. At the top level (`threadTs` is `ts`) the line goes to
+     * the channel: the message has no reply yet, and Slack shows an ephemeral message in a thread
+     * only when the thread is already active (`chat.postEphemeral` reference), accepting the call
+     * and showing nothing. Never throws.
+     */
+    async tellOwnerAbout(channel, threadTs, ts, text) {
+        if (threadTs !== ts) {
+            await this.tellOwner(channel, threadTs, text);
+            return;
+        }
+        try {
+            await this.notice(channel, null, text, { ephemeral: true });
+        }
+        catch (error) {
+            logger.warning(`could not reach the owner in ${channel}: ${describe(error)}`);
+        }
+    }
+    /**
+     * A notice about the message `ts` that the daemon can take back (`withdraw`): a normal post,
+     * since Slack lets nobody delete an ephemeral message. It goes to the message's thread, or to
+     * the channel for a message at the top level, which has no thread yet. Returns the post's
+     * `ts`, null when nothing was posted. Never throws.
+     */
+    async tellAbout(channel, threadTs, ts, text) {
+        try {
+            return await this.deliver(channel, threadTs === ts ? null : threadTs, text, [contextBlock(noticeText(text))], { ephemeral: false });
+        }
+        catch (error) {
+            logger.warning(`could not reach the owner in ${channel}: ${describe(error)}`);
+            return null;
+        }
+    }
+    /** Takes back a notice `tellAbout` posted; one already gone counts as done. Never throws. */
+    async withdraw(channel, ts) {
+        if (this.stopped)
+            return;
+        try {
+            await this.parts.slack.chat.delete({ channel, ts });
+        }
+        catch (error) {
+            if (describe(error) !== "message_not_found") {
+                logger.warning(`could not take back a notice in ${channel}: ${describe(error)}`);
+            }
+        }
+    }
+    /**
+     * Answer in the channel itself, as a normal post: where a word typed in the channel, or a
+     * click on a list posted there, is answered.
+     */
+    async inChannel(channel, text) {
+        await this.parts.chat.channel(channel).notice(text);
+    }
+    /**
+     * The thread as a handler answers in it: what it posts clears the live session's status line,
+     * which is set again.
+     */
+    thread(channel, threadTs) {
+        const ref = { channel, thread: threadTs };
+        return this.parts.chat.answering(ref, () => this.parts.sessions.wrote(channel, threadTs));
+    }
+    /**
+     * A failure after the checks reaches the owner as a line of its own, never as silence: by
+     * `report`, or as a post in the thread, the one push of a turn that failed.
+     */
+    async replyOnFailure(channel, threadTs, work, report) {
+        const told = report ?? ((text) => this.notice(channel, threadTs, text));
+        // Never throws: this runs inside a handler's own `catch`, and a throw would reach the
+        // message listener's outer handler, which posts `ERROR_REPLY` threaded under the word.
+        const guarded = async (text) => {
+            try {
+                await told(text);
+            }
+            catch (error) {
+                if (isCancelled(error))
+                    throw error;
+                logger.warning(`could not report a failure in ${channel}/${threadTs}: ${describe(error)}`);
+            }
+        };
+        try {
+            await work();
+        }
+        catch (error) {
+            if (isCancelled(error))
+                throw error;
+            if (error instanceof DirectoryUnavailable ||
+                error instanceof SessionClosed ||
+                error instanceof SessionGone) {
+                await guarded(error.message);
+                return;
+            }
+            logger.error(`a request failed in ${channel}/${threadTs}: ${describe(error)}`);
+            await guarded(fill(named(texts.ERROR_REPLY, this.parts.names), { error: describe(error) }));
+        }
+    }
+    /**
+     * The two checks every inbound path that names a channel runs on its own: the owner acting from
+     * the workspace read at startup, then the channel as Slack describes it now. Anyone else gets
+     * nothing; the owner, in a channel the guard refuses, is told why (`about` as in
+     * `channelAllowed`).
+     */
+    async admitted(user, team, channel, threadTs, about = null) {
+        if (!this.fromOwner(user, team, channel) || channel === null)
+            return false;
+        return this.channelAllowed(channel, threadTs, about);
+    }
+    /**
+     * The first of the two checks, with nothing awaited: false once the daemon has stopped, for an
+     * event with no channel and for anyone but the owner acting from the workspace read at
+     * startup. A listener that keeps an order takes its place only after it, so that anyone else
+     * takes none.
+     */
+    fromOwner(user, team, channel) {
+        if (this.stopped)
+            return false;
+        if (!channel || !isOwner(this.parts.identity, user, team)) {
+            logger.info("ignored an inbound event from someone other than the owner");
+            return false;
+        }
+        return true;
+    }
+    /**
+     * The second check: the channel as Slack describes it now, the owner told why when refused.
+     * `about` is the `ts` of the message that asked, null when none did (a click): a refusal about
+     * a message at the top level goes to the channel, any other to `threadTs`'s thread.
+     */
+    async channelAllowed(channel, threadTs, about = null) {
+        const reason = await this.parts.guard.refusal(channel);
+        // The check can outlast the daemon: nothing is said, not even to refuse the channel.
+        if (this.stopped)
+            return false;
+        if (reason !== null) {
+            // For the owner alone, even from a top-level message: a channel the guard refuses may
+            // hold people who must not read the bot's words.
+            const told = fill(slackTexts.CHANNEL_REFUSED, { reason });
+            if (about === null)
+                await this.tellOwner(channel, threadTs, told);
+            else
+                await this.tellOwnerAbout(channel, threadTs, about, told);
+            return false;
+        }
+        return true;
+    }
+}

package/dist/chat/slack/app/app.js

@@ -0,0 +1,262 @@
+/**
+ * The Slack side: every inbound path, each checked on its own before it reaches a session. This
+ * builds the Bolt app, with one listener per inbound path (a message, the `file_change` of a
+ * clip, a button, a select, a modal, a Home control). The app registers no slash command.
+ *
+ * What was read in `@slack/bolt` 5.1.0 (`node_modules/@slack/bolt/dist/`), and what follows:
+ *
+ * - `App.js`, the constructor. With `authorize` and no `token`, `app.client` is built with no
+ *   token, and `processEvent` makes a client of its own only for a context that carries a
+ *   `botToken` or a `userToken` (`selectToken`). `authorize` below returns the workspace and the
+ *   bot user `auth.test` gave at startup and no token: no request costs an API call, and Bolt
+ *   never builds a client that could call Slack. Every listener calls Slack through the client
+ *   `buildApp` was given.
+ * - `App.js`, `initReceiver`. `socketMode: true` with an `appToken` builds a
+ *   `SocketModeReceiver` inside the constructor; a `receiver` passed in is used as it is. The
+ *   receiver is passed in: the daemon gives `socketReceiver()`, a test one that opens no socket
+ *   and feeds `App.processEvent({ body, ack })`, the entry point `SocketModeReceiver.js` itself
+ *   calls for each `slack_event`.
+ * - `App.js`, `processEvent`. `body` is the envelope as it came, so `team_id` and
+ *   `is_ext_shared_channel` of an event's envelope reach the listener; `payload` is the event,
+ *   the first action or the view. An event is acknowledged by Bolt before any listener runs
+ *   (`await ack()`); an action or a view submission is acknowledged by its listener, and what a
+ *   view submission answers (`response_action`) is the argument of `ack`. Every listener whose
+ *   constraints match runs, and one that throws reaches `handleError`, the handler set with
+ *   `app.error`: an `UnknownError` holding the thrown value in `original`, unless it has a
+ *   `code` of its own.
+ * - `middleware/builtin.js`. `ignoreSelf` (on by default) drops a `bot_message` of this app and
+ *   any event whose `user` is the bot. It is switched off, which differs from `slack_bolt`'s
+ *   default (it ignores its own events). That is harmless: the listeners drop what a bot wrote
+ *   themselves (`guards.isPromptMessage` refuses any event with a `bot_id`, and the owner check
+ *   refuses a user who is not the owner), so the middleware would add nothing. `app.event("message")`
+ *   filters nothing else (`onlyEvents`, `matchEventType`): a `message_changed` reaches the
+ *   listener, which drops it. `app.action` matches on `action_id` alone, `app.view` on
+ *   `callback_id` and the `view_submission` type.
+ * - `conversation-store.js`. The default store adds a lookup per event for a state this app
+ *   never keeps: switched off (`convoStore: false`).
+ */
+import { App, LogLevel, SocketModeReceiver } from "@slack/bolt";
+import { monotonicClock } from "../../../clock.js";
+import { Listings } from "../../../core/port.js";
+import { download } from "../attachments.js";
+import { BIND_ACTION } from "../bind.js";
+import { HOLD_CANCEL, HOLD_CONTINUE } from "../hold.js";
+import { CLEAN_ACTION, DELETE_ACTION, EDIT_ACTION, FILTER_ACTIONS, HOME_UPDATE_ACTION, NEW_THREAD_ACTION, SHOW_ALL_ACTION, } from "../home.js";
+import { OPEN_BUTTON_ACTION, OPEN_FORM, QUERY_ACTION } from "../openfile/modal.js";
+import { levelLogger } from "../quiet-logger.js";
+import { REQUEST_TIMEOUT_MS } from "../reply/clients.js";
+import { describe } from "../reply/errors.js";
+import { APPROVAL_ALLOW, APPROVAL_DENY, QUESTION_EDIT, QUESTION_FORM, QUESTION_OPEN, QUESTION_SKIP, } from "../requests.js";
+import { RESUME_ACTION } from "../resume.js";
+import { SETUP_BYPASS, SETUP_EFFORT, SETUP_MODEL, SETUP_START } from "../setup.js";
+import { UPDATE_ACTION } from "../update.js";
+import * as voice from "../voice.js";
+import { Answers, logger } from "./answers.js";
+import { Clips } from "./clip.js";
+import { isPromptMessage, isWrittenMessage, messageActor, } from "./guards.js";
+import { HomeControls } from "./home-controls.js";
+import { filesOf, inboundMessage } from "./messages.js";
+import { Open } from "./open.js";
+import { ThreadOrder, threadKey } from "./order.js";
+import { Requests } from "./requests.js";
+import { ResumeBind } from "./resume-bind.js";
+import { str, text } from "./wire.js";
+export const DECISION_ACTIONS = [APPROVAL_ALLOW, APPROVAL_DENY, QUESTION_SKIP];
+// The longest wait between two tries to get the connection back.
+export const RECONNECT_WAIT_SECONDS = 60;
+// The web client `@slack/socket-mode` 3.1.0 asks Slack for a WebSocket URL with. Left to itself
+// the library gives it 100 retries, each wait 1.3 times the one before with no upper limit: with
+// the network gone for two hours it tried 30 times, the last wait 26 minutes, and was still
+// waiting 10 minutes after the network was back (run on mocked timers, 2026-10-10). The waits
+// start as the library's and stop growing at the limit, and the client never gives up, so the
+// connection is back within the limit of the network's return. A try that gets no answer ends
+// at the timeout of the daemon's other clients.
+const RECONNECT = {
+    timeout: REQUEST_TIMEOUT_MS,
+    retryConfig: {
+        forever: true,
+        retries: 100,
+        factor: 1.3,
+        maxTimeout: RECONNECT_WAIT_SECONDS * 1000,
+    },
+};
+/**
+ * The Socket Mode connection the daemon's app listens on; `app.start()` opens it, `app.stop()`
+ * closes it. The libraries' own text is never logged (`levelLogger`): the connection's states
+ * are, by the names the client gives them.
+ */
+export function socketReceiver(appToken, options = {}) {
+    const receiver = new SocketModeReceiver({
+        appToken,
+        logger: levelLogger("socket mode"),
+        logLevel: LogLevel.WARN,
+        ...(options.clientPingTimeout !== undefined && {
+            clientPingTimeout: options.clientPingTimeout,
+        }),
+        installerOptions: { clientOptions: { ...RECONNECT, ...options.clientOptions } },
+    });
+    receiver.client.on("connected", () => logger.info("socket mode: connected"));
+    receiver.client.on("reconnecting", () => logger.warning("socket mode: reconnecting"));
+    receiver.client.on("disconnected", () => logger.info("socket mode: disconnected"));
+    return receiver;
+}
+/** The error a listener threw, under Bolt's wrapping of one that has no `code`. */
+function thrown(error) {
+    return typeof error === "object" && error !== null && "original" in error
+        ? error.original
+        : error;
+}
+/** The Bolt app, with one listener per inbound path. */
+export function buildApp(options) {
+    const { chat, config, identity, sessions } = options;
+    const parts = {
+        slack: options.slack,
+        chat,
+        config,
+        identity,
+        sessions,
+        approvals: options.approvals,
+        holds: options.holds,
+        guard: options.guard,
+        state: options.state,
+        names: options.names,
+        inbound: options.inbound,
+        uploads: options.uploads,
+        home: options.home,
+        limiter: chat.limiter,
+        fetch: options.fetch ??
+            (({ url, mimetype, limit }) => download(url, config.botToken, mimetype, limit)),
+        clock: options.clock ?? monotonicClock,
+        stopped: chat.stopped,
+        now: options.now ?? (() => Date.now() / 1000),
+        listings: options.listings ?? new Listings((directory) => sessions.repository(directory)),
+    };
+    const answers = new Answers(parts);
+    const requests = new Requests(parts, answers);
+    const open = new Open(parts, answers);
+    const resumeBind = new ResumeBind(parts, answers);
+    const clips = new Clips(parts, answers);
+    const home = new HomeControls(parts);
+    const app = new App({
+        receiver: options.receiver,
+        // auth.test already ran at startup; who may act is decided by the guards of each listener.
+        authorize: async () => ({ teamId: identity.teamId, botUserId: identity.botUserId }),
+        ignoreSelf: false,
+        convoStore: false,
+        logger: levelLogger("bolt"),
+        logLevel: LogLevel.WARN,
+    });
+    const registered = [];
+    const order = new ThreadOrder();
+    app.event("message", async ({ event, body }) => {
+        const message = event;
+        const envelope = body;
+        if (!isWrittenMessage(message))
+            return;
+        const [user, team] = messageActor(message, envelope);
+        const channel = text(message.channel);
+        const ts = str(message.ts);
+        const threadTs = str(message.thread_ts || ts);
+        // The owner and the workspace first, with nothing awaited: anyone else takes no place.
+        if (!answers.fromOwner(user, team, channel) || channel === null)
+            return;
+        // (sync) Where the owner's message sits among the replies, whatever becomes of it next:
+        // also a message the filter below drops.
+        parts.chat.ownerPosted(channel, threadTs, ts);
+        if (!isPromptMessage(message))
+            return;
+        // (sync) The place among the thread's messages is taken in the order the listeners were
+        // called, before the first await: the channel check below takes longer for one message than
+        // for the next, and a message that passed it first would be handed over first. The place is
+        // left once the message is handed over (`arrival` in `core/flows/messages.ts` orders it from
+        // there), never held through the turn, a download or a setup the owner has not answered.
+        // The exception is a clip whose transcript is in the file's `vtt`: `Clips.takeClip` hands it
+        // over after the download of that file, so a typed reply sent after it can be handed over
+        // first.
+        const place = order.enter(threadKey(channel, threadTs));
+        let handed;
+        try {
+            await place.turn;
+            // The daemon can have stopped while this message waited for the ones before it: calling
+            // Slack then would break the contract of a listener in flight after the stop.
+            if (answers.stopped)
+                return;
+            if (!(await answers.channelAllowed(channel, threadTs, ts)))
+                return;
+            // (sync) From the check to the call that hands the message over, nothing is awaited.
+            const spoken = voice.clip(filesOf(message));
+            // A failure of the prompt itself (or of the session it starts) lands in that session's
+            // thread: it is the turn's one push. A word answers where it was typed instead. The core
+            // tells the owner of a failure of its own.
+            handed =
+                spoken !== null
+                    ? answers.replyOnFailure(channel, threadTs, () => clips.takeClip(channel, threadTs, ts, message, spoken))
+                    : parts.inbound.message(inboundMessage(parts, answers, channel, threadTs, ts, message));
+        }
+        finally {
+            place.leave();
+        }
+        await handed;
+    });
+    app.event("file_change", ({ event }) => clips.onFileChange(event));
+    registered.push({ kind: "event", id: "message", acknowledgeOnly: false }, { kind: "event", id: "file_change", acknowledgeOnly: false });
+    /** A click or a select: the listener acknowledges, then checks, on its own. */
+    const action = (actionId, listener, options = {}) => {
+        registered.push({
+            kind: "action",
+            id: String(actionId),
+            acknowledgeOnly: options.acknowledgeOnly ?? false,
+        });
+        app.action(actionId, ({ ack, body }) => listener(() => ack(), body));
+    };
+    /** A modal's submit: what the listener answers is what the modal does next. */
+    const view = (callbackId, listener) => {
+        registered.push({ kind: "view", id: callbackId, acknowledgeOnly: false });
+        app.view(callbackId, ({ ack, body }) => 
+        // The answer is built to the view submission reference by the listener itself.
+        listener((answer) => ack(answer), body));
+    };
+    action(SETUP_START, requests.onSetupStart);
+    action(SETUP_MODEL, requests.onSetupModel);
+    // The controls' own state rides on Start's click: a change of either needs nothing here.
+    action(SETUP_EFFORT, requests.onSetupEdit, { acknowledgeOnly: true });
+    action(SETUP_BYPASS, requests.onSetupEdit, { acknowledgeOnly: true });
+    for (const actionId of [HOLD_CONTINUE, HOLD_CANCEL])
+        action(actionId, requests.onHoldDecision);
+    for (const actionId of DECISION_ACTIONS)
+        action(actionId, requests.onDecision);
+    action("answer", requests.onQuestionChoice);
+    action("other", requests.onQuestionTyping);
+    action("notes", requests.onQuestionTyping);
+    action(QUESTION_EDIT, requests.onQuestionEdit);
+    action(QUESTION_OPEN, requests.onQuestionOpen);
+    view(QUESTION_FORM, requests.onQuestionSubmit);
+    action(OPEN_BUTTON_ACTION, open.onOpenChoose);
+    action(QUERY_ACTION, open.onOpenQuery);
+    view(OPEN_FORM, open.onOpenSubmit);
+    action(BIND_ACTION, resumeBind.onBind);
+    action(RESUME_ACTION, resumeBind.onResume);
+    action(UPDATE_ACTION, resumeBind.onUpdate);
+    action(NEW_THREAD_ACTION, home.onHomeLink, { acknowledgeOnly: true });
+    for (const actionId of FILTER_ACTIONS)
+        action(actionId, home.onHomeFilter);
+    action(SHOW_ALL_ACTION, home.onHomeShowAll);
+    action(EDIT_ACTION, home.onHomeEdit);
+    action(DELETE_ACTION, home.onHomeDelete);
+    action(CLEAN_ACTION, home.onHomeClean);
+    action(HOME_UPDATE_ACTION, home.onHomeUpdate);
+    app.error(async (error) => {
+        logger.error(`handler failed: ${describe(thrown(error))}`);
+    });
+    return {
+        app,
+        registered,
+        drafts: requests.drafts,
+        close: () => {
+            requests.close();
+            chat.halt();
+            clips.close();
+        },
+        openFile: (channel, threadTs, folder, words) => open.openWord(channel, threadTs, folder, words),
+    };
+}