allaboard 0.0.0-stage → 0.4.0

package/dist/chat/slack/home.js

@@ -0,0 +1,1069 @@
+/**
+ * The app's Home tab: the owner's index of sessions. Two lines per thread that holds a session,
+ * grouped by channel, each group and each session ordered by the thread's last reply, with a link
+ * that opens the thread: a channel lists its threads by when they started, and Slack's
+ * Threads view by unread replies (Help Center, "Use threads to organize discussions", read
+ * 2026-10-01), so neither finds the thread worked in last.
+ *
+ * A card is built from what the daemon already keeps, what Claude Code knows and what Slack shows:
+ * the thread and its root's reaction from `state.json`, the title from the session's transcript,
+ * as `!resume` shows it, and from Slack the thread's number of replies and the time of its last
+ * one, the same the channel shows under the root. Nothing is stored for the page: the filters the
+ * owner chooses live in memory and start again at their defaults with the daemon.
+ *
+ * `conversations.replies` with the root's `ts` and `limit=1` returns the root alone, carrying
+ * `reply_count`, `latest_reply` and `reactions` (measured 2026-10-01 on a free workspace with
+ * `groups:history`, slack-sdk 3.44.1; a deleted root answers `thread_not_found`). The root's own
+ * reaction fills in the status of a thread that ended before the daemon kept it.
+ *
+ * `views.publish` (docs.slack.dev/reference/methods/views.publish, read 2026-10-01) takes no scope
+ * and may be called at any time, with no event from the owner ("Home tab updates can happen when a
+ * user isn't interacting with Slack or the app", docs.slack.dev/surfaces/app-home), so the page is
+ * rewritten when the index changes, with no event subscribed. A view holds 100 blocks. Ages are
+ * Slack's own `{ago}` date token (docs.slack.dev/messaging/formatting-message-text, seen rendered
+ * in a Home view on 2026-10-01), so they do not go stale between two publishes.
+ *
+ * What reaches the app from the page is a `block_actions` payload per use of a control
+ * (the app's listeners own them): a filter, which carries the state of every control in
+ * `view.state.values`, and the **New thread** link button, which Slack follows itself and still
+ * reports (button element reference, read 2026-10-01). A session's **Open** is a plain link in its
+ * line of details, which reports nothing: the permalink of the thread's last reply, which Slack
+ * opens the thread on (seen in the Mac app and on iOS, 2026-10-05), or of its root while it has
+ * none. **New thread** is the documented deep link to the channel
+ * (docs.slack.dev/interactivity/deep-linking; it opened the channel in the desktop app on
+ * 2026-10-01): the owner's own top-level message there starts the session, so the thread is one
+ * the owner started and its replies notify.
+ *
+ * How the waits are made:
+ * - `publish` runs under a FIFO `Mutex`, so the publishes run one at a time and each is built
+ *   after the one before it landed. A publish is given up through an `AbortSignal` that
+ *   `publish` looks at before each Slack call and before `views.publish`: a call in flight is
+ *   awaited and its answer used, never cut short, and a cancelled publish never sends its page.
+ * - The debounced loop and the retry are each a `Task`; the time limit in `close` is a race
+ *   against the clock's sleep that aborts the publish when the sleep wins.
+ * - `asking` is a `Semaphore` of `THREADS_AT_ONCE` places.
+ * - Every wait goes through the injected `Clock`.
+ */
+import { createHash } from "node:crypto";
+import { systemClock } from "../../clock.js";
+import { Cancelled, Mutex, named, oneLine, Semaphore, TITLE_LIMIT, texts, } from "../../core/port.js";
+import { getLogger } from "../../log.js";
+import { setupGuide } from "../../version.js";
+import { contextBlock, noticeText, plainTextObject } from "./reply/blocks.js";
+import { take } from "./reply/chars.js";
+import { describe, gone } from "./reply/errors.js";
+import { mrkdwnEscape, shownAsWritten } from "./reply/escape.js";
+import { REACTIONS, Status } from "./reply/status.js";
+import { Task } from "./reply/tasks.js";
+import { ID_SHOWN } from "./resume.js";
+import * as slackTexts from "./texts.js";
+import { updateButton, withChangelog } from "./update.js";
+export const logger = getLogger("allaboard.chat.slack.home");
+export const HOME_BLOCKS = 100;
+// What a channel shows while no filter is chosen; a filter shows every session it matches.
+export const PER_CHANNEL = 5;
+// A turn changes its root's reaction several times in a row (⏳, ✋ at an approval, ⏳ again):
+// one publish covers the burst.
+export const DEBOUNCE_SECONDS = 2.0;
+// How long a stop waits for its last publish: the page must never hold the daemon's exit.
+export const CLOSE_SECONDS = 10.0;
+// How many threads Slack is asked about at once on the first publish of a run.
+export const THREADS_AT_ONCE = 8;
+export const NOT_ENABLED = "not_enabled";
+// How long after a page that lacked an answer the next one is tried.
+export const RETRY_SECONDS = 60.0;
+// A select menu holds 100 options (select menu reference): "All channels" and 99 channels.
+export const CHANNEL_OPTIONS = 99;
+export const FILTERS_BLOCK = "home_filters";
+export const SEARCH_BLOCK = "home_search";
+export const CHANNEL_ACTION = "home_channel";
+export const STATUS_ACTION = "home_status";
+export const DATE_ACTION = "home_date";
+export const SEARCH_ACTION = "home_search_text";
+export const SHOW_ALL_ACTION = "home_show_all";
+export const NEW_THREAD_ACTION = "home_new_thread";
+export const EDIT_ACTION = "home_edit";
+export const DELETE_ACTION = "home_delete";
+export const CLEAN_ACTION = "home_clean";
+export const HOME_UPDATE_ACTION = "home_update";
+// How many lines about deletes that did not end the page shows at once, the latest ones.
+export const NOTICES_SHOWN = 5;
+// What the Edit button carries: the mode a click asks for, so a click sent twice asks the same.
+export const EDIT_ON = "edit";
+export const EDIT_OFF = "done";
+// A confirmation dialog's text holds 300 characters (confirmation dialog object reference).
+export const CONFIRM_TEXT = 300;
+export const FILTER_ACTIONS = [CHANNEL_ACTION, STATUS_ACTION, DATE_ACTION, SEARCH_ACTION];
+// A blank row between two sessions: a context line that holds a zero-width space, since Slack
+// sets the distance between blocks itself and takes no empty text.
+export const SPACER = "​";
+// A session is a title, a line of details and the blank row above it.
+export const CARD_BLOCKS = 3;
+export const ALL = "all";
+export const SEARCH_LIMIT = 80;
+// A select option's text holds 75 characters (option object reference).
+export const OPTION_TEXT = 75;
+// The reaction names a session can show and their words, in the order the status menu lists.
+const WORDS = new Map([
+    [Status.WAITING, slackTexts.HOME_WAITING],
+    [Status.WORKING, slackTexts.HOME_WORKING],
+    [Status.DONE, slackTexts.HOME_ENDED],
+    [Status.ERROR, slackTexts.HOME_ERROR],
+]);
+// A session in one of these states is not offered for deleting: its thread is in use.
+const IN_USE = new Set([Status.WAITING, Status.WORKING]);
+/** The reaction that shows a stored status; null for none. */
+function reactionOf(status) {
+    return status === null ? null : REACTIONS[status];
+}
+export const LAST_48 = "48h";
+export const TODAY = "today";
+export const YESTERDAY = "yesterday";
+export const LAST_7 = "7";
+export const LAST_30 = "30";
+// How far back each rolling period reaches, in seconds.
+const REACH = new Map([
+    [LAST_48, 48 * 3600],
+    [LAST_7, 7 * 86400],
+    [LAST_30, 30 * 86400],
+]);
+const DATES = new Map([
+    [LAST_48, slackTexts.HOME_LAST_48],
+    [TODAY, slackTexts.HOME_TODAY],
+    [YESTERDAY, slackTexts.HOME_YESTERDAY],
+    [LAST_7, slackTexts.HOME_LAST_7],
+    [LAST_30, slackTexts.HOME_LAST_30],
+]);
+/** Python's `float(text)` for what a root carries; it throws for anything that is no number. */
+function pyFloat(value) {
+    if (typeof value === "number")
+        return value;
+    const text = String(value).trim();
+    if (!/^[+-]?(\d+\.?\d*|\.\d+)([eE][+-]?\d+)?$/.test(text)) {
+        throw new TypeError("not a number");
+    }
+    return Number(text);
+}
+/** Python's `int(value)` for a count: the number cut toward zero, or a string of digits. */
+function pyInt(value) {
+    if (typeof value === "number" && Number.isFinite(value))
+        return Math.trunc(value);
+    if (typeof value === "string" && /^\s*[+-]?\d+\s*$/.test(value))
+        return Number(value);
+    throw new TypeError("not a whole number");
+}
+/**
+ * Read a root message as `conversations.replies` returns it. A root nobody replied to has no
+ * `reply_count` and no `latest_reply`. Throws on a root in a shape that cannot be read.
+ */
+export function threadFacts(root) {
+    const latest = root.latest_reply;
+    const reactions = Array.isArray(root.reactions) ? root.reactions : [];
+    const names = reactions
+        .filter((r) => typeof r === "object" && r !== null && !Array.isArray(r))
+        .map((r) => String(r.name));
+    return {
+        replies: root.reply_count ? pyInt(root.reply_count) : 0,
+        latestReply: latest ? Math.trunc(pyFloat(latest)) : null,
+        latestTs: latest ? String(latest) : null,
+        reaction: names.find((name) => WORDS.has(name)) ?? null,
+    };
+}
+/** A `HomeFilter` with every field not given at its default. */
+export function homeFilter(fields = {}) {
+    return { channel: null, status: null, date: LAST_48, search: "", ...fields };
+}
+/**
+ * Whether a channel, a status or a search is chosen: the page then shows every session that
+ * matches. The period alone keeps the page's shape, each channel cut to its newest.
+ */
+export function narrowed(filter) {
+    return Boolean(filter.channel || filter.status || filter.search);
+}
+/** The day of the machine's own calendar an instant falls on, as a day number. */
+function localDay(epochSeconds) {
+    const at = new Date(epochSeconds * 1000);
+    return Math.floor(Date.UTC(at.getFullYear(), at.getMonth(), at.getDate()) / 86_400_000);
+}
+/**
+ * A search key: upper case, then lower case, so that `ß` and the final sigma meet their other
+ * spelling. It is not full Unicode case folding (a few hundred scalar values fold differently,
+ * `ẞ` stays `ß`), which is enough here: the title and the query go through this same function.
+ */
+function casefold(text) {
+    return text.toUpperCase().toLowerCase();
+}
+/**
+ * Whether `row` passes every chosen filter. The date is the thread's last reply: `today` and
+ * `yesterday` are calendar days of the machine's own time zone, each instant read with the
+ * offset in force at that instant (a day a clock change makes 23 or 25 hours long stays one day);
+ * the others reach back from now.
+ */
+export function matches(filter, row, now) {
+    if (filter.channel && row.channelId !== filter.channel)
+        return false;
+    if (filter.status && row.status !== filter.status)
+        return false;
+    if (filter.search && !casefold(row.title).includes(casefold(filter.search)))
+        return false;
+    if (filter.date === TODAY || filter.date === YESTERDAY) {
+        const days = localDay(now.getTime() / 1000) - localDay(row.lastActivity);
+        return days === (filter.date === TODAY ? 0 : 1);
+    }
+    const reach = filter.date === null ? undefined : REACH.get(filter.date);
+    if (reach !== undefined)
+        return now.getTime() / 1000 - row.lastActivity <= reach;
+    return true;
+}
+function isObject(value) {
+    return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+/**
+ * The filter a use of a control leaves chosen, from the `view.state.values` its payload carries:
+ * every control's state rides on it, so nothing is tracked per control. Untrusted like every
+ * click, and never throwing on a shape Slack does not send: a status or a date that is not one of
+ * the page's own keeps the current one, and the channel is checked by `Home.publish`, which knows
+ * the page's own.
+ */
+export function readFilter(values, current) {
+    // Found by action id, whatever the block: the blocks' ids change with the choice.
+    const controls = new Map();
+    if (isObject(values)) {
+        for (const block of Object.values(values)) {
+            if (isObject(block))
+                for (const [id, control] of Object.entries(block))
+                    controls.set(id, control);
+        }
+    }
+    const picked = (actionId, nowChosen, known) => {
+        const control = controls.get(actionId);
+        if (!isObject(control))
+            return nowChosen;
+        const option = control.selected_option;
+        const value = isObject(option) ? option.value : undefined;
+        if (value === ALL)
+            return null;
+        if (typeof value !== "string" || (known !== null && !known.has(value)))
+            return nowChosen;
+        return value;
+    };
+    let search = current.search;
+    const box = controls.get(SEARCH_ACTION);
+    if (isObject(box)) {
+        const typed = box.value;
+        search = typeof typed === "string" ? oneLine(typed, SEARCH_LIMIT) : "";
+    }
+    return {
+        channel: picked(CHANNEL_ACTION, current.channel, null),
+        status: picked(STATUS_ACTION, current.status, WORDS),
+        date: picked(DATE_ACTION, current.date, DATES),
+        search,
+    };
+}
+/** Slack's date markup; the fallback is what a client that cannot render it shows. */
+function dateToken(epoch, token) {
+    const iso = new Date(epoch * 1000).toISOString();
+    const fallback = `${iso.slice(0, 10)} ${iso.slice(11, 16)} UTC`;
+    return `<!date^${epoch}^{${token}}|${fallback}>`;
+}
+function linkButton(text, url, actionId) {
+    return { type: "button", action_id: actionId, text: { type: "plain_text", text }, url };
+}
+/** A menu that starts on `chosen`, or on its `ALL` option when nothing is chosen. */
+function select(actionId, options, chosen) {
+    const built = options.map(([text, value]) => ({
+        text: { type: "plain_text", text },
+        value,
+    }));
+    const byValue = new Map(built.map((option) => [option.value, option]));
+    // A choice the menu does not hold (a channel Slack did not answer about) reads as "all".
+    const initial = byValue.get(chosen || ALL) ?? byValue.get(ALL);
+    return { type: "static_select", action_id: actionId, options: built, initial_option: initial };
+}
+function controlsOf(channels, chosen) {
+    // Slack keeps what a control shows for as long as its block keeps its id, whatever
+    // `initial_option` a later page carries (seen 2026-10-01: after a restart the menus still
+    // showed the choices of the run before). An id that follows the choice makes the controls
+    // show what the page was built with: a restart, Show all and a dropped channel included.
+    const choice = JSON.stringify([chosen.channel, chosen.status, chosen.date, chosen.search]);
+    const mark = createHash("sha256").update(choice).digest("hex").slice(0, 8);
+    const search = {
+        type: "plain_text_input",
+        action_id: SEARCH_ACTION,
+        placeholder: { type: "plain_text", text: slackTexts.HOME_SEARCH_HINT },
+        dispatch_action_config: { trigger_actions_on: ["on_enter_pressed"] },
+    };
+    if (chosen.search)
+        search.initial_value = chosen.search;
+    return [
+        {
+            type: "actions",
+            block_id: `${FILTERS_BLOCK}:${mark}`,
+            elements: [
+                select(CHANNEL_ACTION, [
+                    [slackTexts.HOME_ALL_CHANNELS, ALL],
+                    ...[...channels]
+                        .slice(0, CHANNEL_OPTIONS)
+                        .map(([id, name]) => [oneLine(name, OPTION_TEXT), id]),
+                ], chosen.channel),
+                select(STATUS_ACTION, [
+                    [slackTexts.HOME_ALL_STATUSES, ALL],
+                    ...[...WORDS].map(([name, word]) => [capitalize(word), name]),
+                ], chosen.status),
+                select(DATE_ACTION, [
+                    ...[...DATES].map(([key, text]) => [text, key]),
+                    [slackTexts.HOME_ANY_TIME, ALL],
+                ], chosen.date),
+            ],
+        },
+        {
+            type: "input",
+            block_id: `${SEARCH_BLOCK}:${mark}`,
+            dispatch_action: true,
+            label: { type: "plain_text", text: slackTexts.HOME_SEARCH_LABEL },
+            element: search,
+        },
+    ];
+}
+/** Python's `str.capitalize()`: the first character upper case, the rest lower case. */
+function capitalize(text) {
+    const [first = "", ...rest] = Array.from(text);
+    return first.toUpperCase() + rest.join("").toLowerCase();
+}
+function section(text) {
+    return { type: "section", text: { type: "mrkdwn", text } };
+}
+function context(text) {
+    return { ...contextBlock(text) };
+}
+function deletingLine(count, names) {
+    return count === 1
+        ? named(slackTexts.HOME_DELETING_ONE, names)
+        : texts.fill(named(slackTexts.HOME_DELETING_MANY, names), { count });
+}
+function cleaningLine(count, names) {
+    return count === 1
+        ? named(slackTexts.HOME_CLEANING_ONE, names)
+        : texts.fill(named(slackTexts.HOME_CLEANING_MANY, names), { count });
+}
+/**
+ * The line above the sessions. It carries the Edit button when threads can be deleted: a context
+ * block holds no button (context block reference), so the line is a section then.
+ */
+function header(time, editing, canEdit) {
+    const text = texts.fill(slackTexts.HOME_HEADER, { time });
+    if (!canEdit)
+        return context(text);
+    const button = {
+        type: "button",
+        action_id: EDIT_ACTION,
+        text: plainTextObject(editing ? slackTexts.HOME_DONE : slackTexts.HOME_EDIT),
+        value: editing ? EDIT_OFF : EDIT_ON,
+    };
+    if (editing)
+        button.style = "primary";
+    return { type: "section", text: { type: "mrkdwn", text }, accessory: button };
+}
+/**
+ * The update line under the header, in the phase of the update: the offer with its link and an
+ * Update button that asks through Slack's own dialog (this page shows no message that says what
+ * changes first), the two states that wait, and a failure with the button again.
+ */
+function updateLine(line) {
+    const { installed, latest, phase } = line;
+    const button = () => updateButton(HOME_UPDATE_ACTION, latest, { installed });
+    switch (phase) {
+        case "available":
+            return {
+                type: "section",
+                text: {
+                    type: "mrkdwn",
+                    text: withChangelog(texts.fill(texts.UPDATE_HOME_AVAILABLE, { latest, installed }), line.changelog),
+                },
+                accessory: button(),
+            };
+        case "installing":
+            return section(texts.fill(texts.UPDATE_INSTALLING, { latest }));
+        case "restarting":
+            return section([texts.fill(texts.UPDATE_INSTALLED, { latest }), line.note]
+                .filter((x) => x !== null)
+                .join("\n"));
+        case "failed":
+            return {
+                type: "section",
+                text: { type: "mrkdwn", text: noticeText(line.failure ?? "") },
+                accessory: button(),
+            };
+    }
+}
+/** A channel's Clean up, with a confirmation dialog that says what it deletes. */
+function cleanButton(channelId, channelName) {
+    const room = CONFIRM_TEXT - Array.from(texts.fill(slackTexts.HOME_CLEAN_TEXT, { channel: "" })).length;
+    return {
+        type: "button",
+        action_id: CLEAN_ACTION,
+        text: plainTextObject(slackTexts.HOME_CLEAN),
+        value: channelId,
+        confirm: {
+            title: plainTextObject(slackTexts.HOME_CLEAN_TITLE),
+            text: plainTextObject(texts.fill(slackTexts.HOME_CLEAN_TEXT, { channel: oneLine(channelName, room) })),
+            confirm: plainTextObject(slackTexts.HOME_CLEAN_CONFIRM),
+            deny: plainTextObject(slackTexts.HOME_DELETE_DENY),
+            style: "danger",
+        },
+    };
+}
+/**
+ * A channel's name, with how many of its threads are being deleted beside it: the rows that say
+ * so can be among those the channel does not show. Its button is New thread, and in edit mode
+ * Clean up, which gives way to a note while the channel is being cleaned.
+ */
+function channelHeader(teamId, channelId, options) {
+    const { editing, deleting = 0, name = "", canClean = false, cleaning = false } = options;
+    let text = `*<#${channelId}>*`;
+    if (cleaning)
+        text += `   ${slackTexts.HOME_CHANNEL_CLEANING}`;
+    if (deleting === 1)
+        text += `   ${slackTexts.HOME_CHANNEL_DELETING_ONE}`;
+    else if (deleting) {
+        text += `   ${texts.fill(slackTexts.HOME_CHANNEL_DELETING_MANY, { count: deleting })}`;
+    }
+    const head = { type: "section", text: { type: "mrkdwn", text } };
+    if (!editing) {
+        head.accessory = linkButton(slackTexts.HOME_NEW_THREAD, `slack://channel?team=${teamId}&id=${channelId}`, NEW_THREAD_ACTION);
+    }
+    else if (canClean && !cleaning) {
+        head.accessory = cleanButton(channelId, name);
+    }
+    return head;
+}
+function repliesOf(row) {
+    return row.replies === 1
+        ? slackTexts.HOME_REPLY
+        : texts.fill(slackTexts.HOME_REPLIES, { count: row.replies });
+}
+/**
+ * The Delete of a session's row, with Slack's own confirmation dialog, which names the thread.
+ * The dialog shows before the click is sent (confirmation dialog object reference).
+ */
+function deleteButton(row, channelName, names) {
+    const replies = repliesOf(row);
+    const naming = row.replies ? slackTexts.HOME_DELETE_NAMED : slackTexts.HOME_DELETE_NAMED_BARE;
+    const warning = named(slackTexts.HOME_DELETE_TEXT, names);
+    let room = CONFIRM_TEXT - Array.from(warning).length;
+    room -= Array.from(texts.fill(naming, { title: "", channel: channelName, replies })).length;
+    const title = oneLine(row.title, Math.max(room, 1));
+    return {
+        type: "button",
+        action_id: DELETE_ACTION,
+        style: "danger",
+        text: plainTextObject(slackTexts.HOME_DELETE),
+        value: `${row.channelId}:${row.threadTs}`,
+        confirm: {
+            title: plainTextObject(slackTexts.HOME_DELETE_TITLE),
+            text: plainTextObject(texts.fill(naming, { title, channel: channelName, replies }) + warning),
+            confirm: plainTextObject(slackTexts.HOME_DELETE_CONFIRM),
+            deny: plainTextObject(slackTexts.HOME_DELETE_DENY),
+            style: "danger",
+        },
+    };
+}
+function card(row, channelName, editing, names) {
+    const icon = row.status ? `:${row.status}:  ` : "";
+    const title = shownAsWritten(oneLine(row.title, TITLE_LIMIT));
+    const when = row.replies ? slackTexts.HOME_LAST_REPLY : slackTexts.HOME_STARTED;
+    let word = null;
+    if (row.deleting)
+        word = slackTexts.HOME_DELETING;
+    else if (row.status)
+        word = WORDS.get(row.status) ?? null;
+    const details = [
+        word,
+        row.replies ? repliesOf(row) : null,
+        texts.fill(when, { when: dateToken(row.lastActivity, "ago") }),
+        // Open is a link in the small line, not a button: a button sits at the far right of the
+        // title's row, and a row that carries one cannot be small (the maintainer, 2026-10-01).
+        // A reply's permalink carries a query (`?thread_ts=…&cid=…`), and mrkdwn reads `&` as markup.
+        `<${mrkdwnEscape(row.permalink)}|${slackTexts.HOME_OPEN}>`,
+    ];
+    const head = section(`${icon}*${title}*`);
+    if (editing && !row.deleting && !(row.status !== null && IN_USE.has(row.status))) {
+        head.accessory = deleteButton(row, channelName, names);
+    }
+    return [head, context(details.filter((d) => d).join(" · "))];
+}
+/**
+ * The Home tab's view. `rows` are newest first and `channels` maps each bound channel Slack still
+ * has to its name. Only the sessions of the chosen period are shown. With no channel, status or
+ * search chosen, every channel is a group, the ones with sessions first by their newest, each
+ * showing its `PER_CHANNEL` newest and a button to see them all (which chooses that channel);
+ * otherwise only what matches, with no such cut. Never past Slack's 100 blocks: the page says
+ * when it stops short. With `canEdit` the header line carries Edit; in `editing` each session
+ * that is not in use carries Delete and no channel carries New thread. `notices` are the lines
+ * the deletes and clean-ups that did not end left, under the header; `deleting` is how many
+ * threads are being deleted or wait for it, said in a line of full size under the header, since a
+ * row that says so can be one of those a channel does not show.
+ */
+export function homeView(rows, channels, options, names) {
+    const { teamId, chosen, now } = options;
+    const { canEdit = false, deleting = 0, canClean = false } = options;
+    const cleaning = options.cleaning ?? new Set();
+    const editing = (options.editing ?? false) && canEdit;
+    const blocks = [
+        ...controlsOf(channels, chosen),
+        header(dateToken(Math.trunc(now.getTime() / 1000), "time"), editing, canEdit),
+        ...(options.update ? [updateLine(options.update)] : []),
+        ...(deleting ? [section(deletingLine(deleting, names))] : []),
+        ...(cleaning.size > 0 ? [section(cleaningLine(cleaning.size, names))] : []),
+        ...[...(options.notices ?? [])].slice(0, NOTICES_SHOWN).map(context),
+    ];
+    if (channels.size === 0)
+        return { type: "home", blocks: [...blocks, context(slackTexts.HOME_EMPTY)] };
+    const groups = new Map();
+    const group = (channelId) => {
+        let found = groups.get(channelId);
+        if (found === undefined) {
+            found = [];
+            groups.set(channelId, found);
+        }
+        return found;
+    };
+    for (const row of rows) {
+        if (matches(chosen, row, now))
+            group(row.channelId).push(row);
+    }
+    if (chosen.channel)
+        group(chosen.channel);
+    else if (!narrowed(chosen)) {
+        for (const channelId of channels.keys())
+            group(channelId);
+    }
+    if (groups.size === 0)
+        blocks.push(context(slackTexts.HOME_NO_MATCH));
+    const withSessions = new Set(rows.map((row) => row.channelId));
+    // Counted over every session of the channel, shown or not, whatever the filters.
+    const going = new Map();
+    for (const row of rows) {
+        if (row.deleting)
+            going.set(row.channelId, (going.get(row.channelId) ?? 0) + 1);
+    }
+    const wanted = new Map([...groups].map(([id, found]) => [id, narrowed(chosen) ? found : found.slice(0, PER_CHANNEL)]));
+    let shown = 0;
+    for (const [channelId, found] of groups) {
+        const cards = wanted.get(channelId) ?? [];
+        // One block is kept for the line that says the page stops short; a group is a divider, a
+        // header, `CARD_BLOCKS` a card at most, and one closing block at most.
+        const room = Math.floor((HOME_BLOCKS - 1 - blocks.length - 3) / CARD_BLOCKS);
+        if (room < Math.min(1, cards.length) || HOME_BLOCKS - 1 - blocks.length < 3)
+            break;
+        const name = channels.get(channelId) ?? "";
+        blocks.push({ type: "divider" }, channelHeader(teamId, channelId, {
+            editing,
+            deleting: going.get(channelId) ?? 0,
+            name,
+            canClean,
+            cleaning: cleaning.has(channelId),
+        }));
+        cards.slice(0, room).forEach((row, index) => {
+            if (index)
+                blocks.push(context(SPACER));
+            blocks.push(...card(row, name, editing, names));
+        });
+        shown += Math.min(cards.length, room);
+        if (cards.length > room)
+            break;
+        if (found.length === 0) {
+            // A channel with sessions, none of them in the period or under the filters.
+            const hidden = withSessions.has(channelId);
+            blocks.push(context(hidden ? slackTexts.HOME_NO_MATCH : slackTexts.HOME_NO_SESSIONS));
+        }
+        else if (found.length > cards.length) {
+            const showAll = {
+                type: "button",
+                action_id: SHOW_ALL_ACTION,
+                text: {
+                    type: "plain_text",
+                    text: texts.fill(slackTexts.HOME_SHOW_ALL, { count: found.length }),
+                },
+                value: channelId,
+            };
+            blocks.push({ type: "actions", elements: [showAll] });
+        }
+    }
+    // Said only when a session is left out: channels with none can fall off the end unsaid.
+    let wantedCards = 0;
+    for (const cards of wanted.values())
+        wantedCards += cards.length;
+    if (shown < wantedCards)
+        blocks.push(context(texts.fill(slackTexts.HOME_MORE, { rows: shown })));
+    return { type: "home", blocks };
+}
+/** A root that `conversations.replies` did not return among its messages. */
+class RootNotReturned extends Error {
+    constructor() {
+        super("the root is not among the messages");
+        this.name = "RootNotReturned";
+    }
+}
+const keyOf = (channelId, threadTs) => `${channelId}:${threadTs}`;
+/**
+ * Publishes the owner's Home tab. `request` asks for a publish soon and returns at once (a state
+ * write calls it, naming the threads it changed); `choose` sets the filters and publishes now (a
+ * control was used); `publish` builds the page and sends it, one at a time, and never throws: the
+ * page must never break a turn. Always published to the configured owner, whoever opens the app.
+ * `not_enabled` (the Home tab is off in the Slack app's settings) is logged once and ends the
+ * publishing for this run. Any other failure is logged by its code, and a page that Slack did not
+ * fully answer for is tried again after `RETRY_SECONDS`.
+ */
+export class Home {
+    slack;
+    owner;
+    team;
+    state;
+    textNames;
+    sessionsOf;
+    deleteThread;
+    cleanChannel;
+    updateOf;
+    debounce;
+    clock;
+    // Kept in memory like the filters: a restart starts out of edit mode.
+    editing = false;
+    // The filters as they were when edit mode was entered: Done brings them back.
+    beforeEdit = null;
+    // What each delete or clean-up that did not end left to say, by the thread (`channel:thread`)
+    // or the channel it was for, the latest first: one's result never erases another's. A new try
+    // at the same one, and leaving or entering edit mode, clear it.
+    notices = new Map();
+    // Each listed thread's title, for the line that names it.
+    labels = new Map();
+    // The threads a delete was asked for and has not ended: Slack's rate limit makes one take from
+    // seconds to minutes, and the page says so from the click on.
+    deleting = new Set();
+    // The channels a clean-up is on its way for.
+    cleaning = new Set();
+    task = null;
+    // Whether the debounced loop is running: set the moment it ends, which `Task.done` is a turn
+    // of the microtask queue late in saying.
+    settling = false;
+    retry = null;
+    dirty = false;
+    off = false;
+    // Whether the page being built lacks something Slack gave no answer about.
+    incomplete = false;
+    current = homeFilter();
+    // One publish at a time, each built inside the lock: the one that lands last was built last,
+    // so a filter just chosen is never overwritten by an older page.
+    publishing = new Mutex();
+    asking = new Semaphore(THREADS_AT_ONCE);
+    // Each thread's permalink, with the `ts` of the message it opens: the thread's last reply, or
+    // its root while it has none. Asked again only once that `ts` changed. A null link: Slack no
+    // longer has that message (`GONE`).
+    links = new Map();
+    // A channel's name, asked once per run. Null: Slack no longer has the channel, or the bot left
+    // it (`GONE`): the channel and its threads are left out of the page.
+    names = new Map();
+    // What Slack showed of each thread's root. Null: the root is gone (`GONE`).
+    facts = new Map();
+    // The threads a state write changed since their root was read: read again at the next
+    // publish, which every turn causes at its start and at its end.
+    stale = new Set();
+    constructor(slack, options) {
+        this.slack = slack;
+        this.owner = options.ownerUserId;
+        this.team = options.teamId;
+        this.state = options.state;
+        this.textNames = options.names;
+        this.sessionsOf = options.sessionsOf;
+        this.deleteThread = options.delete;
+        this.cleanChannel = options.clean;
+        this.updateOf = options.update;
+        this.debounce = options.debounce ?? DEBOUNCE_SECONDS;
+        this.clock = options.clock ?? systemClock;
+    }
+    /** The filters the page is built with. */
+    get chosen() {
+        return this.current;
+    }
+    /** Ask for a publish soon; `changed` are the (channel, thread) a state write touched. */
+    request(changed = []) {
+        if (this.off)
+            return;
+        for (const ref of changed)
+            this.stale.add(keyOf(ref.channel, ref.thread));
+        this.dirty = true;
+        if (!this.settling) {
+            this.settling = true;
+            this.task = new Task((signal) => this.publishWhenSettled(signal));
+        }
+    }
+    async publishWhenSettled(signal) {
+        try {
+            while (this.dirty && !this.off) {
+                await this.clock.sleep(this.debounce, signal);
+                this.dirty = false;
+                await this.publish(signal);
+            }
+        }
+        finally {
+            this.settling = false;
+        }
+    }
+    async requestLater(signal) {
+        await this.clock.sleep(RETRY_SECONDS, signal);
+        this.request();
+    }
+    /**
+     * Set the filters and publish at once. A channel that is not one of the page's own (not bound,
+     * or gone from Slack) is no filter: `publish` drops it.
+     */
+    async choose(chosen) {
+        this.current = chosen;
+        await this.publish();
+    }
+    /**
+     * Enter or leave edit mode and publish at once. Edit mode is a parenthesis: a filter chosen
+     * inside it (Show all on the channel being cleaned, most often) lasts while it does, and
+     * leaving it brings back the filters the page had on entering.
+     */
+    async edit(on) {
+        const wanted = on && this.deleteThread !== undefined;
+        if (wanted && !this.editing) {
+            this.beforeEdit = this.current;
+        }
+        else if (!wanted && this.editing && this.beforeEdit !== null) {
+            this.current = this.beforeEdit;
+            this.beforeEdit = null;
+        }
+        this.editing = wanted;
+        this.notices.clear();
+        await this.publish();
+    }
+    /**
+     * Delete a thread the page lists. Publishes at once with the row marked as being deleted, then
+     * again when the delete ended: without the row, or with the line that says why it is still
+     * there. A second click on the same thread while it runs does nothing. The page stays in edit
+     * mode.
+     */
+    async delete(channelId, threadTs) {
+        const key = keyOf(channelId, threadTs);
+        if (this.deleteThread === undefined || !this.editing || this.deleting.has(key))
+            return;
+        this.deleting.add(key);
+        this.notices.delete(key);
+        await this.publish();
+        let notice;
+        try {
+            notice = await this.deleteThread(channelId, threadTs);
+        }
+        finally {
+            this.deleting.delete(key);
+        }
+        if (notice) {
+            const label = this.labels.get(key);
+            this.say(key, label ? `“${label}”: ${notice}` : notice);
+        }
+        // A delete that stopped half way changed the thread: its root is read again.
+        this.stale.add(key);
+        await this.publish();
+    }
+    /** Keep a notice under `name`, ahead of the ones already kept. */
+    say(name, notice) {
+        this.notices = new Map([
+            [name, notice],
+            ...[...this.notices].filter(([kept]) => kept !== name),
+        ]);
+    }
+    /**
+     * Clean up a bound channel, as `delete` deletes a thread: the page says so at once, and again
+     * when it ended; a second click while it runs does nothing.
+     */
+    async clean(channelId) {
+        if (this.cleanChannel === undefined || !this.editing || this.cleaning.has(channelId))
+            return;
+        if (!this.state.channels().includes(channelId))
+            return; // the value of a click is untrusted
+        this.cleaning.add(channelId);
+        this.notices.delete(channelId);
+        await this.publish();
+        let notice;
+        try {
+            notice = await this.cleanChannel(channelId);
+        }
+        finally {
+            this.cleaning.delete(channelId);
+        }
+        if (notice) {
+            const label = this.names.get(channelId);
+            this.say(channelId, label ? `#${label}: ${notice}` : notice);
+        }
+        await this.publish();
+    }
+    /**
+     * Publish what a pending request still owed, then stop: the page a stop leaves behind shows the
+     * sessions as the stop left them. Gives up after `CLOSE_SECONDS`.
+     */
+    async close() {
+        const [task, retry] = [this.task, this.retry];
+        this.task = null;
+        this.retry = null;
+        // Waiting out its debounce or cut in the middle of a publish: owed either way.
+        const owed = this.dirty || this.settling;
+        for (const pending of [task, retry]) {
+            if (pending !== null) {
+                pending.cancel();
+                await pending.settled();
+            }
+        }
+        if (owed) {
+            const limit = new AbortController();
+            const publishing = this.publish(limit.signal).catch(() => undefined);
+            const expired = this.clock.sleep(CLOSE_SECONDS, limit.signal).catch(() => undefined);
+            // A Slack that does not answer is not waited for: the publish is told to stop and the
+            // daemon goes on, since a stop never hangs on the page.
+            await Promise.race([publishing, expired]);
+            limit.abort(new Cancelled());
+        }
+        this.off = true;
+    }
+    /** Build the page and send it. Never throws, unless `signal` aborted it. */
+    async publish(signal) {
+        if (this.off)
+            return;
+        const release = await this.publishing.acquire(signal);
+        try {
+            this.incomplete = false;
+            try {
+                await this.publishPage(signal);
+            }
+            catch (error) {
+                if (signal?.aborted)
+                    throw signal.reason;
+                const code = describe(error);
+                if (code === NOT_ENABLED) {
+                    this.off = true;
+                    logger.warning(`the Home tab is not enabled in the Slack app (see ${setupGuide(slackTexts.SETUP_SLACK_APP)}): ` +
+                        "the session index is not published this run");
+                    return;
+                }
+                logger.warning(`could not publish the session index: ${code}`);
+                this.incomplete = true;
+            }
+            if (this.incomplete && (this.retry === null || this.retry.done)) {
+                this.retry = new Task((retrySignal) => this.requestLater(retrySignal));
+            }
+        }
+        finally {
+            release();
+        }
+    }
+    async publishPage(signal) {
+        const bound = this.state.channels();
+        const channels = await this.channelsOf(bound, signal);
+        if (bound.length > 0 && channels.size === 0 && this.incomplete) {
+            return; // Slack answered about no channel: the page stays as it is until it does
+        }
+        const rows = await this.rowsOf(channels, signal);
+        // Untrusted when it came from a click, and a chosen channel can go away. One Slack merely
+        // did not answer about is still the owner's choice.
+        const chosen = this.current.channel;
+        if (chosen && (!bound.includes(chosen) || this.names.get(chosen) === null)) {
+            this.current = { ...this.current, channel: null };
+        }
+        const view = homeView(rows, channels, {
+            teamId: this.team,
+            chosen: this.current,
+            now: new Date(this.clock.time() * 1000),
+            canEdit: this.deleteThread !== undefined,
+            editing: this.editing,
+            notices: [...this.notices.values()],
+            deleting: this.deleting.size,
+            canClean: this.cleanChannel !== undefined,
+            cleaning: new Set(this.cleaning),
+            update: this.updateOf?.() ?? null,
+        }, this.textNames());
+        signal?.throwIfAborted();
+        // `@slack/types` declares this shape as `HomeView`.
+        await this.slack.views.publish({
+            user_id: this.owner,
+            view: view,
+        });
+    }
+    /** Every bound channel Slack still has, with its name, in the order they were bound. */
+    async channelsOf(bound, signal) {
+        const found = new Map();
+        // A channel forgotten and bound again later is asked about again.
+        for (const unbound of [...this.names.keys()]) {
+            if (!bound.includes(unbound))
+                this.names.delete(unbound);
+        }
+        for (const channelId of bound) {
+            signal?.throwIfAborted();
+            if (!this.names.has(channelId)) {
+                try {
+                    const info = await this.slack.conversations.info({ channel: channelId });
+                    const name = info.channel?.name;
+                    if (name === undefined)
+                        throw new TypeError("the channel has no name");
+                    this.names.set(channelId, String(name));
+                }
+                catch (error) {
+                    logger.warning(`could not read channel ${channelId}: ${describe(error)}`);
+                    if (!gone(error)) {
+                        this.incomplete = true;
+                        continue;
+                    }
+                    this.names.set(channelId, null);
+                }
+            }
+            const name = this.names.get(channelId);
+            if (name !== null && name !== undefined)
+                found.set(channelId, name);
+        }
+        return found;
+    }
+    /**
+     * One row per thread that holds a session in one of `channels` and that Slack still has (a
+     * thread whose root is gone cannot be opened: it is left out), last reply first.
+     */
+    async rowsOf(channels, signal) {
+        const threads = this.state.threads();
+        // What is kept per thread goes with the thread: a pruned one leaves nothing behind.
+        const existing = new Set(threads.map(([channelId, threadTs]) => keyOf(channelId, threadTs)));
+        for (const key of [...this.stale])
+            if (!existing.has(key))
+                this.stale.delete(key);
+        for (const cache of [this.links, this.facts]) {
+            for (const key of [...cache.keys()])
+                if (!existing.has(key))
+                    cache.delete(key);
+        }
+        const held = threads.filter(([channelId, , thread]) => thread.sessionId !== null && channels.has(channelId));
+        const titles = await this.titlesOf(new Set(held.map(([, , thread]) => thread.directory)));
+        const seen = await Promise.all(held.map(([channelId, threadTs]) => this.inSlack(channelId, threadTs, signal)));
+        const rows = [];
+        held.forEach(([channelId, threadTs, thread], index) => {
+            const [link, facts] = seen[index];
+            if (link === null || facts === null)
+                return;
+            const sessionId = String(thread.sessionId);
+            rows.push({
+                channelId,
+                threadTs,
+                title: titles.get(sessionId) ||
+                    texts.fill(slackTexts.HOME_UNTITLED, { id: take(sessionId, ID_SHOWN) }),
+                // ❌ over a kept ⏳ or ✋ (an answer that never reached Slack) shows ❌. A thread that
+                // ended before the daemon kept its status shows the root's reaction.
+                status: reactionOf(thread.ended) ?? reactionOf(thread.status) ?? facts.reaction,
+                replies: facts.replies,
+                lastActivity: facts.latestReply || Math.trunc(pyFloat(threadTs)),
+                permalink: link,
+                deleting: this.deleting.has(keyOf(channelId, threadTs)),
+            });
+        });
+        rows.sort((a, b) => b.lastActivity - a.lastActivity);
+        this.labels = new Map(rows.map((row) => [
+            keyOf(row.channelId, row.threadTs),
+            shownAsWritten(oneLine(row.title, TITLE_LIMIT)),
+        ]));
+        return rows;
+    }
+    /**
+     * The title Claude Code gives each session of `directories`, by session id. A folder that
+     * cannot be listed is logged and skipped: its sessions show their id.
+     */
+    async titlesOf(directories) {
+        const found = new Map();
+        for (const directory of directories) {
+            try {
+                const listed = await this.sessionsOf(directory);
+                for (const session of listed)
+                    found.set(session.id, session.title);
+            }
+            catch (error) {
+                logger.warning(`could not list a folder's sessions for the session index: ${describe(error)}`);
+            }
+        }
+        return found;
+    }
+    /**
+     * A thread's permalink and what Slack shows of its root; either is null for a thread the page
+     * leaves out.
+     */
+    async inSlack(channelId, threadTs, signal) {
+        const release = await this.asking.acquire();
+        try {
+            signal?.throwIfAborted();
+            const facts = await this.root(channelId, threadTs);
+            if (facts === null)
+                return [null, null];
+            signal?.throwIfAborted();
+            return [await this.permalink(channelId, threadTs, facts.latestTs ?? threadTs), facts];
+        }
+        finally {
+            release();
+        }
+    }
+    async root(channelId, threadTs) {
+        const key = keyOf(channelId, threadTs);
+        if (this.facts.has(key) && !this.stale.has(key))
+            return this.facts.get(key) ?? null;
+        let facts;
+        try {
+            const answer = await this.slack.conversations.replies({
+                channel: channelId,
+                ts: threadTs,
+                limit: 1,
+            });
+            const messages = Array.isArray(answer.messages) ? answer.messages : [];
+            const root = messages.find((m) => isObject(m) && String(m.ts) === threadTs);
+            if (!isObject(root))
+                throw new RootNotReturned();
+            facts = threadFacts(root);
+        }
+        catch (error) {
+            // A root Slack returns in a shape this cannot read counts as no answer too.
+            logger.warning(`could not read thread ${channelId}/${threadTs}: ${describe(error)}`);
+            if (gone(error)) {
+                this.stale.delete(key);
+                this.facts.set(key, null);
+                return null;
+            }
+            // No answer: what was read before stands, and the thread is asked about again.
+            this.incomplete = true;
+            return this.facts.get(key) ?? null;
+        }
+        this.stale.delete(key);
+        this.facts.set(key, facts);
+        return facts;
+    }
+    /**
+     * The permalink that opens the thread on `messageTs`: Slack scrolls a thread to the reply its
+     * permalink names (seen in the Mac app and on iOS, 2026-10-05).
+     */
+    async permalink(channelId, threadTs, messageTs) {
+        const key = keyOf(channelId, threadTs);
+        const kept = this.links.get(key);
+        if (kept !== undefined && kept[0] === messageTs)
+            return kept[1];
+        let link = null;
+        try {
+            const answer = await this.slack.chat.getPermalink({
+                channel: channelId,
+                message_ts: messageTs,
+            });
+            if (answer.permalink === undefined)
+                throw new TypeError("no permalink");
+            link = String(answer.permalink);
+        }
+        catch (error) {
+            logger.warning(`could not get a permalink for ${channelId}/${messageTs}: ${describe(error)}`);
+            if (!gone(error)) {
+                this.incomplete = true;
+                return null;
+            }
+        }
+        this.links.set(key, [messageTs, link]);
+        return link;
+    }
+}