allaboard 0.0.0-stage → 0.4.0

package/dist/core/files/paths.js

@@ -0,0 +1,9 @@
+/** Paths as Python's `Path` treats them. */
+import { isAbsolute, relative, sep } from "node:path";
+/** `Path.is_relative_to` and `relative_to`: `path` from `root` when it lies under it, else null. */
+export function relativeTo(root, path) {
+    const found = relative(root, path);
+    if (found === ".." || found.startsWith(`..${sep}`) || isAbsolute(found))
+        return null;
+    return found;
+}

package/dist/core/files/read.js

@@ -0,0 +1,191 @@
+/**
+ * What `!open` may share: a path under the session's folder that is a regular file, read once and
+ * handed to the chat as bytes. The path is untrusted (an option's value comes back from the chat),
+ * so it is resolved with its links, held to the folder, and opened by a descriptor that refuses a
+ * link.
+ */
+import { constants } from "node:fs";
+import { open, readlink, realpath, stat } from "node:fs/promises";
+import { basename, dirname, isAbsolute, join, posix, sep } from "node:path";
+import { compareCodePoints } from "../../text.js";
+import { relativeTo } from "./paths.js";
+// Windows has neither flag; the descriptor check below still holds there.
+const OPEN_FLAGS = constants.O_RDONLY | (constants.O_NONBLOCK ?? 0) | (constants.O_NOFOLLOW ?? 0);
+/** The path is not a regular file inside the folder, once its links are resolved. */
+export class NotAFile extends Error {
+    constructor(options) {
+        super("not a regular file inside the folder", options);
+        this.name = "NotAFile";
+    }
+}
+/** The file is over the cap the caller gave. */
+export class TooLarge extends Error {
+    constructor() {
+        super("over the snippet limit");
+        this.name = "TooLarge";
+    }
+}
+// The kernel's own bound on the links one path may cross (Linux `MAXSYMLINKS`).
+const LINK_LIMIT = 40;
+/**
+ * Python's non-strict `os.path.realpath`: the links of what exists are resolved, the rest kept; a
+ * link whose target is missing leads to that target. A loop of links is left where the bound ends.
+ */
+export async function realpathLoose(path, links = 0) {
+    // Made absolute as text and never normalized: `resolve` would fold `link/..` before the link
+    // is followed, and name another folder than the one the kernel reaches.
+    const absolute = isAbsolute(path) ? path : `${process.cwd()}/${path}`;
+    try {
+        return await realpath(absolute);
+    }
+    catch {
+        const parent = dirname(absolute);
+        if (parent === absolute)
+            return absolute;
+        const leaf = join(await realpathLoose(parent, links), basename(absolute));
+        // `realpath` failed on a link: it dangles, or it is part of a loop.
+        const led = await readlink(leaf).catch(() => null);
+        if (led === null || links >= LINK_LIMIT)
+            return leaf;
+        return realpathLoose(isAbsolute(led) ? led : `${dirname(leaf)}${sep}${led}`, links + 1);
+    }
+}
+/**
+ * The regular file `relative` names under `real` (a resolved folder), with its stat. Throws
+ * `NotAFile` for anything else: a path that leaves the folder by `..`, an absolute path or a link,
+ * a directory, a missing file. `relative` is untrusted.
+ *
+ * `realpath` of `fs/promises` is libuv's `realpath(3)`, which follows a `..` after the link
+ * before it, as Python's `os.path.realpath` does; the path is joined as text, never normalized
+ * first, since `path.join` would drop `link/..` lexically.
+ */
+async function locate(real, relative) {
+    if (!relative || relative.includes("\0"))
+        throw new NotAFile();
+    let target;
+    let found;
+    try {
+        // `real / relative`: an absolute `relative` replaces `real`.
+        target = await realpath(isAbsolute(relative) ? relative : `${real}${sep}${relative}`);
+        if (relativeTo(real, target) === null)
+            throw new NotAFile();
+        found = await stat(target, { bigint: true });
+    }
+    catch (error) {
+        throw error instanceof NotAFile ? error : new NotAFile({ cause: error });
+    }
+    if (!found.isFile())
+        throw new NotAFile();
+    return { target, found };
+}
+/** The path as the shared file is titled: `./docs/../docs/a.md` as `docs/a.md`. */
+export function titleOf(relative) {
+    // Python's `posixpath.normpath`: no trailing slash, and exactly two leading slashes are kept.
+    let normal = posix.normalize(relative);
+    if (normal.length > 1 && normal.endsWith("/"))
+        normal = normal.slice(0, -1);
+    if (relative.startsWith("//") && !relative.startsWith("///") && !normal.startsWith("//")) {
+        normal = `/${normal}`;
+    }
+    return normal;
+}
+/**
+ * The content of the already resolved file `target`, opened once; everything after is read from
+ * that descriptor, so what was checked is what is read. Throws `NotAFile`, or `TooLarge` when the
+ * file is over `limit` bytes.
+ *
+ * It is opened with `fs.promises.open` and numeric flags from `fs.constants` (`O_RDONLY |
+ * O_NONBLOCK | O_NOFOLLOW`: a file that became a link in between is refused, a FIFO is never
+ * waited on). The handle's `stat` says it is a regular file under the limit, its `read` takes the
+ * bytes at the current position, up to `limit` + 1, and its `close` ends it.
+ */
+export async function readOnce(target, limit, opener = (path) => open(path, OPEN_FLAGS)) {
+    let handle;
+    try {
+        handle = await opener(target);
+    }
+    catch (error) {
+        throw new NotAFile({ cause: error });
+    }
+    let total = 0;
+    const content = Buffer.allocUnsafe(limit + 1);
+    try {
+        const found = await handle.stat();
+        if (!found.isFile())
+            throw new NotAFile();
+        if (found.size > limit)
+            throw new TooLarge();
+        while (total <= limit) {
+            const { bytesRead } = await handle.read(content, total, limit + 1 - total, null);
+            if (bytesRead === 0)
+                break;
+            total += bytesRead;
+        }
+    }
+    catch (error) {
+        if (error instanceof NotAFile || error instanceof TooLarge)
+            throw error;
+        throw new NotAFile({ cause: error });
+    }
+    finally {
+        await handle.close().catch(() => { });
+    }
+    if (total > limit)
+        throw new TooLarge();
+    return Buffer.from(content.subarray(0, total));
+}
+/**
+ * The content of the file `relative` names under `folder`, at most `limit` bytes. Throws
+ * `NotAFile` or `TooLarge`. The chat gets these bytes: a library handed a path would open it
+ * again, following links and with no size limit.
+ */
+export async function readOpenable(folder, relative, limit) {
+    const { target } = await locate(await realpathLoose(folder), relative);
+    return readOnce(target, limit);
+}
+/**
+ * The paths of `relatives` that are regular files inside `folder`, in order, at most `limit`. The
+ * iterable is read only as far as the checks need.
+ */
+export async function regularFiles(folder, relatives, limit) {
+    const real = await realpathLoose(folder);
+    const found = [];
+    if (limit !== undefined && limit <= 0)
+        return found;
+    for (const relative of relatives) {
+        try {
+            await locate(real, relative);
+        }
+        catch (error) {
+            if (error instanceof NotAFile)
+                continue;
+            throw error;
+        }
+        found.push(relative);
+        // Checked here, not before the next path is taken: the iterable is not read past the limit.
+        if (limit !== undefined && found.length >= limit)
+            break;
+    }
+    return found;
+}
+/**
+ * The paths of `relatives` that are regular files inside `folder`, each once, the most recently
+ * modified first (ties by path).
+ */
+export async function newestFirst(folder, relatives) {
+    const real = await realpathLoose(folder);
+    const dated = [];
+    for (const relative of new Set(relatives)) {
+        try {
+            const { found } = await locate(real, relative);
+            dated.push([found.mtimeNs, relative]);
+        }
+        catch (error) {
+            if (error instanceof NotAFile)
+                continue;
+            throw error;
+        }
+    }
+    dated.sort(([leftTime, left], [rightTime, right]) => leftTime === rightTime ? compareCodePoints(left, right) : leftTime > rightTime ? -1 : 1);
+    return dated.map(([, relative]) => relative);
+}

