allaboard 0.5.0 → 0.6.0

package/dist/chat/slack/tag.js

@@ -0,0 +1,317 @@
+/**
+ * The tag of a thread, shown on its root message and kept at hand by a pin: `!tag <name>` puts
+ * an inline-code `[name]` and a space at the start of the root, replacing a tag already there,
+ * and pins the root; `!untag` removes the prefix and, from a root that carried a tag, the pin (a
+ * pin the owner made by hand on an untagged root is left alone).
+ *
+ * The root is the owner's own message, and `chat.update` changes only "messages posted by the
+ * authenticated user" (docs.slack.dev/reference/methods/chat.update, read 2026-10-19), so the
+ * edit and the pin both go through the owner's user token (`SLACK_USER_TOKEN`, scopes
+ * `chat:write` and `pins:write`); the bot only reads the root. Measured on a dev workspace on
+ * 2026-10-19: that token edits and pins the owner's root; no `pinned_item` message is posted;
+ * no push reaches iOS for any of the four actions; the edit reaches the daemon as
+ * `message_changed`, which `app/guards.ts` drops, so no prompt is sent; `conversations.replies`
+ * with the bot's `groups:history` returns `pinned_to` and `pinned_info` on a pinned root; Slack's
+ * search finds the tag word an edit added. Not tried: a root with real formatting or a file.
+ *
+ * The tag is read back from the root's own blocks (`rootMarks`, which the Home tab uses too), so
+ * `state.json` keeps nothing of it: the first element of the first `rich_text_section` is a text
+ * element in code style whose text is `[name]` for a name that satisfies `TAG_NAME`, followed by
+ * an element that is exactly a space.
+ *
+ * The title of a thread (`titleThread`) replaces the whole root: one `rich_text` block with one
+ * section, the tag's two elements when the root carries a tag, then a bold text element with the
+ * title. The owner's own words are gone from the root once it has a title,
+ * so there is no title line to tell apart from them and nothing to replace selectively. The tag
+ * is read first (`rootMarks`) and kept, so `!tag` and `!untag` work on a titled root as on any
+ * other. Tag and title edits of one root are serialized, since each reads the message and writes
+ * it back whole. Titling needs `chat:write` alone: no pin is involved.
+ *
+ * `pins.add` answers `already_pinned` for a pinned item (docs.slack.dev/reference/methods/pins.add,
+ * read 2026-10-19); `pins.remove` answers `not_pinned` ("The item isn't pinned to the channel") or
+ * `no_pin` ("The pin couldn't be found", docs.slack.dev/reference/methods/pins.remove, read
+ * 2026-10-19). Both mean the pin is already as asked, so neither is a failure.
+ */
+import { isDeepStrictEqual } from "node:util";
+import { TAG_NAME } from "../../core/port.js";
+import { isRecord } from "../../values.js";
+import { ChatError } from "../seam.js";
+import { slackUnescape } from "./app/messages.js";
+import { isTombstone } from "./channels.js";
+import { describe, GONE } from "./reply/errors.js";
+import { mrkdwnEscape } from "./reply/escape.js";
+// What Slack answers when a root can never be read or edited again by this token: the edit window
+// of the workspace closed, the message cannot be updated, the message, its thread or its channel
+// is gone, or the token lacks a scope or a membership.
+const REFUSED_FOR_GOOD = new Set([
+    ...GONE,
+    "edit_window_closed",
+    "cant_update_message",
+    "not_in_channel",
+    "missing_scope",
+]);
+/** `step`, with a refusal that cannot change made a `permanent` `ChatError`. */
+async function permanently(step) {
+    try {
+        return await step();
+    }
+    catch (error) {
+        const code = describe(error);
+        // The same call is refused again at any later turn: say so, so the core stops asking.
+        if (REFUSED_FOR_GOOD.has(code))
+            throw new ChatError(code, { cause: error, permanent: true });
+        throw error;
+    }
+}
+const ALREADY_PINNED = "already_pinned";
+const NOT_PINNED = new Set(["not_pinned", "no_pin"]);
+// The inline-code prefix of a root's `text`, which Slack writes with backticks.
+const TEXT_PREFIX = /^`\[([^\]`]*)\]` ?/;
+/** The name inside a text element that is an inline-code `[name]`, null for any other element. */
+function nameOf(element) {
+    if (!isRecord(element) || element.type !== "text" || typeof element.text !== "string") {
+        return null;
+    }
+    const style = element.style;
+    if (!isRecord(style) || style.code !== true || Object.keys(style).length !== 1)
+        return null;
+    const inner = /^\[(.*)\]$/s.exec(element.text)?.[1];
+    return inner !== undefined && TAG_NAME.test(inner) ? inner : null;
+}
+/** Whether `element` is exactly one space, with no style. */
+function isSpace(element) {
+    return (isRecord(element) && element.type === "text" && element.text === " " && !("style" in element));
+}
+/** The first `rich_text` block of a root's blocks, or undefined. */
+function richText(blocks) {
+    return blocks.find((block) => isRecord(block) && block.type === "rich_text");
+}
+/** The elements of the first section of a root's first `rich_text` block, or null. */
+function leadingElements(blocks) {
+    const elements = richText(blocks)?.elements;
+    const section = Array.isArray(elements) ? elements[0] : undefined;
+    if (!isRecord(section) || section.type !== "rich_text_section")
+        return null;
+    return Array.isArray(section.elements) ? section.elements : null;
+}
+/**
+ * The tag a root message carries and whether it is pinned, as `conversations.replies` returns it.
+ * A root with no blocks at all is read from its text.
+ */
+export function rootMarks(root) {
+    const pinned = Array.isArray(root.pinned_to) && root.pinned_to.length > 0;
+    if (Array.isArray(root.blocks)) {
+        return { tag: nameOf(leadingElements(root.blocks)?.[0]), pinned };
+    }
+    const prefix = typeof root.text === "string" ? TEXT_PREFIX.exec(root.text)?.[1] : undefined;
+    return { tag: prefix !== undefined && TAG_NAME.test(prefix) ? prefix : null, pinned };
+}
+/** `[name]` in code style and a space: what a tagged root starts with. */
+function tagElements(tag) {
+    return [
+        { type: "text", text: `[${tag}]`, style: { code: true } },
+        { type: "text", text: " " },
+    ];
+}
+/** `blocks` with their leading tag taken off and `tag`, when there is one, put in its place. */
+export function retaggedBlocks(blocks, tag) {
+    const copy = structuredClone([...blocks]);
+    const rich = richText(copy);
+    if (rich === undefined) {
+        return tag === null
+            ? copy
+            : [
+                {
+                    type: "rich_text",
+                    elements: [{ type: "rich_text_section", elements: tagElements(tag) }],
+                },
+                ...copy,
+            ];
+    }
+    const elements = Array.isArray(rich.elements) ? rich.elements : [];
+    rich.elements = elements;
+    const section = elements[0];
+    if (isRecord(section) &&
+        section.type === "rich_text_section" &&
+        Array.isArray(section.elements)) {
+        const inner = section.elements;
+        const tagged = nameOf(inner[0]) !== null;
+        if (tagged)
+            inner.splice(0, isSpace(inner[1]) ? 2 : 1);
+        if (tag !== null)
+            inner.unshift(...tagElements(tag));
+        // The tag may have had a section of its own (a root that starts with a list or a code
+        // block), or a block of its own (a root with no rich_text block): taking it off takes those
+        // with it, so a tag and an untag leave the blocks as they were.
+        if (tagged && inner.length === 0) {
+            elements.splice(0, 1);
+            if (elements.length === 0)
+                copy.splice(copy.indexOf(rich), 1);
+        }
+    }
+    else if (tag !== null) {
+        // The root starts with a list or a code block: the tag gets a line of its own.
+        elements.unshift({ type: "rich_text_section", elements: tagElements(tag) });
+    }
+    return copy;
+}
+/**
+ * The root as a titled one reads: a single `rich_text` block holding `tag`, when there is one,
+ * and `title` in bold. The block keeps the id of the root's first `rich_text` block, so that a
+ * title already shown rewrites to the very blocks the root holds and nothing is sent.
+ */
+export function retitledBlocks(blocks, title, tag) {
+    const id = richText(blocks)?.block_id;
+    return [
+        {
+            type: "rich_text",
+            ...(typeof id === "string" && { block_id: id }),
+            elements: [
+                {
+                    type: "rich_text_section",
+                    elements: [
+                        ...(tag === null ? [] : tagElements(tag)),
+                        { type: "text", text: title, style: { bold: true } },
+                    ],
+                },
+            ],
+        },
+    ];
+}
+/** The text fallback of a titled root: `` `[tag]` *title* `` or `*title*`. */
+export function retitledText(title, tag) {
+    // Slack's control characters in a message's text (docs.slack.dev/reference/surfaces/formatting);
+    // the tag is written where `retaggedText` writes it.
+    return retaggedText(`*${mrkdwnEscape(title)}*`, tag);
+}
+/** `text` with its leading `` `[name]` `` taken off and `tag`, when there is one, put in its place. */
+export function retaggedText(text, tag) {
+    const prefix = TEXT_PREFIX.exec(text);
+    const body = prefix !== null && TAG_NAME.test(prefix[1] ?? "") ? text.slice(prefix[0].length) : text;
+    return tag === null ? body : `\`[${tag}]\` ${body}`;
+}
+/** Edits the root of a thread with the owner's own token: its tag and pin, its title line. */
+export class RootEditor {
+    #bot;
+    #owner;
+    // The last edit of each root still running or queued, by channel and thread.
+    #tails = new Map();
+    /** `bot` reads the root; `owner` is the client of the owner's user token and writes. */
+    constructor(bot, owner) {
+        this.#bot = bot;
+        this.#owner = owner;
+    }
+    /**
+     * Puts `tag` on the root of `thread` and pins it, or with a null `tag` takes the tag away and, when the root carried one, the pin. Each
+     * step is skipped when the root is already as asked, so a repeat is harmless. Rejects with a
+     * `ChatError` carrying Slack's code when a call was refused.
+     */
+    tag(channel, thread, tag) {
+        return this.#serially(channel, thread, async () => {
+            const root = await this.#root(channel, thread);
+            const marks = rootMarks(root);
+            await this.#edit(channel, thread, root, {
+                text: (text) => retaggedText(text, tag),
+                blocks: (blocks) => retaggedBlocks(blocks, tag),
+            });
+            if (tag !== null && !marks.pinned)
+                await this.#pin(channel, thread);
+            // Only a root that carried a tag is unpinned: a pin the owner made by hand stays.
+            if (tag === null && marks.pinned && marks.tag !== null)
+                await this.#unpin(channel, thread);
+        });
+    }
+    /**
+     * Rewrites the root of `thread` to its tag, when it has one, and `title` in bold: the owner's
+     * own words leave the root. In one queued task it reads the root once, hands `keep` the words
+     * the root held in the form the agent receives a message (`slackUnescape` of the root's `text`,
+     * the tag left out) and waits for it, and only then edits; when `keep` throws nothing is edited.
+     * Nothing is sent when the root already reads as asked. Rejects with a `ChatError` carrying
+     * Slack's code when a call was refused, `permanent` when the refusal cannot change.
+     */
+    title(channel, thread, title, keep) {
+        // One line: a newline in the title would end the bold element's line early.
+        const line = title.replace(/\s+/g, " ").trim();
+        return this.#serially(channel, thread, async () => {
+            const root = await permanently(() => this.#root(channel, thread));
+            const { tag } = rootMarks(root);
+            if (keep !== undefined) {
+                const text = typeof root.text === "string" ? root.text : "";
+                await keep(slackUnescape(retaggedText(text, null)));
+            }
+            await permanently(() => this.#edit(channel, thread, root, {
+                text: () => retitledText(line, tag),
+                blocks: (blocks) => retitledBlocks(blocks, line, tag),
+            }));
+        });
+    }
+    /** Runs `work` after the edits of the same root asked before it, and wraps its failure. */
+    #serially(channel, thread, work) {
+        const key = `${channel}/${thread}`;
+        const run = (this.#tails.get(key) ?? Promise.resolve()).then(async () => {
+            try {
+                await work();
+            }
+            catch (error) {
+                if (error instanceof ChatError)
+                    throw error;
+                throw new ChatError(describe(error), { cause: error });
+            }
+        });
+        const tail = run.then(() => { }, () => { });
+        this.#tails.set(key, tail);
+        void tail.then(() => {
+            if (this.#tails.get(key) === tail)
+                this.#tails.delete(key);
+        });
+        return run;
+    }
+    async #root(channel, thread) {
+        const answer = await this.#bot.conversations.replies({ channel, ts: thread, limit: 1 });
+        const messages = Array.isArray(answer.messages) ? answer.messages : [];
+        const root = messages.find((message) => isRecord(message) && String(message.ts) === thread);
+        if (!isRecord(root))
+            throw new ChatError("root_not_returned");
+        // A root deleted while replies remain is returned as a tombstone (measured 2026-10-20): it is
+        // gone, and nothing of it is kept or edited. The same refusal `conversations.replies` gives
+        // once the last reply is deleted too.
+        if (isTombstone(root)) {
+            throw new ChatError("thread_not_found", { permanent: true });
+        }
+        return root;
+    }
+    /** Rewrites the root's text and blocks; nothing is sent when they would not change. */
+    async #edit(channel, thread, root, rewrite) {
+        const text = typeof root.text === "string" ? root.text : "";
+        const nextText = rewrite.text(text);
+        const hasBlocks = Array.isArray(root.blocks);
+        const nextBlocks = hasBlocks ? rewrite.blocks(root.blocks) : null;
+        if (nextText === text && (!hasBlocks || isDeepStrictEqual(nextBlocks, root.blocks)))
+            return;
+        await this.#owner.chat.update({
+            channel,
+            ts: thread,
+            text: nextText,
+            // A root with no blocks is shown from its text, which a block would replace.
+            ...(nextBlocks !== null && { blocks: nextBlocks }),
+        });
+    }
+    async #pin(channel, thread) {
+        try {
+            await this.#owner.pins.add({ channel, timestamp: thread });
+        }
+        catch (error) {
+            if (describe(error) !== ALREADY_PINNED)
+                throw error;
+        }
+    }
+    async #unpin(channel, thread) {
+        try {
+            await this.#owner.pins.remove({ channel, timestamp: thread });
+        }
+        catch (error) {
+            if (!NOT_PINNED.has(describe(error)))
+                throw error;
+        }
+    }
+}

