allaboard 0.5.0 → 0.6.0

package/README.md

@@ -14,18 +14,20 @@ Claude Code keeps running on each Mac, with its own files and its own setup.
 npm install -g allaboard
 ```
 
-The [setup guide](https://github.com/duqaXxX/allaboard/blob/v0.5.0/docs/setup.md) says which
+The [setup guide](https://github.com/duqaXxX/allaboard/blob/v0.6.0/docs/setup.md) says which
 systems this version supports, and takes you through
-[creating the Slack app](https://github.com/duqaXxX/allaboard/blob/v0.5.0/docs/setup.md#part-1-the-slack-app)
-from [`slack-app-manifest.json`](https://github.com/duqaXxX/allaboard/blob/v0.5.0/slack-app-manifest.json),
-the settings, and the service that starts allaboard at login:
+[creating the Slack app](https://github.com/duqaXxX/allaboard/blob/v0.6.0/docs/setup.md#part-1-the-slack-app)
+from [`slack-app-manifest.json`](https://github.com/duqaXxX/allaboard/blob/v0.6.0/slack-app-manifest.json),
+the settings, and the service that starts allaboard at login. `allaboard setup` asks for the
+tokens, checks each with Slack, writes the configuration and offers to install the service
+(`allaboard service install` does that later):
 
 ```sh