package/dist/core/files/waiting.js

@@ -0,0 +1,34 @@
+/** What `within` answers when the time ran out first. */
+export const TIMED_OUT = Symbol("timed out");
+/**
+ * `work` with `seconds` of the clock to finish: `TIMED_OUT` when they pass first, after the signal
+ * given to `work` is aborted. A `seconds` of nothing is out of time at once, with `work` not
+ * started. Work that ignores its signal keeps running unseen: a call to the chat or a lookup cannot be
+ * cut short.
+ */
+export async function within(clock, seconds, work) {
+    if (seconds <= 0)
+        return TIMED_OUT;
+    const limit = new AbortController();
+    const finished = new AbortController();
+    const expired = new Promise((resolve) => {
+        clock.sleep(seconds, finished.signal).then(() => {
+            limit.abort(new Error("time limit"));
+            resolve(TIMED_OUT);
+        }, () => { });
+    });
+    const running = work(limit.signal);
+    // Raced out, it may still reject later: nobody is left to read that.
+    running.catch(() => { });
+    try {
+        return await Promise.race([running, expired]);
+    }
+    catch (error) {
+        if (limit.signal.aborted)
+            return TIMED_OUT;
+        throw error;
+    }
+    finally {
+        finished.abort();
+    }
+}

package/dist/core/flows/answers.js

