allaboard 0.0.0-stage → 0.5.0

package/dist/chat/slack/requests.js

@@ -0,0 +1,552 @@
+/**
+ * The agent's permission requests and questions as Slack draws them: the approval message, the
+ * one-line question with Answer and Skip, the form that asks it one question at a time, and the
+ * answered question that replaces a request. Every limit here is Slack's. What is pending and
+ * what the answer is belong to `core/requests.ts`.
+ *
+ * Everything the model wrote (the title, the description, the input, a question's header) goes
+ * to Slack with `&`, `<` and `>` escaped and a zero-width space after each backtick, so no
+ * `<url|label>` can hide what it links and no text can close its code block.
+ */
+import { answerOf, named, oneLine, texts } from "../../core/port.js";
+import { PY_SPACE, strip } from "../../text.js";
+import { isRecord } from "../../values.js";
+import { shownAsWritten } from "./reply/escape.js";
+import * as slackTexts from "./texts.js";
+export const SECTION_LIMIT = 3000;
+export const MESSAGE_BLOCKS = 50; // Slack's limit on blocks in one message
+export const OPTION_TEXT_LIMIT = 75;
+export const LABEL_LIMIT = 2000; // an input block's label
+const TAB_LIMIT = 40; // a question's header in the tab row
+export const APPROVAL_ALLOW = "approval_allow";
+export const APPROVAL_DENY = "approval_deny";
+export const QUESTION_OPEN = "question_open";
+export const QUESTION_SKIP = "question_skip";
+export const QUESTION_FORM = "question_form";
+/** The Edit buttons of the review page: `question_edit_{n}`, n a question's index. */
+export const QUESTION_EDIT = /^question_edit_(\d+)$/;
+// Text typed under Other and in Notes, per question. The draft lives in the daemon's memory
+// (`Requests`), so Slack's 3,000 characters of private_metadata bound neither.
+export const TYPED_LIMIT = 300;
+export const NOTES_LIMIT = 300;
+// The value of the Other option; the others carry their index in the question's options.
+const OTHER_VALUE = "other";
+const RUNS = new RegExp(`[${PY_SPACE}]+`);
+/** The first `limit` characters, counted in code points as Slack counts them. */
+function head(text, limit) {
+    return Array.from(text).slice(0, limit).join("");
+}
+function length(text) {
+    return Array.from(text).length;
+}
+function cut(text, limit) {
+    return length(text) <= limit ? text : `${head(text, limit - 1)}…`;
+}
+/** `text` with every run of white space as one space. */
+function squeezed(text) {
+    return strip(text).split(RUNS).join(" ");
+}
+function button(actionId, label, value, style) {
+    const entry = {
+        type: "button",
+        action_id: actionId,
+        value,
+        text: { type: "plain_text", text: label },
+    };
+    if (style)
+        entry.style = style;
+    return entry;
+}
+function context(text) {
+    return { type: "context", elements: [{ type: "mrkdwn", text }] };
+}
+/** `text` in pieces that each fit `limit` once shown as written, never splitting an escape. */
+function codeChunks(text, limit) {
+    const chunks = [];
+    let chunk = "";
+    let size = 0;
+    for (const char of text) {
+        // Only these four change when shown as written; any other code point stays one character.
+        const width = "&<>`".includes(char) ? length(shownAsWritten(char)) : 1;
+        if (size + width > limit) {
+            chunks.push(chunk);
+            chunk = "";
+            size = 0;
+        }
+        chunk += char;
+        size += width;
+    }
+    return chunk !== "" || chunks.length === 0 ? [...chunks, chunk] : chunks;
+}
+function code(chunk) {
+    return {
+        type: "section",
+        text: { type: "mrkdwn", text: `\`\`\`\n${shownAsWritten(chunk)}\n\`\`\`` },
+    };
+}
+/**
+ * The request the owner approves: everything the tool will run with, never cut silently, since
+ * Approve hands the agent the whole input whatever was shown.
+ */
+export function approvalBlocks(approvalId, request, names) {
+    const heading = request.title
+        ? shownAsWritten(request.title)
+        : texts.fill(named(slackTexts.APPROVAL_PROMPT, names), {
+            tool: shownAsWritten(request.toolName),
+        });
+    const blocks = [
+        { type: "section", text: { type: "mrkdwn", text: head(heading, SECTION_LIMIT) } },
+    ];
+    if (request.description) {
+        blocks.push(context(head(shownAsWritten(request.description), SECTION_LIMIT)));
+    }
+    const detail = JSON.stringify(request.input, null, 2);
+    const chunks = codeChunks(detail, SECTION_LIMIT - length("```\n\n```"));
+    const room = MESSAGE_BLOCKS - blocks.length - 1; // the actions block closes it
+    let codeBlocks;
+    if (chunks.length > room) {
+        // Past one message, the start and the end stay (a payload hides at the end of padding)
+        // and a line says how much is not shown, so the owner can Deny rather than guess.
+        const shown = chunks.slice(0, room - 2);
+        const tail = chunks.at(-1);
+        const hidden = chunks.slice(room - 2, -1).reduce((total, chunk) => total + length(chunk), 0);
+        const notice = texts.fill(slackTexts.APPROVAL_CUT, { count: hidden.toLocaleString("en-US") });
+        codeBlocks = [...shown.map(code), context(notice), code(tail)];
+    }
+    else {
+        codeBlocks = chunks.map(code);
+    }
+    blocks.push(...codeBlocks, {
+        type: "actions",
+        elements: [
+            button(APPROVAL_ALLOW, "Approve", approvalId, "primary"),
+            button(APPROVAL_DENY, "Deny", approvalId, "danger"),
+        ],
+    });
+    return blocks;
+}
+/**
+ * An answered request as the terminal keeps it, for a question whose answers the reply cannot
+ * show: `User answered Claude's questions:`, then `· question → answer` per question, with no
+ * buttons left to press.
+ */
+export function answeredBlocks(questions, answers, names) {
+    const lines = [slackTexts.RECORD_MARK + named(texts.ANSWERED, names)];
+    for (const q of questions) {
+        const answer = Object.hasOwn(answers, q.text) ? answers[q.text] : "";
+        const shown = typeof answer === "string" ? answer : answer.join(", ");
+        lines.push(`${texts.NESTED}· ${shownAsWritten(q.text)} → ${shownAsWritten(shown)}`);
+    }
+    // A context element holds at most 3,000 characters; long questions and answers are cut.
+    return [context(cut(lines.join("\n"), SECTION_LIMIT))];
+}
+/**
+ * The request in the channel: one line naming the questions, with Answer (which opens the form)
+ * and Skip. It stays one line however many questions the agent asks.
+ */
+export function questionBlocks(approvalId, questions, names) {
+    const headers = questions.map((q) => `*${shownAsWritten(q.header || q.text)}*`).join(" · ");
+    const count = questions.length === 1
+        ? named(slackTexts.QUESTIONS_ONE, names)
+        : texts.fill(named(slackTexts.QUESTIONS_MANY, names), { count: questions.length });
+    return [
+        {
+            type: "section",
+            text: { type: "mrkdwn", text: head(`${count}: ${headers}`, SECTION_LIMIT) },
+        },
+        {
+            type: "actions",
+            elements: [
+                button(QUESTION_OPEN, slackTexts.QUESTION_ANSWER, approvalId, "primary"),
+                button(QUESTION_SKIP, "Skip", approvalId),
+            ],
+        },
+    ];
+}
+/** A draft of the request `approvalId` posted in this thread, with nothing filled in unless given. */
+export function newDraft(approvalId, channelId, threadTs, filled = {}) {
+    return {
+        approvalId,
+        channelId,
+        threadTs,
+        generation: filled.generation ?? 0,
+        active: filled.active ?? 0,
+        reviewed: filled.reviewed ?? false,
+        picks: filled.picks ?? new Map(),
+        other: filled.other ?? new Set(),
+        typed: filled.typed ?? new Map(),
+        notes: filled.notes ?? new Map(),
+    };
+}
+/** The `private_metadata` of a form: its ids as JSON, which `loadIds` reads back. */
+export function dumpIds(ids) {
+    return JSON.stringify({
+        a: ids.approvalId,
+        c: ids.channelId,
+        h: ids.threadTs,
+        g: ids.generation,
+        n: ids.active,
+    });
+}
+/**
+ * The ids `dumpIds` wrote; throws on anything else. Generation and page are read when they are
+ * there: the metadata of an earlier version has no generation (0, older than any form now open)
+ * and may carry a whole draft beside the ids, which is left unread.
+ */
+export function loadIds(dumped) {
+    const data = JSON.parse(dumped);
+    if (!isRecord(data) || ![data.a, data.c, data.h].every((id) => typeof id === "string")) {
+        throw new Error("malformed form");
+    }
+    return {
+        approvalId: data.a,
+        channelId: data.c,
+        threadTs: data.h,
+        generation: data.g === undefined ? 0 : index(data.g),
+        active: data.n === undefined ? 0 : index(data.n),
+    };
+}
+function index(value) {
+    const found = typeof value === "string" ? value : typeof value === "number" ? String(value) : "";
+    if (!/^\d+$/.test(found))
+        throw new Error("malformed form");
+    return Number(found);
+}
+function fieldsOf(value) {
+    return isRecord(value) ? value : {};
+}
+/**
+ * The draft with what the question on screen shows now: Slack sends the form's state with Next
+ * and Submit, and with a dispatched action, but only for the blocks on screen. The Other and
+ * Notes fields leave the screen with the choice, so a field the state does not carry keeps what
+ * the draft holds.
+ */
+export function absorb(draft, stateValues) {
+    const at = draft.active;
+    const values = fieldsOf(stateValues);
+    const picked = fieldsOf(fieldsOf(values[`q${at}`]).answer);
+    const single = fieldsOf(picked.selected_option);
+    const several = picked.selected_options;
+    const chosen = Array.isArray(several) && several.length > 0
+        ? several
+        : Object.keys(single).length > 0
+            ? [single]
+            : [];
+    const values_ = chosen.map((o) => fieldsOf(o).value);
+    const picks = new Map(draft.picks);
+    picks.set(at, values_.filter((v) => v !== OTHER_VALUE).map(index));
+    const other = new Set(draft.other);
+    if (values_.includes(OTHER_VALUE))
+        other.add(at);
+    else
+        other.delete(at);
+    return {
+        ...draft,
+        picks: new Map([...picks].filter(([, v]) => v.length > 0)),
+        other,
+        typed: withField(draft.typed, at, fieldsOf(fieldsOf(values[`o${at}`]).other)),
+        notes: withField(draft.notes, at, fieldsOf(fieldsOf(values[`n${at}`]).notes)),
+    };
+}
+/** `kept` with question `at` set to what `field` holds; unchanged when the field is not on screen. */
+function withField(kept, at, field) {
+    const next = new Map(kept);
+    if (Object.keys(field).length === 0)
+        return next;
+    const value = typeof field.value === "string" ? strip(field.value) : "";
+    if (value === "")
+        next.delete(at);
+    else
+        next.set(at, value);
+    return next;
+}
+function answerAt(draft, questions, at) {
+    const question = questions[at];
+    if (question === undefined)
+        throw new RangeError(`no question ${at}`);
+    const picked = draft.picks.get(at) ?? [];
+    if (!draft.other.has(at))
+        return answerOf(question, picked, undefined);
+    // Other chosen with no text is no answer, even beside options picked in a multi select.
+    const typed = draft.typed.get(at);
+    return typed === undefined ? null : answerOf(question, picked, typed);
+}
+/**
+ * Whether a note belongs to the answer of question `at`: only a real option carries one, so Other
+ * alone shows no Notes field and sends no note.
+ */
+function takesNotes(draft, at) {
+    return (draft.picks.get(at) ?? []).length > 0;
+}
+/** An option, or Other with its text, makes an answer, as in the terminal. */
+export function isAnswered(draft, questions, at) {
+    return answerAt(draft, questions, at) !== null;
+}
+/** The index of the first question with no answer, else null. */
+export function firstIncomplete(draft, questions) {
+    const found = questions.findIndex((_, at) => !isAnswered(draft, questions, at));
+    return found === -1 ? null : found;
+}
+/**
+ * Every question's answer by its text and the notes added to it by the question's text, or null
+ * while one question is unanswered. A note kept for a question with no answer, or whose answer
+ * is Other alone, is not sent.
+ */
+export function draftAnswers(draft, questions) {
+    const answers = [];
+    const notes = [];
+    for (const [at, question] of questions.entries()) {
+        const answer = answerAt(draft, questions, at);
+        if (answer === null)
+            return null;
+        answers.push([question.text, answer]);
+        const note = draft.notes.get(at);
+        if (note !== undefined && takesNotes(draft, at))
+            notes.push([question.text, note]);
+    }
+    return { answers: Object.fromEntries(answers), notes: Object.fromEntries(notes) };
+}
+/**
+ * An option's preview as it is shown: its own lines, with no blank line around them; empty when
+ * it holds nothing to read.
+ */
+function previewOf(option) {
+    const preview = option.preview ?? "";
+    return strip(preview) !== "" ? preview.replace(/^\n+|\n+$/g, "") : "";
+}
+/**
+ * Whether an option says more than a choice holds: Slack caps an option object's `text` and
+ * `description` at 75 characters each (option object reference, read 2026-10-03), and it has no
+ * place for a `preview`.
+ */
+function saysMore(question) {
+    return question.options.some((option) => length(squeezed(option.label)) > OPTION_TEXT_LIMIT ||
+        length(squeezed(option.description ?? "")) > OPTION_TEXT_LIMIT ||
+        previewOf(option) !== "");
+}
+function optionEntry(at, option, described) {
+    const entry = {
+        text: { type: "plain_text", text: oneLine(option.label, OPTION_TEXT_LIMIT) },
+        value: String(at),
+    };
+    // Slack refuses an empty text: a description of blanks alone is none.
+    const description = oneLine(option.description ?? "", OPTION_TEXT_LIMIT);
+    if (described && description !== "") {
+        entry.description = { type: "plain_text", text: description };
+    }
+    return entry;
+}
+function bold(text) {
+    return { type: "text", text: cut(text, SECTION_LIMIT), style: { bold: true } };
+}
+/**
+ * An option with every word the agent wrote for it, as one rich text block: its label in bold,
+ * its description, and its preview in a preformatted element, which keeps its line breaks. Rich
+ * text shows its text as written, so nothing in it is read as markup (a modal takes no
+ * `markdown` block; block references, read 2026-10-03). The reference names no limit for a rich
+ * text element's text: a section's is kept for each.
+ */
+function optionWhole(option) {
+    const parts = [bold(oneLine(option.label, SECTION_LIMIT))];
+    const description = strip(option.description ?? "");
+    if (description !== "")
+        parts.push({ type: "text", text: `\n${cut(description, SECTION_LIMIT)}` });
+    const elements = [{ type: "rich_text_section", elements: parts }];
+    const preview = previewOf(option);
+    if (preview !== "") {
+        const shown = { type: "text", text: cut(preview, SECTION_LIMIT) };
+        elements.push({ type: "rich_text_preformatted", elements: [shown] });
+    }
+    return { type: "rich_text", elements };
+}
+/**
+ * A question's header for the tab row: cut, not escaped. Slack's mrkdwn has no escape for `*`, `_`
+ * and `~`, and one inside the header would end the bold of the page on screen early, so they are
+ * left out of the header here and nowhere else.
+ */
+function tabName(question, at) {
+    const header = cut(squeezed(question.header.replace(/[*_~]/g, "")), TAB_LIMIT);
+    return header !== "" ? header : texts.fill(slackTexts.QUESTION_TAB_UNNAMED, { number: at + 1 });
+}
+/**
+ * The terminal's tab row, as one context line: each question's header with `☒` once answered
+ * and `☐` before, the page on screen in bold, then `✔ Submit` (bold on the review page).
+ */
+function tabRow(draft, questions) {
+    const cells = questions.map((question, at) => {
+        const cell = `${isAnswered(draft, questions, at) ? "☒" : "☐"} ${shownAsWritten(tabName(question, at))}`;
+        return at === draft.active ? `*${cell}*` : cell;
+    });
+    const review = draft.active === questions.length;
+    cells.push(review ? `*${slackTexts.QUESTION_TAB_SUBMIT}*` : slackTexts.QUESTION_TAB_SUBMIT);
+    return context(cells.join("   "));
+}
+/** The page that ends a form of several questions: every answer, to read before it is sent. */
+function reviewView(draft, questions, names) {
+    const sections = questions.map((question, at) => {
+        const answer = answerAt(draft, questions, at);
+        const shown = typeof answer === "string" ? answer : (answer ?? []).join(", ");
+        let lines = `● ${question.text}\n→ ${shown}`;
+        // A note kept for a question with no answer, or answered by Other alone, is not sent, so the
+        // page does not show it.
+        const noted = draft.notes.get(at);
+        if (answer !== null && noted !== undefined && takesNotes(draft, at)) {
+            lines += `\n${slackTexts.QUESTION_NOTES}: ${noted}`;
+        }
+        // Cut as written, on the room the escaped text takes, so no escape is split.
+        const [first = "", ...rest] = codeChunks(lines, SECTION_LIMIT - 1);
+        const text = `${shownAsWritten(first)}${rest.length > 0 ? "…" : ""}`;
+        // One action id per question: Slack wants them unique within a view.
+        const edit = button(`question_edit_${at}`, slackTexts.QUESTION_EDIT, String(at));
+        return { type: "section", text: { type: "mrkdwn", text }, accessory: edit };
+    });
+    return {
+        type: "modal",
+        callback_id: QUESTION_FORM,
+        private_metadata: dumpIds(draft),
+        title: { type: "plain_text", text: named(slackTexts.QUESTION_TITLE, names) },
+        submit: { type: "plain_text", text: slackTexts.QUESTION_SUBMIT_ALL },
+        close: { type: "plain_text", text: slackTexts.QUESTION_CLOSE },
+        blocks: [
+            tabRow(draft, questions),
+            { type: "section", text: { type: "mrkdwn", text: slackTexts.QUESTION_REVIEW_HEADING } },
+            ...sections,
+        ],
+    };
+}
+/**
+ * The form, one question at a time, as the terminal's tabs: with several questions a tab row
+ * (one context line) names them and tells which are answered, the button reads `Next (1/3)` and
+ * leads to the next question (whether or not the others have an answer), and `Review` on the
+ * last opens a page that lists every answer with an Edit button (`reviewView`), whose `Submit
+ * answers` sends. Once the review was reached (`Draft.reviewed`) every page's button reads
+ * `Review`. One question has none of that and its `Submit` sends. Each question needs an answer
+ * before the next. The question shows as radio buttons, or checkboxes when several may be
+ * picked, each option with its description, and Other as the last option, as the terminal's list
+ * ends with its own row for a typed answer (tools reference: "type your own text through the
+ * Other row"). The choice is required. While Other is chosen its text field shows, required too;
+ * Notes shows while a real option is chosen, not for Other alone. When an option says more than
+ * a choice holds (`saysMore`), the question and every option are shown whole above the choice,
+ * which keeps the labels alone under the question's header (issue #47).
+ */
+export function questionView(draft, questions, names) {
+    const blocks = [];
+    const count = questions.length;
+    const at = draft.active;
+    if (count > 1 && at === count)
+        return reviewView(draft, questions, names);
+    const question = questions[at];
+    if (question === undefined)
+        throw new RangeError(`no question ${at}`);
+    if (count > 1)
+        blocks.push(tabRow(draft, questions));
+    const whole = saysMore(question);
+    let label = oneLine(question.text, LABEL_LIMIT);
+    if (whole) {
+        const asked = { type: "rich_text_section", elements: [bold(label)] };
+        blocks.push({ type: "rich_text", elements: [asked] });
+        blocks.push(...question.options.map(optionWhole));
+        // A header of blanks alone would leave the choice an empty label, which Slack refuses.
+        const header = strip(question.header);
+        label = oneLine(header !== "" ? header : slackTexts.QUESTION_ANSWER, LABEL_LIMIT);
+    }
+    const options = question.options.map((o, i) => optionEntry(i, o, !whole));
+    const otherOption = {
+        text: { type: "plain_text", text: slackTexts.QUESTION_OTHER },
+        description: { type: "plain_text", text: slackTexts.QUESTION_OTHER_HINT },
+        value: OTHER_VALUE,
+    };
+    const wantsOther = draft.other.has(at);
+    const element = {
+        type: question.multiSelect ? "checkboxes" : "radio_buttons",
+        action_id: "answer",
+        options: [...options, otherOption],
+    };
+    const real = (draft.picks.get(at) ?? []).flatMap((i) => options[i] ?? []);
+    const picked = [...real, ...(wantsOther ? [otherOption] : [])];
+    if (picked.length > 0 && question.multiSelect) {
+        element.initial_options = picked;
+    }
+    else if (picked.length > 0) {
+        element.initial_option = picked[0];
+    }
+    // A change of the choice redraws the form (`Requests.onQuestionChoice`): Other's field and
+    // Notes come and go with it. The two text fields only report to the draft, so that a form
+    // closed with Close and opened again finds what was typed.
+    blocks.push({
+        type: "input",
+        block_id: `q${at}`,
+        dispatch_action: true,
+        label: { type: "plain_text", text: label },
+        element,
+    });
+    const typing = { trigger_actions_on: ["on_character_entered"] };
+    if (wantsOther) {
+        const other = {
+            type: "plain_text_input",
+            action_id: "other",
+            max_length: TYPED_LIMIT,
+            placeholder: { type: "plain_text", text: slackTexts.QUESTION_OTHER_HINT },
+            dispatch_action_config: typing,
+        };
+        const typed = draft.typed.get(at);
+        if (typed)
+            other.initial_value = typed;
+        blocks.push({
+            type: "input",
+            block_id: `o${at}`,
+            dispatch_action: true,
+            label: { type: "plain_text", text: slackTexts.QUESTION_YOUR_ANSWER },
+            element: other,
+        });
+    }
+    if (real.length > 0) {
+        const notes = {
+            type: "plain_text_input",
+            action_id: "notes",
+            max_length: NOTES_LIMIT,
+            placeholder: { type: "plain_text", text: slackTexts.QUESTION_NOTES_HINT },
+            dispatch_action_config: typing,
+        };
+        const noted = draft.notes.get(at);
+        if (noted)
+            notes.initial_value = noted;
+        blocks.push({
+            type: "input",
+            block_id: `n${at}`,
+            optional: true,
+            dispatch_action: true,
+            label: { type: "plain_text", text: slackTexts.QUESTION_NOTES },
+            element: notes,
+        });
+    }
+    const last = at === count - 1;
+    return {
+        type: "modal",
+        callback_id: QUESTION_FORM,
+        private_metadata: dumpIds(draft),
+        title: { type: "plain_text", text: named(slackTexts.QUESTION_TITLE, names) },
+        submit: {
+            type: "plain_text",
+            text: count === 1
+                ? "Submit"
+                : last || draft.reviewed
+                    ? slackTexts.QUESTION_REVIEW
+                    : texts.fill(slackTexts.QUESTION_NEXT, { number: at + 1, count }),
+        },
+        close: { type: "plain_text", text: slackTexts.QUESTION_CLOSE },
+        blocks,
+    };
+}
+/**
+ * The question form once its channel is refused: `told` alone, with no Submit and no draft.
+ * Slack lets an app close a modal only in answer to a submission, so the open one is replaced.
+ */
+export function refusedView(told, names) {
+    return {
+        type: "modal",
+        title: { type: "plain_text", text: named(slackTexts.QUESTION_TITLE, names) },
+        close: { type: "plain_text", text: slackTexts.QUESTION_CLOSE },
+        blocks: [{ type: "section", text: { type: "mrkdwn", text: told } }],
+    };
+}