package/dist/chat/slack/texts.js

@@ -120,6 +120,7 @@ export const HOME_OPEN = "Open";
 export const HOME_NEW_THREAD = "New thread";
 export const HOME_EDIT = "Edit";
 export const HOME_DONE = "Done";
+export const HOME_REFRESH = "Refresh";
 export const HOME_DELETE = "Delete";
 // Bold, behind the hourglass the other two notes carry: mrkdwn has no colour, and the plain
 // word was missed among the row's details.
@@ -156,6 +157,12 @@ export const HOME_DELETE_REFUSED = naming("{chat} refused to delete {count} of t
 export const HOME_CLEAN_REFUSED = naming("{chat} refused to delete {count} of that channel's messages (`cant_delete_message`): your " +
     "workspace does not let you delete them. Every other one is gone.");
 export const HOME_DELETE_BUSY = "Not deleted: that thread is working or waiting for you.";
+// The same two ends as the Home tab's, told in the thread `!delete-thread` was sent in.
+export const THREAD_DELETE_REFUSED = naming("{chat} refused to delete {count} of this thread's messages (`cant_delete_message`): they are " +
+    "not yours or the bot's, or your workspace does not let you delete them. Every other " +
+    "message is gone.");
+export const THREAD_DELETE_FAILED = "Could not delete every message of this thread (`{error}`). Send `!delete-thread` again to " +
+    "continue.";
 export const HOME_DELETE_FAILED = "Could not delete every message of that thread (`{error}`). Delete it again to continue.";
 export const HOME_SHOW_ALL = "Show all {count}";
 export const HOME_UNTITLED = "Session {id}";
@@ -169,6 +176,7 @@ export const HOME_ENDED = "ended";
 export const HOME_ERROR = "error";
 export const HOME_ALL_CHANNELS = "All channels";
 export const HOME_ALL_STATUSES = "All statuses";
+export const HOME_ALL_TAGS = "All tags";
 export const HOME_ANY_TIME = "Any time";
 export const HOME_LAST_48 = "Last 48 hours";
 export const HOME_TODAY = "Today";

package/dist/chat/slack/thread.js

@@ -30,7 +30,14 @@ import { REACTIONS, StatusReaction, ThreadStatus } from "./reply/status.js";
 import { answeredBlocks, approvalBlocks, questionBlocks } from "./requests.js";
 import { setupBlocks } from "./setup.js";
 export const logger = getLogger("allaboard.chat.slack.thread");
-/** Slack draws every part of the chat seam. */
+/** The emoji of each root reaction (`REACTIONS`), as a character. */
+const STATUS_MARKS = {
+    working: "⏳",
+    waiting: "✋",
+    done: "✅",
+    error: "❌",
+};
+/** What Slack draws of the chat seam whatever the configuration. */
 const CAPABILITIES = {
     nativeStreaming: true,
     reactions: true,
@@ -40,7 +47,7 @@ const CAPABILITIES = {
 /** The Slack provider: one `SlackThread` per thread, one `SlackChannel` per channel. */
 export class SlackChat {
     name = "Slack";
-    capabilities = CAPABILITIES;
+    capabilities;
     /**
      * The bot of the workspace, and the app-level token of the connection when there is one: the
      * two things a copied `.env` can leave the same, each of which makes Socket Mode spread events
@@ -49,6 +56,12 @@ export class SlackChat {
     identities;
     /** Present when the provider holds the Home tab (`SlackApp.home`). */
     index;
+    /** Present when the owner's user token is configured (`SlackChatOptions.roots`, `canTag`). */
+    tagThread;
+    /** Present when the owner's user token is configured (`SlackChatOptions.roots`). */
+    titleThread;
+    /** Present when the owner's user token is configured (`SlackApp.deleteThread`). */
+    deleteThread;
     options;
     stopping = new AbortController();
     built = null;
@@ -60,6 +73,12 @@ export class SlackChat {
     named = null;
     constructor(options) {
         this.options = options;
+        this.capabilities = {
+            ...CAPABILITIES,
+            threadTags: options.roots !== undefined && options.canTag === true,
+            threadTitles: options.roots !== undefined,
+            threadDelete: options.app?.deleteThread !== undefined,
+        };
         this.identities = [
             `${options.identity.teamId}:${options.identity.botUserId}`,
             ...(options.app !== undefined ? [options.app.appKey] : []),
@@ -67,6 +86,34 @@ export class SlackChat {
         const home = options.app?.home;
         if (home !== undefined)
             this.index = { refresh: (changed) => home.request(changed) };
+        const roots = options.roots;
+        // The root may have changed even when a later step failed: the Home reads it again.
+        const rereading = async (ref, edit) => {
+            try {
+                await edit();
+            }
+            finally {
+                this.index?.refresh([ref]);
+            }
+        };
+        if (roots !== undefined && options.canTag === true) {
+            this.tagThread = (ref, tag) => rereading(ref, () => roots.tag(ref.channel, ref.thread, tag));
+        }
+        if (roots !== undefined) {
+            this.titleThread = async (ref, title, keep) => {
+                // A title resolving after the stop began touches neither Slack nor the state.
+                if (this.stopped.aborted)
+                    return;
+                await rereading(ref, () => roots.title(ref.channel, ref.thread, title, keep));
+            };
+        }
+        if (options.app?.deleteThread !== undefined) {
+            this.deleteThread = async (ref) => {
+                if (this.built === null)
+                    throw new Error("the Slack app is not started");
+                await this.built.askDelete(ref.channel, ref.thread);
+            };
+        }
     }
     /**
      * The `chat.update` budget every reply in the process draws from, so an edit made outside a
@@ -161,6 +208,13 @@ export class SlackChat {
         });
     }
     escape(text, markup) {
+        // `words` is the owner's own text, drawn in a markdown block as written: measured 2026-10-20,
+        // the block turns `<!here>` into a broadcast and `<@U…>` into a mention, as they were in the
+        // owner's message, and keeps `&&` and code spans as typed, where an entity or a backslash
+        // escape shows literally inside code. Its only reader is `!status`, which only the owner sees
+        // and which never pushes (`ownerOnly`), so a mention in it reaches no one.
+        if (markup === "words")
+            return text;
         return markup === "notice" ? mrkdwnEscape(text) : markdownEscape(text);
     }
     // Slack's channel syntax in a notice. Whether a markdown block renders it was not confirmed
@@ -168,6 +222,11 @@ export class SlackChat {
     channelName(channel, _markup) {
         return `<#${channel}>`;
     }
+    // The character of each reaction a root carries (`REACTIONS`): written as such, as the
+    // bypass mark of the same lines is, rather than as a `:name:` a reference may not render.
+    statusMark(status) {
+        return STATUS_MARKS[status];
+    }
     openedAt(ref) {
         // A Slack ts is the post time in epoch seconds.
         const seconds = ref.thread.trim() === "" ? Number.NaN : Number(ref.thread);
@@ -203,6 +262,7 @@ export class SlackChat {
             state: core.state,
             uploads: app.uploads,
             home: app.home,
+            ...(app.deleteThread !== undefined && { deleteThread: app.deleteThread }),
             receiver: app.receiver,
             ...(steady !== undefined && { clock: steady }),
             ...(app.fetch !== undefined && { fetch: app.fetch }),

package/dist/chat/slack/tokens.js

@@ -0,0 +1,15 @@
+/**
+ * The kind of each Slack token, told by its prefix. The one rule for the daemon's start and for
+ * `allaboard setup`: a swapped pair is named before Slack is called.
+ */
+/** A token variable, the prefix of its kind and the sentence that names it. */
+export const TOKEN_KINDS = {
+    SLACK_BOT_TOKEN: { prefix: "xoxb-", message: "the Bot User OAuth Token (xoxb-...)" },
+    SLACK_APP_TOKEN: { prefix: "xapp-", message: "the app-level token (xapp-...)" },
+    SLACK_USER_TOKEN: { prefix: "xoxp-", message: "the User OAuth Token (xoxp-...)" },
+};
+/** The sentence that says `token` is not the kind `variable` takes, or null when it is. */
+export function wrongKind(variable, token) {
+    const kind = TOKEN_KINDS[variable];
+    return token.startsWith(kind.prefix) ? null : `${variable} must be ${kind.message}`;
+}

package/dist/cli.js

@@ -9,8 +9,10 @@ import { homedir } from "node:os";
 import { createInterface } from "node:readline/promises";
 import { configDirOf, DEFAULT_INSTANCE, INSTANCE_VARIABLE, parseInstanceName, } from "./core/instance.js";
 import { UpdateUnderWay, updateLock } from "./core/lock.js";
+import { answerWizard } from "./core/wizard.js";
 import { installVersion, isNewer, latestVersion, updatableCopy, } from "./host/npm.js";
 import { programOf } from "./host/program.js";
+import { askTerminal, chooseTerminal } from "./host/prompter.js";
 import { runAsync, runCommand } from "./host/run.js";
 import { Launchd } from "./host/service/launchd.js";
 import { loadedOn } from "./host/service/listing.js";
@@ -19,11 +21,13 @@ import { changelogOf, installedVersion } from "./version.js";
 export const USAGE = [
     "usage: allaboard [--instance <name>]                    run the daemon",
     `       allaboard service <${SERVICE_ACTIONS.join("|")}> [--instance <name>]`,
+    "       allaboard setup [--instance <name>]",
     "       allaboard update [--check] [--yes]",
     "       allaboard --version | --help",
     "",
     `--instance picks one of the machine's daemons; ${INSTANCE_VARIABLE} does the same when the flag`,
     "is absent. `service list` shows every instance and takes no --instance.",
+    "`setup` asks for the tokens and writes the instance's `.env`; it refuses a file that exists.",
     "`update` installs the latest version of the copy that `npm install -g` replaces and restarts",
     "the services that run it, asking first unless --yes; --check only prints the versions.",
 ].join("\n");
@@ -96,6 +100,12 @@ export function parseArguments(args, env = {}) {
     const [first, second, ...rest] = positional;
     if (first === "update")
         return parseUpdate([second, ...rest], flag);
+    if (first === "setup") {
+        if (second !== undefined)
+            return invalid(`unknown argument ${JSON.stringify(second)}`);
+        const instance = instanceOf(flag, env);
+        return "kind" in instance ? instance : { kind: "setup", instance };
+    }
     if (first === undefined) {
         const instance = instanceOf(flag, env);
         return "kind" in instance ? instance : { kind: "run", instance };
@@ -123,6 +133,10 @@ export function parseArguments(args, env = {}) {
     }
     return invalid(`unknown argument ${JSON.stringify(first)}`);
 }
+/** The commands the agents in `agents` declare. */
+function executablesOf(agents) {
+    return Object.values(agents).flatMap((agent) => agent.executable ?? []);
+}
 export const machineHost = {
     service: (instance) => process.platform === "darwin"
         ? new Launchd({
@@ -133,13 +147,14 @@ export const machineHost = {
             run: runCommand,
         })
         : null,
-    program: () => programOf(process.argv[1] ?? "", process.env.PATH ?? "", process.execPath),
+    program: (agentExecutables) => programOf(process.argv[1] ?? "", process.env.PATH ?? "", process.execPath, agentExecutables),
 };
 /**
  * Answers an invocation that does not run the daemon, and returns the exit status: 0, 2 for
  * arguments it does not know (with the usage on stderr), or the service action's own status.
+ * `agents` are the registry's, whose commands the service's `PATH` finds.
  */
-export function answer(invocation, output, host = machineHost) {
+export function answer(invocation, output, agents, host = machineHost) {
     switch (invocation.kind) {
         case "version":
             output.out(`${installedVersion()}\n`);
@@ -157,7 +172,7 @@ export function answer(invocation, output, host = machineHost) {
                 return 1;
             }
             const report = invocation.action === "install"
-                ? manager.install(host.program())
+                ? manager.install(host.program(executablesOf(agents)))
                 : manager[invocation.action]();
             for (const line of report.out)
                 output.out(`${line}\n`);
@@ -167,6 +182,29 @@ export function answer(invocation, output, host = machineHost) {
         }
     }
 }
+export const machineSetupHost = {
+    ...machineHost,
+    home: homedir(),
+    // A getter, as in `machineUpdateHost`.
+    get interactive() {
+        return process.stdin.isTTY === true && process.stdout.isTTY === true;
+    },
+    ask: askTerminal,
+    choose: chooseTerminal,
+};
+/**
+ * Answers `allaboard setup` with `modules`, the chats and agents the registry holds, which the
+ * owner picks from. Returns the wizard's exit status.
+ */
+export function answerSetup(invocation, modules, output, host = machineSetupHost) {
+    const manager = host.service(invocation.instance);
+    return answerWizard(invocation.instance, modules, output, {
+        home: host.home,
+        interactive: host.interactive,
+        prompter: { ask: host.ask, choose: host.choose },
+        installService: manager === null ? null : () => manager.install(host.program(executablesOf(modules.agents))),
+    });
+}
 export const machineUpdateHost = {
     ...machineHost,
     run: runAsync,
@@ -256,7 +294,8 @@ export async function answerUpdate(invocation, output, host = machineUpdateHost)
         output.out(`allaboard ${running} · latest ${latest.version}\n`);
         return 0;
     }
-    const updatable = await updatableCopy(host.run, host.program().main, running);
+    // Only the entry is read: an update installs no service.
+    const updatable = await updatableCopy(host.run, host.program([]).main, running);
     if ("refusal" in updatable)
         return failure(output, notUpdated(updatable.refusal));
     const latest = await latestVersion(host.run);