@@ -0,0 +1,133 @@
+import { APPROVE, DENY } from "../requests.js";
+import * as texts from "../texts.js";
+import { chosen } from "./setup.js";
+import { logger } from "./talk.js";
+export function answersFlow(deps, talk) {
+    const { approvals, holds } = deps;
+    // Issue #142: the paths that answer `texts.HOLD_GONE` are told apart by these facts alone.
+    // Ids and flags only: the answer's content and the setup's choice never reach the log.
+    function logRefused(path, ref, message, facts) {
+        const told = Object.entries(facts)
+            .map(([name, value]) => `${name}=${value ? "True" : "False"}`)
+            .join(", ");
+        logger.info(`refused a click (${path}) in ${ref.channel}/${ref.thread} on message ${message ?? "none"}; ${told}`);
+    }
+    /**
+     * Allow, deny or skip: the request must be waiting in this thread. Whether it was a question
+     * only changes the words a refusal carries to the agent (`toAnswer`), except for a permission's
+     * own buttons (`fromPermission`), which a question never shows: those are refused for one.
+     * The message that goes is the one the core stored for the request; the click's only when the
+     * core has none yet (answered before the post returned).
+     */
+    async function decide(ref, requestId, outcome, message, fromPermission) {
+        const pending = approvals.get(requestId);
+        if (pending === null ||
+            pending.channelId !== ref.channel ||
+            pending.threadId !== ref.thread ||
+            (fromPermission && pending.questions !== null && pending.questions.length > 0)) {
+            await talk.tell(ref, texts.APPROVAL_GONE);
+            return false;
+        }
+        const resolved = approvals.resolve(requestId, ref.channel, ref.thread, outcome);
+        if (resolved === null) {
+            await talk.tell(ref, texts.APPROVAL_GONE);
+            return false;
+        }
+        await talk.removeRequest(ref, resolved.messageTs ?? message);
+        return true;
+    }
+    async function answer(ref, requestId, given, message) {
+        switch (given.type) {
+            case "permission":
+                return decide(ref, requestId, given.allow ? APPROVE : DENY, message, true);
+            case "question": {
+                if (given.answers === null)
+                    return decide(ref, requestId, DENY, message, false);
+                const pending = approvals.get(requestId);
+                if (pending === null ||
+                    pending.channelId !== ref.channel ||
+                    pending.threadId !== ref.thread ||
+                    pending.questions === null ||
+                    pending.questions.length === 0) {
+                    await talk.tell(ref, texts.APPROVAL_GONE);
+                    return false;
+                }
+                const resolved = approvals.resolve(requestId, ref.channel, ref.thread, {
+                    kind: "answer",
+                    answers: given.answers,
+                    notes: given.notes,
+                });
+                if (resolved === null) {
+                    await talk.tell(ref, texts.APPROVAL_GONE);
+                    return false;
+                }
+                // The session that asked decides what becomes of the request message: its reply keeps
+                // the answers, or the request itself does (`ThreadSession` keeps them).
+                return true;
+            }
+            case "hold": {
+                // (sync) What the log says of a refused answer is read with the resolve it explains.
+                const held = holds.get(requestId);
+                // A setup carries the model list it offered; a hold carries none (`Pending.context`).
+                if (held?.context != null) {
+                    logRefused("hold decision, wrong kind", ref, message, {
+                        send: given.send,
+                        held: true,
+                        decided: held.decided,
+                        kind_matches: false,
+                    });
+                    await talk.tell(ref, texts.HOLD_GONE);
+                    return false;
+                }
+                const resolved = holds.resolve(requestId, ref.channel, ref.thread, given.send ? true : null);
+                if (resolved === null) {
+                    logRefused("hold decision", ref, message, {
+                        send: given.send,
+                        held: held !== null,
+                        decided: held?.decided ?? false,
+                    });
+                    await talk.tell(ref, texts.HOLD_GONE);
+                    return false;
+                }
+                await talk.removeRequest(ref, resolved.messageTs ?? message);
+                return true;
+            }
+            case "setup": {
+                const pending = holds.get(requestId);
+                if (pending === null) {
+                    logRefused("setup start, not held", ref, message, { held: false });
+                    await talk.tell(ref, texts.HOLD_GONE);
+                    return false;
+                }
+                if (pending.context === null) {
+                    logRefused("setup start, wrong kind", ref, message, {
+                        held: true,
+                        decided: pending.decided,
+                        kind_matches: false,
+                    });
+                    await talk.tell(ref, texts.HOLD_GONE);
+                    return false;
+                }
+                // The controls' own state rides on the answer: nothing about the choice is stored
+                // here, and the model list is the one the request was built from.
+                const choice = chosen(deps, pending.context, given.selection);
+                if (holds.resolve(requestId, ref.channel, ref.thread, choice) === null) {
+                    const sameThread = pending.channelId === ref.channel && pending.threadId === ref.thread;
+                    logRefused("setup start, not resolved", ref, message, {
+                        held: true,
+                        decided: pending.decided,
+                        same_thread: sameThread,
+                    });
+                    // A second Start while the first is applied (issue #142): what ends the apply (the
+                    // summary, `texts.NOT_SENT` or the error) says what happened.
+                    if (!(pending.decided && sameThread))
+                        await talk.tell(ref, texts.HOLD_GONE);
+                    return false;
+                }
+                logger.info(`accepted a setup start in ${ref.channel}/${ref.thread} on message ${message ?? "none"}`);
+                return true;
+            }
+        }
+    }
+    return { answer };
+}

