allaboard 0.5.0 → 0.6.0

package/dist/core/cleanup.js

@@ -9,13 +9,17 @@ export const CLEAN_EVERY_SECONDS = 6 * 60 * 60;
  * none of the bound channels (a channel it gave no answer about is not one it found), nothing is
  * removed: that is what the token of another workspace, or an app removed from every channel,
  * looks like, and forgetting every binding would be the wrong repair. `chat` is the chat's
- * name, for the log lines.
+ * name, for the log lines. Once `stopping` says a stop has begun no further channel is asked
+ * about and nothing is forgotten: the channels left for the next start.
  */
-export async function forgetGoneChannels(lookup, state, live, chat, log = logger) {
+export async function forgetGoneChannels(lookup, state, live, chat, log = logger, stopping = () => false) {
     const bound = state.channels();
     const gone = [];
     const found = [];
     for (const channelId of bound) {
+        // One call to the chat per channel: a stop that begins meanwhile waits for one, not for all.
+        if (stopping())
+            return { forgotten: [], found };
         let answer;
         try {
             answer = await lookup(channelId);
@@ -112,7 +116,8 @@ export async function clean(lookup, state, options) {
     const log = options.logger ?? logger;
     let found = [];
     try {
-        found = (await forgetGoneChannels(lookup, state, live, options.chat, log)).found;
+        found = (await forgetGoneChannels(lookup, state, live, options.chat, log, options.stopping))
+            .found;
     }
     catch (error) {
         log.warning(`could not check the bound channels: ${errorName(error)}`);
@@ -123,6 +128,10 @@ export async function clean(lookup, state, options) {
     catch (error) {
         log.warning(`could not check the threads: ${errorName(error)}`);
     }
+    // A stop closes the sessions after this pass: the keep set `live` gives would then be empty,
+    // and a thread whose session id is not on disk yet would be pruned. The next start prunes.
+    if (options.stopping?.())
+        return;
     try {
         const folders = new Set(state
             .threads()
@@ -143,3 +152,57 @@ export async function clean(lookup, state, options) {
         log.warning(`could not prune stale threads: ${errorName(error)}`);
     }
 }
+/**
+ * The only way a pass of `clean` starts: the one at start, the scheduled ones and the owner's
+ * Refresh all ask here. One pass runs at a time; a request made while one runs shares the single
+ * pass that follows it (the first pass may have read a channel before the owner's change), so any
+ * number of clicks cost at most one more. Once `stopping` says a stop has begun a request does
+ * nothing, and neither does the pass queued behind a running one.
+ */
+export class Cleanups {
+    #run;
+    #stopping;
+    #log;
+    #running = null;
+    #next = null;
+    constructor(run, stopping, log = logger) {
+        this.#run = run;
+        this.#stopping = stopping;
+        this.#log = log;
+    }
+    /** Resolves once a pass that began after this call has ended, or at once during a stop. Never rejects. */
+    request() {
+        if (this.#stopping())
+            return Promise.resolve();
+        // A pass queued behind the running one is joined before the running one is looked at: the
+        // running pass clears `#running` a turn before the queued one starts.
+        if (this.#next !== null)
+            return this.#next;
+        if (this.#running === null)
+            return this.#launch();
+        this.#next ??= this.#running.then(() => {
+            this.#next = null;
+            return this.#stopping() ? undefined : this.#launch();
+        });
+        return this.#next;
+    }
+    /** Resolves once the pass running and the one queued behind it have ended; at once with none. */
+    settled() {
+        return this.#next ?? this.#running ?? Promise.resolve();
+    }
+    #launch() {
+        const pass = (async () => {
+            try {
+                await this.#run();
+            }
+            catch (error) {
+                this.#log.warning(`the cleanup failed: ${errorName(error)}`);
+            }
+            finally {
+                this.#running = null;
+            }
+        })();
+        this.#running = pass;
+        return pass;
+    }
+}

package/dist/core/commands.js

@@ -1,4 +1,5 @@
 import { compareCodePoints, PY_SPACE, strip } from "../text.js";
+import { limitsPage } from "../version.js";
 import * as texts from "./texts.js";
 /** The word each of the daemon's own commands is typed as; a new kind of `Word` fails to compile here. */
 export const WORD = {
@@ -10,9 +11,17 @@ export const WORD = {
     stop: "stop",
     resume: "resume",
     open: "open",
+    tag: "tag",
+    untag: "untag",
+    "delete-thread": "delete-thread",
     allaboard: "allaboard",
 };
 export const DESCRIPTION_LIMIT = 100;
+/**
+ * A thread's tag: 1 to 40 letters, digits, `.`, `_` or `-`, kept as typed. One rule for what
+ * `!tag` accepts and for what a chat reads back as a tag.
+ */
+export const TAG_NAME = /^[\p{L}\p{N}._-]{1,40}$/u;
 // Python's whitespace, which `strip` and `split` follow, is not JavaScript's `\s` (`text.ts`).
 const TRAILING = new RegExp(`[${PY_SPACE}]+$`);
 const STARTS_WITH_SPACE = new RegExp(`^[${PY_SPACE}]`);
@@ -64,6 +73,16 @@ export function parseBang(text) {
             return { kind: "resume", target: rest };
         case "open":
             return { kind: "open", target: rest };
+        case "tag":
+            // Alone, or with a name the rule refuses, it is mistyped: the help shows how it is written.
+            return TAG_NAME.test(rest) ? { kind: "tag", name: rest } : { kind: "invalid" };
+        case "untag":
+            // A thread has one tag, so `!untag devops` means `!untag`: what follows the word says
+            // nothing more, and a word the owner typed must not reach the agent as a prompt.
+            return { kind: "untag" };
+        case "delete-thread":
+            // Anything after it is a mistake: the help shows how it is written, and nothing is deleted.
+            return rest === "" ? { kind: "delete-thread" } : { kind: "invalid" };
         case "allaboard":
             switch (rest.toLowerCase()) {
                 case "":
@@ -134,6 +153,27 @@ export function hostOnly(command, names, agentCommands = true) {
     }
     return null;
 }
+/**
+ * The answer to a command of the agent's terminal that a session from the chat does not offer
+ * (`notOffered`, the agent's words), with what to do instead, or null: for any other name, for one
+ * the session's own list (`offered`) has, and for every one when the agent has no commands of its
+ * own (`agentCommands` false). The caller sends that answer and nothing to the agent.
+ */
+export function notOfferedAnswer(command, offered, notOffered, names, agentCommands = true) {
+    if (!agentCommands)
+        return null;
+    const word = command.text.split(" ", 1)[0].toLowerCase();
+    if (!Object.hasOwn(notOffered, word))
+        return null;
+    if (offered.some((listed) => listed.name.toLowerCase() === word))
+        return null;
+    const instead = notOffered[word] ?? null;
+    return [
+        texts.fill(texts.named(texts.NOT_OFFERED, names), { command: word }),
+        ...(instead === null ? [] : [instead]),
+        texts.fill(texts.NOT_OFFERED_SEE, { link: limitsPage() }),
+    ].join(" ");
+}
 /**
  * The command names a thread refuses, lowercase: the agent's `newSession` names (one thread is
  * one session, and a thread is also the only place a session's commands are listed; they are

package/dist/core/config.js

@@ -84,6 +84,24 @@ function isDirectory(path) {
         throw error;
     }
 }
+/**
+ * The directory `written` names as `ALLOWED_ROOT`, resolved; throws `ConfigError` when it is not an
+ * absolute path (or one starting with `~/`) or does not name a directory. The one rule, for the
+ * daemon's start and for `allaboard setup`.
+ */
+export function allowedRootOf(written) {
+    const expanded = expandUser(written);
+    // A relative path would read from the working directory: the terminal's folder at Checkpoint 2,
+    // `/` under launchd.
+    if (!isAbsolute(expanded)) {
+        throw new ConfigError(`ALLOWED_ROOT must be an absolute path, or one starting with ~/; it is "${written}"`);
+    }
+    const root = resolvePath(expanded);
+    if (!isDirectory(root)) {
+        throw new ConfigError(`ALLOWED_ROOT is not a directory: ${root}`);
+    }
+    return root;
+}
 /** The values of `names` that `values` holds, readable by lookup and shown by nothing. */
 function hiddenVariables(names, values) {
     const hidden = Object.create(null);
@@ -150,17 +168,7 @@ export function loadConfig(modules, configDir, env = process.env) {
     if (missing.length > 0) {
         throw new ConfigError(`missing in ${envPath}: ${missing.join(", ")}`);
     }
-    const written = values.ALLOWED_ROOT;
-    const expanded = expandUser(written);
-    // A relative path would read from the working directory: the terminal's folder at Checkpoint 2,
-    // `/` under launchd.
-    if (!isAbsolute(expanded)) {
-        throw new ConfigError(`ALLOWED_ROOT must be an absolute path, or one starting with ~/; it is "${written}"`);
-    }
-    const root = resolvePath(expanded);
-    if (!isDirectory(root)) {
-        throw new ConfigError(`ALLOWED_ROOT is not a directory: ${root}`);
-    }
+    const root = allowedRootOf(values.ALLOWED_ROOT);
     return Object.defineProperties({ agent, chat, allowedRoot: root, configDir }, {
         agentVariables: {
             value: hiddenVariables([...agentModule.required, ...agentModule.optional], values),

package/dist/core/files/listing.js

@@ -124,6 +124,25 @@ export async function repositoriesOf(folder, lookup) {
     }
     return [...found.values()];
 }
+/**
+ * The usable repositories found at most two levels below `folder` that only want the owner's
+ * trust (`untrusted`, the agent's `untrustedRepository`), one per key and sorted by it: the ones
+ * `repositoriesOf` leaves out for that. None when the repository holding `folder` is usable
+ * (`trusted`), since `repositoriesOf` looks no further then.
+ */
+export async function untrustedRepositories(folder, trusted, untrusted) {
+    if (usable(await trusted(folder)) !== null)
+        return [];
+    const below = await repositoryFolders(folder);
+    const looked = await Promise.all(below.map((candidate) => untrusted(candidate)));
+    // Two worktrees of one checkout share its key, and one trust covers both.
+    const found = new Map();
+    for (const repository of looked.map(usable)) {
+        if (repository !== null)
+            found.set(repository.key, repository);
+    }
+    return [...found.values()].sort((a, b) => compareCodePoints(a.key, b.key));
+}
 /**
  * The regular files under `root` as paths from it, the shallower first: a symlink is neither
  * followed nor listed, no `.git` is entered, nor any folder in `skip` (paths). Stops when

package/dist/core/flows/bind.js

@@ -1,7 +1,9 @@
 import { compareCodePoints } from "../../text.js";
-import { resolveDirectory } from "../sessions/directory.js";
+import { errorName } from "../../values.js";
+import { resolveDirectory, untrustedNotice } from "../sessions/directory.js";
 import * as texts from "../texts.js";
 import { fill, named } from "../texts.js";
+import { isCancelled, logger } from "./talk.js";
 /**
  * The answer to a bind: what keeps a session from starting in the folder, if anything
  * (`BIND_UNAVAILABLE` keeps priority: what would stop every session there matters more than
@@ -21,16 +23,35 @@ export function boundText(directory, unavailable, oldFolders, inNotice) {
     const old = oldFolders.map((folder) => `\`${inNotice(folder)}\``).join(", ");
     return fill(texts.BIND_OK_ELSEWHERE, { directory: inNotice(directory), old });
 }
+// What the owner is told for each reason a typed path binds nothing.
+const REFUSALS = {
+    missing: texts.BIND_MISSING,
+    file: texts.BIND_FILE,
+    outside: texts.BIND_OUTSIDE,
+};
 export function binding(deps, talk) {
     const { agent, chat, sessions, state, names, allowedRoot } = deps;
     const inNotice = (text) => chat.escape(text, "notice");
     /** The folder a typed path or a pick names, inside the allowed root; null, told, otherwise. */
     const folderNamed = async (channel, path) => {
-        const directory = resolveDirectory(path, allowedRoot);
-        if (directory === null) {
-            await talk.inChannel(channel, fill(texts.BIND_OUTSIDE, { path: inNotice(path), root: inNotice(allowedRoot) }));
+        const resolved = resolveDirectory(path, allowedRoot);
+        if ("directory" in resolved)
+            return resolved.directory;
+        const refusal = REFUSALS[resolved.refused];
+        await talk.inChannel(channel, fill(refusal, { path: inNotice(path), root: inNotice(allowedRoot) }));
+        return null;
+    };
+    /** The repositories below `directory` still to trust; a failed lookup is logged and names none. */
+    const untrusted = async (directory) => {
+        try {
+            return await untrustedNotice(agent, directory, names, inNotice);
+        }
+        catch (error) {
+            if (isCancelled(error))
+                throw error;
+            logger.warning(`could not look for repositories to trust: ${errorName(error)}`);
+            return [];
         }
-        return directory;
     };
     // Thread entries keep their own folder either side of the bind (`StateStore.bind`), so the
     // old folders can be read now: those of the channel's threads that differ from the new one.
@@ -41,7 +62,9 @@ export function binding(deps, talk) {
         const oldFolders = [
             ...new Set(threads.map((thread) => thread.directory).filter((old) => old !== directory)),
         ].sort(compareCodePoints);
-        await talk.inChannel(channel, boundText(directory, unavailable, oldFolders, inNotice));
+        // A folder no session can start in names no repository below it: that comes first.
+        const below = unavailable === null ? await untrusted(directory) : [];
+        await talk.inChannel(channel, [boundText(directory, unavailable, oldFolders, inNotice), ...below].join("\n"));
     };
     return {
         async to(channel, path) {

package/dist/core/flows/flows.js

@@ -1,4 +1,5 @@
 import { asking } from "./asking.js";
+import { rootGone } from "./gone.js";
 import { Inbound } from "./inbound.js";
 import { lists } from "./lists.js";
 import { messages } from "./messages.js";
@@ -30,6 +31,7 @@ export function buildFlows(deps) {
             answer: (ref, requestId, answer, message) => answers.answer(ref, requestId, answer, message),
             picked: (pick) => (pick.type === "update" ? updatePicked(pick) : picks.picked(pick)),
             unbound: (channel) => talk.unbound(channel),
+            rootGone: rootGone(deps),
         }),
     };
 }

package/dist/core/flows/gone.js

@@ -0,0 +1,39 @@
+import { errorName } from "../../values.js";
+import { logger } from "./talk.js";
+/**
+ * The handler of a deleted first message: holds the thread, closes its session and removes its
+ * entry, then frees the hold it took. Does nothing for a thread already held (a delete under way)
+ * or in use, or while the daemon stops; the cleanup forgets those at its next pass.
+ */
+export function rootGone(deps) {
+    const { sessions, state, stopped } = deps;
+    return async ({ channel, thread }) => {
+        // Held by a delete already under way (`!delete-thread`, the Home tab's Delete): that delete
+        // removes the entry itself, and the event is its own deletion coming back. The hold is its
+        // to free, never this call's.
+        if (sessions.held(channel, thread))
+            return;
+        // The thread is held until the entry is gone: a message sent in it meanwhile finds no
+        // session and none is rebuilt from the entry (`SessionManager.hold`, as a delete does). A
+        // refusal took no hold, so nothing is freed for it.
+        if (!sessions.hold(channel, thread)) {
+            // A turn is running, or the daemon is stopping. The cleanup forgets the thread at its next
+            // pass, since a tombstoned root is gone for it too.
+            logger.info(stopped.aborted
+                ? `left ${channel}/${thread} to the next start's cleanup: its first message was deleted`
+                : `left ${channel}/${thread} to the cleanup: its first message was deleted while it works`);
+            return;
+        }
+        try {
+            await sessions.closeHeld(channel, thread);
+            state.removeThread(channel, thread);
+            logger.info(`forgot ${channel}/${thread}: its first message was deleted`);
+        }
+        catch (error) {
+            logger.warning(`could not forget ${channel}/${thread}: ${errorName(error)}`);
+        }
+        finally {
+            sessions.free(channel, thread);
+        }
+    };
+}

package/dist/core/flows/inbound.js

@@ -15,6 +15,9 @@ export class Inbound {
     unbound(channel) {
         return this.#flow("unbound")(channel);
     }
+    rootGone(ref) {
+        return this.#flow("rootGone")(ref);
+    }
     #flow(name) {
         const flow = this.#flows[name];
         if (flow === undefined)

package/dist/core/flows/messages.js

@@ -10,7 +10,7 @@
  * hands the messages of a thread over in the order its listeners were called, whatever its
  * checks take, with nothing awaited between its last check and the call.
  */
-import { hostOnly, parseBang, refusedInThread, } from "../commands.js";
+import { hostOnly, notOfferedAnswer, parseBang, refusedInThread, } from "../commands.js";
 import { SessionClosed, SessionGone } from "../sessions/errors.js";
 import { Mutex } from "../sessions/tasks.js";
 import * as texts from "../texts.js";
@@ -245,7 +245,9 @@ export function messages(deps, talk, others) {
             return;
         }
         if (command !== null) {
-            const answer = hostOnly(command, names, agent.capabilities.commands);
+            const answer = hostOnly(command, names, agent.capabilities.commands) ??
+                // A session not connected yet lists nothing: the agent's own list is known once it is.
+                notOfferedAnswer(command, session?.commands ?? [], agent.words.notOffered, names, agent.capabilities.commands);
             if (answer !== null) {
                 // Answered where a word is: under the owner's message in a session's thread, for the
                 // owner alone, and as a post in the channel anywhere else. No session starts.

package/dist/core/flows/status.js

@@ -3,7 +3,12 @@ import { oneLine, TITLE_LIMIT } from "../reply/words.js";
 import * as texts from "../texts.js";
 import { fill } from "../texts.js";
 import { isCancelled, logger } from "./talk.js";
-/** How long ago, in one unit, as a channel's `!status` says it of an idle session. */
+/**
+ * The rows one answer shows, newest first; the older ones are counted. A notice is one line of
+ * small text with a limit, and each row carries a link.
+ */
+export const STATUS_ROWS = 10;
+/** How long ago, in one unit, as a channel's `!status` says it of a session at rest. */
 export function ago(seconds) {
     const whole = Math.trunc(seconds);
     if (whole < 60)
@@ -14,40 +19,88 @@ export function ago(seconds) {
         return `${Math.floor(whole / 3600)}h ago`;
     return `${Math.floor(whole / 86400)}d ago`;
 }
+/** A status that says how a turn ended, or null for any other. */
+function outcome(status) {
+    return status === "done" || status === "error" ? status : null;
+}
 export function channelStatus(deps, talk) {
-    const { state, sessions } = deps;
-    async function row(channel, channelDirectory, session, known) {
-        const stored = state.thread(channel, session.threadId);
-        const info = stored === null ? undefined : known.get(String(stored.sessionId));
+    const { chat, state, sessions } = deps;
+    async function row(channel, channelDirectory, shown) {
+        const { thread, stored, live, info } = shown;
         const title = info === undefined ? "" : oneLine(info.title, TITLE_LIMIT);
-        const linked = await talk.referenceLink({ channel, thread: session.threadId }, title);
+        const label = chat.escape(title, "notice") || texts.STATUS_CHANNEL_SESSION;
+        const linked = await talk.noticeLink({ channel, thread }, label);
+        let status;
         let activity;
-        if (session.waitingForOwner) {
+        // How long the session has rested: said of one at rest alone.
+        let since = "";
+        if (live?.waitingForOwner) {
+            status = "waiting";
             activity = texts.STATUS_CHANNEL_WAITING;
         }
-        else if (session.busy || session.runningKinds) {
-            // A session with only a background task running is not idle either.
+        else if (live?.busy || live?.runningKinds) {
+            // A session with only a background task running is not at rest either.
+            status = "working";
             activity = texts.STATUS_CHANNEL_BUSY;
         }
         else {
-            activity = texts.STATUS_CHANNEL_IDLE;
+            // At rest, live or closed, the row says how its last turn ended, as the root's mark does.
+            status = outcome(stored.status) ?? outcome(stored.ended) ?? "done";
             if (info?.lastModified) {
                 // In milliseconds, and by now the time of the session's last message (dated below).
-                const since = ago(deps.now() - info.lastModified / 1000);
-                activity += fill(texts.STATUS_CHANNEL_SINCE, { ago: since });
+                since = fill(texts.STATUS_CHANNEL_SINCE, {
+                    ago: ago(deps.now() - info.lastModified / 1000),
+                });
             }
+            activity = texts.STATUS_CHANNEL_IDLE + since;
         }
-        let line = fill(texts.STATUS_CHANNEL_ROW, { link: linked, activity });
-        if (session.runningKinds) {
-            line += ` · ${fill(texts.RUNNING, { counts: session.runningKinds })}`;
+        const mark = chat.capabilities.reactions ? chat.statusMark?.(status) : undefined;
+        let line = mark === undefined
+            ? fill(texts.STATUS_CHANNEL_ROW, { link: linked, activity })
+            : fill(texts.STATUS_CHANNEL_MARKED_ROW, { mark, link: linked, since });
+        if (live?.runningKinds) {
+            line += ` · ${fill(texts.RUNNING, { counts: live.runningKinds })}`;
         }
-        if (session.bypass)
+        if (live === null ? stored.bypass === true : live.bypass)
             line += texts.STATUS_CHANNEL_BYPASS;
-        if (session.directory !== channelDirectory) {
-            line += fill(texts.STATUS_CHANNEL_FOLDER, { directory: session.directory });
+        const directory = live?.directory ?? stored.directory;
+        if (directory !== channelDirectory) {
+            line += fill(texts.STATUS_CHANNEL_FOLDER, { directory });
         }
         return line;
     }
+    /**
+     * The title and the time of the last message of each session `threads` hold, by session id.
+     * Dated by the session's last message, not by its file: Claude Code writes entries with no
+     * timestamp to a transcript when it connects the session again, so a session idle for 16
+     * minutes read `just now` (seen 2026-10-07). A folder that cannot be listed is logged and its
+     * sessions shown untitled.
+     */
+    async function listed(threads) {
+        const known = new Map();
+        const byDirectory = new Map();
+        for (const [, stored] of threads) {
+            if (stored.sessionId === null)
+                continue;
+            const ids = byDirectory.get(stored.directory) ?? new Set();
+            ids.add(stored.sessionId);
+            byDirectory.set(stored.directory, ids);
+        }
+        for (const [directory, ids] of byDirectory) {
+            try {
+                const found = await sessions.sessionsIn(directory);
+                const dated = await sessions.dated(directory, found.filter((session) => ids.has(session.id)));
+                for (const session of dated)
+                    known.set(session.id, session);
+            }
+            catch (error) {
+                if (isCancelled(error))
+                    throw error;
+                logger.warning(`could not list a folder's sessions: ${errorName(error)}`);
+            }
+        }
+        return known;
+    }
     return async (channel) => {
         const record = state.channel(channel);
         if (record === null) {
@@ -55,43 +108,40 @@ export function channelStatus(deps, talk) {
             return;
         }
         const lines = [fill(texts.STATUS_CHANNEL_HEADER, { directory: record.directory })];
-        const live = sessions.sessionsOf(channel);
-        if (live.length === 0) {
+        const live = new Map(sessions.sessionsOf(channel).map((session) => [session.threadId, session]));
+        // Every thread that holds a session, as the session index lists them, and a live one whose
+        // session has no id yet (its setup is still open): a restart closes every session, and an
+        // answer of live ones alone was empty right after one (the owner, 2026-10-19).
+        const threads = state
+            .threads()
+            .filter(([id, thread, stored]) => id === channel && (stored.sessionId !== null || live.has(thread)))
+            .map(([, thread, stored]) => [thread, stored]);
+        if (threads.length === 0) {
             lines.push(texts.STATUS_CHANNEL_EMPTY);
         }
         else {
-            // What tells one thread from another (issue #76): the title the agent gave its session,
-            // as the Home tab and a restart's notice name it, and the time of its last message. Not
-            // the time of its file, which the listing gives: Claude Code writes entries with no
-            // timestamp to a transcript when it connects the session again, so a session idle for 16
-            // minutes read `just now` (seen 2026-10-07). Only the sessions the answer shows are
-            // dated, since dating reads their files.
-            const shown = new Set();
-            for (const session of live) {
-                const stored = state.thread(channel, session.threadId);
-                if (stored?.sessionId)
-                    shown.add(stored.sessionId);
-            }
-            const known = new Map();
-            for (const directory of new Set(live.map((session) => session.directory))) {
-                try {
-                    const listed = await sessions.sessionsIn(directory);
-                    const dated = await sessions.dated(directory, listed.filter((session) => shown.has(session.id)));
-                    for (const session of dated)
-                        known.set(session.id, session);
-                }
-                catch (error) {
-                    if (isCancelled(error))
-                        throw error;
-                    logger.warning(`could not list a folder's sessions: ${errorName(error)}`);
-                }
+            const known = await listed(threads);
+            const all = threads.map(([thread, stored]) => {
+                const info = stored.sessionId === null ? undefined : known.get(stored.sessionId);
+                const opened = chat.openedAt({ channel, thread }) ?? 0;
+                return {
+                    thread,
+                    stored,
+                    live: live.get(thread) ?? null,
+                    info,
+                    when: info?.lastModified ? info.lastModified / 1000 : opened,
+                };
+            });
+            all.sort((a, b) => b.when - a.when);
+            const shown = all.slice(0, STATUS_ROWS);
+            lines.push(...(await Promise.all(shown.map((s) => row(channel, record.directory, s)))));
+            if (all.length > shown.length) {
+                lines.push(fill(texts.STATUS_CHANNEL_MORE, { count: all.length - shown.length }));
             }
-            lines.push(...(await Promise.all(live.map((session) => row(channel, record.directory, session, known)))));
         }
-        await talk.say(channel, null, lines.join("\n"));
+        await talk.inChannel(channel, lines.join("\n"));
         const waits = await talk.restartWaits(channel);
         if (waits) {
-            // A notice of its own: the rows are written for a notice, and the status above is a reference.
             await talk.inChannel(channel, [texts.RESTART_WAITS_HEADER, waits].join("\n"));
         }
     };