-allaboard service install
+allaboard setup
 ```
 
 To bring another Mac or another Claude Code account into the same Slack, see
-[the guide's Part 6](https://github.com/duqaXxX/allaboard/blob/v0.5.0/docs/setup.md#part-6-a-second-instance).
+[the guide's Part 6](https://github.com/duqaXxX/allaboard/blob/v0.6.0/docs/setup.md#part-6-a-second-instance).
 
 ## Update
 
@@ -40,5 +42,5 @@ allaboard update
 ## More
 
 - Documentation and source: [github.com/duqaXxX/allaboard](https://github.com/duqaXxX/allaboard)
-- Security model: [SECURITY.md](https://github.com/duqaXxX/allaboard/blob/v0.5.0/SECURITY.md)
+- Security model: [SECURITY.md](https://github.com/duqaXxX/allaboard/blob/v0.6.0/SECURITY.md)
 - License: MIT

package/dist/agent/claude/backend.js

@@ -4,18 +4,53 @@
  * session's start is the core's (`folderTrusted` is its question to ask), not this class's.
  */
 import { homedir } from "node:os";
+import { getSessionInfo as sdkGetSessionInfo, tagSession as sdkTagSession, } from "@anthropic-ai/claude-agent-sdk";
 import { shellQuote } from "../../text.js";
 import { CAPABILITIES } from "./capabilities.js";
 import { chromeEnabled } from "./chrome.js";
 import { aliveSessions, byLastActivity, directorySessions, projectsDir } from "./listing.js";
 import { ClaudeSession } from "./session.js";
-import { trustedRepository, workspaceTrusted } from "./trust.js";
+import { trustedRepository, untrustedRepository, workspaceTrusted } from "./trust.js";
 import { UsageProbe } from "./usage-probe.js";
 export const NAME = "Claude Code";
 /** The shell line that forks a session in a terminal; `environment` is what precedes `claude`. */
 function terminalWith(environment) {
     return `cd {directory} && ${environment}claude --resume {session} --fork-session`;
 }
+/**
+ * The shell line that opens Claude Code in a folder, whose trust dialog records the folder for
+ * the login `environment` names (`CLAUDE_CONFIG_DIR`): another login's record does not count.
+ */
+function trustWith(environment) {
+    return `cd {directory} && ${environment}claude`;
+}
+// The commands `docs/limits.md` lists as not offered, which a session of the SDK refuses with
+// `/<name> isn't available in this environment.` (measured on Claude Code 2.1.292 on 2026-10-09
+// and 2.1.303 on 2026-10-20; claim P23 sends each to every release). `test/docs.test.ts` holds
+// the two lists to the same names. What follows a name is what the page says to do instead.
+const SETTINGS_APPLY = "The settings you made in the terminal apply: change them there.";
+const BOUND_FOLDER = "A thread works in the folder its channel was bound to.";
+const NOT_OFFERED = Object.freeze({
+    rewind: null,
+    plan: null,
+    branch: null,
+    fork: null,
+    subtask: null,
+    btw: null,
+    background: null,
+    cd: BOUND_FOLDER,
+    "add-dir": BOUND_FOLDER,
+    diff: "Ask Claude for the diff.",
+    export: "Copy the reply from its thread.",
+    copy: "Copy the reply from its thread.",
+    permissions: SETTINGS_APPLY,
+    memory: SETTINGS_APPLY,
+    hooks: SETTINGS_APPLY,
+    skills: SETTINGS_APPLY,
+    tasks: SETTINGS_APPLY,
+    sandbox: SETTINGS_APPLY,
+    voice: "Send an audio clip instead.",
+});
 export const WORDS = Object.freeze({
     author: "Claude",
     command: "claude",
@@ -27,6 +62,8 @@ export const WORDS = Object.freeze({
     login: "login",
     logout: "logout",
     terminal: terminalWith(""),
+    trust: trustWith(""),
+    notOffered: NOT_OFFERED,
 });
 /**
  * `WORDS` for a back end whose sessions use the login in `configDir`: the line that continues a
@@ -38,7 +75,12 @@ function wordsFor(configDir) {
     if (configDir === undefined)
         return WORDS;
     const folder = shellQuote(configDir).replaceAll("{", `'"{"'`);
-    return Object.freeze({ ...WORDS, terminal: terminalWith(`CLAUDE_CONFIG_DIR=${folder} `) });
+    const environment = `CLAUDE_CONFIG_DIR=${folder} `;
+    return Object.freeze({
+        ...WORDS,
+        terminal: terminalWith(environment),
+        trust: trustWith(environment),
+    });
 }
 export class ClaudeBackend {
     name = NAME;
@@ -113,10 +155,39 @@ export class ClaudeBackend {
     trustedRepository(folder) {
         return trustedRepository(folder, this.#home, this.#configDir);
     }
+    untrustedRepository(folder) {
+        return untrustedRepository(folder, this.#home, this.#configDir);
+    }
     /** The limits `/usage` reports now, read by a session of the back end's own. */
     usageLimits() {
         return this.#probe.read();
     }
+    /**
+     * Sets or clears (`tag` null) the tag of a session of `folder`, in its transcript: the SDK
+     * appends a `tag` entry, an empty one to clear, and the last entry wins. Like the SDK's
+     * listing it finds the transcript through `CLAUDE_CONFIG_DIR` in the daemon's environment,
+     * which `module.claudeAgent` writes from the same folder it gives this back end as `configDir`
+     * (an instance with a login of its own); with none set, the SDK uses the default login's.
+     * Measured on 2026-10-19 (SDK 0.3.302, CLI 2.1.302): setting, clearing and changing the tag
+     * of a session whose query is alive holds through later turns and the close; the tag reaches
+     * none of the 8 request bodies captured, so the model never sees it; the terminal's
+     * `/resume` picker prints it as `#name`.
+     */
+    tagSession(folder, session, tag) {
+        return sdkTagSession(session, tag, { dir: folder });
+    }
+    /**
+     * The title Claude Code shows for a session of `folder`: `customTitle`, which holds the one
+     * Claude Code generated and the owner's `/rename` alike (the declaration says "/rename only";
+     * measured on 2026-10-20, SDK 0.3.302, CLI 2.1.302: a generated title is there at the `result`
+     * of the turn that wrote it, usually the first, sometimes the third or later). `summary` is not
+     * read: it falls back to the first prompt while there is no title. Reads the session's file
+     * through `getSessionInfo` alone, since it runs after every turn.
+     */
+    async sessionTitle(folder, session) {
+        const info = await sdkGetSessionInfo(session, { dir: folder });
+        return info?.customTitle?.trim() || null;
+    }
     /** Stops the usage probe: its session is closed and no read starts another. */
     close() {
         return this.#probe.stop();

package/dist/agent/claude/capabilities.js

@@ -27,4 +27,8 @@ export const CAPABILITIES = Object.freeze({
     promptDuringTurn: true,
     sessionListing: true,
     folderTrust: true,
+    // The SDK's `tagSession`.
+    sessionTags: true,
+    // The SDK's `getSessionInfo`.
+    sessionTitles: true,
 });

package/dist/agent/claude/module.js

@@ -12,6 +12,15 @@ import { ClaudeBackend } from "./backend.js";
 // Claude Code account (environment variables page, "useful for running multiple accounts side by
 // side", read 2026-10-17); it is handled below, since the daemon reads the folder too.
 export const VARIABLES = ["BASH_DEFAULT_TIMEOUT_MS", "CLAUDE_CONFIG_DIR"];
+const MS_PER_HOUR = 3_600_000;
+const DEFAULT_TIMEOUT_HOURS = 4;
+// The largest delay a Node timer takes (2^31 - 1 ms); Claude Code's own limit on the variable.
+const MAX_TIMER_MS = 2_147_483_647;
+// The shortest timeout the wizard takes: 1 minute, stated as 0.02 hours (72000 ms).
+const MIN_TIMEOUT_MS = 60_000;
+const MIN_TIMEOUT_HOURS = 0.02;
+// One decimal below the cap (596.5 hours is 2147400000 ms), so the stated bound is accepted.
+const MAX_TIMEOUT_HOURS = 596.5;
 /**
  * The declared variables the owner's file sets, each read by its name: the daemon hands a module
  * its variables readable by lookup and shown by nothing, so a spread of them copies none.
@@ -48,6 +57,50 @@ function configDirOf(written, home) {
     }
     return expanded;
 }
+/**
+ * The two questions of `allaboard setup`: the timeout, which Enter sets to 4 hours, and the folder, which Enter skips. The folder is not
+ * required to exist: a second login creates it. The same rule the daemon applies at build.
+ */
+export function claudeSetup(home) {
+    return {
+        intro: [],
+        questions: [
+            {
+                variable: "BASH_DEFAULT_TIMEOUT_MS",
+                message: `Bash command timeout in hours (BASH_DEFAULT_TIMEOUT_MS, Enter for ${DEFAULT_TIMEOUT_HOURS}):`,
+                secret: false,
+                optional: false,
+                default: String(DEFAULT_TIMEOUT_HOURS),
+                check: async (answer) => {
+                    const hours = /^\d+(\.\d+)?$/.test(answer) ? Number(answer) : Number.NaN;
+                    const ms = Math.round(hours * MS_PER_HOUR);
+                    return ms >= MIN_TIMEOUT_MS && ms <= MAX_TIMER_MS
+                        ? { value: String(ms), note: `${ms} ms` }
+                        : {
+                            refusal: `A timeout is a number of hours from ${MIN_TIMEOUT_HOURS} to ${MAX_TIMEOUT_HOURS}, such as 0.5 or 4.`,
+                        };
+                },
+            },
+            {
+                variable: "CLAUDE_CONFIG_DIR",
+                message: "Claude Code configuration folder (CLAUDE_CONFIG_DIR, optional, Enter for ~/.claude):",
+                secret: false,
+                optional: true,
+                check: async (answer) => {
+                    try {
+                        configDirOf(answer, home);
+                        return {};
+                    }
+                    catch (error) {
+                        if (error instanceof AgentConfigError)
+                            return { refusal: error.message };
+                        throw error;
+                    }
+                },
+            },
+        ],
+    };
+}
 /**
  * The entry that builds the Claude back end. `options` are what a test replaces: the SDK's
  * query, the owner's home, the usage probe's start.
@@ -56,6 +109,8 @@ export function claudeAgent(options = {}) {
     return {
         required: [],
         optional: VARIABLES,
+        executable: "claude",
+        setup: () => claudeSetup(options.home ?? homedir()),
         build: (context) => {
             const variables = set(context.variables);
             const configDir = configDirOf(variables.CLAUDE_CONFIG_DIR, options.home ?? homedir());

package/dist/agent/claude/translate.js

@@ -416,7 +416,11 @@ function taskNotification(memory, record) {
         return [];
     const usage = isRecord(record.usage) ? record.usage : {};
     // The replay of a folded notification names the run, which the task's start recorded: a task
-    // whose run this process never saw cannot be named (`SDKTaskStartedMessage.run_id`).
+    // whose run this process never saw cannot be named (`SDKTaskStartedMessage.run_id`). Nor can a
+    // stopped one, which gets no notification of its own (`SDKMessageOrigin.runId`): a Monitor
+    // past its deadline reaches the turn as one of its lines, with no run (recorded 2026-10-20,
+    // `monitor-expired-in-turn`, issue #392), and no stopped task of the other recordings
+    // (`interrupt`, `stop-close-resume`, `background-forms`) has its end replayed with its run.
     const runId = string(record.run_id);
     return [
         {
@@ -426,7 +430,7 @@ function taskNotification(memory, record) {
             summary,
             durationMs: number(usage.duration_ms),
             callId: words(record.tool_use_id),
-            foldNamed: runId !== null && memory.runs.has(runId),
+            foldNamed: reported !== "stopped" && runId !== null && memory.runs.has(runId),
         },
     ];
 }

package/dist/agent/claude/trust.js

@@ -539,6 +539,28 @@ export async function trustedRepository(directory, home = homedir(), configDir)
     }
     return (await isTrusted(repository.key, home, configDir)) ? repository : null;
 }
+/**
+ * The repository holding `directory` when the owner has not trusted its key in Claude Code: the
+ * one `trustedRepository` refuses for that alone. Null with no repository, with a trusted one,
+ * and where the layout has no key, since no trust the dialog gives would cover that. Nothing
+ * here runs git.
+ */
+export async function untrustedRepository(directory, home = homedir(), configDir) {
+    let repository;
+    try {
+        repository = await locate(directory);
+    }
+    catch (error) {
+        if (error instanceof Unkeyed) {
+            return null;
+        }
+        throw error;
+    }
+    if (repository === null) {
+        return null;
+    }
+    return (await isTrusted(repository.key, home, configDir)) ? null : repository;
+}
 /**
  * Whether the owner trusted `directory` in Claude Code, as the terminal would decide; false where
  * git would find a repository that no trusted path stands for.

package/dist/chat/seam.js

@@ -3,8 +3,11 @@
  * (`channel_not_found`), or the error's own name: all a log line may say of it, never content.
  */
 export class ChatError extends Error {
+    /** The chat will refuse the same call again, whenever it is made: retrying cannot help. */
+    permanent;
     constructor(code, options) {
         super(code, options);
         this.name = code;
+        this.permanent = options?.permanent === true;
     }
 }

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

@@ -40,8 +40,9 @@ import { monotonicClock } from "../../../clock.js";
 import { Listings } from "../../../core/port.js";
 import { download } from "../attachments.js";
 import { BIND_ACTION } from "../bind.js";
+import { DELETE_THREAD_CANCEL, DELETE_THREAD_CONFIRM } from "../delete-thread.js";
 import { HOLD_CANCEL, HOLD_CONTINUE } from "../hold.js";
-import { CLEAN_ACTION, DELETE_ACTION, EDIT_ACTION, FILTER_ACTIONS, HOME_UPDATE_ACTION, NEW_THREAD_ACTION, SHOW_ALL_ACTION, } from "../home.js";
+import { CLEAN_ACTION, DELETE_ACTION, EDIT_ACTION, FILTER_ACTIONS, HOME_UPDATE_ACTION, NEW_THREAD_ACTION, REFRESH_ACTION, SHOW_ALL_ACTION, } from "../home.js";
 import { OPEN_BUTTON_ACTION, OPEN_FORM, QUERY_ACTION } from "../openfile/modal.js";
 import { levelLogger } from "../quiet-logger.js";
 import { REQUEST_TIMEOUT_MS } from "../reply/clients.js";
@@ -53,7 +54,8 @@ import { UPDATE_ACTION } from "../update.js";
 import * as voice from "../voice.js";
 import { Answers, logger } from "./answers.js";
 import { Clips } from "./clip.js";
-import { isPromptMessage, isWrittenMessage, messageActor, } from "./guards.js";
+import { DeleteThread } from "./delete-thread.js";
+import { deletedAuthor, deletedTs, isPromptMessage, isTombstoneRemoval, isWrittenMessage, messageActor, } from "./guards.js";
 import { HomeControls } from "./home-controls.js";
 import { filesOf, inboundMessage } from "./messages.js";
 import { Open } from "./open.js";
@@ -123,6 +125,7 @@ export function buildApp(options) {
         inbound: options.inbound,
         uploads: options.uploads,
         home: options.home,
+        ...(options.deleteThread !== undefined && { deleteThread: options.deleteThread }),
         limiter: chat.limiter,
         fetch: options.fetch ??
             (({ url, mimetype, limit }) => download(url, config.botToken, mimetype, limit)),
@@ -137,6 +140,7 @@ export function buildApp(options) {
     const resumeBind = new ResumeBind(parts, answers);
     const clips = new Clips(parts, answers);
     const home = new HomeControls(parts);
+    const deleteThread = new DeleteThread(parts, answers);
     const app = new App({
         receiver: options.receiver,
         // auth.test already ran at startup; who may act is decided by the guards of each listener.
@@ -198,8 +202,48 @@ export function buildApp(options) {
         }
         await handed;
     });
+    // A first message the owner deleted by hand. Its own listener: the guard above stays closed to
+    // every subtype but a person's message. Three checks, on this path's own: the envelope names the
+    // owner's workspace, its ts is a thread the daemon keeps, and the deleted message was the owner's
+    // (`previous_message.user`). No field of either event names who DELETED the message, so the last
+    // check proves whose message went, not who removed it. This may be revisited.
+    app.event("message", async ({ event, body }) => {
+        const message = event;
+        const deleted = deletedTs(message);
+        if (deleted === null)
+            return;
+        const channel = text(message.channel);
+        if (answers.stopped || channel === null)
+            return;
+        if (text(body.team_id) !== identity.teamId) {
+            logger.info("ignored a deleted message from another workspace");
+            return;
+        }
+        // The kept thread first: a deletion of the daemon's own message, or the removal of a tombstone,
+        // is no kept root and is dropped without a word.
+        if (parts.state.thread(channel, deleted) === null)
+            return;
+        // Silently: the tombstone's own removal, which the earlier event already acted on.
+        if (isTombstoneRemoval(message))
+            return;
+        if (deletedAuthor(message) !== identity.ownerUserId) {
+            logger.info(`ignored the deletion of the first message of ${channel}/${deleted}: not the owner's`);
+            return;
+        }
+        const ref = { channel, thread: deleted };
+        try {
+            await parts.inbound.rootGone(ref);
+        }
+        catch (error) {
+            logger.warning(`could not forget ${channel}/${deleted}: ${describe(error)}`);
+        }
+        // Forgetting the entry already asked the index (`onSessionsChange`); one left stands for a
+        // turn that runs, or for a call that failed, and the index reads its row again.
+        if (parts.state.thread(channel, deleted) !== null)
+            parts.chat.index?.refresh([ref]);
+    });
     app.event("file_change", ({ event }) => clips.onFileChange(event));
-    registered.push({ kind: "event", id: "message", acknowledgeOnly: false }, { kind: "event", id: "file_change", acknowledgeOnly: false });
+    registered.push({ kind: "event", id: "message", acknowledgeOnly: false }, { kind: "event", id: "message deleted", acknowledgeOnly: false }, { kind: "event", id: "file_change", acknowledgeOnly: false });
     /** A click or a select: the listener acknowledges, then checks, on its own. */
     const action = (actionId, listener, options = {}) => {
         registered.push({
@@ -207,7 +251,7 @@ export function buildApp(options) {
             id: String(actionId),
             acknowledgeOnly: options.acknowledgeOnly ?? false,
         });
-        app.action(actionId, ({ ack, body }) => listener(() => ack(), body));
+        app.action(actionId, ({ ack, body, respond }) => listener(() => ack(), body, respond));
     };
     /** A modal's submit: what the listener answers is what the modal does next. */
     const view = (callbackId, listener) => {
@@ -234,6 +278,8 @@ export function buildApp(options) {
     action(OPEN_BUTTON_ACTION, open.onOpenChoose);
     action(QUERY_ACTION, open.onOpenQuery);
     view(OPEN_FORM, open.onOpenSubmit);
+    action(DELETE_THREAD_CONFIRM, deleteThread.onConfirm);
+    action(DELETE_THREAD_CANCEL, deleteThread.onCancel);
     action(BIND_ACTION, resumeBind.onBind);
     action(RESUME_ACTION, resumeBind.onResume);
     action(UPDATE_ACTION, resumeBind.onUpdate);
@@ -242,6 +288,7 @@ export function buildApp(options) {
         action(actionId, home.onHomeFilter);
     action(SHOW_ALL_ACTION, home.onHomeShowAll);
     action(EDIT_ACTION, home.onHomeEdit);
+    action(REFRESH_ACTION, home.onHomeRefresh);
     action(DELETE_ACTION, home.onHomeDelete);
     action(CLEAN_ACTION, home.onHomeClean);
     action(HOME_UPDATE_ACTION, home.onHomeUpdate);
@@ -258,5 +305,6 @@ export function buildApp(options) {
             clips.close();
         },
         openFile: (channel, threadTs, folder, words) => open.openWord(channel, threadTs, folder, words),
+        askDelete: (channel, threadTs) => deleteThread.ask(channel, threadTs),
     };
 }

package/dist/chat/slack/app/delete-thread.js

@@ -0,0 +1,90 @@
+/**
+ * `!delete-thread` as the Slack provider hears it: a question only the owner sees, under their
+ * word in the thread, with Delete thread and Cancel. The thread is deleted by the Home tab's own
+ * deleter (`ThreadDeleter.delete`), so both ways share one path and one rule.
+ *
+ * The question is ephemeral: nothing of it is left to delete or to store. A click on it carries
+ * `response_url` and `container.is_ephemeral`, and no `message` (measured 2026-10-19 on bolt
+ * 5.1.0), so the thread is read from the container (`clickThread`). Either button takes the
+ * question away with `respond({ delete_original: true })`: `chat.update` cannot edit an
+ * ephemeral message (chat.update reference, read 2026-10-19), and a question rewritten instead
+ * stays in the channel's view once its thread is gone, until a reload (measured 2026-10-19).
+ */
+import { fill, named, texts } from "../../../core/port.js";
+import { deleteThreadBlocks } from "../delete-thread.js";
+import { describe } from "../reply/errors.js";
+import * as slackTexts from "../texts.js";
+import { logger } from "./answers.js";
+import { interactionActor } from "./guards.js";
+import { clickThread, record, text } from "./wire.js";
+/** The line, under the owner's word, for a delete that left the thread. */
+function deleteLine(refusal, names) {
+    switch (refusal.reason) {
+        case "busy":
+            return texts.DELETE_THREAD_BUSY;
+        case "refused":
+            return fill(named(slackTexts.THREAD_DELETE_REFUSED, names), { count: refusal.count });
+        case "failed":
+            return fill(slackTexts.THREAD_DELETE_FAILED, { error: refusal.error });
+    }
+}
+export class DeleteThread {
+    parts;
+    answers;
+    constructor(parts, answers) {
+        this.parts = parts;
+        this.answers = answers;
+    }
+    /** Shows the owner alone the question, in the thread; resolves once it is posted. */
+    async ask(channel, threadTs) {
+        await this.answers.deliver(channel, threadTs, slackTexts.HOME_DELETE_TITLE, deleteThreadBlocks(this.parts.names), { ephemeral: true });
+    }
+    /** Delete thread: the question goes, then the thread; a delete that stopped says why. */
+    onConfirm = async (ack, body, respond) => {
+        const where = await this.admitted(ack, body);
+        if (where === null)
+            return;
+        const [channel, threadTs] = where;
+        const { deleteThread, chat, names } = this.parts;
+        if (deleteThread === undefined) {
+            // A question left from a run that had the owner's token: it stays, and says why.
+            await this.answers.tellOwner(channel, threadTs, named(texts.DELETE_THREAD_UNAVAILABLE, names));
+            return;
+        }
+        await this.withdraw(respond);
+        const refusal = await deleteThread(channel, threadTs);
+        // A thread that is gone needs no line, and its removal from `state.json` refreshes the Home.
+        // One still there says why, and its root is read again: the delete may have stopped half way.
+        if (refusal === null)
+            return;
+        chat.index?.refresh([{ channel, thread: threadTs }]);
+        await this.answers.tellOwner(channel, threadTs, deleteLine(refusal, names));
+    };
+    /** Cancel: the question goes, and nothing else changes. */
+    onCancel = async (ack, body, respond) => {
+        if ((await this.admitted(ack, body)) !== null)
+            await this.withdraw(respond);
+    };
+    /** Acknowledges, then the channel and the thread of the owner's click; null for anyone else's. */
+    async admitted(ack, body) {
+        await ack();
+        const [user, team] = interactionActor(body);
+        const channel = text(record(body.channel).id);
+        const threadTs = clickThread(body);
+        if (!(await this.answers.admitted(user, team, channel, threadTs)) || channel === null) {
+            return null;
+        }
+        return [channel, threadTs];
+    }
+    /** Takes the question away. A failure leaves it showing until a reload, and is logged. */
+    async withdraw(respond) {
+        if (respond === undefined)
+            return; // a click with no `response_url`: nothing to answer
+        try {
+            await respond({ delete_original: true });
+        }
+        catch (error) {
+            logger.warning(`could not take back the delete question: ${describe(error)}`);
+        }
+    }
+}

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

@@ -6,6 +6,7 @@
  */
 import { getLogger } from "../../../log.js";
 import { isSpace } from "../../../text.js";
+import { isTombstone } from "../channels.js";
 import { describe } from "../reply/errors.js";
 import * as slackTexts from "../texts.js";
 export const logger = getLogger("allaboard.chat.slack.app.guards");
@@ -118,6 +119,49 @@ export function isWrittenMessage(event) {
         WRITTEN_SUBTYPES.includes(subtype) &&
         !("bot_id" in event));
 }
+/**
+ * The `ts` of the message a deletion removed, when `event` says one was deleted; null for any
+ * other event. Two shapes, both seen on 2026-10-20 when the owner's user token deleted roots:
+ * `message_deleted` (`deleted_ts`; the reference, docs.slack.dev/reference/events/message/
+ * message_deleted, read 2026-10-20), which comes for a message with no replies and for the last
+ * reply deleted afterwards; and a `message_changed` whose inner `message.subtype` is `tombstone`,
+ * which comes for a root whose replies remain (the reference for `message_changed` does not
+ * name the subtype: it is measured). A `message_changed` of an edit has no such subtype, so the
+ * daemon's own edits of a root (title, tag) are not deletions.
+ *
+ * Neither event says who deleted the message. `deletedAuthor` gives who wrote it, which is the
+ * most the events prove.
+ */
+export function deletedTs(event) {
+    if (event.type !== "message")
+        return null;
+    if (event.subtype === "message_deleted")
+        return text(event.deleted_ts);
+    if (event.subtype === "message_changed") {
+        const inner = record(event.message);
+        return isTombstone(inner) ? text(inner.ts) : null;
+    }
+    return null;
+}
+/**
+ * The author of the message a deletion event removed: `previous_message.user`, measured on
+ * 2026-10-20 in both shapes (the root's author, the owner, for a root; the bot for a reply). Not
+ * `message.user` of a tombstone, which is a Slack system user. Null when the event has no
+ * `previous_message`. The removal of a tombstone never reaches it (`isTombstoneRemoval` drops it
+ * first). This proves whose message was deleted, not who deleted it, which no field of the events
+ * says.
+ */
+export function deletedAuthor(event) {
+    return text(record(event.previous_message).user);
+}
+/**
+ * Whether `event` is the removal of a tombstone: the last reply of a deleted root went, and the
+ * deleted message was the tombstone (`previous_message.subtype` `tombstone`, measured
+ * 2026-10-20). The earlier tombstone event already forgot the thread.
+ */
+export function isTombstoneRemoval(event) {
+    return isTombstone(event.previous_message);
+}
 const SHARED_FLAGS = ["is_shared", "is_ext_shared", "is_org_shared", "is_pending_ext_shared"];
 export class ChannelGuard {
     #slack;

package/dist/chat/slack/app/home-controls.js

@@ -1,6 +1,6 @@
 /**
  * The controls of the session index (the app's Home tab, `home.ts`): its filters, Show all, Edit,
- * Delete, Clean up and the update line's button.
+ * Refresh, Delete, Clean up and the update line's button.
  */
 import { EDIT_ON, readFilter } from "../home.js";
 import { logger } from "./answers.js";
@@ -55,6 +55,13 @@ export class HomeControls {
             return;
         await this.home.edit(str(firstAction(body).value) === EDIT_ON);
     };
+    // The click asks for a cleanup of state.json and a fresh page; `Home.refresh` never throws.
+    onHomeRefresh = async (ack, body) => {
+        await ack();
+        if (!this.homeOwner(body))
+            return;
+        await this.home.refresh();
+    };
     // Slack sends this click only once the owner confirmed in the button's own dialog.
     onHomeDelete = async (ack, body) => {
         await ack();

package/dist/chat/slack/channels.js

@@ -1,4 +1,5 @@
 /** What the daemon asks Slack about the channels it is bound to, and the threads in them. */
+import { isRecord } from "../../values.js";
 import { ChatError } from "../seam.js";
 import { THREAD_NOT_FOUND } from "./delete.js";
 import { describe } from "./reply/errors.js";
@@ -23,15 +24,32 @@ export function channelLookup(slack) {
     };
 }
 /**
- * What the cleanup asks about a thread: `conversations.replies` on its root with `limit=1`, which
- * a deleted root answers with `thread_not_found` (measured 2026-10-01, see `home.ts`). Only that
- * code says the thread is gone; any other failure crosses as a `ChatError` named by Slack's code.
+ * Whether `root`, a message `conversations.replies` returned, is a tombstone: a root deleted while
+ * replies remain, which Slack returns with `subtype` `tombstone` and the text `This message was
+ * deleted.` (measured 2026-10-20 on a development app; the subtype is not in the method's
+ * reference). Such a root is gone, as one answered with `thread_not_found` is.
+ */
+export function isTombstone(root) {
+    return isRecord(root) && root.subtype === "tombstone";
+}
+/**
+ * What the cleanup asks about a thread: `conversations.replies` on its root with `limit=1`. A root
+ * deleted with no replies, or whose last reply was deleted since, answers `thread_not_found`
+ * (measured 2026-10-01, see `home.ts`). A root deleted while replies remain is returned as a
+ * tombstone, a message with `subtype` `tombstone` and the text `This message was deleted.` (measured
+ * 2026-10-20; the subtype is not in the method's reference). Those two say the thread is gone; any
+ * other failure crosses as a `ChatError` named by Slack's code.
  */
 export function threadLookup(slack) {
     return async (ref) => {
         try {
-            await slack.conversations.replies({ channel: ref.channel, ts: ref.thread, limit: 1 });
-            return "there";
+            const answer = await slack.conversations.replies({
+                channel: ref.channel,
+                ts: ref.thread,
+                limit: 1,
+            });
+            const root = answer.messages?.find((message) => message.ts === ref.thread);
+            return isTombstone(root) ? "gone" : "there";
         }
         catch (error) {
             const code = describe(error);