package/dist/core/flows/ask-owner.js

@@ -0,0 +1,95 @@
+import { errorName } from "../../values.js";
+import * as texts from "../texts.js";
+import { named } from "../texts.js";
+import { isCancelled, logger } from "./talk.js";
+/**
+ * Put a question that holds the owner's message and wait for the answer: whatever the owner
+ * answered, or null when it was cancelled (`!stop`, a drain) or never shown (`Not sent.` or the
+ * unposted notice, told already). `settle(answer, shownAt, pending)` applies an answer and
+ * writes its summary while the thread still shows it waiting and the hold is still open, so a
+ * `!stop` or drain meanwhile cancels (`Pending.cancelled`: nothing is sent, the message is
+ * removed, `Not sent.`). When it throws, the message is removed, the hold ends as a cancel would
+ * and the error goes on.
+ */
+export async function askOwner(deps, talk, ref, session, question) {
+    const { sessions, holds, state } = deps;
+    // (sync) The check and the hold it guards: a drain cancels every hold open when it starts
+    // and never one opened after, so nothing is awaited between the two.
+    if (talk.stopped)
+        return null;
+    if (sessions.draining) {
+        // a restart could have started during an await before this
+        await talk.refuseRestarting(ref);
+        return null;
+    }
+    const [holdId, pending] = holds.open(ref.channel, ref.thread, question.context ?? null);
+    let shownAt;
+    try {
+        shownAt = await talk.thread(ref).ask(holdId, question.request(holdId), question.title);
+    }
+    catch (error) {
+        if (isCancelled(error))
+            throw error;
+        // Nobody can answer a question that was never shown: fail closed, as an unpostable
+        // approval does, rather than send into a folder another session is using.
+        logger.error(`could not post a hold in ${ref.channel}/${ref.thread}: ${errorName(error)}`);
+        holds.discard(holdId);
+        await talk.tell(ref, named(texts.HOLD_UNPOSTED, deps.names));
+        return null;
+    }
+    // False when the answer came before `ask` returned (a fast answer, `!stop`, a drain): nobody
+    // knew the message then, so it is still ours to settle or remove, and `holdStart`/`holdEnd`
+    // (and the waiting status they hold) never run for it.
+    const waiting = holds.posted(holdId, shownAt);
+    if (waiting) {
+        // Crash repair (issue #19): a hold question is a request like an approval. Best-effort:
+        // outside the try/finally below on purpose, so a failed write here can never skip
+        // `holdStart`/`holdEnd` and leave the hold itself undiscarded; the message is already
+        // live either way, so a failure is logged loudly.
+        try {
+            state.addRequest(ref.channel, ref.thread, shownAt, question.kind);
+        }
+        catch (error) {
+            logger.error(`posted a hold in ${ref.channel}/${ref.thread} that state.json could not record: ${errorName(error)}`);
+        }
+    }
+    let answer = null;
+    let sent = false;
+    try {
+        if (waiting)
+            session.holdStart();
+        answer = await pending.answer;
+        if (answer === null) {
+            if (!waiting)
+                await talk.removeRequest(ref, shownAt);
+        }
+        else if (question.settle !== undefined) {
+            try {
+                await question.settle(answer, shownAt, pending);
+            }
+            catch (error) {
+                if (isCancelled(error))
+                    throw error;
+                if (!pending.cancelled) {
+                    await talk.removeRequest(ref, shownAt);
+                    throw error;
+                }
+                logger.warning(`a cancelled hold in ${ref.channel}/${ref.thread} failed while applied: ${errorName(error)}`);
+            }
+        }
+        if (pending.cancelled) {
+            answer = null;
+            if (!waiting)
+                await talk.removeRequest(ref, shownAt);
+        }
+        sent = answer !== null;
+    }
+    finally {
+        if (waiting)
+            await session.holdEnd({ continued: sent });
+        holds.discard(holdId); // catches a cancelled wait, and ends an answered hold
+    }
+    if (answer === null)
+        await talk.tell(ref, texts.NOT_SENT);
+    return answer;
+}