package/dist/chat/slack/resume.js

@@ -0,0 +1,127 @@
+/**
+ * `!resume`: Claude Code's session picker, as a message with a Resume button per session.
+ *
+ * The terminal's `/resume` is interactive and the SDK does not offer it (not among the session's
+ * commands, Claude Code 2.1.280), so the daemon answers the word itself, the way the terminal
+ * does: `/resume` alone opens the picker, `/resume <session>` resumes by id or name (commands
+ * reference, read 2026-09-25). Each row shows what a picker row shows: the session's name or
+ * title, the time since its last activity, its git branch and its size (sessions reference, read
+ * 2026-09-25). The rows come from the agent's session listing, newest first. Ordering that list
+ * by the sessions' last message belongs to the Claude back end, which reads the transcripts.
+ */
+import { oneLine, TITLE_LIMIT, texts } from "../../core/port.js";
+import { contextBlock } from "./reply/blocks.js";
+import { take } from "./reply/chars.js";
+import { shownAsWritten } from "./reply/escape.js";
+import * as slackTexts from "./texts.js";
+export const RESUME_ROWS = 20;
+export const RESUME_ACTION = "session_resume";
+// The first characters of a session id the list shows, and the fewest `!resume` takes as an id:
+// the core's `ID_PREFIX_MIN`.
+export const ID_SHOWN = 8;
+const SLACK_TS = /^\d+\.\d+$/;
+/** The Resume button's value: the session, and the thread of the owner's `!resume` message it is
+ * resumed into (the list is a top-level post, not that thread). */
+export function resumeValue(sessionId, threadTs) {
+    return `${sessionId}@${threadTs}`;
+}
+/** The session id and thread ts a Resume button carries; null for any other shape. The value is
+ * untrusted like every click's: only its form is checked here. */
+export function parseResumeValue(value) {
+    const at = value.indexOf("@");
+    if (at === -1)
+        return null;
+    const sessionId = value.slice(0, at);
+    const threadTs = value.slice(at + 1);
+    if (sessionId === "" || !SLACK_TS.test(threadTs))
+        return null;
+    return [sessionId, threadTs];
+}
+/** As the terminal's picker writes it ("2 days ago", seen 2026-09-25). */
+function age(modifiedMs, now) {
+    const seconds = Math.max(0, now.getTime() / 1000 - modifiedMs / 1000);
+    for (const [unit, length] of [
+        ["day", 86400],
+        ["hour", 3600],
+        ["minute", 60],
+    ]) {
+        if (seconds >= length) {
+            // The whole quotient: one that the division rounded up is taken back.
+            let count = Math.floor(seconds / length);
+            if (count * length > seconds)
+                count -= 1;
+            return `${count} ${unit}${count > 1 ? "s" : ""} ago`;
+        }
+    }
+    return "just now";
+}
+/** `bytes` over `unit`, with one decimal as Python's `f"{x:.1f}"` writes it: an exact tie goes to
+ * the even tenth, where `toFixed` goes up. A size over a power of two is exact in a double. */
+function tenths(bytes, unit) {
+    const scaled = (bytes / unit) * 10;
+    const floor = Math.floor(scaled);
+    const rest = scaled - floor;
+    const rounded = rest > 0.5 || (rest === 0.5 && floor % 2 === 1) ? floor + 1 : floor;
+    return `${Math.floor(rounded / 10)}.${rounded % 10}`;
+}
+/** As the terminal's picker writes it ("953.1KB" for 976,000 bytes: 1,024 per KB). */
+function size(bytes) {
+    if (bytes === null)
+        return null;
+    if (bytes < 1024 * 1024)
+        return `${tenths(bytes, 1024)}KB`;
+    return `${tenths(bytes, 1024 * 1024)}MB`;
+}
+function row(session, now, threadTs) {
+    // Shown as the terminal's picker shows it, HEAD outside a repository included.
+    const branch = session.branch ? shownAsWritten(session.branch) : null;
+    const title = shownAsWritten(oneLine(session.title, TITLE_LIMIT));
+    // The terminal's picker shows no id, since picking a row resumes it; here the id's start is
+    // what `!resume <id>` takes. Plain text, as the rest of the row (the maintainer, 2026-09-26).
+    const parts = [
+        title,
+        age(session.lastModified, now),
+        branch,
+        size(session.size),
+        take(session.id, ID_SHOWN),
+    ];
+    return {
+        type: "section",
+        block_id: `session-${session.id}`,
+        text: { type: "mrkdwn", text: parts.filter((part) => part).join(" · ") },
+        accessory: {
+            type: "button",
+            action_id: RESUME_ACTION,
+            value: resumeValue(session.id, threadTs),
+            text: { type: "plain_text", text: slackTexts.RESUME_BUTTON },
+        },
+    };
+}
+/**
+ * The picker: the newest RESUME_ROWS of `sessions`, the ones of `directory` that can be resumed.
+ * `openElsewhere` counts the sessions a thread already holds (one session lives in one
+ * thread): they are left out of the rows, since resuming one is refused anyway, and named by one
+ * line under the list, so the limit applies to what the owner can act on. Each Resume button
+ * carries `threadTs`, the thread of the owner's `!resume` message, where the session is resumed.
+ */
+export function resumeBlocks(directory, sessions, openElsewhere, now, threadTs) {
+    // The list's own lines are the daemon's notices, small and grey; the rows keep their button.
+    const shown = shownAsWritten(directory);
+    let held = [];
+    if (openElsewhere === 1)
+        held = [contextBlock(slackTexts.RESUME_OPEN_ONE)];
+    else if (openElsewhere)
+        held = [contextBlock(texts.fill(slackTexts.RESUME_OPEN_MANY, { count: openElsewhere }))];
+    if (sessions.length === 0) {
+        const empty = held.length > 0 ? slackTexts.RESUME_NONE_LEFT : slackTexts.RESUME_EMPTY;
+        return [contextBlock(texts.fill(empty, { directory: shown })), ...held];
+    }
+    const blocks = [
+        contextBlock(texts.fill(texts.RESUME_LIST, { directory: shown })),
+        ...sessions.slice(0, RESUME_ROWS).map((s) => row(s, now, threadTs)),
+    ];
+    if (sessions.length > RESUME_ROWS) {
+        blocks.push(contextBlock(texts.fill(slackTexts.RESUME_MORE, { rows: RESUME_ROWS })));
+    }
+    return [...blocks, ...held];
+}