package/dist/core/flows/asking.js

@@ -0,0 +1,14 @@
+/**
+ * The questions the daemon and the agent put to the owner, and what follows each answer: a
+ * tool's permission, the agent's questions, the same-folder hold, a session's setup.
+ */
+import { answersFlow } from "./answers.js";
+import { holdFlow } from "./hold.js";
+import { setupFlow } from "./setup.js";
+export function asking(deps, talk) {
+    return {
+        setup: setupFlow(deps, talk),
+        hold: holdFlow(deps, talk),
+        answers: answersFlow(deps, talk),
+    };
+}

package/dist/core/flows/bind.js

@@ -0,0 +1,95 @@
+import { compareCodePoints } from "../../text.js";
+import { resolveDirectory } from "../sessions/directory.js";
+import * as texts from "../texts.js";
+import { fill, named } from "../texts.js";
+/**
+ * The answer to a bind: what keeps a session from starting in the folder, if anything
+ * (`BIND_UNAVAILABLE` keeps priority: what would stop every session there matters more than
+ * where an existing thread's session lives), else the old folders existing threads keep working
+ * in, if any. `inNotice` makes a folder safe to stand inside the notice.
+ */
+export function boundText(directory, unavailable, oldFolders, inNotice) {
+    if (unavailable !== null) {
+        return fill(texts.BIND_UNAVAILABLE, {
+            directory: inNotice(directory),
+            reason: unavailable.message,
+        });
+    }
+    if (oldFolders.length === 0) {
+        return fill(texts.BIND_OK, { directory: inNotice(directory) });
+    }
+    const old = oldFolders.map((folder) => `\`${inNotice(folder)}\``).join(", ");
+    return fill(texts.BIND_OK_ELSEWHERE, { directory: inNotice(directory), old });
+}
+export function binding(deps, talk) {
+    const { agent, chat, sessions, state, names, allowedRoot } = deps;
+    const inNotice = (text) => chat.escape(text, "notice");
+    /** The folder a typed path or a pick names, inside the allowed root; null, told, otherwise. */
+    const folderNamed = async (channel, path) => {
+        const directory = resolveDirectory(path, allowedRoot);
+        if (directory === null) {
+            await talk.inChannel(channel, fill(texts.BIND_OUTSIDE, { path: inNotice(path), root: inNotice(allowedRoot) }));
+        }
+        return directory;
+    };
+    // Thread entries keep their own folder either side of the bind (`StateStore.bind`), so the
+    // old folders can be read now: those of the channel's threads that differ from the new one.
+    const announce = async (channel, directory) => {
+        const unavailable = await sessions.unavailable(directory);
+        const record = state.channel(channel);
+        const threads = record === null ? [] : [...record.threads.values()];
+        const oldFolders = [
+            ...new Set(threads.map((thread) => thread.directory).filter((old) => old !== directory)),
+        ].sort(compareCodePoints);
+        await talk.inChannel(channel, boundText(directory, unavailable, oldFolders, inNotice));
+    };
+    return {
+        async to(channel, path) {
+            const directory = await folderNamed(channel, path);
+            if (directory === null)
+                return;
+            if (!(await sessions.bind(channel, directory))) {
+                await talk.inChannel(channel, texts.BIND_BUSY);
+                return;
+            }
+            await announce(channel, directory);
+        },
+        async list(channel) {
+            const record = state.channel(channel);
+            const folders = await sessions.foldersIn(allowedRoot);
+            // An agent with no record of trust is offered every folder: no title names its trust.
+            const trusted = folders.length > 0 ? named(texts.BIND_LIST, names) : named(texts.BIND_EMPTY, names);
+            const title = fill(agent.capabilities.folderTrust ? trusted : texts.BIND_LIST_ANY, {
+                root: allowedRoot,
+            });
+            await chat.channel(channel).offer({
+                type: "folders",
+                root: allowedRoot,
+                folders,
+                bound: record === null ? null : record.directory,
+            }, title);
+        },
+        async picked(pick) {
+            const { channel } = pick;
+            // The pick is not trusted: its folder goes through the same check as a typed `!bind`.
+            const directory = await folderNamed(channel, pick.path);
+            if (directory === null)
+                return;
+            const record = state.channel(channel);
+            if (record !== null && record.directory === directory) {
+                await talk.inChannel(channel, fill(texts.BIND_ALREADY, { directory: inNotice(directory) }));
+                return;
+            }
+            // A list can be old: unlike a typed `!bind`, a pick never ends work in flight either.
+            if (!(await sessions.bind(channel, directory))) {
+                await talk.inChannel(channel, texts.BIND_BUSY);
+                return;
+            }
+            await announce(channel, directory);
+            // The list is a message of the channel, not a thread's request: withdrawn through the
+            // channel, as `!resume` does.
+            if (!talk.stopped)
+                await chat.channel(channel).withdraw(pick.list);
+        },
+    };
+}

package/dist/core/flows/contract.js

@@ -0,0 +1 @@
+export {};

package/dist/core/flows/flows.js

@@ -0,0 +1,35 @@
+import { asking } from "./asking.js";
+import { Inbound } from "./inbound.js";
+import { lists } from "./lists.js";
+import { messages } from "./messages.js";
+import { Talk } from "./talk.js";
+import { updating } from "./update.js";
+export function buildFlows(deps) {
+    const talk = new Talk(deps);
+    const { setup, hold, answers } = asking(deps, talk);
+    const { resume, bind, picks } = lists(deps, talk);
+    const allaboard = deps.updates === undefined ? undefined : updating(deps, deps.updates, talk);
+    const flows = { setup, hold, resume, bind, ...(allaboard ? { allaboard } : {}) };
+    const all = messages(deps, talk, flows);
+    // A failure after the provider's checks reaches the owner in the channel of the offer; a click
+    // on the chat's own page has none, and that page shows the state.
+    const updatePicked = (pick) => {
+        const { channel } = pick;
+        if (allaboard === undefined)
+            return Promise.resolve();
+        return talk.replyOnFailure({ channel: channel ?? "page", thread: pick.list ?? "page" }, () => allaboard.picked(pick), (told) => (channel === null ? Promise.resolve() : talk.inChannel(channel, told)));
+    };
+    return {
+        inbound: new Inbound({
+            // The notice decides before the message is handled and is not waited for: the message
+            // takes its place in its thread's line first (`messages.ts`), the line follows it.
+            message: async (message) => {
+                const told = allaboard?.notice(message);
+                await Promise.all([told, all.message(message)]);
+            },
+            answer: (ref, requestId, answer, message) => answers.answer(ref, requestId, answer, message),
+            picked: (pick) => (pick.type === "update" ? updatePicked(pick) : picks.picked(pick)),
+            unbound: (channel) => talk.unbound(channel),
+        }),
+    };
+}

package/dist/core/flows/hold.js

@@ -0,0 +1,22 @@
+import * as texts from "../texts.js";
+import { fill } from "../texts.js";
+import { askOwner } from "./ask-owner.js";
+export function holdFlow(deps, talk) {
+    /**
+     * Post `Another session is working in this folder: <link>. Send anyway?` and wait for the
+     * owner's answer, cancelled the same way by `!stop` (in this thread or the whole channel) or
+     * a drain. True to send the message on; false when it was not, either way telling the owner
+     * `Not sent.` already.
+     */
+    async function beforeSending(ref, session, other) {
+        const otherRef = { channel: other.channelId, thread: other.threadId };
+        const link = await talk.noticeLink(otherRef, "Session");
+        const answer = await askOwner(deps, talk, ref, session, {
+            kind: "hold",
+            title: fill(texts.HOLD_QUESTION, { link }),
+            request: (requestId) => ({ type: "hold", requestId, other: otherRef, link }),
+        });
+        return answer === true;
+    }
+    return { beforeSending };
+}

package/dist/core/flows/inbound.js

@@ -0,0 +1,24 @@
+export class Inbound {
+    #flows;
+    constructor(flows = {}) {
+        this.#flows = flows;
+    }
+    message(message) {
+        return this.#flow("message")(message);
+    }
+    answer(ref, requestId, answer, message) {
+        return this.#flow("answer")(ref, requestId, answer, message);
+    }
+    picked(pick) {
+        return this.#flow("picked")(pick);
+    }
+    unbound(channel) {
+        return this.#flow("unbound")(channel);
+    }
+    #flow(name) {
+        const flow = this.#flows[name];
+        if (flow === undefined)
+            throw new Error(`the core has no flow for ${name}`);
+        return flow;
+    }
+}